Scope::parseValue() - Code Metrics - Inspection of "Enabling data to be transformed from an array into..." - flipbox/transform - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 500060...605dcd )

by Nate

created 2017-06-07 07:13 UTC

Scope::parseValue() A

↳ Parent: Scope

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
dl	0
loc	8
ccs	0
cts	7
cp	0
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	4
nc	2
nop	3
crap	6

<?php

/**
 * @author    Flipbox Factory
 * @copyright Copyright (c) 2017, Flipbox Digital
 * @link      https://github.com/flipbox/transform/releases/latest
 * @license   https://github.com/flipbox/transform/blob/master/LICENSE
 */

namespace Flipbox\Transform;

use Flipbox\Transform\Transformers\TransformerInterface;

/**
 * @author Flipbox Factory <[email protected]>
 * @since 1.0.0
 */
class Scope
{
    /**
     * @var string
     */
    protected $scopeIdentifier;

    /**
     * @var Transform
     */
    protected $transform;

    /**
     * @var array
     */
    protected $parentScopes = [];

    /**
     * Scope constructor.
     * @param Transform $transform
     * @param string|null $scopeIdentifier
     * @param array $parentScopes
     */
    public function __construct(
        Transform $transform,
        string $scopeIdentifier = null,
        array $parentScopes = []
    ) {
        $this->transform = $transform;
        $this->scopeIdentifier = $scopeIdentifier;
        $this->parentScopes = $parentScopes;
    }

    /**
     * @return Transform
     */
    public function getTransform(): Transform
    {
        return $this->transform;
    }

    /**
     * @param $key
     * @return ParamBag
     */
    public function getParams(string $key = null): ParamBag
    {
        return $this->getTransform()->getParams(
            $this->getIdentifier($key)
        );
    }

    /**
     * Get the current identifier.
     *
     * @return string|null
     */
    public function getScopeIdentifier()
    {
        return $this->scopeIdentifier;
    }

    /**
     * Get the unique identifier for this scope.
     *
     * @param string $appendIdentifier
     *
     * @return string
     */
    public function getIdentifier(string $appendIdentifier = null): string
    {
        return implode(
            '.',
            array_filter(array_merge(
                $this->parentScopes,
                [
                    $this->scopeIdentifier,
                    $appendIdentifier
                ]
            ))
        );
    }

    /**
     * Getter for parentScopes.
     *
     * @return array
     */
    public function getParentScopes(): array
    {
        return $this->parentScopes;
    }

    /**
     * Is Requested.
     *
     * Check if - in relation to the current scope - this specific segment is allowed.
     * That means, if a.b.c is requested and the current scope is a.b, then c is allowed. If the current
     * scope is a then c is not allowed, even if it is there and potentially transformable.
     *
     * @internal
     *
     * @param string $checkScopeSegment
     *
     * @return bool Returns the new number of elements in the array.
     */
    public function isRequested($checkScopeSegment): bool
    {
        return in_array(
            $this->scopeString($checkScopeSegment),
            $this->transform->getIncludes()
        );
    }

    /**
     * Is Excluded.
     *
     * Check if - in relation to the current scope - this specific segment should
     * be excluded. That means, if a.b.c is excluded and the current scope is a.b,
     * then c will not be allowed in the transformation whether it appears in
     * the list of default or available, requested includes.
     *
     * @internal
     *
     * @param string $checkScopeSegment
     *
     * @return bool
     */
    public function isExcluded($checkScopeSegment): bool
    {
        return in_array(
            $this->scopeString($checkScopeSegment),
            $this->transform->getExcludes()
        );
    }

    /**
     * @param TransformerInterface|callable $transformer
     * @param mixed $data
     * @return array
     */
    public function transform(callable $transformer, $data): array
    {
        $includedData = [];

        // Transform data
        $transformedData = $this->parseValue($transformer, $data);

        // Bail now
        if (null === $transformedData) {
            return $includedData;
        }

        foreach ($transformedData as $key => $val) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            if (!$this->includeValue($transformer, $key)) {
                continue;
            }
            $includedData[$key] = $this->parseValue($val, $data, $key);
        }

        // Return only the requested fields
        $includedData = $this->filterFields($includedData);

        return $includedData;
    }

    /**
     * @param callable $transformer
     * @param string $key
     * @return bool
     */
    protected function includeValue(callable $transformer, string $key): bool
    {
        // Ignore optional (that have not been explicitly requested)
        if ($transformer instanceof TransformerInterface &&
            in_array($key, $transformer->getIncludes(), true) &&
            !$this->isRequested($key)
        ) {
            return false;
        }

        // Ignore excludes
        if ($this->isExcluded($key)) {
            return false;
        }

        return true;
    }

    /**
     * @param $val
     * @param $data
     * @param string|null $key
     * @return array|string|null
     */
    protected function parseValue($val, $data, string $key = null)
    {
        if (is_callable($val)) {
            return call_user_func_array($val, [$data, $this, $key]);
        }

        return $val;
    }

    /**
     * @param string $identifier
     * @return Scope
     */
    public function childScope(string $identifier): Scope
    {
        $parentScopes = $this->getParentScopes();
        $parentScopes[] = $this->getScopeIdentifier();

        return new Scope(
            $this->getTransform(),
            $identifier,
            $parentScopes
        );
    }

    /**
     * Check, if this is the root scope.
     *
     * @return bool
     */
    protected function isRootScope(): bool
    {
        return empty($this->parentScopes);
    }

    /**
     * Filter the provided data with the requested filter fields for
     * the scope resource
     *
     * @internal
     *
     * @param array $data
     *
     * @return array
     */
    protected function filterFields(array $data): array
    {
        $fields = $this->getFilterFields();

        if ($fields === null) {
            return $data;
        }

        return array_intersect_key(
            $data,
            array_flip(
                iterator_to_array($fields)
            )
        );
    }

    /**
     * Return the requested filter fields for the scope resource
     *
     * @internal
     *
     * @return ParamBag|null
     */
    protected function getFilterFields()
    {
        return $this->transform->getField(
            $this->getScopeIdentifier()
        );
    }

    /**
     * @param string $checkScopeSegment
     * @return string
     */
    private function scopeString(string $checkScopeSegment): string
    {
        if ($this->parentScopes) {

            $scopeArray = array_slice($this->parentScopes, 1);
            array_push($scopeArray, $this->scopeIdentifier, $checkScopeSegment);
        } else {
            $scopeArray = [$checkScopeSegment];
        }

        return implode('.', (array)$scopeArray);
    }
}


1			<?php
2
3			/**
4			* @author Flipbox Factory
5			* @copyright Copyright (c) 2017, Flipbox Digital
6			* @link https://github.com/flipbox/transform/releases/latest
7			* @license https://github.com/flipbox/transform/blob/master/LICENSE
8			*/
9
10			namespace Flipbox\Transform;
11
12			use Flipbox\Transform\Transformers\TransformerInterface;
13
14			/**
15			* @author Flipbox Factory <[email protected]>
16			* @since 1.0.0
17			*/
18			class Scope
19			{
20			/**
21			* @var string
22			*/
23			protected $scopeIdentifier;
24
25			/**
26			* @var Transform
27			*/
28			protected $transform;
29
30			/**
31			* @var array
32			*/
33			protected $parentScopes = [];
34
35			/**
36			* Scope constructor.
37			* @param Transform $transform
38			* @param string\|null $scopeIdentifier
39			* @param array $parentScopes
40			*/
41			public function __construct(
42			Transform $transform,
43			string $scopeIdentifier = null,
44			array $parentScopes = []
45			) {
46			$this->transform = $transform;
47			$this->scopeIdentifier = $scopeIdentifier;
48			$this->parentScopes = $parentScopes;
49			}
50
51			/**
52			* @return Transform
53			*/
54			public function getTransform(): Transform
55			{
56			return $this->transform;
57			}
58
59			/**
60			* @param $key
61			* @return ParamBag
62			*/
63			public function getParams(string $key = null): ParamBag
64			{
65			return $this->getTransform()->getParams(
66			$this->getIdentifier($key)
67			);
68			}
69
70			/**
71			* Get the current identifier.
72			*
73			* @return string\|null
74			*/
75			public function getScopeIdentifier()
76			{
77			return $this->scopeIdentifier;
78			}
79
80			/**
81			* Get the unique identifier for this scope.
82			*
83			* @param string $appendIdentifier
84			*
85			* @return string
86			*/
87			public function getIdentifier(string $appendIdentifier = null): string
88			{
89			return implode(
90			'.',
91			array_filter(array_merge(
92			$this->parentScopes,
93			[
94			$this->scopeIdentifier,
95			$appendIdentifier
96			]
97			))
98			);
99			}
100
101			/**
102			* Getter for parentScopes.
103			*
104			* @return array
105			*/
106			public function getParentScopes(): array
107			{
108			return $this->parentScopes;
109			}
110
111			/**
112			* Is Requested.
113			*
114			* Check if - in relation to the current scope - this specific segment is allowed.
115			* That means, if a.b.c is requested and the current scope is a.b, then c is allowed. If the current
116			* scope is a then c is not allowed, even if it is there and potentially transformable.
117			*
118			* @internal
119			*
120			* @param string $checkScopeSegment
121			*
122			* @return bool Returns the new number of elements in the array.
123			*/
124			public function isRequested($checkScopeSegment): bool
125			{
126			return in_array(
127			$this->scopeString($checkScopeSegment),
128			$this->transform->getIncludes()
129			);
130			}
131
132			/**
133			* Is Excluded.
134			*
135			* Check if - in relation to the current scope - this specific segment should
136			* be excluded. That means, if a.b.c is excluded and the current scope is a.b,
137			* then c will not be allowed in the transformation whether it appears in
138			* the list of default or available, requested includes.
139			*
140			* @internal
141			*
142			* @param string $checkScopeSegment
143			*
144			* @return bool
145			*/
146			public function isExcluded($checkScopeSegment): bool
147			{
148			return in_array(
149			$this->scopeString($checkScopeSegment),
150			$this->transform->getExcludes()
151			);
152			}
153
154			/**
155			* @param TransformerInterface\|callable $transformer
156			* @param mixed $data
157			* @return array
158			*/
159			public function transform(callable $transformer, $data): array
160			{
161			$includedData = [];
162
163			// Transform data
164			$transformedData = $this->parseValue($transformer, $data);
165
166			// Bail now
167			if (null === $transformedData) {
168			return $includedData;
169			}
170
171			foreach ($transformedData as $key => $val) {
			0 ignored issues – show Bug introduced 2017-06-03 15:06 UTC by Report Bug Copy Issue Report The expression `$transformedData` of type `array\|string` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
172			if (!$this->includeValue($transformer, $key)) {
173			continue;
174			}
175			$includedData[$key] = $this->parseValue($val, $data, $key);
176			}
177
178			// Return only the requested fields
179			$includedData = $this->filterFields($includedData);
180
181			return $includedData;
182			}
183
184			/**
185			* @param callable $transformer
186			* @param string $key
187			* @return bool
188			*/
189			protected function includeValue(callable $transformer, string $key): bool
190			{
191			// Ignore optional (that have not been explicitly requested)
192			if ($transformer instanceof TransformerInterface &&
193			in_array($key, $transformer->getIncludes(), true) &&
194			!$this->isRequested($key)
195			) {
196			return false;
197			}
198
199			// Ignore excludes
200			if ($this->isExcluded($key)) {
201			return false;
202			}
203
204			return true;
205			}
206
207			/**
208			* @param $val
209			* @param $data
210			* @param string\|null $key
211			* @return array\|string\|null
212			*/
213			protected function parseValue($val, $data, string $key = null)
214			{
215			if (is_callable($val)) {
216			return call_user_func_array($val, [$data, $this, $key]);
217			}
218
219			return $val;
220			}
221
222			/**
223			* @param string $identifier
224			* @return Scope
225			*/
226			public function childScope(string $identifier): Scope
227			{
228			$parentScopes = $this->getParentScopes();
229			$parentScopes[] = $this->getScopeIdentifier();
230
231			return new Scope(
232			$this->getTransform(),
233			$identifier,
234			$parentScopes
235			);
236			}
237
238			/**
239			* Check, if this is the root scope.
240			*
241			* @return bool
242			*/
243			protected function isRootScope(): bool
244			{
245			return empty($this->parentScopes);
246			}
247
248			/**
249			* Filter the provided data with the requested filter fields for
250			* the scope resource
251			*
252			* @internal
253			*
254			* @param array $data
255			*
256			* @return array
257			*/
258			protected function filterFields(array $data): array
259			{
260			$fields = $this->getFilterFields();
261
262			if ($fields === null) {
263			return $data;
264			}
265
266			return array_intersect_key(
267			$data,
268			array_flip(
269			iterator_to_array($fields)
270			)
271			);
272			}
273
274			/**
275			* Return the requested filter fields for the scope resource
276			*
277			* @internal
278			*
279			* @return ParamBag\|null
280			*/
281			protected function getFilterFields()
282			{
283			return $this->transform->getField(
284			$this->getScopeIdentifier()
285			);
286			}
287
288			/**
289			* @param string $checkScopeSegment
290			* @return string
291			*/
292			private function scopeString(string $checkScopeSegment): string
293			{
294			if ($this->parentScopes) {
			0 ignored issues – show Bug Best Practice introduced 2017-04-18 08:45 UTC by Report Bug Copy Issue Report The expression `$this->parentScopes` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
295			$scopeArray = array_slice($this->parentScopes, 1);
296			array_push($scopeArray, $this->scopeIdentifier, $checkScopeSegment);
297			} else {
298			$scopeArray = [$checkScopeSegment];
299			}
300
301			return implode('.', (array)$scopeArray);
302			}
303			}
304

flipbox / transform

Push — master ( 500060...605dcd )

Scope::parseValue() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like