RequestExpander - Code Metrics - Inspection of "Handle null payloads more effectively" - Algo-Web/POData - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#167)

by Alex

created 2017-09-30 11:45 UTC

RequestExpander B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	398
Duplicated Lines	6.78 %

Coupling/Cohesion

Components	1
Dependencies	14

Importance

Changes

Metric	Value
wmc	42
c	0
b	0
f	0
lcom	1
cbo	14
dl	27
loc	398
rs	8.295

18 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getRequest()	0	4	1
A	getProviders()	0	4	1
A	getService()	0	4	1
A	getStack()	0	4	1
B	handleExpansion()	0	12	6
D	executeExpansion()	0	44	9
A	getCurrentResourceSetWrapper()	7	7	2
A	pushSegmentForRoot()	0	7	1
B	pushSegmentForNavigationProperty()	0	26	2
A	getExpandedProjectionNodes()	0	14	4
A	getCurrentExpandedProjectionNode()	20	20	4
A	pushSegment()	0	4	1
A	popSegment()	0	4	1
A	executeCollectionExpansionGetRelated()	0	21	1
A	executeSingleExpansionGetRelated()	0	22	2
A	executeCollectionExpansionProcessExpansion()	0	21	3
A	pushPropertyToNavigation()	0	7	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like RequestExpander often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use RequestExpander, and based on these observations, apply Extract Interface, too.

<?php

namespace POData\UriProcessor;

use POData\Common\InvalidOperationException;
use POData\IService;
use POData\Providers\Metadata\ResourceProperty;
use POData\Providers\Metadata\ResourcePropertyKind;
use POData\Providers\Metadata\ResourceSetWrapper;
use POData\Providers\Metadata\ResourceTypeKind;
use POData\Providers\ProvidersWrapper;
use POData\Providers\Query\QueryResult;
use POData\Providers\Query\QueryType;
use POData\UriProcessor\QueryProcessor\ExpandProjectionParser\ExpandedProjectionNode;

class RequestExpander
{
    /**
     * Description of the OData request that a client has submitted.
     *
     * @var RequestDescription
     */
    private $request;

    /**
     * Holds reference to the data service instance.
     *
     * @var IService
     */
    private $service;

    /**
     * Holds reference to the wrapper over IDSMP and IDSQP implementation.
     *
     * @var ProvidersWrapper
     */
    private $providers;

    /**
     * Holds reference to segment stack being processed.
     *
     * @var SegmentStack
     */
    private $stack;

    public function __construct(RequestDescription $request, IService $service, ProvidersWrapper $wrapper)
    {
        $this->request = $request;
        $this->service = $service;
        $this->providers = $wrapper;
        $this->stack = new SegmentStack($request);
    }

    /**
     * Gets reference to the request submitted by client.
     *
     * @return RequestDescription
     */
    public function getRequest()
    {
        return $this->request;
    }

    /**
     * Gets reference to the request submitted by client.
     *
     * @return ProvidersWrapper
     */
    public function getProviders()
    {
        return $this->providers;
    }

    /**
     * Gets the data service instance.
     *
     * @return IService
     */
    public function getService()
    {
        return $this->service;
    }

    /**
     * Gets the segment stack instance.
     *
     * @return SegmentStack
     */
    public function getStack()
    {
        return $this->stack;
    }

    /**
     * Perform expansion.
     *
     * @return void
     */
    public function handleExpansion()
    {
        $node = $this->getRequest()->getRootProjectionNode();
        if (null !== $node && $node->isExpansionSpecified()) {
            $result = $this->getRequest()->getTargetResult();
            if (null !== $result && (!is_array($result) || !empty($result))) {
                $needPop = $this->pushSegmentForRoot();
                $this->executeExpansion($result);
                $this->popSegment(true === $needPop);
            }
        }
    }

    /**
     * Execute queries for expansion.
     *
     * @param array|mixed $result Resource(s) whose navigation properties needs to be expanded
     */
    private function executeExpansion($result)
    {
        $expandedProjectionNodes = $this->getExpandedProjectionNodes();
        foreach ($expandedProjectionNodes as $expandedProjectionNode) {
            $resourceType = $expandedProjectionNode->getResourceType();
            $isCollection = ResourcePropertyKind::RESOURCESET_REFERENCE
                            == $expandedProjectionNode->getResourceProperty()->getKind();
            $expandedPropertyName = $expandedProjectionNode->getResourceProperty()->getName();
            $originalIsArray = is_array($result);

            if (!$originalIsArray) {
                $result = [$result];

            }

            foreach ($result as $entry) {
                // Check for null entry
                if ($entry instanceof QueryResult && empty($entry->results)) {
                    continue;
                }
                if ($isCollection) {
                    $result1 = $this->executeCollectionExpansionGetRelated($expandedProjectionNode, $entry);
                    if (!empty($result1)) {
                        $this->executeCollectionExpansionProcessExpansion(
                            $entry,
                            $result1,
                            $expandedProjectionNode,
                            $resourceType,
                            $expandedPropertyName
                        );
                    } else {
                        $resultSet = $originalIsArray ? [] : $result1;
                        $resourceType->setPropertyValue($entry, $expandedPropertyName, $resultSet);
                    }
                } else {
                    $this->executeSingleExpansionGetRelated(
                        $expandedProjectionNode,
                        $entry,
                        $resourceType,
                        $expandedPropertyName
                    );
                }
            }
        }
    }

    /**
     * Resource set wrapper for the resource being retrieved.
     *
     * @return ResourceSetWrapper
     */
    private function getCurrentResourceSetWrapper()

    {
        $wraps = $this->getStack()->getSegmentWrappers();
        $count = count($wraps);

        return 0 == $count ? $this->getRequest()->getTargetResourceSetWrapper() : $wraps[$count - 1];
    }

    /**
     * Pushes a segment for the root of the tree
     * Note: Calls to this method should be balanced with calls to popSegment.
     *
     * @return bool true if the segment was pushed, false otherwise
     */
    private function pushSegmentForRoot()

    {
        $segmentName = $this->getRequest()->getContainerName();
        $segmentResourceSetWrapper = $this->getRequest()->getTargetResourceSetWrapper();

        return $this->pushSegment($segmentName, $segmentResourceSetWrapper);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
    }

    /**
     * Pushes a segment for the current navigation property being written out.
     * Note: Refer 'ObjectModelSerializerNotes.txt' for more details about
     * 'Segment Stack' and this method.
     * Note: Calls to this method should be balanced with calls to popSegment.
     *
     * @param ResourceProperty &$resourceProperty Current navigation property
     *                                            being written out
     *
     * @throws InvalidOperationException If this function invoked with non-navigation
     *                                   property instance
     *
     * @return bool true if a segment was pushed, false otherwise
     */
    private function pushSegmentForNavigationProperty(ResourceProperty &$resourceProperty)

    {
        if ($resourceProperty->getTypeKind() == ResourceTypeKind::ENTITY()) {
            assert(!empty($this->getStack()->getSegmentNames()), '!is_empty($this->getStack()->getSegmentNames())');
            $currentResourceSetWrapper = $this->getCurrentResourceSetWrapper();
            $currentResourceType = $currentResourceSetWrapper->getResourceType();
            $currentResourceSetWrapper = $this->getService()
                ->getProvidersWrapper()
                ->getResourceSetWrapperForNavigationProperty(
                    $currentResourceSetWrapper,
                    $currentResourceType,
                    $resourceProperty
                );

            assert(null !== $currentResourceSetWrapper, '!null($currentResourceSetWrapper)');

            return $this->pushSegment(
                $resourceProperty->getName(),
                $currentResourceSetWrapper
            );
        } else {
            throw new InvalidOperationException(
                'pushSegmentForNavigationProperty should not be called with non-entity type'
            );
        }
    }

    /**
     * Gets collection of expanded projection nodes under the current node.
     *
     * @return ExpandedProjectionNode[] List of nodes describing expansions for the current segment
     */
    protected function getExpandedProjectionNodes()
    {
        $expandedProjectionNode = $this->getCurrentExpandedProjectionNode();
        $expandedProjectionNodes = [];
        if (null !== $expandedProjectionNode) {
            foreach ($expandedProjectionNode->getChildNodes() as $node) {
                if ($node instanceof ExpandedProjectionNode) {
                    $expandedProjectionNodes[] = $node;
                }
            }
        }

        return $expandedProjectionNodes;
    }

    /**
     * Find a 'ExpandedProjectionNode' instance in the projection tree
     * which describes the current segment.
     *
     * @return ExpandedProjectionNode|null
     */
    private function getCurrentExpandedProjectionNode()

    {
        $expandedProjectionNode = $this->getRequest()->getRootProjectionNode();
        if (null !== $expandedProjectionNode) {
            $names = $this->getStack()->getSegmentNames();
            $depth = count($names);
            if (0 != $depth) {
                for ($i = 1; $i < $depth; ++$i) {
                    $expandedProjectionNode = $expandedProjectionNode->findNode($names[$i]);
                    assert(null !== $expandedProjectionNode, '!is_null($expandedProjectionNode)');
                    assert(
                        $expandedProjectionNode instanceof ExpandedProjectionNode,
                        '$expandedProjectionNode instanceof ExpandedProjectionNode'
                    );
                }
            }
        }

        return $expandedProjectionNode;
    }

    /**
     * Pushes information about the segment whose instance is going to be
     * retrieved from the IDSQP implementation
     * Note: Calls to this method should be balanced with calls to popSegment.
     *
     * @param string             $segmentName         Name of segment to push
     * @param ResourceSetWrapper &$resourceSetWrapper The resource set wrapper
     *                                                to push
     *
     * @return bool true if the segment was push, false otherwise
     */
    private function pushSegment($segmentName, ResourceSetWrapper &$resourceSetWrapper)

    {
        return $this->getStack()->pushSegment($segmentName, $resourceSetWrapper);
    }

    /**
     * Pops segment information from the 'Segment Stack'
     * Note: Calls to this method should be balanced with previous calls
     * to _pushSegment.
     *
     * @param bool $needPop Is a pop required. Only true if last push
     *                      was successful
     *
     * @throws InvalidOperationException If found un-balanced call
     *                                   with _pushSegment
     */
    private function popSegment($needPop)
    {
        $this->getStack()->popSegment($needPop);
    }

    /**
     * @param ExpandedProjectionNode $expandedProjectionNode
     * @param $entry
     *
     * @return object[]|null
     */
    private function executeCollectionExpansionGetRelated($expandedProjectionNode, $entry)
    {
        $currentResourceSet = $this->getCurrentResourceSetWrapper()->getResourceSet();
        $resourceSetOfProjectedProperty = $expandedProjectionNode
            ->getResourceSetWrapper()
            ->getResourceSet();
        $projectedProperty = $expandedProjectionNode->getResourceProperty();
        $result = $this->getProviders()->getRelatedResourceSet(
            QueryType::ENTITIES(), //it's always entities for an expansion
            $currentResourceSet,
            $entry,
            $resourceSetOfProjectedProperty,
            $projectedProperty,
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
            null, // $filter
            null, // $orderby
            null, // $top
            null  // $skip
        )->results;

        return $result;
    }

    /**
     * @param ExpandedProjectionNode $expandedProjectionNode
     * @param $entry
     * @param \POData\Providers\Metadata\ResourceType $resourceType
     * @param string                                  $expandedPropertyName
     *
     * @throws InvalidOperationException
     * @throws \POData\Common\ODataException
     */
    private function executeSingleExpansionGetRelated(
        $expandedProjectionNode,
        $entry,
        $resourceType,
        $expandedPropertyName
    ) {
        $currentResourceSet = $this->getCurrentResourceSetWrapper()->getResourceSet();
        $resourceSetOfProjectedProperty = $expandedProjectionNode
            ->getResourceSetWrapper()
            ->getResourceSet();
        $projectedProperty = $expandedProjectionNode->getResourceProperty();
        $result = $this->getProviders()->getRelatedResourceReference(
            $currentResourceSet,
            $entry,
            $resourceSetOfProjectedProperty,
            $projectedProperty
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        );
        $resourceType->setPropertyValue($entry, $expandedPropertyName, $result);
        if (null !== $result) {
            $this->pushPropertyToNavigation($result, $expandedProjectionNode);
        }
    }

    /**
     * @param $entry
     * @param $result
     * @param ExpandedProjectionNode                  $expandedProjectionNode
     * @param \POData\Providers\Metadata\ResourceType $resourceType
     * @param string                                  $expandedPropertyName
     *
     * @throws InvalidOperationException
     */
    private function executeCollectionExpansionProcessExpansion(
        $entry,
        $result,
        $expandedProjectionNode,
        $resourceType,
        $expandedPropertyName
    ) {
        $internalOrderByInfo = $expandedProjectionNode->getInternalOrderByInfo();
        if (null !== $internalOrderByInfo) {
            $orderByFunction = $internalOrderByInfo->getSorterFunction();
            usort($result, $orderByFunction);
            unset($internalOrderByInfo);
            $takeCount = $expandedProjectionNode->getTakeCount();
            if (null !== $takeCount) {
                $result = array_slice($result, 0, $takeCount);

            }
        }

        $resourceType->setPropertyValue($entry, $expandedPropertyName, $result);
        $this->pushPropertyToNavigation($result, $expandedProjectionNode);
    }

    /**
     * @param $result
     * @param ExpandedProjectionNode $expandedProjectionNode
     *
     * @throws InvalidOperationException
     */
    private function pushPropertyToNavigation($result, $expandedProjectionNode)
    {
        $projectedProperty = $expandedProjectionNode->getResourceProperty();
        $needPop = $this->pushSegmentForNavigationProperty($projectedProperty);
/** @return stdClass|null */
function mayReturnNull() { }

function doesNotAcceptNull(stdClass $x) { }

// With potential error.
function withoutCheck() {
    $x = mayReturnNull();
    doesNotAcceptNull($x); // Potential error here.
}

// Safe - Alternative 1
function withCheck1() {
    $x = mayReturnNull();
    if ( ! $x instanceof stdClass) {
        throw new \LogicException('$x must be defined.');
    }
    doesNotAcceptNull($x);
}

// Safe - Alternative 2
function withCheck2() {
    $x = mayReturnNull();
    if ($x instanceof stdClass) {
        doesNotAcceptNull($x);
    }
}
        $this->executeExpansion($result);
        $this->popSegment(true === $needPop);
    }
}


1		<?php
2
3		namespace POData\UriProcessor;
4
5		use POData\Common\InvalidOperationException;
6		use POData\IService;
7		use POData\Providers\Metadata\ResourceProperty;
8		use POData\Providers\Metadata\ResourcePropertyKind;
9		use POData\Providers\Metadata\ResourceSetWrapper;
10		use POData\Providers\Metadata\ResourceTypeKind;
11		use POData\Providers\ProvidersWrapper;
12		use POData\Providers\Query\QueryResult;
13		use POData\Providers\Query\QueryType;
14		use POData\UriProcessor\QueryProcessor\ExpandProjectionParser\ExpandedProjectionNode;
15
16		class RequestExpander
17		{
18		/**
19		* Description of the OData request that a client has submitted.
20		*
21		* @var RequestDescription
22		*/
23		private $request;
24
25		/**
26		* Holds reference to the data service instance.
27		*
28		* @var IService
29		*/
30		private $service;
31
32		/**
33		* Holds reference to the wrapper over IDSMP and IDSQP implementation.
34		*
35		* @var ProvidersWrapper
36		*/
37		private $providers;
38
39		/**
40		* Holds reference to segment stack being processed.
41		*
42		* @var SegmentStack
43		*/
44		private $stack;
45
46		public function __construct(RequestDescription $request, IService $service, ProvidersWrapper $wrapper)
47		{
48		$this->request = $request;
49		$this->service = $service;
50		$this->providers = $wrapper;
51		$this->stack = new SegmentStack($request);
52		}
53
54		/**
55		* Gets reference to the request submitted by client.
56		*
57		* @return RequestDescription
58		*/
59		public function getRequest()
60		{
61		return $this->request;
62		}
63
64		/**
65		* Gets reference to the request submitted by client.
66		*
67		* @return ProvidersWrapper
68		*/
69		public function getProviders()
70		{
71		return $this->providers;
72		}
73
74		/**
75		* Gets the data service instance.
76		*
77		* @return IService
78		*/
79		public function getService()
80		{
81		return $this->service;
82		}
83
84		/**
85		* Gets the segment stack instance.
86		*
87		* @return SegmentStack
88		*/
89		public function getStack()
90		{
91		return $this->stack;
92		}
93
94		/**
95		* Perform expansion.
96		*
97		* @return void
98		*/
99		public function handleExpansion()
100		{
101		$node = $this->getRequest()->getRootProjectionNode();
102		if (null !== $node && $node->isExpansionSpecified()) {
103		$result = $this->getRequest()->getTargetResult();
104		if (null !== $result && (!is_array($result) \|\| !empty($result))) {
105		$needPop = $this->pushSegmentForRoot();
106		$this->executeExpansion($result);
107		$this->popSegment(true === $needPop);
108		}
109		}
110		}
111
112		/**
113		* Execute queries for expansion.
114		*
115		* @param array\|mixed $result Resource(s) whose navigation properties needs to be expanded
116		*/
117		private function executeExpansion($result)
118		{
119		$expandedProjectionNodes = $this->getExpandedProjectionNodes();
120		foreach ($expandedProjectionNodes as $expandedProjectionNode) {
121		$resourceType = $expandedProjectionNode->getResourceType();
122		$isCollection = ResourcePropertyKind::RESOURCESET_REFERENCE
123		== $expandedProjectionNode->getResourceProperty()->getKind();
124		$expandedPropertyName = $expandedProjectionNode->getResourceProperty()->getName();
125		$originalIsArray = is_array($result);
126
127		if (!$originalIsArray) {
128		$result = [$result];
		0 ignored issues – show Coding Style introduced 2017-07-15 02:33 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$result`. This often makes code more readable. Loading history...
129		}
130
131		foreach ($result as $entry) {
132		// Check for null entry
133		if ($entry instanceof QueryResult && empty($entry->results)) {
134		continue;
135		}
136		if ($isCollection) {
137		$result1 = $this->executeCollectionExpansionGetRelated($expandedProjectionNode, $entry);
138		if (!empty($result1)) {
139		$this->executeCollectionExpansionProcessExpansion(
140		$entry,
141		$result1,
142		$expandedProjectionNode,
143		$resourceType,
144		$expandedPropertyName
145		);
146		} else {
147		$resultSet = $originalIsArray ? [] : $result1;
148		$resourceType->setPropertyValue($entry, $expandedPropertyName, $resultSet);
149		}
150		} else {
151		$this->executeSingleExpansionGetRelated(
152		$expandedProjectionNode,
153		$entry,
154		$resourceType,
155		$expandedPropertyName
156		);
157		}
158		}
159		}
160		}
161
162		/**
163		* Resource set wrapper for the resource being retrieved.
164		*
165		* @return ResourceSetWrapper
166		*/
167	View Code Duplication	private function getCurrentResourceSetWrapper()
		0 ignored issues – show Duplication introduced 2017-07-31 16:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
168		{
169		$wraps = $this->getStack()->getSegmentWrappers();
170		$count = count($wraps);
171
172		return 0 == $count ? $this->getRequest()->getTargetResourceSetWrapper() : $wraps[$count - 1];
173		}
174
175		/**
176		* Pushes a segment for the root of the tree
177		* Note: Calls to this method should be balanced with calls to popSegment.
178		*
179		* @return bool true if the segment was pushed, false otherwise
180		*/
181		private function pushSegmentForRoot()
		0 ignored issues – show Coding Style introduced 2017-07-31 16:57 UTC by Report Bug Copy Issue Report `function pushSegmentForRoot()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
182		{
183		$segmentName = $this->getRequest()->getContainerName();
184		$segmentResourceSetWrapper = $this->getRequest()->getTargetResourceSetWrapper();
185
186		return $this->pushSegment($segmentName, $segmentResourceSetWrapper);
		0 ignored issues – show Bug introduced 2017-02-08 08:32 UTC by Report Bug Copy Issue Report It seems like `$segmentResourceSetWrapper` defined by `$this->getRequest()->get...getResourceSetWrapper()` on line `184` can be `null`; however, `POData\UriProcessor\RequestExpander::pushSegment()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
187		}
188
189		/**
190		* Pushes a segment for the current navigation property being written out.
191		* Note: Refer 'ObjectModelSerializerNotes.txt' for more details about
192		* 'Segment Stack' and this method.
193		* Note: Calls to this method should be balanced with calls to popSegment.
194		*
195		* @param ResourceProperty &$resourceProperty Current navigation property
196		* being written out
197		*
198		* @throws InvalidOperationException If this function invoked with non-navigation
199		* property instance
200		*
201		* @return bool true if a segment was pushed, false otherwise
202		*/
203		private function pushSegmentForNavigationProperty(ResourceProperty &$resourceProperty)
		0 ignored issues – show Coding Style introduced 2017-07-31 16:57 UTC by Report Bug Copy Issue Report `function pushSegmentForNavigationProperty()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
204		{
205		if ($resourceProperty->getTypeKind() == ResourceTypeKind::ENTITY()) {
206		assert(!empty($this->getStack()->getSegmentNames()), '!is_empty($this->getStack()->getSegmentNames())');
207		$currentResourceSetWrapper = $this->getCurrentResourceSetWrapper();
208		$currentResourceType = $currentResourceSetWrapper->getResourceType();
209		$currentResourceSetWrapper = $this->getService()
210		->getProvidersWrapper()
211		->getResourceSetWrapperForNavigationProperty(
212		$currentResourceSetWrapper,
213		$currentResourceType,
214		$resourceProperty
215		);
216
217		assert(null !== $currentResourceSetWrapper, '!null($currentResourceSetWrapper)');
218
219		return $this->pushSegment(
220		$resourceProperty->getName(),
221		$currentResourceSetWrapper
222		);
223		} else {
224		throw new InvalidOperationException(
225		'pushSegmentForNavigationProperty should not be called with non-entity type'
226		);
227		}
228		}
229
230		/**
231		* Gets collection of expanded projection nodes under the current node.
232		*
233		* @return ExpandedProjectionNode[] List of nodes describing expansions for the current segment
234		*/
235		protected function getExpandedProjectionNodes()
236		{
237		$expandedProjectionNode = $this->getCurrentExpandedProjectionNode();
238		$expandedProjectionNodes = [];
239		if (null !== $expandedProjectionNode) {
240		foreach ($expandedProjectionNode->getChildNodes() as $node) {
241		if ($node instanceof ExpandedProjectionNode) {
242		$expandedProjectionNodes[] = $node;
243		}
244		}
245		}
246
247		return $expandedProjectionNodes;
248		}
249
250		/**
251		* Find a 'ExpandedProjectionNode' instance in the projection tree
252		* which describes the current segment.
253		*
254		* @return ExpandedProjectionNode\|null
255		*/
256	View Code Duplication	private function getCurrentExpandedProjectionNode()
		0 ignored issues – show Duplication introduced 2017-07-31 16:57 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
257		{
258		$expandedProjectionNode = $this->getRequest()->getRootProjectionNode();
259		if (null !== $expandedProjectionNode) {
260		$names = $this->getStack()->getSegmentNames();
261		$depth = count($names);
262		if (0 != $depth) {
263		for ($i = 1; $i < $depth; ++$i) {
264		$expandedProjectionNode = $expandedProjectionNode->findNode($names[$i]);
265		assert(null !== $expandedProjectionNode, '!is_null($expandedProjectionNode)');
266		assert(
267		$expandedProjectionNode instanceof ExpandedProjectionNode,
268		'$expandedProjectionNode instanceof ExpandedProjectionNode'
269		);
270		}
271		}
272		}
273
274		return $expandedProjectionNode;
275		}
276
277		/**
278		* Pushes information about the segment whose instance is going to be
279		* retrieved from the IDSQP implementation
280		* Note: Calls to this method should be balanced with calls to popSegment.
281		*
282		* @param string $segmentName Name of segment to push
283		* @param ResourceSetWrapper &$resourceSetWrapper The resource set wrapper
284		* to push
285		*
286		* @return bool true if the segment was push, false otherwise
287		*/
288		private function pushSegment($segmentName, ResourceSetWrapper &$resourceSetWrapper)
		0 ignored issues – show Coding Style introduced 2017-07-31 16:57 UTC by Report Bug Copy Issue Report `function pushSegment()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
289		{
290		return $this->getStack()->pushSegment($segmentName, $resourceSetWrapper);
291		}
292
293		/**
294		* Pops segment information from the 'Segment Stack'
295		* Note: Calls to this method should be balanced with previous calls
296		* to _pushSegment.
297		*
298		* @param bool $needPop Is a pop required. Only true if last push
299		* was successful
300		*
301		* @throws InvalidOperationException If found un-balanced call
302		* with _pushSegment
303		*/
304		private function popSegment($needPop)
305		{
306		$this->getStack()->popSegment($needPop);
307		}
308
309		/**
310		* @param ExpandedProjectionNode $expandedProjectionNode
311		* @param $entry
312		*
313		* @return object[]\|null
314		*/
315		private function executeCollectionExpansionGetRelated($expandedProjectionNode, $entry)
316		{
317		$currentResourceSet = $this->getCurrentResourceSetWrapper()->getResourceSet();
318		$resourceSetOfProjectedProperty = $expandedProjectionNode
319		->getResourceSetWrapper()
320		->getResourceSet();
321		$projectedProperty = $expandedProjectionNode->getResourceProperty();
322		$result = $this->getProviders()->getRelatedResourceSet(
323		QueryType::ENTITIES(), //it's always entities for an expansion
324		$currentResourceSet,
325		$entry,
326		$resourceSetOfProjectedProperty,
327		$projectedProperty,
		0 ignored issues – show Bug introduced 2017-07-21 13:50 UTC by Report Bug Copy Issue Report It seems like `$projectedProperty` defined by `$expandedProjectionNode->getResourceProperty()` on line `321` can be `null`; however, `POData\Providers\Provide...getRelatedResourceSet()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
328		null, // $filter
329		null, // $orderby
330		null, // $top
331		null // $skip
332		)->results;
333
334		return $result;
335		}
336
337		/**
338		* @param ExpandedProjectionNode $expandedProjectionNode
339		* @param $entry
340		* @param \POData\Providers\Metadata\ResourceType $resourceType
341		* @param string $expandedPropertyName
342		*
343		* @throws InvalidOperationException
344		* @throws \POData\Common\ODataException
345		*/
346		private function executeSingleExpansionGetRelated(
347		$expandedProjectionNode,
348		$entry,
349		$resourceType,
350		$expandedPropertyName
351		) {
352		$currentResourceSet = $this->getCurrentResourceSetWrapper()->getResourceSet();
353		$resourceSetOfProjectedProperty = $expandedProjectionNode
354		->getResourceSetWrapper()
355		->getResourceSet();
356		$projectedProperty = $expandedProjectionNode->getResourceProperty();
357		$result = $this->getProviders()->getRelatedResourceReference(
358		$currentResourceSet,
359		$entry,
360		$resourceSetOfProjectedProperty,
361		$projectedProperty
		0 ignored issues – show Bug introduced 2017-07-21 13:50 UTC by Report Bug Copy Issue Report It seems like `$projectedProperty` defined by `$expandedProjectionNode->getResourceProperty()` on line `356` can be `null`; however, `POData\Providers\Provide...atedResourceReference()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
362		);
363		$resourceType->setPropertyValue($entry, $expandedPropertyName, $result);
364		if (null !== $result) {
365		$this->pushPropertyToNavigation($result, $expandedProjectionNode);
366		}
367		}
368
369		/**
370		* @param $entry
371		* @param $result
372		* @param ExpandedProjectionNode $expandedProjectionNode
373		* @param \POData\Providers\Metadata\ResourceType $resourceType
374		* @param string $expandedPropertyName
375		*
376		* @throws InvalidOperationException
377		*/
378		private function executeCollectionExpansionProcessExpansion(
379		$entry,
380		$result,
381		$expandedProjectionNode,
382		$resourceType,
383		$expandedPropertyName
384		) {
385		$internalOrderByInfo = $expandedProjectionNode->getInternalOrderByInfo();
386		if (null !== $internalOrderByInfo) {
387		$orderByFunction = $internalOrderByInfo->getSorterFunction();
388		usort($result, $orderByFunction);
389		unset($internalOrderByInfo);
390		$takeCount = $expandedProjectionNode->getTakeCount();
391		if (null !== $takeCount) {
392		$result = array_slice($result, 0, $takeCount);
		0 ignored issues – show Coding Style introduced 2017-07-15 02:33 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$result`. This often makes code more readable. Loading history...
393		}
394		}
395
396		$resourceType->setPropertyValue($entry, $expandedPropertyName, $result);
397		$this->pushPropertyToNavigation($result, $expandedProjectionNode);
398		}
399
400		/**
401		* @param $result
402		* @param ExpandedProjectionNode $expandedProjectionNode
403		*
404		* @throws InvalidOperationException
405		*/
406		private function pushPropertyToNavigation($result, $expandedProjectionNode)
407		{
408		$projectedProperty = $expandedProjectionNode->getResourceProperty();
409		$needPop = $this->pushSegmentForNavigationProperty($projectedProperty);
		0 ignored issues – show Bug introduced 2017-07-21 13:50 UTC by Report Bug Copy Issue Report It seems like `$projectedProperty` defined by `$expandedProjectionNode->getResourceProperty()` on line `408` can be `null`; however, `POData\UriProcessor\Requ...ForNavigationProperty()` does not accept `null`, maybe add an additional type check? Unless you are absolutely sure that the expression can never be null because of other conditions, we strongly recommend to add an additional type check to your code: /** @return stdClass\|null */ function mayReturnNull() { } function doesNotAcceptNull(stdClass $x) { } // With potential error. function withoutCheck() { $x = mayReturnNull(); doesNotAcceptNull($x); // Potential error here. } // Safe - Alternative 1 function withCheck1() { $x = mayReturnNull(); if ( ! $x instanceof stdClass) { throw new \LogicException('$x must be defined.'); } doesNotAcceptNull($x); } // Safe - Alternative 2 function withCheck2() { $x = mayReturnNull(); if ($x instanceof stdClass) { doesNotAcceptNull($x); } } Loading history...
410		$this->executeExpansion($result);
411		$this->popSegment(true === $needPop);
412		}
413		}
414

Algo-Web / POData