DocumentorService - Code Metrics - Inspection of "HTML Documentation for API" - psfs/core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( daf0f3...03b505 )

by Fran

created 2016-06-25 11:53 UTC

DocumentorService D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	471
Duplicated Lines	2.55 %

Coupling/Cohesion

Components	2
Dependencies	4

Importance

Changes	5
Bugs	0	Features	0

Metric	Value
dl	12
loc	471
rs	4.8717
c	5
b	0
f	0
wmc	81
lcom	2
cbo	4

17 Methods

Rating	Name	Duplication	Size	Complexity
B	getModules()	0	18	5
A	extractApiEndpoints()	0	18	4
B	extractApiInfo()	0	21	5
A	extractRoute()	0	7	1
A	extractMethod()	0	7	1
A	extractVisibility()	0	10	2
B	extractDescription()	4	15	5
A	extractVarType()	0	11	3
A	extractPayload()	0	11	2
A	extractDtoProperties()	8	17	4
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 PSFS\base\Logger;
    use PSFS\base\Service;
    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 (array_keys($domains) as $domain) {
                    try {
                        if (!preg_match('/^\@ROOT/i', $domain)) {
                            $modules[] = str_replace('/', '', str_replace('@', '', $domain));
                        }
                    } catch (\Exception $e) {
                        $modules[] = $e->getMessage();
                    }
                }
            }

            return $modules;
        }

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

            return $endpoints;
        }

        /**
         * Method that extract all the endpoit information by reflection
         *
         * @param string $namespace
         *
         * @return array
         */
        public function extractApiInfo($namespace)
        {
            $info = [];
            $reflection = new \ReflectionClass($namespace);
            $publicMethods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC);
            if (count($publicMethods)) {
                /** @var \ReflectionMethod $method */
                foreach ($publicMethods as $method) {
                    try {
                        $mInfo = $this->extractMethodInfo($namespace, $method, $reflection);
                        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 method from doc comments
         *
         * @param string $comments
         *
         * @return string
         */
        protected function extractMethod($comments = '')
        {
            $method = 'GET';
            preg_match('/@(get|post|put|delete)\n/i', $comments, $method);

            return strtoupper($method[1]);
        }

        /**
         * 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
         */
        protected 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)) {
                foreach ($reflector->getProperties(\ReflectionMethod::IS_PUBLIC) as $property) {

                    $type = $this->extractVarType($property->getDocComment());
                    if(class_exists($type)) {
                        $properties[$property->getName()] = $this->extractModelFields($type);
                    } else {
                        $properties[$property->getName()] = $type;
                    }
                }
            }

            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();
                    if (count($fieldNames)) {
                        foreach ($fieldNames as $field) {
                            $variable = $reflector->getProperty(strtolower($field));
                            $varDoc = $variable->getDocComment();
                            $payload[$field] = $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
         *
         * @return array

         */
        protected function extractMethodInfo($namespace, \ReflectionMethod $method, \ReflectionClass $reflection)
        {
            $methodInfo = NULL;
            $docComments = $method->getDocComment();
            $shortName = $reflection->getShortName();
            $modelNamespace = str_replace('Api', 'Models', $namespace);
            if (FALSE !== $docComments && preg_match('/\@route\ /i', $docComments)) {
                $visibility = $this->extractVisibility($docComments);
                $route = str_replace('{__API__}', $shortName, $this->extractRoute($docComments));
                if ($visibility && preg_match('/^\/api\//i', $route)) {
                    try {
                        $methodInfo = [
                            'url'         => $route,
                            'method'      => $this->extractMethod($docComments),
                            'description' => str_replace('{__API__}', $shortName, $this->extractDescription($docComments)),

                            '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':
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

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

psfs / core