Mpociot\ApiDoc\Generators\LaravelGenerator

Complexity

Total Complexity

55

Size/Duplication

Total Lines	350
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	11

Importance

Changes	9
Bugs	3	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	getUri()	0	8	2
A	getMethods()	0	8	2
A	prepareMiddleware()	0	4	1
A	callRoute()	0	21	2
B	getRouteRules()	0	29	6
C	processRoute()	0	63	11
F	getTransformerResponse()	0	86	21
B	getResponseClassResponse()	0	23	5
A	getDataTag()	0	17	3
A	getDataResponse()	0	6	2

<?php

namespace Mpociot\ApiDoc\Generators;

use ReflectionClass;
use League\Fractal\Manager;
use Illuminate\Routing\Route;
use League\Fractal\Resource\Item;
use Illuminate\Support\Facades\App;
use Illuminate\Support\Facades\Request;
use League\Fractal\Resource\Collection;
use Illuminate\Foundation\Http\FormRequest;

class LaravelGenerator extends AbstractGenerator
{
    /**
     * @param  \Illuminate\Routing\Route $route
     * @param array $bindings
     * @param array $headers
     * @param bool $withResponse
     *
     * @return array
     */
    public function processRoute($route, $bindings = [], $headers = [], $withResponse = true)
    {
        $content = '';

        $routeAction = $route->getAction();
        $routeGroup = $this->getRouteGroup($routeAction['uses']);
        $routeDescription = $this->getRouteDescription($routeAction['uses']);
        $showresponse = null;

        if ($withResponse) {
            $response = null;
            $docblockResponse = $this->getDocblockResponse($routeDescription['tags']);
            if ($docblockResponse) {
                // we have a response from the docblock ( @response )
                $response = $docblockResponse;
                $showresponse = true;
            }
            if (! $response) {
                $transformerResponse = $this->getTransformerResponse($routeDescription['tags']);
                if ($transformerResponse) {
                    // we have a transformer response from the docblock ( @transformer || @transformercollection )
                    $response = $transformerResponse;
                    $showresponse = true;
                }
            }
            if (! $response) {
                $responseClassResponse = $this->getResponseClassResponse($routeDescription['tags']);
                if ($responseClassResponse) {
                    // we have a class response from the docblock ( @responseClass )
                    $response = $responseClassResponse;
                    $showresponse = true;
                }
            }
            if (! $response) {
                $dataResponse = $this->getDataResponse($routeDescription['tags']);
                if ($dataResponse) {
                    // we have a data response from the docblock ( @data )
                    $response = $dataResponse;
                    $showresponse = true;
                }
            }
            if (! $response) {
                $response = $this->getRouteResponse($route, $bindings, $headers);
            }
            if ($response->headers->get('Content-Type') === 'application/json') {
                $content = json_encode(json_decode($response->getContent()), JSON_PRETTY_PRINT);
            } else {
                $content = $response->getContent();
            }
        }

        return $this->getParameters([
            'id' => md5($this->getUri($route).':'.implode($this->getMethods($route))),
            'resource' => $routeGroup,
            'title' => $routeDescription['short'],
            'description' => $routeDescription['long'],
            'methods' => $this->getMethods($route),
            'uri' => $this->getUri($route),
            'parameters' => [],
            'response' => $content,
            'showresponse' => $showresponse,
        ], $routeAction, $bindings);
    }

    /**
     * Get a response from the transformer tags.
     *
     * @param array $tags
     *
     * @return mixed
     */
    protected function getTransformerResponse($tags)
    {
        try {
            $transFormerTag = $this->getFirstTagFromDocblock($tags, ['transformer', 'transformercollection']);

            if (empty($transFormerTag) || count($transFormerTag) == 0) {
                // we didn't have any of the tags so goodbye
                return false;
            }

            $modelTag = $this->getFirstTagFromDocblock($tags, ['transformermodel']);
            $transformer = $transFormerTag->getContent();
            if (! \class_exists($transformer)) {
                // if we can't find the transformer we can't generate a response
                return;
            }
            $demoData = [];

            $reflection = new ReflectionClass($transformer);
            $method = $reflection->getMethod('transform');
            $parameter = \array_first($method->getParameters());
            $type = null;
            if ($modelTag) {
                $type = $modelTag->getContent();
            }
            if (version_compare(PHP_VERSION, '7.0.0') >= 0 && \is_null($type)) {
                // we can only get the type with reflection for PHP 7
                if ($parameter->hasType() && ! $parameter->getType()->isBuiltin() && \class_exists((string) $parameter->getType())) {
                    //we have a type
                    $type = (string) $parameter->getType();
                }
            }

            // if we have modelTag
            if ($type) {

The expression $type of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

                // we have a class so we try to create an instance
                $demoData = new $type;
                try {
                    // try a factory
                    $demoData = \factory($type)->make();
                } catch (\Exception $e) {
                    if ($demoData instanceof \Illuminate\Database\Eloquent\Model) {
                        // we can't use a factory but can try to get one from the database
                        try {
                            // check if we can find one
                            $newDemoData = $type::first();
                            if ($newDemoData) {
                                $demoData = $newDemoData;
                            }
                        } catch (\Exception $e) {
                            // do nothing
                        }
                    }
                }
            } else {
                // or try get data use ( @data ) tag
                $demoData = $this->getDataTag($tags);
            }

            $serializerTags = $this->getFirstTagFromDocblock($tags, 'serializer');

            if (is_object($serializerTags)) {
                $serializer = $serializerTags->getContent();
            }

            $fractal = new Manager();
            $resource = [];
            // allow use custom serializer
            if (! empty($serializer) && class_exists($serializer)) {
                $fractal->setSerializer(new $serializer());
            }
            if ($transFormerTag->getName() == 'transformer') {
                // just one
                $resource = new Item($demoData, new $transformer);
            }
            if ($transFormerTag->getName() == 'transformercollection') {
                // a collection
                $resource = new Collection([$demoData, $demoData], new $transformer);
            }

            return \response($fractal->createData($resource)->toJson());

It seems like $resource defined by array() on line 161 can also be of type array; however, League\Fractal\Manager::createData() does only seem to accept object<League\Fractal\Resource\ResourceInterface>, maybe add an additional type check?

        } catch (\Exception $e) {
            // it isn't possible to parse the transformer
            return;
        }
    }

    /**
     * Get response content use responseclass tag.
     *
     * @param $tags
     *
     * @return bool|void
     */
    protected function getResponseClassResponse($tags)
    {
        try {
            $responseClassTag = $this->getFirstTagFromDocblock($tags, ['responseclass']);

            if (empty($responseClassTag) || count($responseClassTag) == 0) {
                // we didn't have any of the tags so goodbye
                return false;
            }

            $responseClass = $responseClassTag->getContent();
            if (! \class_exists($responseClass)) {
                // if we can't find the response class we can't generate a response
                return;
            }

            $demoData = new $responseClass($this->getDataTag($tags, null));

null is of type null, but the function expects a array.

            return \response($demoData);

$demoData is of type object, but the function expects a string.

        } catch (\Exception $exception) {
            return;
        }
    }

    /**
     * @param Route $route
     *
     * @return mixed
     */
    public function getUri($route)
    {
        if (version_compare(app()->version(), '5.4', '<')) {
            return $route->getUri();

The method getUri() does not seem to exist on object<Illuminate\Routing\Route>.

        }

        return $route->uri();
    }

    /**
     * @param Route $route
     *
     * @return mixed
     */
    public function getMethods($route)
    {
        if (version_compare(app()->version(), '5.4', '<')) {
            return $route->getMethods();

The method getMethods() does not exist on Illuminate\Routing\Route. Did you maybe mean methods()?

        }

        return $route->methods();
    }

    /**
     * Prepares / Disables route middlewares.
     *
     * @param  bool $disable
     *
     * @return  void
     */
    public function prepareMiddleware($disable = true)
    {
        App::instance('middleware.disable', true);

The method instance() does not exist on Illuminate\Support\Facades\App. Did you maybe mean clearResolvedInstance()?

    }

    /**
     * Call the given URI and return the Response.
     *
     * @param  string $method
     * @param  string $uri
     * @param  array $parameters
     * @param  array $cookies
     * @param  array $files
     * @param  array $server
     * @param  string $content
     *
     * @return \Illuminate\Http\Response
     */
    public function callRoute($method, $uri, $parameters = [], $cookies = [], $files = [], $server = [], $content = null)
    {
        $server = collect([
            'CONTENT_TYPE' => 'application/json',
            'Accept' => 'application/json',
        ])->merge($server)->toArray();

        $request = Request::create($uri, $method, $parameters, $cookies, $files, $this->transformHeadersToServerVars($server), $content);

The method create() does not exist on Illuminate\Support\Facades\Request. Did you maybe mean createFreshMockInstance()?

        $kernel = App::make('Illuminate\Contracts\Http\Kernel');
        $response = $kernel->handle($request);

        $kernel->terminate($request, $response);

        if (file_exists($file = App::bootstrapPath().'/app.php')) {
            $app = require $file;
            $app->make('Illuminate\Contracts\Console\Kernel')->bootstrap();
        }

        return $response;
    }

    /**
     * @param  string $route
     * @param  array $bindings
     *
     * @return array
     */
    protected function getRouteRules($route, $bindings)
    {
        list($class, $method) = explode('@', $route);
        $reflection = new ReflectionClass($class);
        $reflectionMethod = $reflection->getMethod($method);

        foreach ($reflectionMethod->getParameters() as $parameter) {
            $parameterType = $parameter->getClass();
            if (! is_null($parameterType) && class_exists($parameterType->name)) {
                $className = $parameterType->name;

                if (is_subclass_of($className, FormRequest::class)) {

Due to PHP Bug #53727, is_subclass_of might return inconsistent results on some PHP versions if \Illuminate\Foundation\Http\FormRequest::class can be an interface. If so, you could instead use ReflectionClass::implementsInterface.

                    $parameterReflection = new $className;
                    $parameterReflection->setContainer(app());
                    // Add route parameter bindings
                    $parameterReflection->query->add($bindings);
                    $parameterReflection->request->add($bindings);

                    if (method_exists($parameterReflection, 'validator')) {
                        return app()->call([$parameterReflection, 'validator'])->getRules();
                    } else {
                        return app()->call([$parameterReflection, 'rules']);
                    }
                }
            }
        }

        return [];
    }

    /**
     * Get Custom Data from data tag.
     *
     * @param $tags
     * @param array $default
     *
     * @return array|null
     */
    protected function getDataTag($tags, $default = [])
    {
        $additionData = $this->getFirstTagFromDocblock($tags, 'data');

        if (empty($additionData) || count($additionData) == 0) {
            // we didn't have any of the tags so goodbye
            return $default;
        }

        $additionData = explode(',', $additionData->getContent());

        $additionData = array_column(array_map(function ($v) {
            return explode('|', $v);
        }, $additionData), 1, 0);

        return $additionData;
    }

    /**
     * Get Response use @data tag.
     *
     * @param $tags
     *
     * @return bool|\Illuminate\Contracts\Routing\ResponseFactory|\Symfony\Component\HttpFoundation\Response
     */
    protected function getDataResponse($tags)
    {
        $data = $this->getDataTag($tags, false);

false is of type boolean, but the function expects a array.

        return $data ? \response($data) : false;

$data is of type array, but the function expects a string.

    }
}