Token::isObjectOperator() - Code Metrics - Inspection of "Domain structure" - mkusher/padawan.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#35)

by Aleh

created 2016-05-08 10:19 UTC

Token::isObjectOperator() A

↳ Parent: Token

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Padawan\Domain\Completion;

class Token
{
    public function __construct($code, $symbol)
    {
        if (empty($code) && empty($symbol)) {
            $this->type = self::T_EMPTY;
            return;
        }
        $this->add($code, $symbol);
    }

    public function add($code, $symbol)
    {
        switch ($code) {
        case T_WHITESPACE:

            $this->addType(self::T_WHITESPACE);
        case T_NS_SEPARATOR:
            $this->addType(self::T_CONTINUE_PROCESS);
            break;
        case T_STRING:
            $this->addType(self::T_STRING);
            $this->addType(self::T_CONTINUE_PROCESS);
            break;
        case T_VARIABLE:
        case T_DOUBLE_COLON:

            if ($this->isWhitespace()) {
                $this->resetType(self::T_UNKNOWN);
                break;
            }
        case T_OBJECT_OPERATOR:

            if ($this->hasString() && $this->hasWhitespace()) {
                $this->resetType(self::T_UNKNOWN);
                break;
            }
        case T_NAMESPACE:
        case T_USE:
        case T_NEW:
        case T_EXTENDS:
        case T_IMPLEMENTS:
        case '$':
        case '(':
            $this->resetType(self::$MAP[$code]);
            break;
        case ';':
        case ',':
        case '-':
        case ':':
        case '=':
        case ')':
        case ']':
            $this->resetType(self::T_TERMINATE);
            break;
        default:
            $this->addType(self::T_UNKNOWN);
        }
        if (!$this->isReady()) {
            $this->symbol = $symbol . $this->symbol;
        }
    }

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

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

    public function isUnknown()
    {
        return (bool) ($this->type & self::T_UNKNOWN);
    }

    public function isReady()
    {
        return !((bool) ($this->type & self::T_CONTINUE_PROCESS));
    }

    public function isTerminate()
    {
        return (bool) ($this->type & self::T_TERMINATE);
    }

    public function isObjectOperator()
    {
        return (bool) ($this->type & self::T_OBJECT_OPERATOR);
    }

    public function isStaticOperator()
    {
        return (bool) ($this->type & self::T_STATIC_OPERATOR);
    }

    public function isUseOperator()
    {
        return (bool) ($this->type & self::T_USE_OPERATOR);
    }

    public function isNamespaceOperator()
    {
        return (bool) ($this->type & self::T_NAMESPACE_OPERATOR);
    }

    public function isExtendsOperator()
    {
        return (bool) ($this->type & self::T_EXTENDS_OPERATOR);
    }

    public function isImplementsOperator()
    {
        return (bool) ($this->type & self::T_IMPLEMENTS_OPERATOR);
    }

    public function isNewOperator()
    {
        return (bool) ($this->type & self::T_NEW_OPERATOR);
    }

    public function isVar()
    {
        return (bool) ($this->type & self::T_VAR);
    }

    public function isWhitespace()
    {
        return (bool) ($this->type & self::T_WHITESPACE);
    }

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

    public function hasString()
    {
        return (bool) ($this->type & self::T_STRING);
    }

    public function isString()
    {
        return $this->type === self::T_STRING
            || $this->type === (self::T_STRING | self::T_CONTINUE_PROCESS);
    }

    public function isMethodCall()
    {
        return (bool) ($this->type & self::T_METHOD_CALL);
    }

    public function isEmpty()
    {
        return (bool) ($this->type & self::T_EMPTY);
    }

    protected function resetType($type = 0)
    {
        $this->type = $type;
    }
    protected function addType($type)
    {
        $this->type |= $type;
    }

    /**
     * @param integer $type
     */
    protected function removeType($type)
    {
        if((bool) ($this->type & $type)){
            $this->type ^= $type;
        }
    }

    const T_UNKNOWN             = 0;
    const T_CONTINUE_PROCESS    = 1;
    const T_TERMINATE           = 2;
    const T_OBJECT_OPERATOR     = 4;
    const T_STATIC_OPERATOR     = 8;
    const T_USE_OPERATOR        = 16;
    const T_NAMESPACE_OPERATOR  = 32;
    const T_EXTENDS_OPERATOR    = 64;
    const T_IMPLEMENTS_OPERATOR = 128;
    const T_NEW_OPERATOR        = 256;
    const T_VAR                 = 512;
    const T_WHITESPACE          = 1024;
    const T_METHOD_CALL         = 2048;
    const T_STRING              = 4096;
    const T_EMPTY               = 8192;

    protected static $MAP = [
        T_VARIABLE              => Token::T_VAR,
        T_OBJECT_OPERATOR       => Token::T_OBJECT_OPERATOR,
        T_DOUBLE_COLON          => Token::T_STATIC_OPERATOR,
        T_USE                   => Token::T_USE_OPERATOR,
        T_NAMESPACE             => Token::T_NAMESPACE_OPERATOR,
        T_NEW                   => Token::T_NEW_OPERATOR,
        T_EXTENDS               => Token::T_EXTENDS_OPERATOR,
        T_IMPLEMENTS            => Token::T_IMPLEMENTS_OPERATOR,
        '$'                     => Token::T_VAR,
        '('                     => Token::T_METHOD_CALL
    ];

    private $symbol = "";
    private $type   = 0;

}


1			<?php
2
3			namespace Padawan\Domain\Completion;
4
5			class Token
6			{
7			public function __construct($code, $symbol)
8			{
9			if (empty($code) && empty($symbol)) {
10			$this->type = self::T_EMPTY;
11			return;
12			}
13			$this->add($code, $symbol);
14			}
15
16			public function add($code, $symbol)
17			{
18			switch ($code) {
19			case T_WHITESPACE:
			0 ignored issues – show Coding Style introduced 2016-05-08 10:22 UTC by Report Bug Copy Issue Report There must be a comment when fall-through is intentional in a non-empty case body Loading history...
20			$this->addType(self::T_WHITESPACE);
21			case T_NS_SEPARATOR:
22			$this->addType(self::T_CONTINUE_PROCESS);
23			break;
24			case T_STRING:
25			$this->addType(self::T_STRING);
26			$this->addType(self::T_CONTINUE_PROCESS);
27			break;
28			case T_VARIABLE:
29			case T_DOUBLE_COLON:
			0 ignored issues – show Coding Style introduced 2016-05-08 10:22 UTC by Report Bug Copy Issue Report There must be a comment when fall-through is intentional in a non-empty case body Loading history...
30			if ($this->isWhitespace()) {
31			$this->resetType(self::T_UNKNOWN);
32			break;
33			}
34			case T_OBJECT_OPERATOR:
			0 ignored issues – show Coding Style introduced 2016-05-08 10:22 UTC by Report Bug Copy Issue Report There must be a comment when fall-through is intentional in a non-empty case body Loading history...
35			if ($this->hasString() && $this->hasWhitespace()) {
36			$this->resetType(self::T_UNKNOWN);
37			break;
38			}
39			case T_NAMESPACE:
40			case T_USE:
41			case T_NEW:
42			case T_EXTENDS:
43			case T_IMPLEMENTS:
44			case '$':
45			case '(':
46			$this->resetType(self::$MAP[$code]);
47			break;
48			case ';':
49			case ',':
50			case '-':
51			case ':':
52			case '=':
53			case ')':
54			case ']':
55			$this->resetType(self::T_TERMINATE);
56			break;
57			default:
58			$this->addType(self::T_UNKNOWN);
59			}
60			if (!$this->isReady()) {
61			$this->symbol = $symbol . $this->symbol;
62			}
63			}
64
65			public function getSymbol()
66			{
67			return $this->symbol;
68			}
69
70			public function getType()
71			{
72			return $this->type;
73			}
74
75			public function isUnknown()
76			{
77			return (bool) ($this->type & self::T_UNKNOWN);
78			}
79
80			public function isReady()
81			{
82			return !((bool) ($this->type & self::T_CONTINUE_PROCESS));
83			}
84
85			public function isTerminate()
86			{
87			return (bool) ($this->type & self::T_TERMINATE);
88			}
89
90			public function isObjectOperator()
91			{
92			return (bool) ($this->type & self::T_OBJECT_OPERATOR);
93			}
94
95			public function isStaticOperator()
96			{
97			return (bool) ($this->type & self::T_STATIC_OPERATOR);
98			}
99
100			public function isUseOperator()
101			{
102			return (bool) ($this->type & self::T_USE_OPERATOR);
103			}
104
105			public function isNamespaceOperator()
106			{
107			return (bool) ($this->type & self::T_NAMESPACE_OPERATOR);
108			}
109
110			public function isExtendsOperator()
111			{
112			return (bool) ($this->type & self::T_EXTENDS_OPERATOR);
113			}
114
115			public function isImplementsOperator()
116			{
117			return (bool) ($this->type & self::T_IMPLEMENTS_OPERATOR);
118			}
119
120			public function isNewOperator()
121			{
122			return (bool) ($this->type & self::T_NEW_OPERATOR);
123			}
124
125			public function isVar()
126			{
127			return (bool) ($this->type & self::T_VAR);
128			}
129
130			public function isWhitespace()
131			{
132			return (bool) ($this->type & self::T_WHITESPACE);
133			}
134
135			public function hasWhitespace()
136			{
137			return $this->isWhitespace();
138			}
139
140			public function hasString()
141			{
142			return (bool) ($this->type & self::T_STRING);
143			}
144
145			public function isString()
146			{
147			return $this->type === self::T_STRING
148			\|\| $this->type === (self::T_STRING \| self::T_CONTINUE_PROCESS);
149			}
150
151			public function isMethodCall()
152			{
153			return (bool) ($this->type & self::T_METHOD_CALL);
154			}
155
156			public function isEmpty()
157			{
158			return (bool) ($this->type & self::T_EMPTY);
159			}
160
161			protected function resetType($type = 0)
162			{
163			$this->type = $type;
164			}
165			protected function addType($type)
166			{
167			$this->type \|= $type;
168			}
169
170			/**
171			* @param integer $type
172			*/
173			protected function removeType($type)
174			{
175			if((bool) ($this->type & $type)){
176			$this->type ^= $type;
177			}
178			}
179
180			const T_UNKNOWN = 0;
181			const T_CONTINUE_PROCESS = 1;
182			const T_TERMINATE = 2;
183			const T_OBJECT_OPERATOR = 4;
184			const T_STATIC_OPERATOR = 8;
185			const T_USE_OPERATOR = 16;
186			const T_NAMESPACE_OPERATOR = 32;
187			const T_EXTENDS_OPERATOR = 64;
188			const T_IMPLEMENTS_OPERATOR = 128;
189			const T_NEW_OPERATOR = 256;
190			const T_VAR = 512;
191			const T_WHITESPACE = 1024;
192			const T_METHOD_CALL = 2048;
193			const T_STRING = 4096;
194			const T_EMPTY = 8192;
195
196			protected static $MAP = [
197			T_VARIABLE => Token::T_VAR,
198			T_OBJECT_OPERATOR => Token::T_OBJECT_OPERATOR,
199			T_DOUBLE_COLON => Token::T_STATIC_OPERATOR,
200			T_USE => Token::T_USE_OPERATOR,
201			T_NAMESPACE => Token::T_NAMESPACE_OPERATOR,
202			T_NEW => Token::T_NEW_OPERATOR,
203			T_EXTENDS => Token::T_EXTENDS_OPERATOR,
204			T_IMPLEMENTS => Token::T_IMPLEMENTS_OPERATOR,
205			'$' => Token::T_VAR,
206			'(' => Token::T_METHOD_CALL
207			];
208
209			private $symbol = "";
210			private $type = 0;
211
212			}
213

mkusher / padawan.php

Pull Request — master (#35)

Token::isObjectOperator() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like