Parameters::hasPathSchema() - Code Metrics - Inspection of "feat: validate path parameters" - eleven-labs/api-validator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 14fe81...675c2f )

by Guillem

created 2018-11-13 18:05 UTC

Parameters::hasPathSchema() A

↳ Parent: Parameters

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0
ccs	0
cts	2
cp	0
crap	2

<?php
namespace ElevenLabs\Api\Definition;

class Parameters implements \Serializable, \IteratorAggregate
{
    /**
     * @var Parameter[]
     */
    private $parameters;

    public function __construct(array $parameters)
    {
        $this->parameters = [];
        foreach ($parameters as $parameter) {
            $this->addParameter($parameter);
        }
    }

    public function getIterator()
    {
        return new \ArrayIterator($this->parameters);
    }

    public function hasBodySchema()
    {
        $body = $this->getBody();

        return ($body !== null && $body->hasSchema());
    }

    /**
     * JSON Schema for the body.
     *
     * @return \stdClass|null
     */
    public function getBodySchema()
    {
        return $this->getBody()->getSchema();
    }

    /**
     * @return bool
     */
    public function hasPathSchema()
    {
        return $this->getPathSchema() !== null;
    }

    /**
     * JSON Schema for the path parameters.
     *
     * @return \stdClass|null
     */
    public function getPathSchema()
    {
        return $this->getSchema($this->getPath());
    }

    /**
     * @return bool
     */
    public function hasQueryParametersSchema()
    {
        return $this->getQueryParametersSchema() !== null;
    }

    /**
     * JSON Schema for the query parameters.
     *
     * @return \stdClass|null
     */
    public function getQueryParametersSchema()
    {
        return $this->getSchema($this->getQuery());
    }

    /**
     * @return bool
     */
    public function hasHeadersSchema()
    {
        return $this->getHeadersSchema() !== null;
    }

    /**
     * JSON Schema for the headers.
     *
     * @return \stdClass|null
     */
    public function getHeadersSchema()
    {
        return $this->getSchema($this->getHeaders());
    }

    /**
     * @return Parameter[]
     */
    public function getPath()
    {
        return $this->findByLocation('path');
    }

    /**
     * @return Parameter[]
     */
    public function getQuery()
    {
        return $this->findByLocation('query');
    }

    /**
     * @return Parameter[]
     */
    public function getHeaders()
    {
        return $this->findByLocation('header');
    }

    /**
     * @return Parameter|null
     */
    public function getBody()
    {
        $match = $this->findByLocation('body');
        if (empty($match)) {
            return null;
        }

        return current($match);
    }

    /**
     * Get one request parameter by name
     *
     * @param string $name
     * @return Parameter|null
     */
    public function getByName($name)
    {
        if (! isset($this->parameters[$name])) {
            return null;
        }

        return $this->parameters[$name];
    }

    /**
     * @param Parameter[] $parameters
     *
     * @return \stdClass|null
     */
    private function getSchema(array $parameters)
    {
        if (empty($parameters)) {
            return null;
        }

        $schema = new \stdClass();
        $schema->type = 'object';
        $schema->required = [];
        $schema->properties = new \stdClass();
        foreach ($parameters as $name => $parameter) {
            if ($parameter->isRequired()) {
                $schema->required[] = $parameter->getName();
            }
            $schema->properties->{$name} = $parameter->getSchema();
        }

        return $schema;
    }

    public function serialize()
    {
        return serialize(['parameters' => $this->parameters]);
    }

    public function unserialize($serialized)
    {
        $data = unserialize($serialized);
        $this->parameters = $data['parameters'];
    }

    private function findByLocation($location)
    {
        return array_filter(
            $this->parameters,
            function (Parameter $parameter) use ($location) {
                return $parameter->getLocation() === $location;
            }
        );
    }

    private function addParameter(Parameter $parameter)
    {
        if (!in_array($parameter->getLocation(), Parameter::LOCATIONS, true)) {
            throw new \InvalidArgumentException(
                sprintf(
                    '%s is not a supported parameter location, supported: %s',
                    $parameter->getLocation(),
                    implode(', ', Parameter::LOCATIONS)
                )
            );
        }

        $this->parameters[$parameter->getName()] = $parameter;
    }
}


1		<?php
2		namespace ElevenLabs\Api\Definition;
3
4		class Parameters implements \Serializable, \IteratorAggregate
5		{
6		/**
7		* @var Parameter[]
8		*/
9		private $parameters;
10
11	22	public function __construct(array $parameters)
12		{
13	22	$this->parameters = [];
14	22	foreach ($parameters as $parameter) {
15	14	$this->addParameter($parameter);
16		}
17	21	}
18
19	1	public function getIterator()
20		{
21	1	return new \ArrayIterator($this->parameters);
22		}
23
24	2	public function hasBodySchema()
25		{
26	2	$body = $this->getBody();
27
28	2	return ($body !== null && $body->hasSchema());
29		}
30
31		/**
32		* JSON Schema for the body.
33		*
34		* @return \stdClass\|null
35		*/
36	2	public function getBodySchema()
37		{
38	2	return $this->getBody()->getSchema();
39		}
40
41		/**
42		* @return bool
43		*/
44		public function hasPathSchema()
45		{
46		return $this->getPathSchema() !== null;
47		}
48
49		/**
50		* JSON Schema for the path parameters.
51		*
52		* @return \stdClass\|null
53		*/
54		public function getPathSchema()
55		{
56		return $this->getSchema($this->getPath());
57		}
58
59		/**
60		* @return bool
61		*/
62	1	public function hasQueryParametersSchema()
63		{
64	1	return $this->getQueryParametersSchema() !== null;
65		}
66
67		/**
68		* JSON Schema for the query parameters.
69		*
70		* @return \stdClass\|null
71		*/
72	2	public function getQueryParametersSchema()
73		{
74	2	return $this->getSchema($this->getQuery());
75		}
76
77		/**
78		* @return bool
79		*/
80	2	public function hasHeadersSchema()
81		{
82	2	return $this->getHeadersSchema() !== null;
83		}
84
85		/**
86		* JSON Schema for the headers.
87		*
88		* @return \stdClass\|null
89		*/
90	2	public function getHeadersSchema()
91		{
92	2	return $this->getSchema($this->getHeaders());
93		}
94
95		/**
96		* @return Parameter[]
97		*/
98	1	public function getPath()
99		{
100	1	return $this->findByLocation('path');
101		}
102
103		/**
104		* @return Parameter[]
105		*/
106	2	public function getQuery()
107		{
108	2	return $this->findByLocation('query');
109		}
110
111		/**
112		* @return Parameter[]
113		*/
114	2	public function getHeaders()
115		{
116	2	return $this->findByLocation('header');
117		}
118
119		/**
120		* @return Parameter\|null
121		*/
122	3	public function getBody()
123		{
124	3	$match = $this->findByLocation('body');
125	3	if (empty($match)) {
126	1	return null;
127		}
128
129	2	return current($match);
130		}
131
132		/**
133		* Get one request parameter by name
134		*
135		* @param string $name
136		* @return Parameter\|null
137		*/
138	1	public function getByName($name)
139		{
140	1	if (! isset($this->parameters[$name])) {
141		return null;
142		}
143
144	1	return $this->parameters[$name];
145		}
146
147		/**
148		* @param Parameter[] $parameters
149		*
150		* @return \stdClass\|null
151		*/
152	3	private function getSchema(array $parameters)
153		{
154	3	if (empty($parameters)) {
155	1	return null;
156		}
157
158	2	$schema = new \stdClass();
159	2	$schema->type = 'object';
160	2	$schema->required = [];
161	2	$schema->properties = new \stdClass();
162	2	foreach ($parameters as $name => $parameter) {
163	2	if ($parameter->isRequired()) {
164	1	$schema->required[] = $parameter->getName();
165		}
166	2	$schema->properties->{$name} = $parameter->getSchema();
167		}
168
169	2	return $schema;
170		}
171
172	3	public function serialize()
173		{
174	3	return serialize(['parameters' => $this->parameters]);
175		}
176
177	3	public function unserialize($serialized)
178		{
179	3	$data = unserialize($serialized);
180	3	$this->parameters = $data['parameters'];
181	3	}
182
183	6	private function findByLocation($location)
184		{
185	6	return array_filter(
186	6	$this->parameters,
187		function (Parameter $parameter) use ($location) {
188	5	return $parameter->getLocation() === $location;
189	6	}
190		);
191		}
192
193	14	private function addParameter(Parameter $parameter)
194		{
195	14	if (!in_array($parameter->getLocation(), Parameter::LOCATIONS, true)) {
196	1	throw new \InvalidArgumentException(
197	1	sprintf(
198	1	'%s is not a supported parameter location, supported: %s',
199	1	$parameter->getLocation(),
200	1	implode(', ', Parameter::LOCATIONS)
201		)
202		);
203		}
204
205	13	$this->parameters[$parameter->getName()] = $parameter;
206	13	}
207		}
208

eleven-labs / api-validator

Push — master ( 14fe81...675c2f )

Parameters::hasPathSchema() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like