Argument::serialize() - Code Metrics - Inspection of "Merge pull request #178 from koriym/arg" - ray-di/Ray.Di - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 2.x ( 804da3...144798 )

by Akihito

created 2018-05-02 19:06 UTC

Argument::serialize() A

↳ Parent: Argument

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	16
ccs	10
cts	10
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	11
nc	1
nop	0
crap	1

<?php

declare(strict_types=1);
/**
 * This file is part of the Ray.Di package.
 *
 * @license http://opensource.org/licenses/MIT MIT
 */
namespace Ray\Di;

final class Argument implements \Serializable
{
    /**
     * @var string
     */
    private $index;

    /**
     * @var bool
     */
    private $isDefaultAvailable;

    /**
     * @var mixed
     */
    private $default;

    /**
     * @var string
     */
    private $meta;

    /**
     * @var \ReflectionParameter
     */
    private $reflection;

    public function __construct(\ReflectionParameter $parameter, string $name)
    {
        $type = $this->getType($parameter);
        $isOptional = $parameter->isOptional();
        $this->isDefaultAvailable = $parameter->isDefaultValueAvailable() || $isOptional;
        if ($isOptional) {
            $this->default = null;
        }
        $this->setDefaultValue($parameter);
        $this->index = $type . '-' . $name;
        $this->reflection = $parameter;
        $this->meta = sprintf(
            "dependency '%s' with name '%s' used in %s:%d ($%s)",
            $type,
            $name,
            $this->reflection->getDeclaringFunction()->getFileName(),
            $this->reflection->getDeclaringFunction()->getStartLine(),
            $parameter->getName()

        );
    }

    /**
     * @return string
     */
    public function __toString()
    {
        return $this->index;
    }

    /**
     * Return reflection
     */
    public function get() : \ReflectionParameter
    {
        return $this->reflection;
    }

    /**
     * @return bool
     */
    public function isDefaultAvailable() : bool
    {
        return $this->isDefaultAvailable;
    }

    /**
     * @return mixed
     */
    public function getDefaultValue()
    {
        return $this->default;
    }

    public function getMeta() : string
    {
        return $this->meta;
    }

    public function serialize() : string
    {
        $ref = [
            $this->reflection->getDeclaringFunction()->class,

            $this->reflection->getDeclaringFunction()->name,
            $this->reflection->getName()

        ];

        return \serialize([
            $this->index,
            $this->isDefaultAvailable,
            $this->default,
            $this->meta,
            $ref
        ]);
    }

    public function unserialize($serialized)
    {
        list($this->index,
            $this->isDefaultAvailable,
            $this->default,
            $this->meta,
            $ref
        ) = unserialize($serialized);
        $this->reflection = new \ReflectionParameter([$ref[0], $ref[1]], $ref[2]);
    }

    private function setDefaultValue(\ReflectionParameter $parameter)
    {
        if (! $this->isDefaultAvailable) {
            return;
        }
        try {
            $this->default = $parameter->getDefaultValue();
        } /* @noinspection PhpRedundantCatchClauseInspection */ catch (\ReflectionException $e) {
            // probably it is internal class like \PDO
            $this->default = null;
        }
    }

    private function getType(\ReflectionParameter $parameter) : string
    {
        $type = $parameter->getType();
        if ($type instanceof \ReflectionType && \in_array((string) $type, ['bool', 'int', 'string', 'array', 'resource', 'callable'], true)) {
if ($x instanceof DoesNotExist) {
    // Do something.
}
            return '';
        }

        return (string) $type;
    }
}


1		<?php
2
3		declare(strict_types=1);
4		/**
5		* This file is part of the Ray.Di package.
6		*
7		* @license http://opensource.org/licenses/MIT MIT
8		*/
9		namespace Ray\Di;
10
11		final class Argument implements \Serializable
12		{
13		/**
14		* @var string
15		*/
16		private $index;
17
18		/**
19		* @var bool
20		*/
21		private $isDefaultAvailable;
22
23		/**
24		* @var mixed
25		*/
26		private $default;
27
28		/**
29		* @var string
30		*/
31		private $meta;
32
33		/**
34		* @var \ReflectionParameter
35		*/
36		private $reflection;
37
38	68	public function __construct(\ReflectionParameter $parameter, string $name)
39		{
40	68	$type = $this->getType($parameter);
41	68	$isOptional = $parameter->isOptional();
42	68	$this->isDefaultAvailable = $parameter->isDefaultValueAvailable() \|\| $isOptional;
43	68	if ($isOptional) {
44	12	$this->default = null;
45		}
46	68	$this->setDefaultValue($parameter);
47	68	$this->index = $type . '-' . $name;
48	68	$this->reflection = $parameter;
49	68	$this->meta = sprintf(
50	68	"dependency '%s' with name '%s' used in %s:%d ($%s)",
51	68	$type,
52	68	$name,
53	68	$this->reflection->getDeclaringFunction()->getFileName(),
54	68	$this->reflection->getDeclaringFunction()->getStartLine(),
55	68	$parameter->getName()
		0 ignored issues – show Bug introduced 2016-09-26 15:00 UTC by Report Bug Copy Issue Report Consider using `$parameter->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
56		);
57	68	}
58
59		/**
60		* @return string
61		*/
62	41	public function __toString()
63		{
64	41	return $this->index;
65		}
66
67		/**
68		* Return reflection
69		*/
70	39	public function get() : \ReflectionParameter
71		{
72	39	return $this->reflection;
73		}
74
75		/**
76		* @return bool
77		*/
78	13	public function isDefaultAvailable() : bool
79		{
80	13	return $this->isDefaultAvailable;
81		}
82
83		/**
84		* @return mixed
85		*/
86	7	public function getDefaultValue()
87		{
88	7	return $this->default;
89		}
90
91	7	public function getMeta() : string
92		{
93	7	return $this->meta;
94		}
95
96	3	public function serialize() : string
97		{
98		$ref = [
99	3	$this->reflection->getDeclaringFunction()->class,
		0 ignored issues – show Bug introduced 2018-05-02 19:04 UTC by Report Bug Copy Issue Report The property `class` does not seem to exist in `ReflectionFunction`. An attempt at access to an undefined property has been detected. This may either be a typographical error or the property has been renamed but there are still references to its old name. If you really want to allow access to undefined properties, you can define magic methods to allow access. See the php core documentation on Overloading. Loading history...
100	3	$this->reflection->getDeclaringFunction()->name,
101	3	$this->reflection->getName()
		0 ignored issues – show Bug introduced 2018-05-02 19:04 UTC by Report Bug Copy Issue Report Consider using `$this->reflection->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
102		];
103
104	3	return \serialize([
105	3	$this->index,
106	3	$this->isDefaultAvailable,
107	3	$this->default,
108	3	$this->meta,
109	3	$ref
110		]);
111		}
112
113	4	public function unserialize($serialized)
114		{
115	4	list($this->index,
116	4	$this->isDefaultAvailable,
117	4	$this->default,
118	4	$this->meta,
119		$ref
120	4	) = unserialize($serialized);
121	4	$this->reflection = new \ReflectionParameter([$ref[0], $ref[1]], $ref[2]);
122	4	}
123
124	68	private function setDefaultValue(\ReflectionParameter $parameter)
125		{
126	68	if (! $this->isDefaultAvailable) {
127	66	return;
128		}
129		try {
130	12	$this->default = $parameter->getDefaultValue();
131	1	} /* @noinspection PhpRedundantCatchClauseInspection */ catch (\ReflectionException $e) {
132		// probably it is internal class like \PDO
133	1	$this->default = null;
134		}
135	12	}
136
137	68	private function getType(\ReflectionParameter $parameter) : string
138		{
139	68	$type = $parameter->getType();
140	68	if ($type instanceof \ReflectionType && \in_array((string) $type, ['bool', 'int', 'string', 'array', 'resource', 'callable'], true)) {
		0 ignored issues – show Bug introduced 2018-04-21 13:47 UTC by Report Bug Copy Issue Report The class `ReflectionType` does not exist. Did you forget a USE statement, or did you not list all dependencies? This error could be the result of: 1. Missing dependencies PHP Analyzer uses your `composer.json` file (if available) to determine the dependencies of your project and to determine all the available classes and functions. It expects the `composer.json` to be in the root folder of your repository. Are you sure this class is defined by one of your dependencies, or did you maybe not list a dependency in either the `require` or `require-dev` section? 2. Missing use statement PHP does not complain about undefined classes in `ìnstanceof` checks. For example, the following PHP code will work perfectly fine: if ($x instanceof DoesNotExist) { // Do something. } If you have not tested against this specific condition, such errors might go unnoticed. Loading history...
141	3	return '';
142		}
143
144	68	return (string) $type;
145		}
146		}
147

ray-di / Ray.Di

Push — 2.x ( 804da3...144798 )

Argument::serialize() A

Complexity

Size

Duplication

Code Coverage

Importance

1. Missing dependencies

2. Missing use statement

Duplication Side-by-Side

Filter issues like