functions.php ➔ pointer_push() - Code Metrics - Inspection of "Cleanup Dereferencer (#87)" - thephpleague/json-guard - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 64ede7...feafc2 )

by Matt

created 2017-01-18 15:07 UTC

functions.php ➔ pointer_push() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes

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

<?php

namespace League\JsonGuard;

use Sabre\Uri;

/**
 * @param string $json
 * @param bool   $assoc
 * @param int    $depth
 * @param int    $options
 * @return mixed
 * @throws \InvalidArgumentException
 */
function json_decode($json, $assoc = false, $depth = 512, $options = 0)
{
    $data = \json_decode($json, $assoc, $depth, $options);

    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new \InvalidArgumentException(sprintf('Invalid JSON: %s', json_last_error_msg()));
    }

    return $data;
}

/**
 * @param $string
 * @return int
 */
function strlen($string)
{
    if (extension_loaded('intl')) {
        return grapheme_strlen($string);
    }

    if (extension_loaded('mbstring')) {
        return mb_strlen($string, mb_detect_encoding($string));
    }

    return \strlen($string);
}

/**
 * Returns the string representation of a value.
 *
 * @param mixed $value
 * @return string
 */
function as_string($value)
{
    if (is_resource($value)) {
        return '<RESOURCE>';
    }

    return (string) json_encode($value);
}

/**
 * Get the properties matching $pattern from the $data.
 *
 * @param string       $pattern
 * @param array|object $data
 * @return array
 */
function properties_matching_pattern($pattern, $data)
{
    // If an object is supplied, extract an array of the property names.
    if (is_object($data)) {
        $data = array_keys(get_object_vars($data));
    }

    return preg_grep(delimit_pattern($pattern), $data);
}

/**
 * Delimit a regular expression pattern.
 *
 * The regular expression syntax used for JSON schema is ECMA 262, from Javascript,
 * and does not use delimiters.  Since the PCRE functions do, this function will
 * delimit a pattern and escape the delimiter if found in the pattern.
 *
 * @see http://json-schema.org/latest/json-schema-validation.html#anchor6
 * @see http://php.net/manual/en/regexp.reference.delimiters.php
 *
 * @param string $pattern
 *
 * @return string
 */
function delimit_pattern($pattern)
{
    return '/' . str_replace('/', '\\/', $pattern) . '/';
}

/**
 * Escape a JSON Pointer.
 *
 * @param  string $pointer
 * @return string
 */
function escape_pointer($pointer)
{
    $pointer = str_replace('~', '~0', $pointer);
    return str_replace('/', '~1', $pointer);
}


/**
 * Push a segment onto the given JSON Pointer.
 *
 * @param string $path
 * @param string $segment
 *
 * @return string
 */
function pointer_push($path, $segment)
{
    return $path . '/' . escape_pointer($segment);
}

/**
 * Determines if the value is an integer or an integer that was cast to a string
 * because it is larger than PHP_INT_MAX.
 *
 * @param  mixed $value
 * @return boolean
 */
function is_json_integer($value)
{
    if (is_string($value) && strlen($value) && $value[0] === '-') {
        $value = substr($value, 1);
    }

    return is_int($value) || (is_string($value) && ctype_digit($value) && compare($value, PHP_INT_MAX) === 1);
}

/**
 * Determines if the value is a number.  A number is a float, integer, or a number that was cast
 * to a string because it is larger than PHP_INT_MAX.
 *
 * @param mixed $value
 *
 * @return boolean
 */
function is_json_number($value)
{
    return is_float($value) || is_json_integer($value);
}

/**
 * @param string|double|int $leftOperand
 * @param string|double|int $rightOperand
 *
 * @return int Returns 0 if the two operands are equal, 1 if the left_operand is larger than the right_operand,
 * -1 otherwise.
 */
function compare($leftOperand, $rightOperand)
{
    return Comparator::compare($leftOperand, $rightOperand);
}

/**
 * Removes the fragment from a reference.
 *
 * @param  string $ref
 * @return string
 */
function strip_fragment($ref)
{
    $fragment = parse_url($ref, PHP_URL_FRAGMENT);

    return $fragment ? str_replace($fragment, '', $ref) : $ref;
}

/**
 * Determine if a reference is relative.
 * A reference is relative if it does not being with a prefix.
 *
 * @param string $ref
 *
 * @return bool
 */
function is_relative_ref($ref)
{
    return !preg_match('#^.+\:\/\/.*#', $ref);
}

/**
 * @param string $value
 *
 * @return bool
 */
function is_internal_ref($value)
{
    return is_string($value) && substr($value, 0, 1) === '#';
}

/**
 * Resolve the given id against the parent scope and return the resolved URI.
 *
 * @param string $id          The id to resolve.  This should be a valid relative or absolute URI.
 * @param string $parentScope The parent scope to resolve against.  Should be a valid URI or empty.
 *
 * @return string
 */
function resolve_uri($id, $parentScope)
{
    // If there is no parent scope, there is nothing to resolve against.
    if ($parentScope === '') {
        return $id;
    }

    return Uri\resolve($parentScope, $id);
}

/**
 * Recursively iterates over each value in the schema passing them to the callback function.
 * If the callback function returns true, the value is returned into the result array, keyed by a JSON Pointer.
 *
 * @param mixed    $schema
 * @param callable $callback
 * @param string   $pointer
 *
 * @return array
 */
function schema_extract($schema, callable $callback, $pointer = '')
{
    $matches = [];

    if (!is_array($schema) && !is_object($schema)) {
        return $matches;
    }

    foreach ($schema as $keyword => $value) {
        switch (true) {
            case is_object($value):
                $matches = array_merge($matches, schema_extract($value, $callback, pointer_push($pointer, $keyword)));
                break;
            case is_array($value):
                foreach ($value as $k => $v) {
                    $matches = array_merge(
                        $matches,
                        schema_extract($v, $callback, pointer_push(pointer_push($pointer, $keyword), $k))
                    );
                }
                break;
            case $callback($keyword, $value):
                $matches[$pointer] = $value;
                break;
        }
    }

    return $matches;
}


1		<?php
2
3		namespace League\JsonGuard;
4
5		use Sabre\Uri;
6
7		/**
8		* @param string $json
9		* @param bool $assoc
10		* @param int $depth
11		* @param int $options
12		* @return mixed
13		* @throws \InvalidArgumentException
14		*/
15		function json_decode($json, $assoc = false, $depth = 512, $options = 0)
16		{
17	52	$data = \json_decode($json, $assoc, $depth, $options);
18
19	52	if (json_last_error() !== JSON_ERROR_NONE) {
20	2	throw new \InvalidArgumentException(sprintf('Invalid JSON: %s', json_last_error_msg()));
21		}
22
23	50	return $data;
24		}
25
26		/**
27		* @param $string
28		* @return int
29		*/
30		function strlen($string)
31		{
32	100	if (extension_loaded('intl')) {
33	100	return grapheme_strlen($string);
34		}
35
36		if (extension_loaded('mbstring')) {
37		return mb_strlen($string, mb_detect_encoding($string));
38		}
39
40		return \strlen($string);
41		}
42
43		/**
44		* Returns the string representation of a value.
45		*
46		* @param mixed $value
47		* @return string
48		*/
49		function as_string($value)
50		{
51	154	if (is_resource($value)) {
52	2	return '<RESOURCE>';
53		}
54
55	152	return (string) json_encode($value);
56		}
57
58		/**
59		* Get the properties matching $pattern from the $data.
60		*
61		* @param string $pattern
62		* @param array\|object $data
63		* @return array
64		*/
65		function properties_matching_pattern($pattern, $data)
66		{
67		// If an object is supplied, extract an array of the property names.
68	12	if (is_object($data)) {
69	12	$data = array_keys(get_object_vars($data));
70	12	}
71
72	12	return preg_grep(delimit_pattern($pattern), $data);
73		}
74
75		/**
76		* Delimit a regular expression pattern.
77		*
78		* The regular expression syntax used for JSON schema is ECMA 262, from Javascript,
79		* and does not use delimiters. Since the PCRE functions do, this function will
80		* delimit a pattern and escape the delimiter if found in the pattern.
81		*
82		* @see http://json-schema.org/latest/json-schema-validation.html#anchor6
83		* @see http://php.net/manual/en/regexp.reference.delimiters.php
84		*
85		* @param string $pattern
86		*
87		* @return string
88		*/
89		function delimit_pattern($pattern)
90		{
91	16	return '/' . str_replace('/', '\\/', $pattern) . '/';
92		}
93
94		/**
95		* Escape a JSON Pointer.
96		*
97		* @param string $pointer
98		* @return string
99		*/
100		function escape_pointer($pointer)
101		{
102	116	$pointer = str_replace('~', '~0', $pointer);
103	116	return str_replace('/', '~1', $pointer);
104		}
105
106
107		/**
108		* Push a segment onto the given JSON Pointer.
109		*
110		* @param string $path
111		* @param string $segment
112		*
113		* @return string
114		*/
115		function pointer_push($path, $segment)
116		{
117	112	return $path . '/' . escape_pointer($segment);
118		}
119
120		/**
121		* Determines if the value is an integer or an integer that was cast to a string
122		* because it is larger than PHP_INT_MAX.
123		*
124		* @param mixed $value
125		* @return boolean
126		*/
127		function is_json_integer($value)
128		{
129	154	if (is_string($value) && strlen($value) && $value[0] === '-') {
130	6	$value = substr($value, 1);
131	6	}
132
133	154	return is_int($value) \|\| (is_string($value) && ctype_digit($value) && compare($value, PHP_INT_MAX) === 1);
134		}
135
136		/**
137		* Determines if the value is a number. A number is a float, integer, or a number that was cast
138		* to a string because it is larger than PHP_INT_MAX.
139		*
140		* @param mixed $value
141		*
142		* @return boolean
143		*/
144		function is_json_number($value)
145		{
146	124	return is_float($value) \|\| is_json_integer($value);
147		}
148
149		/**
150		* @param string\|double\|int $leftOperand
151		* @param string\|double\|int $rightOperand
152		*
153		* @return int Returns 0 if the two operands are equal, 1 if the left_operand is larger than the right_operand,
154		* -1 otherwise.
155		*/
156		function compare($leftOperand, $rightOperand)
157		{
158	42	return Comparator::compare($leftOperand, $rightOperand);
159		}
160
161		/**
162		* Removes the fragment from a reference.
163		*
164		* @param string $ref
165		* @return string
166		*/
167		function strip_fragment($ref)
168		{
169	46	$fragment = parse_url($ref, PHP_URL_FRAGMENT);
170
171	46	return $fragment ? str_replace($fragment, '', $ref) : $ref;
172		}
173
174		/**
175		* Determine if a reference is relative.
176		* A reference is relative if it does not being with a prefix.
177		*
178		* @param string $ref
179		*
180		* @return bool
181		*/
182		function is_relative_ref($ref)
183		{
184	26	return !preg_match('#^.+\:\/\/.*#', $ref);
185		}
186
187		/**
188		* @param string $value
189		*
190		* @return bool
191		*/
192		function is_internal_ref($value)
193		{
194	56	return is_string($value) && substr($value, 0, 1) === '#';
195		}
196
197		/**
198		* Resolve the given id against the parent scope and return the resolved URI.
199		*
200		* @param string $id The id to resolve. This should be a valid relative or absolute URI.
201		* @param string $parentScope The parent scope to resolve against. Should be a valid URI or empty.
202		*
203		* @return string
204		*/
205		function resolve_uri($id, $parentScope)
206		{
207		// If there is no parent scope, there is nothing to resolve against.
208	38	if ($parentScope === '') {
209	14	return $id;
210		}
211
212	32	return Uri\resolve($parentScope, $id);
213		}
214
215		/**
216		* Recursively iterates over each value in the schema passing them to the callback function.
217		* If the callback function returns true, the value is returned into the result array, keyed by a JSON Pointer.
218		*
219		* @param mixed $schema
220		* @param callable $callback
221		* @param string $pointer
222		*
223		* @return array
224		*/
225		function schema_extract($schema, callable $callback, $pointer = '')
226		{
227	166	$matches = [];
228
229	166	if (!is_array($schema) && !is_object($schema)) {
230	42	return $matches;
231		}
232
233	166	foreach ($schema as $keyword => $value) {
234	166	switch (true) {
235	166	case is_object($value):
236	98	$matches = array_merge($matches, schema_extract($value, $callback, pointer_push($pointer, $keyword)));
237	98	break;
238	166	case is_array($value):
239	66	foreach ($value as $k => $v) {
240	62	$matches = array_merge(
241	62	$matches,
242	62	schema_extract($v, $callback, pointer_push(pointer_push($pointer, $keyword), $k))
243	62	);
244	66	}
245	66	break;
246	162	case $callback($keyword, $value):
247	56	$matches[$pointer] = $value;
248	56	break;
249		}
250	166	}
251
252	166	return $matches;
253		}
254

thephpleague / json-guard

Push — master ( 64ede7...feafc2 )

functions.php ➔ pointer_push() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like