ReflectedMethod::getNamespace() - Code Metrics - Halleck45/PhpMetrics - Measure and Improve Code Quality continuously with Scrutinizer

ReflectedMethod::getNamespace() A
last analyzed 2015-12-15 11:18 UTC

↳ Parent: ReflectedMethod

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
c	1
b	1
f	0
dl	0
loc	4
rs	10
cc	1
eloc	2
nc	1
nop	0

<?php

/*
 * (c) Jean-François Lépine <https://twitter.com/Halleck45>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Hal\Component\OOP\Reflected;
use Hal\Component\OOP\Reflected\ReflectedClass\ReflectedAnonymousClass;
use Hal\Component\OOP\Resolver\NameResolver;
use Hal\Component\OOP\Resolver\TypeResolver;


/**
 * Result (method)
 *
 * @author Jean-François Lépine <https://twitter.com/Halleck45>
 */
class ReflectedMethod {

    CONST VISIBILITY_PUBLIC = 'public';
    CONST VISIBILITY_PRIVATE = 'private';
    CONST VISIBILITY_PROTECTED = 'protected';
    CONST STATE_LOCAL = 1;
    CONST STATE_STATIC = 2;


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

    /**
     * @var array
     */
    private $arguments = array();

    /**
     * @var array
     */
    private $returns = array();

    /**
     * @var array
     */
    private $dependencies = array();

    /**
     * Resolver for names
     *
     * @var NameResolver
     */
    private $nameResolver;

    /**
     * @var array
     */
    private $tokens = array();

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

    /**
     * Usage of method (getter, setter...)
     *
     * @var string
     */
    private $usage;

    /**
     * @var int
     */
    private $visibility = self::VISIBILITY_PUBLIC;

    /**
     * @var int
     */
    private $state = self::STATE_LOCAL;

    /**
     * Anonymous class contained in this method
     *
     * @var array
     */
    private $anonymousClasses = array();

    /**
     * @var array
     */
    private $instanciedClasses = array();

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

    /**
     * @var array
     */
    private $internalCalls = array();

    /**
     * @var array
     */
    private $externalCalls = array();

    /**
     * @param string $name
     */
    public function __construct($name)
    {
        $this->name = (string) $name;
        $this->nameResolver = new NameResolver();
    }

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

    /**
     * @return \SplObjectStorage
     */
    public function getArguments()
    {
        return $this->arguments;
    }

    /**
     * Attach argument
     *
     * @param ReflectedArgument $arg
     * @return $this
     */
    public function pushArgument(ReflectedArgument $arg) {
        array_push($this->arguments, $arg);
        return $this;
    }

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

    /**
     * @param string $content
     * @return $this
     */
    public function setContent($content)
    {
        $this->content = $content;
        return $this;
    }

    /**
     * @return array
     */
    public function getTokens()
    {
        return $this->tokens;
    }

    /**
     * @param \Hal\Component\Token\TokenCollection $tokens
     * @return self
     */
    public function setTokens($tokens)
    {
        $this->tokens = $tokens;

        return $this;
    }

    /**
     * Get returned value
     *
     * @return array
     */
    public function getReturns() {
        // on read : compare with aliases. We cannot make it in pushDependency() => aliases aren't yet known
        $result = array();
        $resolver = new TypeResolver();
        foreach($this->returns as $return) {
            $type = $this->nameResolver->resolve($return->getType(), null);

            if("\\" !== $type[0] &&!$resolver->isNative($type)) {
                $type = $this->namespace.'\\'.$type;
            }

            $return->setType($type);
            $result[] = $return;
        }
        return array_values($result);
    }

    /**
     * Attach ne return information
     *
     *      It make no sense for the moment to store any information abour return value / type. Maybe in PHP 6 ? :)
     *
     * @param ReflectedReturn $return
     * @return $this
     */
    public function pushReturn(ReflectedReturn $return) {
        array_push($this->returns, $return);
        return $this;
    }

    /**
     * Push dependency
     *
     * @param $name
     * @return self
     */
    public function pushDependency($name) {
        array_push($this->dependencies, $name);
        return $this;
    }

    /**
     * @return array
     */
    public function getDependencies()
    {
        // on read : compare with aliases. We cannot make it in pushDependency() => aliases aren't yet known
        $dependencies = array();
        foreach($this->dependencies as $name) {
            array_push($dependencies, $this->nameResolver->resolve($name, null));
        }

        // returned values
        $resolver = new TypeResolver();
        foreach($this->returns as $return) {
            $name = $return->getType();
            if(!$resolver->isNative($name)) {
                array_push($dependencies, $this->nameResolver->resolve($name, null));
            }
        }

        // anonymous classes in method (inner class)
        foreach($this->anonymousClasses as $c) {
            array_push($dependencies, $c->getParent());
            $dependencies = array_merge($dependencies, $c->getDependencies());
        }
        return array_unique($dependencies);
    }

    /**
     * @param NameResolver $resolver
     * @return self
     */
    public function setNameResolver(NameResolver $resolver)
    {
        $this->nameResolver = $resolver;
        return $this;
    }

    /**
     * @return bool
     */
    public function isSetter() {
        return MethodUsage::USAGE_SETTER == $this->getUsage();
    }

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

    /**
     * @param string $usage
     */
    public function setUsage($usage)
    {
        $this->usage = $usage;
    }

    /**
     * @return bool
     */
    public function isGetter() {
        return MethodUsage::USAGE_GETTER == $this->getUsage();
    }

    /**
     * @return int
     */
    public function getVisibility()
    {
        return $this->visibility;
    }

    /**
     * @param int $visibility
     * @return $this
     */
    public function setVisibility($visibility)
    {
        $this->visibility = $visibility;
        return $this;
    }

    /**
     * @return int
     */
    public function getState()
    {
        return $this->state;
    }

    /**
     * @param int $state
     * @return ReflectedMethod
     */
    public function setState($state)
    {
        $this->state = $state;
        return $this;
    }
    /**
     * @param ReflectedAnonymousClass $class
     * @return $this
     */
    public function pushAnonymousClass(ReflectedAnonymousClass $class) {
        $this->anonymousClasses[] = $class;
        return $this;
    }

    /**
     * @return array
     */
    public function getAnonymousClasses()
    {
        return $this->anonymousClasses;
    }

    /**
     * @param string $namespace
     * @return ReflectedMethod
     */
    public function setNamespace($namespace)
    {
        $this->namespace = $namespace;
        return $this;
    }

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

    /**
     * @param $class
     * @return $this
     */
    public function pushInstanciedClass($class) {
        $this->instanciedClasses[] = $class;
        return $this;
    }

    /**
     * @return array
     */
    public function getInstanciedClasses()
    {
        $classes = array();
        foreach($this->instanciedClasses as $name) {
            array_push($classes, $this->nameResolver->resolve($name, null));
        }
        return $classes;
    }

    /**
     * @param $call
     * @return $this
     */
    public function pushInternalCall($call)
    {
        $this->internalCalls[] = $call;
        return $this;
    }

    /**
     * @return array
     */
    public function getInternalCalls()
    {
        return $this->internalCalls;
    }

    /**
     * @param $call
     * @return $this
     */
    public function pushExternalCall($call)
    {
        $this->externalCalls[] = $call;
        return $this;
    }

    /**
     * @return array
     */
    public function getExternalCalls()
    {
        return $this->externalCalls;
    }



};

1			<?php
2
3			/*
4			* (c) Jean-François Lépine <https://twitter.com/Halleck45>
5			*
6			* For the full copyright and license information, please view the LICENSE
7			* file that was distributed with this source code.
8			*/
9
10			namespace Hal\Component\OOP\Reflected;
11			use Hal\Component\OOP\Reflected\ReflectedClass\ReflectedAnonymousClass;
12			use Hal\Component\OOP\Resolver\NameResolver;
13			use Hal\Component\OOP\Resolver\TypeResolver;
14
15
16			/**
17			* Result (method)
18			*
19			* @author Jean-François Lépine <https://twitter.com/Halleck45>
20			*/
21			class ReflectedMethod {
22
23			CONST VISIBILITY_PUBLIC = 'public';
24			CONST VISIBILITY_PRIVATE = 'private';
25			CONST VISIBILITY_PROTECTED = 'protected';
26			CONST STATE_LOCAL = 1;
27			CONST STATE_STATIC = 2;
28
29
30			/**
31			* @var string
32			*/
33			private $name;
34
35			/**
36			* @var array
37			*/
38			private $arguments = array();
39
40			/**
41			* @var array
42			*/
43			private $returns = array();
44
45			/**
46			* @var array
47			*/
48			private $dependencies = array();
49
50			/**
51			* Resolver for names
52			*
53			* @var NameResolver
54			*/
55			private $nameResolver;
56
57			/**
58			* @var array
59			*/
60			private $tokens = array();
61
62			/**
63			* @var string
64			*/
65			private $content;
66
67			/**
68			* Usage of method (getter, setter...)
69			*
70			* @var string
71			*/
72			private $usage;
73
74			/**
75			* @var int
76			*/
77			private $visibility = self::VISIBILITY_PUBLIC;
78
79			/**
80			* @var int
81			*/
82			private $state = self::STATE_LOCAL;
83
84			/**
85			* Anonymous class contained in this method
86			*
87			* @var array
88			*/
89			private $anonymousClasses = array();
90
91			/**
92			* @var array
93			*/
94			private $instanciedClasses = array();
95
96			/**
97			* @var string
98			*/
99			private $namespace;
100
101			/**
102			* @var array
103			*/
104			private $internalCalls = array();
105
106			/**
107			* @var array
108			*/
109			private $externalCalls = array();
110
111			/**
112			* @param string $name
113			*/
114			public function __construct($name)
115			{
116			$this->name = (string) $name;
117			$this->nameResolver = new NameResolver();
118			}
119
120			/**
121			* @return string
122			*/
123			public function getName()
124			{
125			return $this->name;
126			}
127
128			/**
129			* @return \SplObjectStorage
130			*/
131			public function getArguments()
132			{
133			return $this->arguments;
134			}
135
136			/**
137			* Attach argument
138			*
139			* @param ReflectedArgument $arg
140			* @return $this
141			*/
142			public function pushArgument(ReflectedArgument $arg) {
143			array_push($this->arguments, $arg);
144			return $this;
145			}
146
147			/**
148			* @return string
149			*/
150			public function getContent()
151			{
152			return $this->content;
153			}
154
155			/**
156			* @param string $content
157			* @return $this
158			*/
159			public function setContent($content)
160			{
161			$this->content = $content;
162			return $this;
163			}
164
165			/**
166			* @return array
167			*/
168			public function getTokens()
169			{
170			return $this->tokens;
171			}
172
173			/**
174			* @param \Hal\Component\Token\TokenCollection $tokens
175			* @return self
176			*/
177			public function setTokens($tokens)
178			{
179			$this->tokens = $tokens;
			0 ignored issues – show Documentation Bug introduced 2015-11-25 11:13 UTC by Report Bug Copy Issue Report It seems like `$tokens` of type `object<Hal\Component\Token\TokenCollection>` is incompatible with the declared type `array` of property `$tokens`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
180			return $this;
181			}
182
183			/**
184			* Get returned value
185			*
186			* @return array
187			*/
188			public function getReturns() {
189			// on read : compare with aliases. We cannot make it in pushDependency() => aliases aren't yet known
190			$result = array();
191			$resolver = new TypeResolver();
192			foreach($this->returns as $return) {
193			$type = $this->nameResolver->resolve($return->getType(), null);
194
195			if("\\" !== $type[0] &&!$resolver->isNative($type)) {
196			$type = $this->namespace.'\\'.$type;
197			}
198
199			$return->setType($type);
200			$result[] = $return;
201			}
202			return array_values($result);
203			}
204
205			/**
206			* Attach ne return information
207			*
208			* It make no sense for the moment to store any information abour return value / type. Maybe in PHP 6 ? :)
209			*
210			* @param ReflectedReturn $return
211			* @return $this
212			*/
213			public function pushReturn(ReflectedReturn $return) {
214			array_push($this->returns, $return);
215			return $this;
216			}
217
218			/**
219			* Push dependency
220			*
221			* @param $name
222			* @return self
223			*/
224			public function pushDependency($name) {
225			array_push($this->dependencies, $name);
226			return $this;
227			}
228
229			/**
230			* @return array
231			*/
232			public function getDependencies()
233			{
234			// on read : compare with aliases. We cannot make it in pushDependency() => aliases aren't yet known
235			$dependencies = array();
236			foreach($this->dependencies as $name) {
237			array_push($dependencies, $this->nameResolver->resolve($name, null));
238			}
239
240			// returned values
241			$resolver = new TypeResolver();
242			foreach($this->returns as $return) {
243			$name = $return->getType();
244			if(!$resolver->isNative($name)) {
245			array_push($dependencies, $this->nameResolver->resolve($name, null));
246			}
247			}
248
249			// anonymous classes in method (inner class)
250			foreach($this->anonymousClasses as $c) {
251			array_push($dependencies, $c->getParent());
252			$dependencies = array_merge($dependencies, $c->getDependencies());
253			}
254			return array_unique($dependencies);
255			}
256
257			/**
258			* @param NameResolver $resolver
259			* @return self
260			*/
261			public function setNameResolver(NameResolver $resolver)
262			{
263			$this->nameResolver = $resolver;
264			return $this;
265			}
266
267			/**
268			* @return bool
269			*/
270			public function isSetter() {
271			return MethodUsage::USAGE_SETTER == $this->getUsage();
272			}
273
274			/**
275			* @return string
276			*/
277			public function getUsage()
278			{
279			return $this->usage;
280			}
281
282			/**
283			* @param string $usage
284			*/
285			public function setUsage($usage)
286			{
287			$this->usage = $usage;
288			}
289
290			/**
291			* @return bool
292			*/
293			public function isGetter() {
294			return MethodUsage::USAGE_GETTER == $this->getUsage();
295			}
296
297			/**
298			* @return int
299			*/
300			public function getVisibility()
301			{
302			return $this->visibility;
303			}
304
305			/**
306			* @param int $visibility
307			* @return $this
308			*/
309			public function setVisibility($visibility)
310			{
311			$this->visibility = $visibility;
312			return $this;
313			}
314
315			/**
316			* @return int
317			*/
318			public function getState()
319			{
320			return $this->state;
321			}
322
323			/**
324			* @param int $state
325			* @return ReflectedMethod
326			*/
327			public function setState($state)
328			{
329			$this->state = $state;
330			return $this;
331			}
332			/**
333			* @param ReflectedAnonymousClass $class
334			* @return $this
335			*/
336			public function pushAnonymousClass(ReflectedAnonymousClass $class) {
337			$this->anonymousClasses[] = $class;
338			return $this;
339			}
340
341			/**
342			* @return array
343			*/
344			public function getAnonymousClasses()
345			{
346			return $this->anonymousClasses;
347			}
348
349			/**
350			* @param string $namespace
351			* @return ReflectedMethod
352			*/
353			public function setNamespace($namespace)
354			{
355			$this->namespace = $namespace;
356			return $this;
357			}
358
359			/**
360			* @return string
361			*/
362			public function getNamespace()
363			{
364			return $this->namespace;
365			}
366
367			/**
368			* @param $class
369			* @return $this
370			*/
371			public function pushInstanciedClass($class) {
372			$this->instanciedClasses[] = $class;
373			return $this;
374			}
375
376			/**
377			* @return array
378			*/
379			public function getInstanciedClasses()
380			{
381			$classes = array();
382			foreach($this->instanciedClasses as $name) {
383			array_push($classes, $this->nameResolver->resolve($name, null));
384			}
385			return $classes;
386			}
387
388			/**
389			* @param $call
390			* @return $this
391			*/
392			public function pushInternalCall($call)
393			{
394			$this->internalCalls[] = $call;
395			return $this;
396			}
397
398			/**
399			* @return array
400			*/
401			public function getInternalCalls()
402			{
403			return $this->internalCalls;
404			}
405
406			/**
407			* @param $call
408			* @return $this
409			*/
410			public function pushExternalCall($call)
411			{
412			$this->externalCalls[] = $call;
413			return $this;
414			}
415
416			/**
417			* @return array
418			*/
419			public function getExternalCalls()
420			{
421			return $this->externalCalls;
422			}
423
424
425
426			};

Halleck45 / PhpMetrics

ReflectedMethod::getNamespace() A last analyzed 2015-12-15 11:18 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

ReflectedMethod::getNamespace() A
last analyzed 2015-12-15 11:18 UTC