GenerateDocumentation::handle() - Code Metrics - Inspection of "Make "Skipping route" message descriptive" - mpociot/laravel-apidoc-generator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c3ccef...6f6146 )

unknown

created 2020-02-04 22:40 UTC

GenerateDocumentation::handle() A

↳ Parent: GenerateDocumentation

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	29
rs	9.456
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php

namespace Mpociot\ApiDoc\Commands;

use Illuminate\Console\Command;
use Illuminate\Routing\Route;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\URL;
use Mpociot\ApiDoc\Extracting\Generator;
use Mpociot\ApiDoc\Matching\RouteMatcher\Match;
use Mpociot\ApiDoc\Matching\RouteMatcherInterface;
use Mpociot\ApiDoc\Tools\DocumentationConfig;
use Mpociot\ApiDoc\Tools\Flags;
use Mpociot\ApiDoc\Tools\Utils;
use Mpociot\ApiDoc\Writing\Writer;
use Mpociot\Reflection\DocBlock;
use ReflectionClass;
use ReflectionException;

class GenerateDocumentation extends Command
{
    /**
     * The name and signature of the console command.
     *
     * @var string
     */
    protected $signature = 'apidoc:generate
                            {--force : Force rewriting of existing routes}
    ';

    /**
     * The console command description.
     *
     * @var string
     */
    protected $description = 'Generate your API documentation from existing Laravel routes.';

    /**
     * @var DocumentationConfig
     */
    private $docConfig;

    /**
     * @var string
     */
    private $baseUrl;

    /**
     * Execute the console command.
     *
     * @param RouteMatcherInterface $routeMatcher
     *
     * @return void
     */
    public function handle(RouteMatcherInterface $routeMatcher)
    {
        // Using a global static variable here, so fuck off if you don't like it.
        // Also, the --verbose option is included with all Artisan commands.
        Flags::$shouldBeVerbose = $this->option('verbose');

        $this->docConfig = new DocumentationConfig(config('apidoc'));
        $this->baseUrl = $this->docConfig->get('base_url') ?? config('app.url');

        URL::forceRootUrl($this->baseUrl);

        $routes = $routeMatcher->getRoutes($this->docConfig->get('routes'), $this->docConfig->get('router'));

        $generator = new Generator($this->docConfig);
        $parsedRoutes = $this->processRoutes($generator, $routes);

        $groupedRoutes = collect($parsedRoutes)
            ->groupBy('metadata.groupName')
            ->sortBy(static function ($group) {
                /* @var $group Collection */
                return $group->first()['metadata']['groupName'];
            }, SORT_NATURAL);
        $writer = new Writer(
            $this,
            $this->docConfig,
            $this->option('force')
        );
        $writer->writeDocs($groupedRoutes);
    }

    /**
     * @param \Mpociot\ApiDoc\Extracting\Generator $generator
     * @param Match[] $routes
     *
     * @throws \ReflectionException
     *
     * @return array
     */
    private function processRoutes(Generator $generator, array $routes)
    {
        $parsedRoutes = [];
        foreach ($routes as $routeItem) {
            $route = $routeItem->getRoute();
            /** @var Route $route */
            $messageFormat = '%s route: [%s] %s';
            $routeMethods = implode(',', $generator->getMethods($route));
            $routePath = $generator->getUri($route);

            if ($this->isClosureRoute($route->getAction())) {
                $this->warn(sprintf($messageFormat, 'Skipping', $routeMethods, $routePath).': Closure routes are not supported.');
                continue;
            }

            $routeControllerAndMethod = Utils::getRouteClassAndMethodNames($route->getAction());
            if (! $this->isValidRoute($routeControllerAndMethod)) {
                $this->warn(sprintf($messageFormat, 'Skipping invalid', $routeMethods, $routePath));
                continue;
            }

            if (! $this->doesControllerMethodExist($routeControllerAndMethod)) {
                $this->warn(sprintf($messageFormat, 'Skipping', $routeMethods, $routePath).': Controller method does not exist.');
                continue;
            }

            if (! $this->isRouteVisibleForDocumentation($routeControllerAndMethod)) {
                $this->warn(sprintf($messageFormat, 'Skipping', $routeMethods, $routePath).': @hideFromAPIDocumentation was specified.');
                continue;
            }

            try {
                $parsedRoutes[] = $generator->processRoute($route, $routeItem->getRules());
                $this->info(sprintf($messageFormat, 'Processed', $routeMethods, $routePath));
            } catch (\Exception $exception) {
                $this->warn(sprintf($messageFormat, 'Skipping', $routeMethods, $routePath).'- Exception '.get_class($exception).' encountered : '.$exception->getMessage());
            }
        }

        return $parsedRoutes;
    }

    /**
     * @param array $routeControllerAndMethod
     *
     * @return bool
     */
    private function isValidRoute(array $routeControllerAndMethod = null)
    {;
        if (is_array($routeControllerAndMethod)) {
            $routeControllerAndMethod = implode('@', $routeControllerAndMethod);
        }

        return ! is_callable($routeControllerAndMethod) && ! is_null($routeControllerAndMethod);
    }

    /**
     * @param array $routeAction
     *
     * @return bool
     */
    private function isClosureRoute(array $routeAction)
    {
        return $routeAction['uses'] instanceof \Closure;
    }

    /**
     *
     * @param array $routeControllerAndMethod
     *
     * @throws ReflectionException
     *
     * @return bool
     */
    private function doesControllerMethodExist(array $routeControllerAndMethod)
    {
        [$class, $method] = $routeControllerAndMethod;

        $reflection = new ReflectionClass($class);

        if (! $reflection->hasMethod($method)) {

            return false;
        }

        return true;
    }

    /**
     * @param array $routeControllerAndMethod
     *
     * @throws ReflectionException
     *
     * @return bool
     */
    private function isRouteVisibleForDocumentation(array $routeControllerAndMethod)
    {
        [$class, $method] = $routeControllerAndMethod;

        $reflection = new ReflectionClass($class);

        $comment = $reflection->getMethod($method)->getDocComment();


        if ($comment) {
            $phpdoc = new DocBlock($comment);

            return collect($phpdoc->getTags())
                ->filter(function ($tag) {
                    return $tag->getName() === 'hideFromAPIDocumentation';
                })
                ->isEmpty();
        }

        return true;
    }
}


1			<?php
2
3			namespace Mpociot\ApiDoc\Commands;
4
5			use Illuminate\Console\Command;
6			use Illuminate\Routing\Route;
7			use Illuminate\Support\Collection;
8			use Illuminate\Support\Facades\URL;
9			use Mpociot\ApiDoc\Extracting\Generator;
10			use Mpociot\ApiDoc\Matching\RouteMatcher\Match;
11			use Mpociot\ApiDoc\Matching\RouteMatcherInterface;
12			use Mpociot\ApiDoc\Tools\DocumentationConfig;
13			use Mpociot\ApiDoc\Tools\Flags;
14			use Mpociot\ApiDoc\Tools\Utils;
15			use Mpociot\ApiDoc\Writing\Writer;
16			use Mpociot\Reflection\DocBlock;
17			use ReflectionClass;
18			use ReflectionException;
19
20			class GenerateDocumentation extends Command
21			{
22			/**
23			* The name and signature of the console command.
24			*
25			* @var string
26			*/
27			protected $signature = 'apidoc:generate
28			{--force : Force rewriting of existing routes}
29			';
30
31			/**
32			* The console command description.
33			*
34			* @var string
35			*/
36			protected $description = 'Generate your API documentation from existing Laravel routes.';
37
38			/**
39			* @var DocumentationConfig
40			*/
41			private $docConfig;
42
43			/**
44			* @var string
45			*/
46			private $baseUrl;
47
48			/**
49			* Execute the console command.
50			*
51			* @param RouteMatcherInterface $routeMatcher
52			*
53			* @return void
54			*/
55			public function handle(RouteMatcherInterface $routeMatcher)
56			{
57			// Using a global static variable here, so fuck off if you don't like it.
58			// Also, the --verbose option is included with all Artisan commands.
59			Flags::$shouldBeVerbose = $this->option('verbose');
60
61			$this->docConfig = new DocumentationConfig(config('apidoc'));
62			$this->baseUrl = $this->docConfig->get('base_url') ?? config('app.url');
63
64			URL::forceRootUrl($this->baseUrl);
65
66			$routes = $routeMatcher->getRoutes($this->docConfig->get('routes'), $this->docConfig->get('router'));
67
68			$generator = new Generator($this->docConfig);
69			$parsedRoutes = $this->processRoutes($generator, $routes);
70
71			$groupedRoutes = collect($parsedRoutes)
72			->groupBy('metadata.groupName')
73			->sortBy(static function ($group) {
74			/* @var $group Collection */
75			return $group->first()['metadata']['groupName'];
76			}, SORT_NATURAL);
77			$writer = new Writer(
78			$this,
79			$this->docConfig,
80			$this->option('force')
81			);
82			$writer->writeDocs($groupedRoutes);
83			}
84
85			/**
86			* @param \Mpociot\ApiDoc\Extracting\Generator $generator
87			* @param Match[] $routes
88			*
89			* @throws \ReflectionException
90			*
91			* @return array
92			*/
93			private function processRoutes(Generator $generator, array $routes)
94			{
95			$parsedRoutes = [];
96			foreach ($routes as $routeItem) {
97			$route = $routeItem->getRoute();
98			/** @var Route $route */
99			$messageFormat = '%s route: [%s] %s';
100			$routeMethods = implode(',', $generator->getMethods($route));
101			$routePath = $generator->getUri($route);
102
103			if ($this->isClosureRoute($route->getAction())) {
104			$this->warn(sprintf($messageFormat, 'Skipping', $routeMethods, $routePath).': Closure routes are not supported.');
105			continue;
106			}
107
108			$routeControllerAndMethod = Utils::getRouteClassAndMethodNames($route->getAction());
109			if (! $this->isValidRoute($routeControllerAndMethod)) {
110			$this->warn(sprintf($messageFormat, 'Skipping invalid', $routeMethods, $routePath));
111			continue;
112			}
113
114			if (! $this->doesControllerMethodExist($routeControllerAndMethod)) {
115			$this->warn(sprintf($messageFormat, 'Skipping', $routeMethods, $routePath).': Controller method does not exist.');
116			continue;
117			}
118
119			if (! $this->isRouteVisibleForDocumentation($routeControllerAndMethod)) {
120			$this->warn(sprintf($messageFormat, 'Skipping', $routeMethods, $routePath).': @hideFromAPIDocumentation was specified.');
121			continue;
122			}
123
124			try {
125			$parsedRoutes[] = $generator->processRoute($route, $routeItem->getRules());
126			$this->info(sprintf($messageFormat, 'Processed', $routeMethods, $routePath));
127			} catch (\Exception $exception) {
128			$this->warn(sprintf($messageFormat, 'Skipping', $routeMethods, $routePath).'- Exception '.get_class($exception).' encountered : '.$exception->getMessage());
129			}
130			}
131
132			return $parsedRoutes;
133			}
134
135			/**
136			* @param array $routeControllerAndMethod
137			*
138			* @return bool
139			*/
140			private function isValidRoute(array $routeControllerAndMethod = null)
141			{;
142			if (is_array($routeControllerAndMethod)) {
143			$routeControllerAndMethod = implode('@', $routeControllerAndMethod);
144			}
145
146			return ! is_callable($routeControllerAndMethod) && ! is_null($routeControllerAndMethod);
147			}
148
149			/**
150			* @param array $routeAction
151			*
152			* @return bool
153			*/
154			private function isClosureRoute(array $routeAction)
155			{
156			return $routeAction['uses'] instanceof \Closure;
157			}
158
159			/**
160			*
161			* @param array $routeControllerAndMethod
162			*
163			* @throws ReflectionException
164			*
165			* @return bool
166			*/
167			private function doesControllerMethodExist(array $routeControllerAndMethod)
168			{
169			[$class, $method] = $routeControllerAndMethod;
			0 ignored issues – show Bug introduced 2020-02-04 22:41 UTC by Report Bug Copy Issue Report The variable `$class` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2020-02-04 22:41 UTC by Report Bug Copy Issue Report The variable `$method` does not exist. Did you mean `$routeControllerAndMethod`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
170			$reflection = new ReflectionClass($class);
171
172			if (! $reflection->hasMethod($method)) {
			0 ignored issues – show Bug introduced 2020-02-04 22:41 UTC by Report Bug Copy Issue Report The variable `$method` does not exist. Did you mean `$routeControllerAndMethod`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
173			return false;
174			}
175
176			return true;
177			}
178
179			/**
180			* @param array $routeControllerAndMethod
181			*
182			* @throws ReflectionException
183			*
184			* @return bool
185			*/
186			private function isRouteVisibleForDocumentation(array $routeControllerAndMethod)
187			{
188			[$class, $method] = $routeControllerAndMethod;
			0 ignored issues – show Bug introduced 2020-02-04 22:41 UTC by Report Bug Copy Issue Report The variable `$class` does not exist. Did you forget to declare it? This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug. Loading history... Bug introduced 2020-02-04 22:41 UTC by Report Bug Copy Issue Report The variable `$method` does not exist. Did you mean `$routeControllerAndMethod`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
189			$reflection = new ReflectionClass($class);
190
191			$comment = $reflection->getMethod($method)->getDocComment();
			0 ignored issues – show Bug introduced 2020-02-04 22:41 UTC by Report Bug Copy Issue Report The variable `$method` does not exist. Did you mean `$routeControllerAndMethod`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
192
193			if ($comment) {
194			$phpdoc = new DocBlock($comment);
195
196			return collect($phpdoc->getTags())
197			->filter(function ($tag) {
198			return $tag->getName() === 'hideFromAPIDocumentation';
199			})
200			->isEmpty();
201			}
202
203			return true;
204			}
205			}
206

mpociot / laravel-apidoc-generator

Push — master ( c3ccef...6f6146 )

GenerateDocumentation::handle() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like