PathParameterParser::getDefaultValue() - Code Metrics - Inspection of "Scrutinizer config, @default tag" - autaut03/laravel-api-docs-generator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( f1daf3...8fd0f0 )

by Alex

created 2017-12-31 01:23 UTC

PathParameterParser::getDefaultValue() A

↳ Parent: PathParameterParser

Complexity

Conditions	4
Paths	3

Size

Total Lines	13
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	13
rs	9.2
c	0
b	0
f	0
cc	4
eloc	6
nc	3
nop	0

<?php

namespace AlexWells\ApiDocsGenerator\Parser;

use AlexWells\ApiDocsGenerator\Exceptions\NoTypeSpecifiedException;
use Illuminate\Database\Eloquent\Model;
use ReflectionParameter;

class PathParameterParser
{
    /**
     * Path parameter name.
     *
     * @var string
     */
    protected $name;

    /**
     * Should method parameters without type throw an exception.
     *
     * @var bool
     */
    protected $typeChecksEnabled;

    /**
     * A route wrapper object.
     *
     * @var RouteWrapper
     */
    protected $route;

    /**
     * Parsed parameter reflection.
     *
     * @var
     */
    protected $parameterReflection;

    /**
     * PathParameterParser constructor.
     * @param RouteWrapper $route
     */
    public function __construct($name, $typeChecksEnabled, RouteWrapper $route)
    {
        $this->name = $name;
        $this->typeChecksEnabled = $typeChecksEnabled;
        $this->route = $route;
    }

    /**
     * Parse parameter
     *
     * @return array
     */
    public function parse()
    {
        return [
            'name' => $this->getName(),
            'required' => $this->isRequired(),
            'type' => $this->getType(),
            'default' => $this->getDefaultValue(),
            'regex' => $this->getRegex(),
            'description' => $this->getDescription()
        ];
    }

    public function getName()
    {
        return rtrim($this->name, '?');
    }

    /**
     * Checks if the parameter is required.
     *
     * @return bool
     */
    public function isRequired()
    {
        return ! ends_with($this->name, '?');
    }

    /**
     * Returns parameter's type.
     * @return string
     * @throws NoTypeSpecifiedException
     */
    public function getType()
    {
        if(! ($reflection = $this->getParameterReflection())) {
            return null;
        }

        if(! ($parameterType = $reflection->getType())) {
            if($this->typeChecksEnabled) {
                throw new NoTypeSpecifiedException("No type specified for parameter " . $this->getName());
            }

            return null;
        }

        if ($parameterType->isBuiltin()) {
            return strval($parameterType);
        }

        if (! ($parameterClass = $reflection->getClass())) {
            return null;
        }

        $type = $parameterClass->getShortName();

        if ($parameterClass->isSubclassOf(Model::class)) {
            //if (empty($description)) {
            //    $description = "`$type` id"; // TODO
            //}
            $type = 'model_id';
        }

        return $type;
    }

    /**
     * Returns parameter's default value.
     *
     * @return mixed
     */
    public function getDefaultValue()
    {
        $default = $this->route->getDefaultTagsParser()->get('path', $this->getName());

        if(!is_null($default)) {
            return $default;
        }

        if(! ($reflection = $this->getParameterReflection()) || ! $reflection->isDefaultValueAvailable()) {
            return null;
        }

        return strval($reflection->getDefaultValue());
    }

    /**
     * Returns parameter's regex pattern (from ->where() calls).
     *
     * @return string|null
     */
    public function getRegex()
    {
        return $this->route->getOriginalRoute()->wheres[$this->getName()] ?? null;
    }

    /**
     * Returns parameter's description.
     *
     * @return string
     */
    public function getDescription()
    {
        return $this->route->getDescribeTagsParser()->get('path', $this->getName());

    }

    /**
     * Returns parameter's reflection.
     *
     * @return ReflectionParameter
     */
    protected function getParameterReflection()
    {
        if (! $this->parameterReflection) {
            return $this->parameterReflection = $this->route->getMethodParameterByName($this->getName());
        }

        return $this->parameterReflection;
    }
}

1			<?php
2
3			namespace AlexWells\ApiDocsGenerator\Parser;
4
5			use AlexWells\ApiDocsGenerator\Exceptions\NoTypeSpecifiedException;
6			use Illuminate\Database\Eloquent\Model;
7			use ReflectionParameter;
8
9			class PathParameterParser
10			{
11			/**
12			* Path parameter name.
13			*
14			* @var string
15			*/
16			protected $name;
17
18			/**
19			* Should method parameters without type throw an exception.
20			*
21			* @var bool
22			*/
23			protected $typeChecksEnabled;
24
25			/**
26			* A route wrapper object.
27			*
28			* @var RouteWrapper
29			*/
30			protected $route;
31
32			/**
33			* Parsed parameter reflection.
34			*
35			* @var
36			*/
37			protected $parameterReflection;
38
39			/**
40			* PathParameterParser constructor.
41			* @param RouteWrapper $route
42			*/
43			public function __construct($name, $typeChecksEnabled, RouteWrapper $route)
44			{
45			$this->name = $name;
46			$this->typeChecksEnabled = $typeChecksEnabled;
47			$this->route = $route;
48			}
49
50			/**
51			* Parse parameter
52			*
53			* @return array
54			*/
55			public function parse()
56			{
57			return [
58			'name' => $this->getName(),
59			'required' => $this->isRequired(),
60			'type' => $this->getType(),
61			'default' => $this->getDefaultValue(),
62			'regex' => $this->getRegex(),
63			'description' => $this->getDescription()
64			];
65			}
66
67			public function getName()
68			{
69			return rtrim($this->name, '?');
70			}
71
72			/**
73			* Checks if the parameter is required.
74			*
75			* @return bool
76			*/
77			public function isRequired()
78			{
79			return ! ends_with($this->name, '?');
80			}
81
82			/**
83			* Returns parameter's type.
84			* @return string
85			* @throws NoTypeSpecifiedException
86			*/
87			public function getType()
88			{
89			if(! ($reflection = $this->getParameterReflection())) {
90			return null;
91			}
92
93			if(! ($parameterType = $reflection->getType())) {
94			if($this->typeChecksEnabled) {
95			throw new NoTypeSpecifiedException("No type specified for parameter " . $this->getName());
96			}
97
98			return null;
99			}
100
101			if ($parameterType->isBuiltin()) {
102			return strval($parameterType);
103			}
104
105			if (! ($parameterClass = $reflection->getClass())) {
106			return null;
107			}
108
109			$type = $parameterClass->getShortName();
110
111			if ($parameterClass->isSubclassOf(Model::class)) {
112			//if (empty($description)) {
113			// $description = "`$type` id"; // TODO
114			//}
115			$type = 'model_id';
116			}
117
118			return $type;
119			}
120
121			/**
122			* Returns parameter's default value.
123			*
124			* @return mixed
125			*/
126			public function getDefaultValue()
127			{
128			$default = $this->route->getDefaultTagsParser()->get('path', $this->getName());
129
130			if(!is_null($default)) {
131			return $default;
132			}
133
134			if(! ($reflection = $this->getParameterReflection()) \|\| ! $reflection->isDefaultValueAvailable()) {
135			return null;
136			}
137
138			return strval($reflection->getDefaultValue());
139			}
140
141			/**
142			* Returns parameter's regex pattern (from ->where() calls).
143			*
144			* @return string\|null
145			*/
146			public function getRegex()
147			{
148			return $this->route->getOriginalRoute()->wheres[$this->getName()] ?? null;
149			}
150
151			/**
152			* Returns parameter's description.
153			*
154			* @return string
155			*/
156			public function getDescription()
157			{
158			return $this->route->getDescribeTagsParser()->get('path', $this->getName());
			1 ignored issue – show Bug Best Practice introduced 2017-12-31 01:26 UTC by Report Bug Copy Issue Report The expression `return $this->route->get...ath', $this->getName())` also could return the type `array` which is incompatible with the documented return type `string`. Loading history...
159			}
160
161			/**
162			* Returns parameter's reflection.
163			*
164			* @return ReflectionParameter
165			*/
166			protected function getParameterReflection()
167			{
168			if (! $this->parameterReflection) {
169			return $this->parameterReflection = $this->route->getMethodParameterByName($this->getName());
170			}
171
172			return $this->parameterReflection;
173			}
174			}

autaut03 / laravel-api-docs-generator

Push — master ( f1daf3...8fd0f0 )

PathParameterParser::getDefaultValue() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like