MethodNode::addArgument() - Code Metrics - Inspection of "Implement PHP 7.2 object type-hint" - phpspec/prophecy - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#390)

by Olivier

created 2018-02-11 22:08 UTC

MethodNode::addArgument() A

↳ Parent: MethodNode

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

/*
 * This file is part of the Prophecy.
 * (c) Konstantin Kudryashov <[email protected]>
 *     Marcello Duarte <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Prophecy\Doubler\Generator\Node;

use Prophecy\Exception\InvalidArgumentException;

/**
 * Method node.
 *
 * @author Konstantin Kudryashov <[email protected]>
 */
class MethodNode
{
    private $name;
    private $code;
    private $visibility = 'public';
    private $static = false;
    private $returnsReference = false;
    private $returnType;
    private $nullableReturnType = false;

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

    /**
     * @param string $name
     * @param string $code
     */
    public function __construct($name, $code = null)
    {
        $this->name = $name;
        $this->code = $code;
    }

    public function getVisibility()
    {
        return $this->visibility;
    }

    /**
     * @param string $visibility
     */
    public function setVisibility($visibility)

    {
        $visibility = strtolower($visibility);

        if (!in_array($visibility, array('public', 'private', 'protected'))) {
            throw new InvalidArgumentException(sprintf(
                '`%s` method visibility is not supported.', $visibility
            ));
        }

        $this->visibility = $visibility;
    }

    public function isStatic()
    {
        return $this->static;
    }

    public function setStatic($static = true)
    {
        $this->static = (bool) $static;
    }

    public function returnsReference()
    {
        return $this->returnsReference;
    }

    public function setReturnsReference()
    {
        $this->returnsReference = true;
    }

    public function getName()
    {
        return $this->name;
    }

    public function addArgument(ArgumentNode $argument)
    {
        $this->arguments[] = $argument;
    }

    /**
     * @return ArgumentNode[]
     */
    public function getArguments()
    {
        return $this->arguments;
    }

    public function hasReturnType()
    {
        return null !== $this->returnType;
    }

    /**
     * @param string $type
     */
    public function setReturnType($type = null)
    {
        switch ($type) {
            case '':
                $this->returnType = null;
                break;

            case 'string':
            case 'float':
            case 'int':
            case 'bool':
            case 'array':
            case 'callable':
            case 'iterable':
            case 'void':
                $this->returnType = $type;
                break;

            case 'double':
            case 'real':
                $this->returnType = 'float';
                break;

            case 'boolean':
                $this->returnType = 'bool';
                break;

            case 'integer':
                $this->returnType = 'int';
                break;

            case 'object':
                if (version_compare(PHP_VERSION, '7.2', '>=')) {
                    $this->returnType = $type;
                    break;
                }
                // Fall-through to default case for PHP < 7.2

            default:
                $this->returnType = '\\' . ltrim($type, '\\');
        }
    }

    public function getReturnType()
    {
        return $this->returnType;
    }

    /**
     * @param bool $bool
     */
    public function setNullableReturnType($bool = true)
    {
        $this->nullableReturnType = (bool) $bool;
    }

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

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

    public function getCode()
    {
        if ($this->returnsReference)
        {
            return "throw new \Prophecy\Exception\Doubler\ReturnByReferenceException('Returning by reference not supported', get_class(\$this), '{$this->name}');";
        }

        return (string) $this->code;
    }

    public function useParentCode()
    {
        $this->code = sprintf(
            'return parent::%s(%s);', $this->getName(), implode(', ',
                array_map(array($this, 'generateArgument'), $this->arguments)
            )
        );
    }

    private function generateArgument(ArgumentNode $arg)
    {
        $argument = '$'.$arg->getName();

        if ($arg->isVariadic()) {
            $argument = '...'.$argument;
        }

        return $argument;
    }
}


1		<?php
2
3		/*
4		* This file is part of the Prophecy.
5		* (c) Konstantin Kudryashov <[email protected]>
6		* Marcello Duarte <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11
12		namespace Prophecy\Doubler\Generator\Node;
13
14		use Prophecy\Exception\InvalidArgumentException;
15
16		/**
17		* Method node.
18		*
19		* @author Konstantin Kudryashov <[email protected]>
20		*/
21		class MethodNode
22		{
23		private $name;
24		private $code;
25		private $visibility = 'public';
26		private $static = false;
27		private $returnsReference = false;
28		private $returnType;
29		private $nullableReturnType = false;
30
31		/**
32		* @var ArgumentNode[]
33		*/
34		private $arguments = array();
35
36		/**
37		* @param string $name
38		* @param string $code
39		*/
40		public function __construct($name, $code = null)
41		{
42		$this->name = $name;
43		$this->code = $code;
44		}
45
46		public function getVisibility()
47		{
48		return $this->visibility;
49		}
50
51		/**
52		* @param string $visibility
53		*/
54	View Code Duplication	public function setVisibility($visibility)
		0 ignored issues – show Duplication introduced 2017-08-04 14:21 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
55		{
56		$visibility = strtolower($visibility);
57
58		if (!in_array($visibility, array('public', 'private', 'protected'))) {
59		throw new InvalidArgumentException(sprintf(
60		'`%s` method visibility is not supported.', $visibility
61		));
62		}
63
64		$this->visibility = $visibility;
65		}
66
67		public function isStatic()
68		{
69		return $this->static;
70		}
71
72		public function setStatic($static = true)
73		{
74		$this->static = (bool) $static;
75		}
76
77		public function returnsReference()
78		{
79		return $this->returnsReference;
80		}
81
82		public function setReturnsReference()
83		{
84		$this->returnsReference = true;
85		}
86
87		public function getName()
88		{
89		return $this->name;
90		}
91
92		public function addArgument(ArgumentNode $argument)
93		{
94		$this->arguments[] = $argument;
95		}
96
97		/**
98		* @return ArgumentNode[]
99		*/
100		public function getArguments()
101		{
102		return $this->arguments;
103		}
104
105		public function hasReturnType()
106		{
107		return null !== $this->returnType;
108		}
109
110		/**
111		* @param string $type
112		*/
113		public function setReturnType($type = null)
114		{
115		switch ($type) {
116		case '':
117		$this->returnType = null;
118		break;
119
120		case 'string':
121		case 'float':
122		case 'int':
123		case 'bool':
124		case 'array':
125		case 'callable':
126		case 'iterable':
127		case 'void':
128		$this->returnType = $type;
129		break;
130
131		case 'double':
132		case 'real':
133		$this->returnType = 'float';
134		break;
135
136		case 'boolean':
137		$this->returnType = 'bool';
138		break;
139
140		case 'integer':
141		$this->returnType = 'int';
142		break;
143
144		case 'object':
145		if (version_compare(PHP_VERSION, '7.2', '>=')) {
146		$this->returnType = $type;
147		break;
148		}
149		// Fall-through to default case for PHP < 7.2
150
151		default:
152		$this->returnType = '\\' . ltrim($type, '\\');
153		}
154		}
155
156		public function getReturnType()
157		{
158		return $this->returnType;
159		}
160
161		/**
162		* @param bool $bool
163		*/
164		public function setNullableReturnType($bool = true)
165		{
166		$this->nullableReturnType = (bool) $bool;
167		}
168
169		/**
170		* @return bool
171		*/
172		public function hasNullableReturnType()
173		{
174		return $this->nullableReturnType;
175		}
176
177		/**
178		* @param string $code
179		*/
180		public function setCode($code)
181		{
182		$this->code = $code;
183		}
184
185		public function getCode()
186		{
187		if ($this->returnsReference)
188		{
189		return "throw new \Prophecy\Exception\Doubler\ReturnByReferenceException('Returning by reference not supported', get_class(\$this), '{$this->name}');";
190		}
191
192		return (string) $this->code;
193		}
194
195		public function useParentCode()
196		{
197		$this->code = sprintf(
198		'return parent::%s(%s);', $this->getName(), implode(', ',
199		array_map(array($this, 'generateArgument'), $this->arguments)
200		)
201		);
202		}
203
204		private function generateArgument(ArgumentNode $arg)
205		{
206		$argument = '$'.$arg->getName();
207
208		if ($arg->isVariadic()) {
209		$argument = '...'.$argument;
210		}
211
212		return $argument;
213		}
214		}
215

phpspec / prophecy

Pull Request — master (#390)

MethodNode::addArgument() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like