DocumentorService - Code Metrics - Inspection of "Check if namespace exists when checking doc" - psfs/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0a9e87...9dd3d7 )

by Fran

created 2017-02-11 00:36 UTC

DocumentorService D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	481
Duplicated Lines	0.83 %

Coupling/Cohesion

Components	2
Dependencies	6

Importance

Changes

Metric	Value
dl	4
loc	481
rs	4.8717
c	0
b	0
f	0
wmc	81
lcom	2
cbo	6

18 Methods

Rating	Name	Duplication	Size	Complexity
B	getModules()	0	22	5
B	extractApiEndpoints()	0	21	5
B	extractApiInfo()	0	18	5
A	extractRoute()	0	7	1
A	extractApi()	0	7	1
A	checkDeprecated()	0	4	1
A	extractVisibility()	0	10	2
B	extractDescription()	4	15	5
A	extractVarType()	0	11	3
A	extractPayload()	0	11	2
A	extractDtoProperties()	0	10	2
D	extractReturn()	0	28	9
C	extractModelFields()	0	25	8
C	extractMethodInfo()	0	29	7
C	translateSwaggerFormats()	0	38	13
C	extractSwaggerDefinition()	0	39	7
A	swaggerFormatter()	0	23	3
A	extractDtoName()	0	10	2

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like DocumentorService often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use DocumentorService, and based on these observations, apply Extract Interface, too.

<?php
    namespace PSFS\services;

    use Propel\Runtime\Map\TableMap;
    use PSFS\base\Logger;
    use PSFS\base\Service;
    use PSFS\base\types\helpers\InjectorHelper;
    use PSFS\base\types\helpers\RouterHelper;
    use Symfony\Component\Finder\Finder;

    /**
     * Class DocumentorService
     * @package PSFS\services
     */
    class DocumentorService extends Service
    {
        const DTO_INTERFACE = '\\PSFS\\base\\dto\\Dto';
        const MODEL_INTERFACE = '\\Propel\\Runtime\\ActiveRecord\\ActiveRecordInterface';
        /**
         * @Inyectable
         * @var \PSFS\base\Router route
         */
        protected $route;

        /**
         * Method that extract all modules
         * @return array
         */
        public function getModules()
        {
            $modules = [];
            $domains = $this->route->getDomains();
            if (count($domains)) {
                foreach ($domains as $module => $info) {
                    try {
                        $module = str_replace('/', '', str_replace('@', '', $module));
                        if (!preg_match('/^ROOT/i', $module)) {
                            $modules[] = [
                                'name' => $module,
                                'path' => realpath($info['template'] . DIRECTORY_SEPARATOR . '..'),
                            ];
                        }
                    } catch (\Exception $e) {
                        $modules[] = $e->getMessage();
                    }
                }
            }

            return $modules;
        }

        /**
         * Method that extract all endpoints for each module
         *
         * @param array $module
         *
         * @return array
         */
        public function extractApiEndpoints(array $module)
        {
            $module_path = $module['path'] . DIRECTORY_SEPARATOR . 'Api';
            $module_name = $module['name'];
            $endpoints = [];
            if (file_exists($module_path)) {
                $finder = new Finder();
                $finder->files()->in($module_path)->depth(0)->name('*.php');
                if (count($finder)) {
                    /** @var \SplFileInfo $file */
                    foreach ($finder as $file) {
                        $namespace = "\\{$module_name}\\Api\\" . str_replace('.php', '', $file->getFilename());
                        $info = $this->extractApiInfo($namespace, $module_name);
                        if(!empty($info)) {
                            $endpoints[$namespace] = $info;
                        }
                    }
                }
            }
            return $endpoints;
        }

        /**
         * Method that extract all the endpoit information by reflection
         *
         * @param string $namespace
         *
         * @return array
         */
        public function extractApiInfo($namespace, $module)
        {
            $info = [];
            if(class_exists($namespace)) {
                $reflection = new \ReflectionClass($namespace);
                foreach ($reflection->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
                    try {
                        $mInfo = $this->extractMethodInfo($namespace, $method, $reflection, $module);
                        if (NULL !== $mInfo) {
                            $info[] = $mInfo;
                        }
                    } catch (\Exception $e) {
                        Logger::getInstance()->errorLog($e->getMessage());
                    }
                }
            }
            return $info;
        }

        /**
         * Extract route from doc comments
         *
         * @param string $comments
         *
         * @return string
         */
        protected function extractRoute($comments = '')
        {
            $route = '';
            preg_match('/@route\ (.*)\n/i', $comments, $route);

            return $route[1];
        }

        /**
         * Extract api from doc comments
         *
         * @param string $comments
         *
         * @return string
         */
        protected function extractApi($comments = '')
        {
            $api = '';
            preg_match('/@api\ (.*)\n/i', $comments, $api);

            return $api[1];
        }

        /**
         * Extract api from doc comments
         *
         * @param string $comments
         *
         * @return boolean
         */
        protected function checkDeprecated($comments = '')
        {
            return false != preg_match('/@deprecated\n/i', $comments);

        }

        /**
         * Extract visibility from doc comments
         *
         * @param string $comments
         *
         * @return boolean
         */
        protected function extractVisibility($comments = '')
        {
            $visible = TRUE;
            preg_match('/@visible\ (true|false)\n/i', $comments, $visibility);
            if (count($visibility)) {
                $visible = !('false' == $visibility[1]);
            }

            return $visible;
        }

        /**
         * Method that extract the description for the endpoint
         *
         * @param string $comments
         *
         * @return string
         */
        protected function extractDescription($comments = '')
        {
            $description = '';
            $docs = explode("\n", $comments);
            if (count($docs)) {
                foreach ($docs as &$doc) {
                    if (!preg_match('/(\*\*|\@)/i', $doc) && preg_match('/\*\ /i', $doc)) {

                        $doc = explode('* ', $doc);
                        $description = $doc[1];
                    }
                }
            }

            return $description;
        }

        /**
         * Method that extract the type of a variable
         *
         * @param string $comments
         *
         * @return string
         */
        public static function extractVarType($comments = '')
        {
            $type = 'string';
            preg_match('/@var\ (.*) (.*)\n/i', $comments, $varType);
            if (count($varType)) {
                $aux = trim($varType[1]);
                $type = str_replace(' ', '', strlen($aux) > 0 ? $varType[1] : $varType[2]);
            }

            return $type;
        }

        /**
         * Method that extract the payload for the endpoint
         *
         * @param string $model
         * @param string $comments
         *
         * @return array
         */
        protected function extractPayload($model, $comments = '')
        {
            $payload = [];
            preg_match('/@payload\ (.*)\n/i', $comments, $doc);
            if (count($doc)) {
                $namespace = str_replace('{__API__}', $model, $doc[1]);
                $payload = $this->extractModelFields($namespace);
            }

            return $payload;
        }

        /**
         * Extract all the properties from Dto class
         *
         * @param string $class
         *
         * @return array
         */
        protected function extractDtoProperties($class)
        {
            $properties = [];
            $reflector = new \ReflectionClass($class);
            if ($reflector->isSubclassOf(self::DTO_INTERFACE)) {
	            $properties = array_merge($properties, InjectorHelper::extractProperties($reflector, \ReflectionMethod::IS_PUBLIC));

            }

            return $properties;
        }

        /**
         * Extract return class for api endpoint
         *
         * @param string $model
         * @param string $comments
         *
         * @return string

         */
        protected function extractReturn($model, $comments = '')
        {
            $modelDto  = [];
            preg_match('/\@return\ (.*)\((.*)\)\n/i', $comments, $returnTypes);
            if (count($returnTypes)) {
                // Extract principal DTO information
                if (array_key_exists(1, $returnTypes)) {
                    $modelDto = $this->extractDtoProperties($returnTypes[1]);
                }
                if (array_key_exists(2, $returnTypes)) {
                    $subDtos = preg_split('/,?\ /', str_replace('{__API__}', $model, $returnTypes[2]));
                    if (count($subDtos)) {
                        foreach ($subDtos as $subDto) {
                            $isArray = false;
                            list($field, $dto) = explode('=', $subDto);
                            if (false !== strpos($dto, '[') && false !== strpos($dto, ']')) {
                                $dto = str_replace(']', '', str_replace('[', '', $dto));
                                $isArray = true;
                            }
                            $dto = $this->extractModelFields($dto);
                            $modelDto[$field] = ($isArray) ? [$dto] : $dto;
                        }
                    }
                }
            }

            return $modelDto;
        }

        /**
         * Extract all fields from a ActiveResource model
         *
         * @param string $namespace
         *
         * @return mixed
         */
        protected function extractModelFields($namespace)
        {
            $payload = [];
            try {
                $reflector = new \ReflectionClass($namespace);
                // Checks if reflector is a subclass of propel ActiveRecords
                if (NULL !== $reflector && $reflector->isSubclassOf(self::MODEL_INTERFACE)) {
                    $tableMap = $namespace::TABLE_MAP;
                    $fieldNames = $tableMap::getFieldNames(TableMap::TYPE_FIELDNAME);
                    if (count($fieldNames)) {
                        foreach ($fieldNames as $field) {
                            $variable = $reflector->getProperty(strtolower($field));
                            $varDoc = $variable->getDocComment();
                            $payload[$tableMap::translateFieldName($field, TableMap::TYPE_FIELDNAME, TableMap::TYPE_PHPNAME)] = $this->extractVarType($varDoc);

                        }
                    }
                } elseif (null !== $reflector && $reflector->isSubclassOf(self::DTO_INTERFACE)) {
                    $payload = $this->extractDtoProperties($namespace);
                }
            } catch (\Exception $e) {
                Logger::getInstance()->errorLog($e->getMessage());
            }

            return $payload;
        }

        /**
         * Method that extract all the needed info for each method in each API
         *
         * @param string $namespace
         * @param \ReflectionMethod $method
         * @param \ReflectionClass $reflection
         * @param string $module
         *
         * @return array

         */
        protected function extractMethodInfo($namespace, \ReflectionMethod $method, \ReflectionClass $reflection, $module)

        {
            $methodInfo = NULL;
            $docComments = $method->getDocComment();
            if (FALSE !== $docComments && preg_match('/\@route\ /i', $docComments)) {
                $api = self::extractApi($reflection->getDocComment());
                list($route, $info) = RouterHelper::extractRouteInfo($method, $api, $module);
                $route = explode('#|#', $route);
                $modelNamespace = str_replace('Api', 'Models', $namespace);
                if ($info['visible'] && !self::checkDeprecated($docComments)) {
                    try {
                        $methodInfo = [
                            'url'         => array_pop($route),
                            'method'      => $info['http'],
                            'description' => $info['label'],
                            'return'      => $this->extractReturn($modelNamespace, $docComments),
                        ];
                        if (in_array($methodInfo['method'], ['POST', 'PUT'])) {
                            $methodInfo['payload'] = $this->extractPayload($modelNamespace, $docComments);
                        }
                    } catch (\Exception $e) {
                        jpre($e->getMessage());
                        Logger::getInstance()->errorLog($e->getMessage());
                    }
                }
            }

            return $methodInfo;
        }

        /**
         * Translator from php types to swagger types
         * @param string $format
         *
         * @return array

         */
        public static function translateSwaggerFormats($format)
        {
            switch(strtolower($format)) {
                case 'bool':
                case 'boolean':
                    $swaggerType = 'boolean';
                    $swaggerFormat = '';
                    break;
                default:
                case 'string':
                case 'varchar':
                    $swaggerType = 'string';
                    $swaggerFormat = '';
                    break;
                case 'binary':
                case 'varbinary':
                    $swaggerType = 'string';
                    $swaggerFormat = 'binary';
                    break;
                case 'int':
                case 'integer':
                case 'float':
                case 'double':
                    $swaggerType = 'integer';
                    $swaggerFormat = 'int32';
                    break;
                case 'date':
                    $swaggerType = 'string';
                    $swaggerFormat = 'date';
                    break;
                case 'datetime':
                    $swaggerType = 'string';
                    $swaggerFormat = 'date-time	';
                    break;

            }
            return [$swaggerType, $swaggerFormat];
        }

        /**
         * Method that parse the definitions for the api's
         * @param array $endpoint
         *
         * @return array
         */
        public static function extractSwaggerDefinition(array $endpoint)
        {
            $definitions = [];
            if (array_key_exists('definitions', $endpoint)) {
                foreach ($endpoint['definitions'] as $dtoName => $definition) {
                    $dto = [
                        "type" => "object",
                        "properties" => [],
                    ];
                    foreach ($definition as $field => $format) {
                        if (is_array($format)) {
                            $subDtoName = preg_replace('/Dto$/', '', $dtoName);
                            $subDtoName = preg_replace('/DtoList$/', '', $subDtoName);
                            $subDto = self::extractSwaggerDefinition(['definitions' => [
                                $subDtoName => $format,
                            ]]);
                            if (array_key_exists($subDtoName, $subDto)) {
                                $definitions = $subDto;
                            } else {
                                $definitions[$subDtoName] = $subDto;
                            }
                            $dto['properties'][$field] = [
                                '$ref' => "#/definitions/" . $subDtoName,
                            ];
                        } else {
                            list($type, $format) = self::translateSwaggerFormats($format);
                            $dto['properties'][$field] = [
                                "type" => $type,
                            ];
                            if (strlen($format)) {
                               $dto['properties'][$field]['format'] = $format;
                            }
                        }
                    }
                    $definitions[$dtoName] = $dto;
                }
            }
            return $definitions;
        }

        /**
         * Method that export
         * @param array $modules
         *
         * @return array
         */
        public static function swaggerFormatter(array $modules = [])
        {
            $endpoints = [];
            pre($modules, true);
            $dtos = [];
            $formatted = [
                "swagger" => "2.0",
                "host" => Router::getInstance()->getRoute(''),
                "basePath" => "/api",
                "schemes" => ["http", "https"],
                "externalDocs" => [
                    "description" => "Principal Url",
                    "url" => Router::getInstance()->getRoute(''),
                ]
            ];
            foreach($endpoints as $model) {
                foreach ($model as $endpoint) {
                    $dtos += self::extractSwaggerDefinition($endpoint);
                }
            }
            $formatted['definitions'] = $dtos;
            return $formatted;
        }

        /**
         * Method that extract the Dto class for the api documentation
         * @param string $dto
         * @param boolean $isArray
         *
         * @return string
         */
        protected function extractDtoName($dto, $isArray = false)
        {
            $dto = explode('\\', $dto);
            $modelDto = array_pop($dto) . "Dto";
            if ($isArray) {
                $modelDto .= "List";
            }

            return $modelDto;
        }
    }


1		<?php
2		namespace PSFS\services;
3
4		use Propel\Runtime\Map\TableMap;
5		use PSFS\base\Logger;
6		use PSFS\base\Service;
7		use PSFS\base\types\helpers\InjectorHelper;
8		use PSFS\base\types\helpers\RouterHelper;
9		use Symfony\Component\Finder\Finder;
10
11		/**
12		* Class DocumentorService
13		* @package PSFS\services
14		*/
15		class DocumentorService extends Service
16		{
17		const DTO_INTERFACE = '\\PSFS\\base\\dto\\Dto';
18		const MODEL_INTERFACE = '\\Propel\\Runtime\\ActiveRecord\\ActiveRecordInterface';
19		/**
20		* @Inyectable
21		* @var \PSFS\base\Router route
22		*/
23		protected $route;
24
25		/**
26		* Method that extract all modules
27		* @return array
28		*/
29		public function getModules()
30		{
31		$modules = [];
32		$domains = $this->route->getDomains();
33		if (count($domains)) {
34		foreach ($domains as $module => $info) {
35		try {
36		$module = str_replace('/', '', str_replace('@', '', $module));
37		if (!preg_match('/^ROOT/i', $module)) {
38		$modules[] = [
39		'name' => $module,
40		'path' => realpath($info['template'] . DIRECTORY_SEPARATOR . '..'),
41		];
42		}
43		} catch (\Exception $e) {
44		$modules[] = $e->getMessage();
45		}
46		}
47		}
48
49		return $modules;
50		}
51
52		/**
53		* Method that extract all endpoints for each module
54		*
55		* @param array $module
56		*
57		* @return array
58		*/
59		public function extractApiEndpoints(array $module)
60		{
61		$module_path = $module['path'] . DIRECTORY_SEPARATOR . 'Api';
62		$module_name = $module['name'];
63		$endpoints = [];
64		if (file_exists($module_path)) {
65		$finder = new Finder();
66		$finder->files()->in($module_path)->depth(0)->name('*.php');
67		if (count($finder)) {
68		/** @var \SplFileInfo $file */
69		foreach ($finder as $file) {
70		$namespace = "\\{$module_name}\\Api\\" . str_replace('.php', '', $file->getFilename());
71		$info = $this->extractApiInfo($namespace, $module_name);
72		if(!empty($info)) {
73		$endpoints[$namespace] = $info;
74		}
75		}
76		}
77		}
78		return $endpoints;
79		}
80
81		/**
82		* Method that extract all the endpoit information by reflection
83		*
84		* @param string $namespace
85		*
86		* @return array
87		*/
88		public function extractApiInfo($namespace, $module)
89		{
90		$info = [];
91		if(class_exists($namespace)) {
92		$reflection = new \ReflectionClass($namespace);
93		foreach ($reflection->getMethods(\ReflectionMethod::IS_PUBLIC) as $method) {
94		try {
95		$mInfo = $this->extractMethodInfo($namespace, $method, $reflection, $module);
96		if (NULL !== $mInfo) {
97		$info[] = $mInfo;
98		}
99		} catch (\Exception $e) {
100		Logger::getInstance()->errorLog($e->getMessage());
101		}
102		}
103		}
104		return $info;
105		}
106
107		/**
108		* Extract route from doc comments
109		*
110		* @param string $comments
111		*
112		* @return string
113		*/
114		protected function extractRoute($comments = '')
115		{
116		$route = '';
117		preg_match('/@route\ (.*)\n/i', $comments, $route);
118
119		return $route[1];
120		}
121
122		/**
123		* Extract api from doc comments
124		*
125		* @param string $comments
126		*
127		* @return string
128		*/
129		protected function extractApi($comments = '')
130		{
131		$api = '';
132		preg_match('/@api\ (.*)\n/i', $comments, $api);
133
134		return $api[1];
135		}
136
137		/**
138		* Extract api from doc comments
139		*
140		* @param string $comments
141		*
142		* @return boolean
143		*/
144		protected function checkDeprecated($comments = '')
145		{
146		return false != preg_match('/@deprecated\n/i', $comments);
		1 ignored issue – show Bug Best Practice introduced 2017-02-11 00:35 UTC by Report Bug Copy Issue Report It seems like you are loosely comparing `preg_match('/@deprecated\\n/i', $comments)` of type `integer` to the boolean `false`. If you are specifically checking for non-zero, consider using something more explicit like `> 0` or `!== 0` instead. Loading history...
147		}
148
149		/**
150		* Extract visibility from doc comments
151		*
152		* @param string $comments
153		*
154		* @return boolean
155		*/
156		protected function extractVisibility($comments = '')
157		{
158		$visible = TRUE;
159		preg_match('/@visible\ (true\|false)\n/i', $comments, $visibility);
160		if (count($visibility)) {
161		$visible = !('false' == $visibility[1]);
162		}
163
164		return $visible;
165		}
166
167		/**
168		* Method that extract the description for the endpoint
169		*
170		* @param string $comments
171		*
172		* @return string
173		*/
174		protected function extractDescription($comments = '')
175		{
176		$description = '';
177		$docs = explode("\n", $comments);
178		if (count($docs)) {
179		foreach ($docs as &$doc) {
180	View Code Duplication	if (!preg_match('/(\\\|\@)/i', $doc) && preg_match('/\*\ /i', $doc)) {
		0 ignored issues – show Duplication introduced 2016-05-08 10:40 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
181		$doc = explode('* ', $doc);
182		$description = $doc[1];
183		}
184		}
185		}
186
187		return $description;
188		}
189
190		/**
191		* Method that extract the type of a variable
192		*
193		* @param string $comments
194		*
195		* @return string
196		*/
197		public static function extractVarType($comments = '')
198		{
199		$type = 'string';
200		preg_match('/@var\ (.) (.)\n/i', $comments, $varType);
201		if (count($varType)) {
202		$aux = trim($varType[1]);
203		$type = str_replace(' ', '', strlen($aux) > 0 ? $varType[1] : $varType[2]);
204		}
205
206		return $type;
207		}
208
209		/**
210		* Method that extract the payload for the endpoint
211		*
212		* @param string $model
213		* @param string $comments
214		*
215		* @return array
216		*/
217		protected function extractPayload($model, $comments = '')
218		{
219		$payload = [];
220		preg_match('/@payload\ (.*)\n/i', $comments, $doc);
221		if (count($doc)) {
222		$namespace = str_replace('{__API__}', $model, $doc[1]);
223		$payload = $this->extractModelFields($namespace);
224		}
225
226		return $payload;
227		}
228
229		/**
230		* Extract all the properties from Dto class
231		*
232		* @param string $class
233		*
234		* @return array
235		*/
236		protected function extractDtoProperties($class)
237		{
238		$properties = [];
239		$reflector = new \ReflectionClass($class);
240		if ($reflector->isSubclassOf(self::DTO_INTERFACE)) {
241		$properties = array_merge($properties, InjectorHelper::extractProperties($reflector, \ReflectionMethod::IS_PUBLIC));
		0 ignored issues – show Coding Style introduced 2016-12-02 22:44 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 129 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
242		}
243
244		return $properties;
245		}
246
247		/**
248		* Extract return class for api endpoint
249		*
250		* @param string $model
251		* @param string $comments
252		*
253		* @return string
		0 ignored issues – show Documentation introduced 2016-05-08 18:01 UTC by Report Bug Copy Issue Report Should the return type not be `array`? Also, consider making the array more specific, something like `array<String>`, or `String[]`. This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. If the return type contains the type array, this check recommends the use of a more specific type like `String[]` or `array<String>`. Loading history...
254		*/
255		protected function extractReturn($model, $comments = '')
256		{
257		$modelDto = [];
258		preg_match('/\@return\ (.)\((.)\)\n/i', $comments, $returnTypes);
259		if (count($returnTypes)) {
260		// Extract principal DTO information
261		if (array_key_exists(1, $returnTypes)) {
262		$modelDto = $this->extractDtoProperties($returnTypes[1]);
263		}
264		if (array_key_exists(2, $returnTypes)) {
265		$subDtos = preg_split('/,?\ /', str_replace('{__API__}', $model, $returnTypes[2]));
266		if (count($subDtos)) {
267		foreach ($subDtos as $subDto) {
268		$isArray = false;
269		list($field, $dto) = explode('=', $subDto);
270		if (false !== strpos($dto, '[') && false !== strpos($dto, ']')) {
271		$dto = str_replace(']', '', str_replace('[', '', $dto));
272		$isArray = true;
273		}
274		$dto = $this->extractModelFields($dto);
275		$modelDto[$field] = ($isArray) ? [$dto] : $dto;
276		}
277		}
278		}
279		}
280
281		return $modelDto;
282		}
283
284		/**
285		* Extract all fields from a ActiveResource model
286		*
287		* @param string $namespace
288		*
289		* @return mixed
290		*/
291		protected function extractModelFields($namespace)
292		{
293		$payload = [];
294		try {
295		$reflector = new \ReflectionClass($namespace);
296		// Checks if reflector is a subclass of propel ActiveRecords
297		if (NULL !== $reflector && $reflector->isSubclassOf(self::MODEL_INTERFACE)) {
298		$tableMap = $namespace::TABLE_MAP;
299		$fieldNames = $tableMap::getFieldNames(TableMap::TYPE_FIELDNAME);
300		if (count($fieldNames)) {
301		foreach ($fieldNames as $field) {
302		$variable = $reflector->getProperty(strtolower($field));
303		$varDoc = $variable->getDocComment();
304		$payload[$tableMap::translateFieldName($field, TableMap::TYPE_FIELDNAME, TableMap::TYPE_PHPNAME)] = $this->extractVarType($varDoc);
		0 ignored issues – show Coding Style introduced 2017-01-24 22:14 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 159 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
305		}
306		}
307		} elseif (null !== $reflector && $reflector->isSubclassOf(self::DTO_INTERFACE)) {
308		$payload = $this->extractDtoProperties($namespace);
309		}
310		} catch (\Exception $e) {
311		Logger::getInstance()->errorLog($e->getMessage());
312		}
313
314		return $payload;
315		}
316
317		/**
318		* Method that extract all the needed info for each method in each API
319		*
320		* @param string $namespace
321		* @param \ReflectionMethod $method
322		* @param \ReflectionClass $reflection
323		* @param string $module
324		*
325		* @return array
		0 ignored issues – show Documentation introduced 2017-02-11 00:35 UTC by Report Bug Copy Issue Report Should the return type not be `array\|null`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
326		*/
327		protected function extractMethodInfo($namespace, \ReflectionMethod $method, \ReflectionClass $reflection, $module)
		0 ignored issues – show Coding Style introduced 2016-05-08 10:40 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 120 characters; contains 122 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
328		{
329		$methodInfo = NULL;
330		$docComments = $method->getDocComment();
331		if (FALSE !== $docComments && preg_match('/\@route\ /i', $docComments)) {
332		$api = self::extractApi($reflection->getDocComment());
333		list($route, $info) = RouterHelper::extractRouteInfo($method, $api, $module);
334		$route = explode('#\|#', $route);
335		$modelNamespace = str_replace('Api', 'Models', $namespace);
336		if ($info['visible'] && !self::checkDeprecated($docComments)) {
337		try {
338		$methodInfo = [
339		'url' => array_pop($route),
340		'method' => $info['http'],
341		'description' => $info['label'],
342		'return' => $this->extractReturn($modelNamespace, $docComments),
343		];
344		if (in_array($methodInfo['method'], ['POST', 'PUT'])) {
345		$methodInfo['payload'] = $this->extractPayload($modelNamespace, $docComments);
346		}
347		} catch (\Exception $e) {
348		jpre($e->getMessage());
349		Logger::getInstance()->errorLog($e->getMessage());
350		}
351		}
352		}
353
354		return $methodInfo;
355		}
356
357		/**
358		* Translator from php types to swagger types
359		* @param string $format
360		*
361		* @return array
		0 ignored issues – show Documentation introduced 2016-06-25 12:03 UTC by Report Bug Copy Issue Report Consider making the return type a bit more specific; maybe use `string[]`. This check looks for the generic type `array` as a return type and suggests a more specific type. This type is inferred from the actual code. Loading history...
362		*/
363		public static function translateSwaggerFormats($format)
364		{
365		switch(strtolower($format)) {
366		case 'bool':
367		case 'boolean':
368		$swaggerType = 'boolean';
369		$swaggerFormat = '';
370		break;
371		default:
372		case 'string':
373		case 'varchar':
374		$swaggerType = 'string';
375		$swaggerFormat = '';
376		break;
377		case 'binary':
378		case 'varbinary':
379		$swaggerType = 'string';
380		$swaggerFormat = 'binary';
381		break;
382		case 'int':
383		case 'integer':
384		case 'float':
385		case 'double':
386		$swaggerType = 'integer';
387		$swaggerFormat = 'int32';
388		break;
389		case 'date':
390		$swaggerType = 'string';
391		$swaggerFormat = 'date';
392		break;
393		case 'datetime':
394		$swaggerType = 'string';
395		$swaggerFormat = 'date-time ';
396		break;
397
398		}
399		return [$swaggerType, $swaggerFormat];
400		}
401
402		/**
403		* Method that parse the definitions for the api's
404		* @param array $endpoint
405		*
406		* @return array
407		*/
408		public static function extractSwaggerDefinition(array $endpoint)
409		{
410		$definitions = [];
411		if (array_key_exists('definitions', $endpoint)) {
412		foreach ($endpoint['definitions'] as $dtoName => $definition) {
413		$dto = [
414		"type" => "object",
415		"properties" => [],
416		];
417		foreach ($definition as $field => $format) {
418		if (is_array($format)) {
419		$subDtoName = preg_replace('/Dto$/', '', $dtoName);
420		$subDtoName = preg_replace('/DtoList$/', '', $subDtoName);
421		$subDto = self::extractSwaggerDefinition(['definitions' => [
422		$subDtoName => $format,
423		]]);
424		if (array_key_exists($subDtoName, $subDto)) {
425		$definitions = $subDto;
426		} else {
427		$definitions[$subDtoName] = $subDto;
428		}
429		$dto['properties'][$field] = [
430		'$ref' => "#/definitions/" . $subDtoName,
431		];
432		} else {
433		list($type, $format) = self::translateSwaggerFormats($format);
434		$dto['properties'][$field] = [
435		"type" => $type,
436		];
437		if (strlen($format)) {
438		$dto['properties'][$field]['format'] = $format;
439		}
440		}
441		}
442		$definitions[$dtoName] = $dto;
443		}
444		}
445		return $definitions;
446		}
447
448		/**
449		* Method that export
450		* @param array $modules
451		*
452		* @return array
453		*/
454		public static function swaggerFormatter(array $modules = [])
455		{
456		$endpoints = [];
457		pre($modules, true);
458		$dtos = [];
459		$formatted = [
460		"swagger" => "2.0",
461		"host" => Router::getInstance()->getRoute(''),
462		"basePath" => "/api",
463		"schemes" => ["http", "https"],
464		"externalDocs" => [
465		"description" => "Principal Url",
466		"url" => Router::getInstance()->getRoute(''),
467		]
468		];
469		foreach($endpoints as $model) {
470		foreach ($model as $endpoint) {
471		$dtos += self::extractSwaggerDefinition($endpoint);
472		}
473		}
474		$formatted['definitions'] = $dtos;
475		return $formatted;
476		}
477
478		/**
479		* Method that extract the Dto class for the api documentation
480		* @param string $dto
481		* @param boolean $isArray
482		*
483		* @return string
484		*/
485		protected function extractDtoName($dto, $isArray = false)
486		{
487		$dto = explode('\\', $dto);
488		$modelDto = array_pop($dto) . "Dto";
489		if ($isArray) {
490		$modelDto .= "List";
491		}
492
493		return $modelDto;
494		}
495		}
496

psfs / core