Parameter::getNestedProperty() - Code Metrics - Inspection of "refactoring large methods into smaller ones" - php-opencloud/openstack - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c7ca15...b7663d )

by Jamie

created 2015-11-26 13:28 UTC

Parameter::getNestedProperty() A

↳ Parent: Parameter

Complexity

Conditions	4
Paths	3

Size

Total Lines	10
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	4

Metric	Value
dl	0
loc	10
ccs	6
cts	6
cp	1
rs	9.2
cc	4
eloc	7
nc	3
nop	1
crap	4

<?php

namespace OpenStack\Common\Api;

use OpenStack\Common\HydratorStrategyTrait;

/**
 * Represents an individual request parameter in a RESTful operation. A parameter can take on many forms:
 * in a URL path, in a URL query, in a JSON body, and in a HTTP header. It is worth documenting brifly each
 * variety of parameter:
 *
 * * Header parameters are those which populate a HTTP header in a request. Header parameters can have
 *   aliases; for example, a user-facing name of "Foo" can be sent over the wire as "X-Foo_Bar", as defined
 *   by ``sentAs``. Prefixes can also be used.
 *
 * * Query parameters are those which populate a URL query parameter. The value is therefore usually
 *   confined to a string.
 *
 * * JSON parameters are those which populate a JSON request body. These are the most complex variety
 *   of Parameter, since there are so many different ways a JSON document can be constructed. The SDK
 *   supports deep-nesting according to a XPath syntax; for more information, see {@see \OpenStack\Common\JsonPath}.
 *   Nested object and array properties are also supported since JSON is a recursive data type. What
 *   this means is that a Parameter can have an assortment of child Parameters, one for each object
 *   property or array element.
 *
 * * Raw parameters are those which populate a non-JSON request body. This is typically used for
 *   uploading payloads (such as Swift object data) to a remote API.
 *
 * * Path parameters are those which populate a URL path. They are serialized according to URL
 *   placeholders.
 *
 * @package OpenStack\Common\Api
 */
class Parameter
{
    use HydratorStrategyTrait;

    const DEFAULT_LOCATION = 'json';

    /**
     * The human-friendly name of the parameter. This is what the user will input.
     *
     * @var string
     */
    private $name;

    /**
     * The alias for this parameter. Although the user will always interact with the human-friendly $name property,
     * the $sentAs is what's used over the wire.
     *
     * @var string
     */
    private $sentAs;

    /**
     * For array parameters (for example, an array of security group names when creating a server), each array element
     * will need to adhere to a common schema. For the aforementioned example, each element will need to be a string.
     * For more complicated parameters, you might be validated an array of complicated objects.
     *
     * @var Parameter
     */
    private $itemSchema;

    /**
     * For object parameters, each property will need to adhere to a specific schema. For every property in the
     * object, it has its own schema - meaning that this property is a hash of name/schema pairs.
     *
     * The *only* exception to this rule is for metadata parameters, which are arbitrary key/value pairs. Since it does
     * not make sense to have a schema for each metadata key, a common schema is use for every one. So instead of this
     * property being a hash of schemas, it is a single Parameter object instead. This single Parameter schema will
     * then be applied to each metadata key provided.
     *
     * @var []Parameter|Parameter
     */
    private $properties;

    /**
     * The value's PHP type which this parameter represents; either "string", "bool", "object", "array", "NULL".
     *
     * @var string
     */
    private $type;

    /**
     * Indicates whether this parameter requires a value from the user.
     *
     * @var bool
     */
    private $required;

    /**
     * The location in the HTTP request where this parameter will populate; either "header", "url", "query", "raw" or
     * "json".
     *
     * @var string
     */
    private $location;

    /**
     * Relevant to "json" location parameters only. This property allows for deep nesting through the use of
     * {@see OpenStack\Common\JsonPath}.
     *
     * @var string
     */
    private $path;

    /**
     * Allows for the prefixing of parameter names.
     *
     * @var string
     */
    private $prefix;

    /**
     * @param array $data
     */
    public function __construct(array $data)
    {
        $this->hydrate($data);

        if (!$this->type) {
            $this->type = 'string';
        }

        $this->location = $this->location ?: self::DEFAULT_LOCATION;
        $this->required = (bool)$this->required;

        $this->stockItemSchema($data);
        $this->stockProperties($data);
    }

    private function stockItemSchema(array $data)
    {
        if (isset($data['items'])) {
            $this->itemSchema = new Parameter($data['items']);
        }
    }

    private function stockProperties(array $data)
    {
        if (isset($data['properties'])) {
            if (strpos(strtolower($this->name), 'metadata') !== false) {
                $this->properties = new Parameter($data['properties']);
            } else {
                foreach ($data['properties'] as $name => $property) {
                    $this->properties[$name] = new Parameter($property + ['name' => $name]);
                }
            }
        }
    }

    /**
     * Retrieve the name that will be used over the wire.
     *
     * @return string
     */
    public function getName()
    {
        return $this->sentAs ?: $this->name;
    }

    /**
     * Indicates whether the user must provide a value for this parameter.
     *
     * @return bool
     */
    public function isRequired()
    {
        return $this->required === true;
    }

    /**
     * Validates a given user value and checks whether it passes basic sanity checking, such as types.
     *
     * @param $userValues The value provided by the user
     *
     * @return bool       TRUE if the validation passes
     * @throws \Exception If validation fails
     */
    public function validate($userValues)
    {
        // Check inputted type
        if (!$this->hasCorrectType($userValues)) {
            throw new \Exception(
                sprintf(
                    'The key provided "%s" has the wrong value type. You provided %s but was expecting %s',
                    $this->name, print_r($userValues, true), $this->type
                )
            );
        }

        if ($this->isArray()) {
            foreach ($userValues as $userValue) {
                $this->itemSchema->validate($userValue);
            }
        } elseif ($this->isObject()) {
            foreach ($userValues as $key => $userValue) {
                // Check that nested keys are properly defined, but permit arbitrary structures if it's metadata
                $property = $this->getNestedProperty($key);
                $property->validate($userValue);
            }
        }

        return true;
    }

    /**
     * Internal method which retrieves a nested property for object parameters.
     *
     * @param $key The name of the child parameter
     *
     * @returns Parameter
     * @throws \Exception
     */
    private function getNestedProperty($key)
    {
        if ($this->name == 'metadata' && $this->properties instanceof Parameter) {
            return $this->properties;
        } elseif (isset($this->properties[$key])) {
            return $this->properties[$key];
        } else {
            throw new \Exception(sprintf('The key provided "%s" is not defined', $key));
        }
    }

    /**
     * Internal method which indicates whether the user value is of the same type as the one expected
     * by this parameter.
     *
     * @param $userValue The value being checked
     *
     * @return bool
     */
    private function hasCorrectType($userValue)
    {
        // Helper fn to see whether an array is associative (i.e. a JSON object)
        $isAssociative = function ($value) {
            return is_array($value) && (bool)count(array_filter(array_keys($value), 'is_string'));
        };

        // For params defined as objects, we'll let the user get away with
        // passing in an associative array - since it's effectively a hash
        if ($this->type == 'object' && $isAssociative($userValue)) {
            return true;
        }

        return gettype($userValue) == $this->type;
    }

    /**
     * Indicates whether this parameter represents an array type
     *
     * @return bool
     */
    public function isArray()
    {
        return $this->type == 'array' && $this->itemSchema instanceof Parameter;
    }

    /**
     * Indicates whether this parameter represents an object type
     *
     * @return bool
     */
    public function isObject()
    {
        return $this->type == 'object' && !empty($this->properties);
    }

    public function getLocation()
    {
        return $this->location;
    }

    /**
     * Verifies whether the given location matches the parameter's location.
     *
     * @param $value
     *
     * @return bool
     */
    public function hasLocation($value)
    {
        return $this->location == $value;
    }

    /**
     * Retrieves the parameter's path.
     *
     * @return string|null
     */
    public function getPath()
    {
        return $this->path;
    }

    /**
     * Retrieves the common schema that an array parameter applies to all its child elements.
     *
     * @return Parameter
     */
    public function getItemSchema()
    {
        return $this->itemSchema;
    }

    /**
     * Sets the name of the parameter to a new value
     *
     * @param string $name
     */
    public function setName($name)
    {
        $this->name = $name;
    }

    /**
     * Retrieves the child parameter for an object parameter.
     *
     * @param string $name The name of the child property
     *
     * @return null|Parameter
     */
    public function getProperty($name)
    {
        if ($this->properties instanceof Parameter) {
            $this->properties->setName($name);
            return $this->properties;
        }

        return isset($this->properties[$name]) ? $this->properties[$name] : null;
    }

    /**
     * Retrieves the prefix for a parameter, if any.
     *
     * @return string|null
     */
    public function getPrefix()
    {
        return $this->prefix;
    }
}

1		<?php
2
3		namespace OpenStack\Common\Api;
4
5		use OpenStack\Common\HydratorStrategyTrait;
6
7		/**
8		* Represents an individual request parameter in a RESTful operation. A parameter can take on many forms:
9		* in a URL path, in a URL query, in a JSON body, and in a HTTP header. It is worth documenting brifly each
10		* variety of parameter:
11		*
12		* * Header parameters are those which populate a HTTP header in a request. Header parameters can have
13		* aliases; for example, a user-facing name of "Foo" can be sent over the wire as "X-Foo_Bar", as defined
14		* by ``sentAs``. Prefixes can also be used.
15		*
16		* * Query parameters are those which populate a URL query parameter. The value is therefore usually
17		* confined to a string.
18		*
19		* * JSON parameters are those which populate a JSON request body. These are the most complex variety
20		* of Parameter, since there are so many different ways a JSON document can be constructed. The SDK
21		* supports deep-nesting according to a XPath syntax; for more information, see {@see \OpenStack\Common\JsonPath}.
22		* Nested object and array properties are also supported since JSON is a recursive data type. What
23		* this means is that a Parameter can have an assortment of child Parameters, one for each object
24		* property or array element.
25		*
26		* * Raw parameters are those which populate a non-JSON request body. This is typically used for
27		* uploading payloads (such as Swift object data) to a remote API.
28		*
29		* * Path parameters are those which populate a URL path. They are serialized according to URL
30		* placeholders.
31		*
32		* @package OpenStack\Common\Api
33		*/
34		class Parameter
35		{
36		use HydratorStrategyTrait;
37
38		const DEFAULT_LOCATION = 'json';
39
40		/**
41		* The human-friendly name of the parameter. This is what the user will input.
42		*
43		* @var string
44		*/
45		private $name;
46
47		/**
48		* The alias for this parameter. Although the user will always interact with the human-friendly $name property,
49		* the $sentAs is what's used over the wire.
50		*
51		* @var string
52		*/
53		private $sentAs;
54
55		/**
56		* For array parameters (for example, an array of security group names when creating a server), each array element
57		* will need to adhere to a common schema. For the aforementioned example, each element will need to be a string.
58		* For more complicated parameters, you might be validated an array of complicated objects.
59		*
60		* @var Parameter
61		*/
62		private $itemSchema;
63
64		/**
65		* For object parameters, each property will need to adhere to a specific schema. For every property in the
66		* object, it has its own schema - meaning that this property is a hash of name/schema pairs.
67		*
68		* The only exception to this rule is for metadata parameters, which are arbitrary key/value pairs. Since it does
69		* not make sense to have a schema for each metadata key, a common schema is use for every one. So instead of this
70		* property being a hash of schemas, it is a single Parameter object instead. This single Parameter schema will
71		* then be applied to each metadata key provided.
72		*
73		* @var []Parameter\|Parameter
74		*/
75		private $properties;
76
77		/**
78		* The value's PHP type which this parameter represents; either "string", "bool", "object", "array", "NULL".
79		*
80		* @var string
81		*/
82		private $type;
83
84		/**
85		* Indicates whether this parameter requires a value from the user.
86		*
87		* @var bool
88		*/
89		private $required;
90
91		/**
92		* The location in the HTTP request where this parameter will populate; either "header", "url", "query", "raw" or
93		* "json".
94		*
95		* @var string
96		*/
97		private $location;
98
99		/**
100		* Relevant to "json" location parameters only. This property allows for deep nesting through the use of
101		* {@see OpenStack\Common\JsonPath}.
102		*
103		* @var string
104		*/
105		private $path;
106
107		/**
108		* Allows for the prefixing of parameter names.
109		*
110		* @var string
111		*/
112		private $prefix;
113
114		/**
115		* @param array $data
116		*/
117	195	public function __construct(array $data)
118		{
119	195	$this->hydrate($data);
120
121	195	if (!$this->type) {
122	99	$this->type = 'string';
123	99	}
124
125	195	$this->location = $this->location ?: self::DEFAULT_LOCATION;
126	195	$this->required = (bool)$this->required;
127
128	195	$this->stockItemSchema($data);
129	195	$this->stockProperties($data);
130	195	}
131
132	195	private function stockItemSchema(array $data)
133		{
134	195	if (isset($data['items'])) {
135	25	$this->itemSchema = new Parameter($data['items']);
136	25	}
137	195	}
138
139	195	private function stockProperties(array $data)
140		{
141	195	if (isset($data['properties'])) {
142	39	if (strpos(strtolower($this->name), 'metadata') !== false) {
143	22	$this->properties = new Parameter($data['properties']);
144	22	} else {
145	27	foreach ($data['properties'] as $name => $property) {
146	27	$this->properties[$name] = new Parameter($property + ['name' => $name]);
147	27	}
148		}
149	39	}
150	195	}
151
152		/**
153		* Retrieve the name that will be used over the wire.
154		*
155		* @return string
156		*/
157	88	public function getName()
158		{
159	88	return $this->sentAs ?: $this->name;
160		}
161
162		/**
163		* Indicates whether the user must provide a value for this parameter.
164		*
165		* @return bool
166		*/
167	4	public function isRequired()
168		{
169	4	return $this->required === true;
170		}
171
172		/**
173		* Validates a given user value and checks whether it passes basic sanity checking, such as types.
174		*
175		* @param $userValues The value provided by the user
176		*
177		* @return bool TRUE if the validation passes
178		* @throws \Exception If validation fails
179		*/
180	9	public function validate($userValues)
181		{
182		// Check inputted type
183	9	if (!$this->hasCorrectType($userValues)) {
184	3	throw new \Exception(
185	3	sprintf(
186	3	'The key provided "%s" has the wrong value type. You provided %s but was expecting %s',
187	3	$this->name, print_r($userValues, true), $this->type
188	3	)
189	3	);
190		}
191
192	8	if ($this->isArray()) {
193	2	foreach ($userValues as $userValue) {
194	2	$this->itemSchema->validate($userValue);
195	1	}
196	7	} elseif ($this->isObject()) {
197	3	foreach ($userValues as $key => $userValue) {
198		// Check that nested keys are properly defined, but permit arbitrary structures if it's metadata
199	3	$property = $this->getNestedProperty($key);
200	2	$property->validate($userValue);
201	2	}
202	2	}
203
204	6	return true;
205		}
206
207		/**
208		* Internal method which retrieves a nested property for object parameters.
209		*
210		* @param $key The name of the child parameter
211		*
212		* @returns Parameter
213		* @throws \Exception
214		*/
215	3	private function getNestedProperty($key)
216		{
217	3	if ($this->name == 'metadata' && $this->properties instanceof Parameter) {
218	1	return $this->properties;
219	2	} elseif (isset($this->properties[$key])) {
220	1	return $this->properties[$key];
221		} else {
222	1	throw new \Exception(sprintf('The key provided "%s" is not defined', $key));
223		}
224		}
225
226		/**
227		* Internal method which indicates whether the user value is of the same type as the one expected
228		* by this parameter.
229		*
230		* @param $userValue The value being checked
231		*
232		* @return bool
233		*/
234		private function hasCorrectType($userValue)
235		{
236		// Helper fn to see whether an array is associative (i.e. a JSON object)
237	9	$isAssociative = function ($value) {
238	4	return is_array($value) && (bool)count(array_filter(array_keys($value), 'is_string'));
239	9	};
240
241		// For params defined as objects, we'll let the user get away with
242		// passing in an associative array - since it's effectively a hash
243	9	if ($this->type == 'object' && $isAssociative($userValue)) {
244	3	return true;
245		}
246
247	8	return gettype($userValue) == $this->type;
248		}
249
250		/**
251		* Indicates whether this parameter represents an array type
252		*
253		* @return bool
254		*/
255	69	public function isArray()
256		{
257	69	return $this->type == 'array' && $this->itemSchema instanceof Parameter;
258		}
259
260		/**
261		* Indicates whether this parameter represents an object type
262		*
263		* @return bool
264		*/
265	68	public function isObject()
266		{
267	68	return $this->type == 'object' && !empty($this->properties);
268		}
269
270	162	public function getLocation()
271		{
272	162	return $this->location;
273		}
274
275		/**
276		* Verifies whether the given location matches the parameter's location.
277		*
278		* @param $value
279		*
280		* @return bool
281		*/
282	1	public function hasLocation($value)
283		{
284	1	return $this->location == $value;
285		}
286
287		/**
288		* Retrieves the parameter's path.
289		*
290		* @return string\|null
291		*/
292	62	public function getPath()
293		{
294	62	return $this->path;
295		}
296
297		/**
298		* Retrieves the common schema that an array parameter applies to all its child elements.
299		*
300		* @return Parameter
301		*/
302	18	public function getItemSchema()
303		{
304	18	return $this->itemSchema;
305		}
306
307		/**
308		* Sets the name of the parameter to a new value
309		*
310		* @param string $name
311		*/
312	13	public function setName($name)
313		{
314	13	$this->name = $name;
315	13	}
316
317		/**
318		* Retrieves the child parameter for an object parameter.
319		*
320		* @param string $name The name of the child property
321		*
322		* @return null\|Parameter
323		*/
324	21	public function getProperty($name)
325		{
326	21	if ($this->properties instanceof Parameter) {
327	12	$this->properties->setName($name);
328	12	return $this->properties;
329		}
330
331	10	return isset($this->properties[$name]) ? $this->properties[$name] : null;
332		}
333
334		/**
335		* Retrieves the prefix for a parameter, if any.
336		*
337		* @return string\|null
338		*/
339	15	public function getPrefix()
340		{
341	15	return $this->prefix;
342		}
343		}

php-opencloud / openstack

GitHub Access Token became invalid

Push — master ( c7ca15...b7663d )

Parameter::getNestedProperty() A

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like