Issues in Method.php - All Issues - Inspection of "Update changelog for 5.3.5 release" - Kunstmaan/KunstmaanBundlesCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ba8ed9...770316 )

by Jeroen

created 2019-10-18 12:57 UTC

FixturesBundle/Parser/Property/Method.php (1 issue)

Showing only issues like (Show All)

Check for unnecessary variable assignments.

Unused Code Major

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Kunstmaan\FixturesBundle\Parser\Property;

class Method implements PropertyParserInterface
{
    const REGEX = '/<[a-zA-Z0-9]+\([^\)]*\)>/';

    /**
     * Check if this parser is applicable
     *
     * @return bool
     */
    public function canParse($value)
    {
        if (is_string($value) && preg_match(self::REGEX, $value)) {
            return true;
        }

        return false;
    }

    /**
     * Parse provided value into new data
     *
     * @param $value
     * @param $providers
     * @param array $references
     * @param array $additional
     *
     * @return mixed
     *
     * @throws \Exception
     */
    public function parse($value, $providers, $references = [], $additional = [])
    {
        preg_match_all(self::REGEX, $value, $matches);

        foreach ($matches[0] as $pattern) {
            preg_match_all('/[^,\(\)<>]+/', $pattern, $arguments);
            $arguments = $arguments[0];
            $method = array_shift($arguments);
            $arguments = array_map(function ($arg) {
                return trim(trim($arg), '\'""');
            }, $arguments);

            foreach ($providers as $provider) {
                /*
                 * Call method from provider with/without arguments
                 * 1: Arguments are passed through from fixture
                 * 2: Search if method needs arguments en find them through typehint and additional params
                 * 3: Magic methods without arguments
                 */
                if (method_exists($provider, $method)) {
                    $refl = new \ReflectionMethod($provider, $method);

                    if (count($arguments) < $refl->getNumberOfRequiredParameters()) {
                        $parameters = $refl->getParameters();
                        $parametersNeeded = array_slice($parameters, count($arguments));
                        $arguments = array_merge($arguments, $this->findArguments($parametersNeeded, $additional));

                        if (count($parameters) !== count($arguments)) {
                            throw new \Exception('Can not match all arguments for provider ' . get_class($provider));
                        }
                    }

                    $value = $this->processValue($pattern, $refl->invokeArgs($provider, $arguments), $value, $matches[0]);

                    break;
                } elseif (is_callable([$provider, $method])) {
                    $value = $this->processValue($pattern, call_user_func_array(array($provider, $method), $arguments), $value, $matches[0]);

                    break;
                }
            }
        }

        return $value;
    }

    private function processValue($pattern, $result, $value, $patterns)
    {
        if (!is_string($result) && !is_int($result) && count($patterns) > 1 && strlen(str_replace($pattern, '', $value)) > 0) {
            throw new \Exception(sprintf('Collision during processing of pattern "%s" on value "%s"', $pattern, $value));
        }

        if (!is_string($result) && !is_int($result)) {
            return $result;
        }

        return str_replace($pattern, $result, $value);
    }

    /**
     * @param $parameters
     * @param $additional
     *
     * @return array
     */
    private function findArguments($parameters, $additional)
    {
        $arguments = [];
        if (count($parameters) == 0) {
            return $arguments;
        }

        foreach ($parameters as $parameter) {
            $argument = $this->typeHintChecker($parameter, $additional);
            if ($argument !== null) {
                $arguments[] = $argument;

                continue;
            }

            $argument = $this->getArgumentByName($parameter, $additional);
            if ($argument !== null) {
                $arguments[] = $argument;
            }
        }

        return $arguments;
    }

    /**
     * @param \ReflectionParameter $parameter
     * @param $parameters
     *
     * @return null|object
     */
    private function typeHintChecker(\ReflectionParameter $parameter, $parameters)
    {
        $class = $parameter->getClass();
        $typeHint = null;
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        if (!$class instanceof \ReflectionClass) {
            return null;
        }

        $typeHint = $class->getName();
        foreach ($parameters as $item) {
            if ($item instanceof $typeHint) {
                return $item;
            }
        }

        return null;
    }

    /**
     * @param \ReflectionParameter $parameter
     * @param $parameters
     *
     * @return null|mixed
     */
    private function getArgumentByName(\ReflectionParameter $parameter, $parameters)
    {
        foreach ($parameters as $name => $item) {
            $paramName = $parameter->getName();
            if ($name === $paramName) {
                return $item;
            }
        }

        return null;
    }
}


1			<?php
2
3			namespace Kunstmaan\FixturesBundle\Parser\Property;
4
5			class Method implements PropertyParserInterface
6			{
7			const REGEX = '/<[a-zA-Z0-9]+\([^\)]*\)>/';
8
9			/**
10			* Check if this parser is applicable
11			*
12			* @return bool
13			*/
14			public function canParse($value)
15			{
16			if (is_string($value) && preg_match(self::REGEX, $value)) {
17			return true;
18			}
19
20			return false;
21			}
22
23			/**
24			* Parse provided value into new data
25			*
26			* @param $value
27			* @param $providers
28			* @param array $references
29			* @param array $additional
30			*
31			* @return mixed
32			*
33			* @throws \Exception
34			*/
35			public function parse($value, $providers, $references = [], $additional = [])
36			{
37			preg_match_all(self::REGEX, $value, $matches);
38
39			foreach ($matches[0] as $pattern) {
40			preg_match_all('/[^,\(\)<>]+/', $pattern, $arguments);
41			$arguments = $arguments[0];
42			$method = array_shift($arguments);
43			$arguments = array_map(function ($arg) {
44			return trim(trim($arg), '\'""');
45			}, $arguments);
46
47			foreach ($providers as $provider) {
48			/*
49			* Call method from provider with/without arguments
50			* 1: Arguments are passed through from fixture
51			* 2: Search if method needs arguments en find them through typehint and additional params
52			* 3: Magic methods without arguments
53			*/
54			if (method_exists($provider, $method)) {
55			$refl = new \ReflectionMethod($provider, $method);
56
57			if (count($arguments) < $refl->getNumberOfRequiredParameters()) {
58			$parameters = $refl->getParameters();
59			$parametersNeeded = array_slice($parameters, count($arguments));
60			$arguments = array_merge($arguments, $this->findArguments($parametersNeeded, $additional));
61
62			if (count($parameters) !== count($arguments)) {
63			throw new \Exception('Can not match all arguments for provider ' . get_class($provider));
64			}
65			}
66
67			$value = $this->processValue($pattern, $refl->invokeArgs($provider, $arguments), $value, $matches[0]);
68
69			break;
70			} elseif (is_callable([$provider, $method])) {
71			$value = $this->processValue($pattern, call_user_func_array(array($provider, $method), $arguments), $value, $matches[0]);
72
73			break;
74			}
75			}
76			}
77
78			return $value;
79			}
80
81			private function processValue($pattern, $result, $value, $patterns)
82			{
83			if (!is_string($result) && !is_int($result) && count($patterns) > 1 && strlen(str_replace($pattern, '', $value)) > 0) {
84			throw new \Exception(sprintf('Collision during processing of pattern "%s" on value "%s"', $pattern, $value));
85			}
86
87			if (!is_string($result) && !is_int($result)) {
88			return $result;
89			}
90
91			return str_replace($pattern, $result, $value);
92			}
93
94			/**
95			* @param $parameters
96			* @param $additional
97			*
98			* @return array
99			*/
100			private function findArguments($parameters, $additional)
101			{
102			$arguments = [];
103			if (count($parameters) == 0) {
104			return $arguments;
105			}
106
107			foreach ($parameters as $parameter) {
108			$argument = $this->typeHintChecker($parameter, $additional);
109			if ($argument !== null) {
110			$arguments[] = $argument;
111
112			continue;
113			}
114
115			$argument = $this->getArgumentByName($parameter, $additional);
116			if ($argument !== null) {
117			$arguments[] = $argument;
118			}
119			}
120
121			return $arguments;
122			}
123
124			/**
125			* @param \ReflectionParameter $parameter
126			* @param $parameters
127			*
128			* @return null\|object
129			*/
130			private function typeHintChecker(\ReflectionParameter $parameter, $parameters)
131			{
132			$class = $parameter->getClass();
133			$typeHint = null;
			0 ignored issues – show Unused Code introduced 2017-11-21 06:15 UTC by Report Bug Copy Issue Report Show Similar Issues like this `$typeHint` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
134			if (!$class instanceof \ReflectionClass) {
135			return null;
136			}
137
138			$typeHint = $class->getName();
139			foreach ($parameters as $item) {
140			if ($item instanceof $typeHint) {
141			return $item;
142			}
143			}
144
145			return null;
146			}
147
148			/**
149			* @param \ReflectionParameter $parameter
150			* @param $parameters
151			*
152			* @return null\|mixed
153			*/
154			private function getArgumentByName(\ReflectionParameter $parameter, $parameters)
155			{
156			foreach ($parameters as $name => $item) {
157			$paramName = $parameter->getName();
158			if ($name === $paramName) {
159			return $item;
160			}
161			}
162
163			return null;
164			}
165			}
166

Kunstmaan / KunstmaanBundlesCMS

Push — master ( ba8ed9...770316 )

FixturesBundle/Parser/Property/Method.php (1 issue)

Showing only issues like (Show All)

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like