DocumentorService - Code Metrics - Inspection of "Updated js dependencies" - psfs/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c957ae...7ee1b6 )

by Fran

created 2017-02-16 08:20 UTC

DocumentorService D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	483
Duplicated Lines	0.83 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes

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

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

psfs / core