ClassMetadata::hasPublicMethod() - Code Metrics - Inspection of "Working on class loader and types..." - RunOpenCode/abstract-builder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ed922a...ce73d9 )

by Nikola

created 2017-06-24 14:52 UTC

ClassMetadata::hasPublicMethod() B

↳ Parent: ClassMetadata

Complexity

Conditions	6
Paths	5

Size

Total Lines	15
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	42

Importance

Changes

Metric	Value
dl	0
loc	15
ccs	0
cts	12
cp	0
rs	8.8571
c	0
b	0
f	0
cc	6
eloc	7
nc	5
nop	2
crap	42

<?php
/*
 * This file is part of the Abstract builder package, an RunOpenCode project.
 *
 * (c) 2017 RunOpenCode
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace RunOpenCode\AbstractBuilder\Ast;

use RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException;

/**
 * Class ClassMetadata
 *
 * @package RunOpenCode\AbstractBuilder\Ast
 */
class ClassMetadata
{
    /**
     * @var array
     */
    private $ast;

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

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

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

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

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

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

    /**
     * @var MethodMetadata[]
     */
    private $methods;

    /**
     * @var ClassMetadata
     */
    private $parent;

    /**
     * ClassMetadata constructor.
     *
     * @param $ast
     * @param string $namespace
     * @param string $class
     * @param null|string $filename
     * @param bool $final
     * @param bool $abstract
     * @param MethodMetadata[] $methods
     *
     * @throws \RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException
     */
    public function __construct($ast, $namespace, $class, $filename = null, $final = false, $abstract = false, array $methods = [], ClassMetadata $parent = null)
    {
        $this->ast = $ast;
        $this->namespace = trim($namespace, '\\');
        $this->class = trim($class, '\\');
        $this->filename = $filename;
        $this->final = $final;
        $this->abstract = $abstract;
        $this->methods = $methods;
        $this->parent = $parent;

        $this->fqcn = '\\'.$this->class;

        if ($this->namespace) {
            $this->fqcn = '\\'.$this->namespace.'\\'.$this->class;
        }


        foreach (explode('\\', ltrim($this->fqcn, '\\')) as $part) {

            if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $part)) {
                throw new InvalidArgumentException(sprintf('Provided full qualified class name "%s" is not valid PHP class name.', $this->fqcn));
            }
        }
    }

    /**
     * @return
     */
    public function getAst()
    {
        return $this->ast;
    }

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

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

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

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

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

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

    /**
     * @return MethodMetadata[]
     */
    public function getMethods()
    {
        return $this->methods;
    }

    /**
     * @return MethodMetadata|null
     */
    public function getConstructor()
    {
        foreach ($this->methods as $method) {

            if ('__construct' === $method->getName()) {
                return $method;
            }
        }

        if (null !== $this->parent) {
            return $this->parent->getConstructor();
        }

        return null;
    }

    /**
     * Check if class inherits some other class.
     *
     * @return bool
     */
    public function hasParent()
    {
        return null !== $this->parent;
    }

    /**
     * @return ClassMetadata|null
     */
    public function getParent()
    {
        return $this->parent;
    }

    /**
     * Check if class has public method, with optional tree traverse.
     *
     * @param string $name
     * @param bool $traverse
     *
     * @return bool
     */
    public function hasPublicMethod($name, $traverse = true)
    {
        foreach ($this->methods as $method) {

            if ($method->isPublic() && $name === $method->getName()) {
                return true;
            }
        }

        if ($traverse && $this->hasParent()) {
            return $this->getParent()->hasPublicMethod($name, $traverse);
        }

        return false;
    }

    /**
     * @return bool
     */
    public function isAutoloadable()
    {
        return class_exists($this->getFqcn(), true);
    }

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

    /**
     * Initialize new, non-existing class.
     *
     * @param string $fqcn
     *
     * @return ClassMetadata|static $this
     */
    public static function create($fqcn)
    {
        $parts = explode('\\', trim($fqcn, '\\'));
        $class = array_pop($parts);
        $namespace = implode('\\', $parts);

        return new static([], $namespace, $class);
    }

    /**
     * Clones original metadata object, with possible values overwrite
     *
     * @param ClassMetadata $original
     * @param array $overwrite
     *
     * @return ClassMetadata|static $this
     */
    public static function clone(ClassMetadata $original, array $overwrite = [])
    {
        $data = [
            'ast' => $original->getAst(),
            'namespace' => $original->getNamespace(),
            'class' => $original->getClass(),
            'filename' => $original->getFilename(),
            'final' => $original->isFinal(),
            'abstract ' => $original->isAbstract(),
            'methods' => $original->getMethods(),
            'parent' => $original->getParent()
        ];

        $data = array_merge($data, $overwrite);

        return (new \ReflectionClass(static::class))->newInstanceArgs(array_values($data));
    }
}


1			<?php
2			/*
3			* This file is part of the Abstract builder package, an RunOpenCode project.
4			*
5			* (c) 2017 RunOpenCode
6			*
7			* For the full copyright and license information, please view the LICENSE
8			* file that was distributed with this source code.
9			*/
10			namespace RunOpenCode\AbstractBuilder\Ast;
11
12			use RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException;
13
14			/**
15			* Class ClassMetadata
16			*
17			* @package RunOpenCode\AbstractBuilder\Ast
18			*/
19			class ClassMetadata
20			{
21			/**
22			* @var array
23			*/
24			private $ast;
25
26			/**
27			* @var string
28			*/
29			private $namespace;
30
31			/**
32			* @var string
33			*/
34			private $class;
35
36			/**
37			* @var string
38			*/
39			private $fqcn;
40
41			/**
42			* @var string
43			*/
44			private $filename;
45
46			/**
47			* @var bool
48			*/
49			private $final;
50
51			/**
52			* @var bool
53			*/
54			private $abstract;
55
56			/**
57			* @var MethodMetadata[]
58			*/
59			private $methods;
60
61			/**
62			* @var ClassMetadata
63			*/
64			private $parent;
65
66			/**
67			* ClassMetadata constructor.
68			*
69			* @param $ast
70			* @param string $namespace
71			* @param string $class
72			* @param null\|string $filename
73			* @param bool $final
74			* @param bool $abstract
75			* @param MethodMetadata[] $methods
76			*
77			* @throws \RunOpenCode\AbstractBuilder\Exception\InvalidArgumentException
78			*/
79			public function __construct($ast, $namespace, $class, $filename = null, $final = false, $abstract = false, array $methods = [], ClassMetadata $parent = null)
80			{
81			$this->ast = $ast;
82			$this->namespace = trim($namespace, '\\');
83			$this->class = trim($class, '\\');
84			$this->filename = $filename;
85			$this->final = $final;
86			$this->abstract = $abstract;
87			$this->methods = $methods;
88			$this->parent = $parent;
89
90			$this->fqcn = '\\'.$this->class;
91
92			if ($this->namespace) {
93			$this->fqcn = '\\'.$this->namespace.'\\'.$this->class;
94			}
95
96
97			foreach (explode('\\', ltrim($this->fqcn, '\\')) as $part) {
98
99			if (!preg_match('/^[a-zA-Z_\x7f-\xff][a-zA-Z0-9_\x7f-\xff]*$/', $part)) {
100			throw new InvalidArgumentException(sprintf('Provided full qualified class name "%s" is not valid PHP class name.', $this->fqcn));
101			}
102			}
103			}
104
105			/**
106			* @return
107			*/
108			public function getAst()
109			{
110			return $this->ast;
111			}
112
113			/**
114			* @return string
115			*/
116			public function getNamespace()
117			{
118			return $this->namespace;
119			}
120
121			/**
122			* @return string
123			*/
124			public function getClass()
125			{
126			return $this->class;
127			}
128
129			/**
130			* @return string
131			*/
132			public function getFqcn()
133			{
134			return $this->fqcn;
135			}
136
137			/**
138			* @return string
139			*/
140			public function getFilename()
141			{
142			return $this->filename;
143			}
144
145			/**
146			* @return bool
147			*/
148			public function isFinal()
149			{
150			return $this->final;
151			}
152
153			/**
154			* @return bool
155			*/
156			public function isAbstract()
157			{
158			return $this->abstract;
159			}
160
161			/**
162			* @return MethodMetadata[]
163			*/
164			public function getMethods()
165			{
166			return $this->methods;
167			}
168
169			/**
170			* @return MethodMetadata\|null
171			*/
172			public function getConstructor()
173			{
174			foreach ($this->methods as $method) {
175
176			if ('__construct' === $method->getName()) {
177			return $method;
178			}
179			}
180
181			if (null !== $this->parent) {
182			return $this->parent->getConstructor();
183			}
184
185			return null;
186			}
187
188			/**
189			* Check if class inherits some other class.
190			*
191			* @return bool
192			*/
193			public function hasParent()
194			{
195			return null !== $this->parent;
196			}
197
198			/**
199			* @return ClassMetadata\|null
200			*/
201			public function getParent()
202			{
203			return $this->parent;
204			}
205
206			/**
207			* Check if class has public method, with optional tree traverse.
208			*
209			* @param string $name
210			* @param bool $traverse
211			*
212			* @return bool
213			*/
214			public function hasPublicMethod($name, $traverse = true)
215			{
216			foreach ($this->methods as $method) {
217
218			if ($method->isPublic() && $name === $method->getName()) {
219			return true;
220			}
221			}
222
223			if ($traverse && $this->hasParent()) {
224			return $this->getParent()->hasPublicMethod($name, $traverse);
225			}
226
227			return false;
228			}
229
230			/**
231			* @return bool
232			*/
233			public function isAutoloadable()
234			{
235			return class_exists($this->getFqcn(), true);
236			}
237
238			/**
239			* {@inheritdoc}
240			*/
241			public function __toString()
242			{
243			return $this->getFqcn();
244			}
245
246			/**
247			* Initialize new, non-existing class.
248			*
249			* @param string $fqcn
250			*
251			* @return ClassMetadata\|static $this
252			*/
253			public static function create($fqcn)
254			{
255			$parts = explode('\\', trim($fqcn, '\\'));
256			$class = array_pop($parts);
257			$namespace = implode('\\', $parts);
258
259			return new static([], $namespace, $class);
260			}
261
262			/**
263			* Clones original metadata object, with possible values overwrite
264			*
265			* @param ClassMetadata $original
266			* @param array $overwrite
267			*
268			* @return ClassMetadata\|static $this
269			*/
270			public static function clone(ClassMetadata $original, array $overwrite = [])
271			{
272			$data = [
273			'ast' => $original->getAst(),
274			'namespace' => $original->getNamespace(),
275			'class' => $original->getClass(),
276			'filename' => $original->getFilename(),
277			'final' => $original->isFinal(),
278			'abstract ' => $original->isAbstract(),
279			'methods' => $original->getMethods(),
280			'parent' => $original->getParent()
281			];
282
283			$data = array_merge($data, $overwrite);
284
285			return (new \ReflectionClass(static::class))->newInstanceArgs(array_values($data));
286			}
287			}
288

RunOpenCode / abstract-builder

Push — master ( ed922a...ce73d9 )

ClassMetadata::hasPublicMethod() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like