ArgumentResolver::validateAgainstExtraArguments() - Code Metrics - Inspection of "[POC] Validate for extra arguments" - sroze/ArgumentResolver - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#7)

by Daniel

created 2018-07-02 19:43 UTC

ArgumentResolver::validateAgainstExtraArguments() A

↳ Parent: ArgumentResolver

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.9332
c	0
b	0
f	0
cc	2
nc	2
nop	2

<?php

namespace ArgumentResolver;

use ArgumentResolver\Argument\ArgumentDescription;
use ArgumentResolver\Argument\ArgumentDescriptions;
use ArgumentResolver\Argument\ArgumentDescriptor;
use ArgumentResolver\Exception\ArgumentResolutionException;
use ArgumentResolver\Exception\ResolutionException;
use ArgumentResolver\Resolution\ConstraintResolver;
use ArgumentResolver\Resolution\Resolution;
use ArgumentResolver\Resolution\ResolutionConstraint;
use ArgumentResolver\Resolution\ResolutionConstraintCollection;
use ArgumentResolver\Resolution\Resolutions;

class ArgumentResolver
{
    /**
     * @var ArgumentDescriptor
     */
    private $argumentDescriptor;

    /**
     * @var ConstraintResolver
     */
    private $constraintResolver;

    /**
     * @param ArgumentDescriptor $argumentDescriptor
     * @param ConstraintResolver $constraintResolver
     */
    public function __construct(ArgumentDescriptor $argumentDescriptor, ConstraintResolver $constraintResolver)
    {
        $this->argumentDescriptor = $argumentDescriptor;
        $this->constraintResolver = $constraintResolver;
    }

    /**
     * Resolve the arguments needed by the given callable and the order of these
     * arguments.
     *
     * It returns an array with the value of arguments in the right order.
     *
     * @param mixed $callable
     * @param array $availableArguments
     *
     * @return array
     */
    public function resolveArguments($callable, array $availableArguments = [])
    {
        $descriptions = $this->argumentDescriptor->getDescriptions($callable)->sortByPosition();
        $constraints = $this->constraintResolver->resolveConstraints($descriptions);

        $resolutions = new Resolutions();
        foreach ($descriptions as $description) {
            $resolutions->addCollection(
                $this->getArgumentResolutions($constraints, $description, $availableArguments)
            );
        }

        $this->addMissingResolutions($resolutions, $descriptions);

        $arguments = $resolutions->sortByPriority()->toArgumentsArray();

        $this->validateAgainstExtraArguments($availableArguments, $resolutions);

        return $arguments;
    }

    /**
     * @param ResolutionConstraintCollection $constraints
     * @param ArgumentDescription            $description
     * @param array                          $availableArguments
     *
     * @return Resolution[]
     */
    private function getArgumentResolutions(ResolutionConstraintCollection $constraints, ArgumentDescription $description, array $availableArguments)
    {
        $resolutions = [];

        foreach ($availableArguments as $argumentName => $argumentValue) {
            $priority = $this->getArgumentPriority($constraints, $description, $argumentName, $argumentValue);

            if ($priority > 0) {
                $resolutions[] = new Resolution($description->getPosition(), $argumentName, $argumentValue, $priority);
            }
        }

        return $resolutions;
    }

    /**
     * @param ResolutionConstraintCollection $constraints
     * @param ArgumentDescription            $description
     * @param string                         $argumentName
     * @param mixed                          $argumentValue
     *
     * @return int
     */
    private function getArgumentPriority(ResolutionConstraintCollection $constraints, ArgumentDescription $description, $argumentName, $argumentValue)
    {
        $priority = 0;
        if ($description->getName() === $argumentName) {
            $priority++;
        }

        if ($description->isScalar()) {
            return $priority;
        }

        if ($description->getType() === $this->argumentDescriptor->getValueType($argumentValue)) {
            $priority += 2;
        } elseif ($constraints->hasConstraint(ResolutionConstraint::STRICT_MATCHING, [
            'type' => $description->getType(),
        ])) {
            throw new ResolutionException(sprintf(
                'Strict matching for type "%s" can\'t be resolved',
                $description->getType()
            ));
        }

        return $priority;
    }

    /**
     * @param Resolutions          $resolutions
     * @param ArgumentDescriptions $descriptions
     *
     * @throws ResolutionException
     */
    private function addMissingResolutions(Resolutions $resolutions, ArgumentDescriptions $descriptions)
    {
        $missingResolutionPositions = $resolutions->getMissingResolutionPositions($descriptions->count());

        foreach ($missingResolutionPositions as $position) {
            $description = $descriptions->getByPosition($position);
            if ($description->isRequired()) {
                throw new ArgumentResolutionException(
                    sprintf(
                        'Argument at position %d is required and wasn\'t resolved',
                        $description->getPosition()
                    ),
                    $description
/** @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);
    }
}
                );
            }

            $resolutions->add(new Resolution($description->getPosition(), $description->getName(), $description->getDefaultValue(), 0));
        }
    }

    private function validateAgainstExtraArguments(array $availableArguments, Resolutions $resolutions)
    {
        $unrecognisedArguments = array_diff(array_keys($availableArguments), $resolutions->argumentNames());
        if (count($unrecognisedArguments) > 1) {
            throw new RuntimeException(sprintf(
                'The following arguments are not known: "%s", known arguments: "%s"',
                implode('", "', $unrecognisedArguments), implode('", "', $resolutions->argumentNames())
            ));
        }
    }
}


1			<?php
2
3			namespace ArgumentResolver;
4
5			use ArgumentResolver\Argument\ArgumentDescription;
6			use ArgumentResolver\Argument\ArgumentDescriptions;
7			use ArgumentResolver\Argument\ArgumentDescriptor;
8			use ArgumentResolver\Exception\ArgumentResolutionException;
9			use ArgumentResolver\Exception\ResolutionException;
10			use ArgumentResolver\Resolution\ConstraintResolver;
11			use ArgumentResolver\Resolution\Resolution;
12			use ArgumentResolver\Resolution\ResolutionConstraint;
13			use ArgumentResolver\Resolution\ResolutionConstraintCollection;
14			use ArgumentResolver\Resolution\Resolutions;
15
16			class ArgumentResolver
17			{
18			/**
19			* @var ArgumentDescriptor
20			*/
21			private $argumentDescriptor;
22
23			/**
24			* @var ConstraintResolver
25			*/
26			private $constraintResolver;
27
28			/**
29			* @param ArgumentDescriptor $argumentDescriptor
30			* @param ConstraintResolver $constraintResolver
31			*/
32			public function __construct(ArgumentDescriptor $argumentDescriptor, ConstraintResolver $constraintResolver)
33			{
34			$this->argumentDescriptor = $argumentDescriptor;
35			$this->constraintResolver = $constraintResolver;
36			}
37
38			/**
39			* Resolve the arguments needed by the given callable and the order of these
40			* arguments.
41			*
42			* It returns an array with the value of arguments in the right order.
43			*
44			* @param mixed $callable
45			* @param array $availableArguments
46			*
47			* @return array
48			*/
49			public function resolveArguments($callable, array $availableArguments = [])
50			{
51			$descriptions = $this->argumentDescriptor->getDescriptions($callable)->sortByPosition();
52			$constraints = $this->constraintResolver->resolveConstraints($descriptions);
53
54			$resolutions = new Resolutions();
55			foreach ($descriptions as $description) {
56			$resolutions->addCollection(
57			$this->getArgumentResolutions($constraints, $description, $availableArguments)
58			);
59			}
60
61			$this->addMissingResolutions($resolutions, $descriptions);
62
63			$arguments = $resolutions->sortByPriority()->toArgumentsArray();
64
65			$this->validateAgainstExtraArguments($availableArguments, $resolutions);
66
67			return $arguments;
68			}
69
70			/**
71			* @param ResolutionConstraintCollection $constraints
72			* @param ArgumentDescription $description
73			* @param array $availableArguments
74			*
75			* @return Resolution[]
76			*/
77			private function getArgumentResolutions(ResolutionConstraintCollection $constraints, ArgumentDescription $description, array $availableArguments)
78			{
79			$resolutions = [];
80
81			foreach ($availableArguments as $argumentName => $argumentValue) {
82			$priority = $this->getArgumentPriority($constraints, $description, $argumentName, $argumentValue);
83
84			if ($priority > 0) {
85			$resolutions[] = new Resolution($description->getPosition(), $argumentName, $argumentValue, $priority);
86			}
87			}
88
89			return $resolutions;
90			}
91
92			/**
93			* @param ResolutionConstraintCollection $constraints
94			* @param ArgumentDescription $description
95			* @param string $argumentName
96			* @param mixed $argumentValue
97			*
98			* @return int
99			*/
100			private function getArgumentPriority(ResolutionConstraintCollection $constraints, ArgumentDescription $description, $argumentName, $argumentValue)
101			{
102			$priority = 0;
103			if ($description->getName() === $argumentName) {
104			$priority++;
105			}
106
107			if ($description->isScalar()) {
108			return $priority;
109			}
110
111			if ($description->getType() === $this->argumentDescriptor->getValueType($argumentValue)) {
112			$priority += 2;
113			} elseif ($constraints->hasConstraint(ResolutionConstraint::STRICT_MATCHING, [
114			'type' => $description->getType(),
115			])) {
116			throw new ResolutionException(sprintf(
117			'Strict matching for type "%s" can\'t be resolved',
118			$description->getType()
119			));
120			}
121
122			return $priority;
123			}
124
125			/**
126			* @param Resolutions $resolutions
127			* @param ArgumentDescriptions $descriptions
128			*
129			* @throws ResolutionException
130			*/
131			private function addMissingResolutions(Resolutions $resolutions, ArgumentDescriptions $descriptions)
132			{
133			$missingResolutionPositions = $resolutions->getMissingResolutionPositions($descriptions->count());
134
135			foreach ($missingResolutionPositions as $position) {
136			$description = $descriptions->getByPosition($position);
137			if ($description->isRequired()) {
138			throw new ArgumentResolutionException(
139			sprintf(
140			'Argument at position %d is required and wasn\'t resolved',
141			$description->getPosition()
142			),
143			$description
			0 ignored issues – show Bug introduced 2017-12-16 16:46 UTC by Report Bug Copy Issue Report It seems like `$description` defined by `$descriptions->getByPosition($position)` on line `136` can be `null`; however, `ArgumentResolver\Excepti...xception::__construct()` 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...
144			);
145			}
146
147			$resolutions->add(new Resolution($description->getPosition(), $description->getName(), $description->getDefaultValue(), 0));
148			}
149			}
150
151			private function validateAgainstExtraArguments(array $availableArguments, Resolutions $resolutions)
152			{
153			$unrecognisedArguments = array_diff(array_keys($availableArguments), $resolutions->argumentNames());
154			if (count($unrecognisedArguments) > 1) {
155			throw new RuntimeException(sprintf(
156			'The following arguments are not known: "%s", known arguments: "%s"',
157			implode('", "', $unrecognisedArguments), implode('", "', $resolutions->argumentNames())
158			));
159			}
160			}
161			}
162

sroze / ArgumentResolver

Pull Request — master (#7)

ArgumentResolver::validateAgainstExtraArguments() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like