QuerySequence::buildStrategyCondition() - Code Metrics - Inspection of "Extend class pattern. Add with/without/withPossibl..." - funivan/PhpTokenizer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 7d7c0f...5ee576 )

by Shcherbak

created 2016-02-03 11:20 UTC

QuerySequence::buildStrategyCondition() B

↳ Parent: QuerySequence

Complexity

Conditions	6
Paths	4

Size

Total Lines	21
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	11
CRAP Score	6

Importance

Changes	1
Bugs	1	Features	0

Metric	Value
c	1
b	1
f	0
dl	0
loc	21
ccs	11
cts	11
cp	1
rs	8.7624
cc	6
eloc	11
nc	4
nop	2
crap	6

<?php

  namespace Funivan\PhpTokenizer\QuerySequence;

  use Funivan\PhpTokenizer\Collection;
  use Funivan\PhpTokenizer\Exception\InvalidArgumentException;
  use Funivan\PhpTokenizer\Strategy\Move;
  use Funivan\PhpTokenizer\Strategy\Possible;
  use Funivan\PhpTokenizer\Strategy\QueryStrategy;
  use Funivan\PhpTokenizer\Strategy\Search;
  use Funivan\PhpTokenizer\Strategy\StrategyInterface;
  use Funivan\PhpTokenizer\Strategy\Strict;
  use Funivan\PhpTokenizer\Token;

  /**
   * Start from specific position and check token from this position according to strategies
   */
  class QuerySequence implements QuerySequenceInterface {

    /**
     * @var bool
     */
    private $valid = true;

    /**
     * @var int
     */
    private $position = 0;

    /**
     * @var Collection
     */
    private $collection;

    /**
     * @var
     */
    private $skipWhitespaces = false;


    /**
     * @inheritdoc
     */
    public function __construct(Collection $collection, $initialPosition = 0) {
      $this->collection = $collection;
      $this->position = $initialPosition;
    }


    /**
     * @return Collection
     */
    public function getCollection() {
      return $this->collection;
    }


    /**
     * @param int $position
     * @return QuerySequence
     */
    public function setPosition($position) {
      $this->position = $position;
      return $this;
    }


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


    /**
     * Strict validation of condition
     *
     * @param int|string|Strict $condition
     * @return Token
     */
    public function strict($condition) {
      $query = $this->buildStrategyCondition($condition, Strict::create());
      return $this->process($query);
    }


    /**
     * Check if token possible valid for our condition
     *
     * @param int|string|Possible $condition
     * @return Token
     */
    public function possible($condition) {
      $query = $this->buildStrategyCondition($condition, Possible::create());
      return $this->process($query);
    }


    /**
     * @param string $start
     * @param string $end
     * @return Collection
     */
    public function section($start, $end) {

      $token = $this->strict($start);
      if (!$token->isValid()) {
        # cant find start position
        return new Collection();
      }

      $this->moveToToken($token);

      $section = new \Funivan\PhpTokenizer\Strategy\Section();
      $section->setDelimiters($start, $end);
      $lastToken = $this->process($section);
      if (!$lastToken->isValid()) {
        return new Collection();
      }

      return $this->collection->extractByTokens($token, $lastToken);
    }


    /**
     * By default we search forward
     *
     * @param int|string|Search $condition
     * @param null $direction
     * @return Token
     */
    public function search($condition, $direction = null) {
      $strategy = Search::create();
      if ($direction !== null) {
        $strategy->setDirection($direction);
      }
      $query = $this->buildStrategyCondition($condition, $strategy);
      return $this->process($query);
    }


    /**
     * Relative move
     * +10 move forward 10 tokens
     * -5 move backward 5 tokens
     *
     * @param int $steps
     * @return Token
     */
    public function move($steps) {
      return $this->process(Move::create($steps));
    }


    /**
     * Move to specific position
     *
     * @param Token $token
     * @return Token|null
     */
    public function moveToToken(Token $token) {

      if (!$token->isValid()) {
        $this->setValid(false);
        return new Token();
      }

      $tokenIndex = $token->getIndex();


      foreach ($this->collection as $index => $collectionToken) {
        if ($collectionToken->getIndex() == $tokenIndex) {
          $this->setPosition($index);
          return $collectionToken;
        }
      }

      $this->setValid(false);
      return new Token();
    }


    /**
     * Array may contain Int, String or any StrategyInterface object
     *
     * @param array $conditions
     * @return Collection
     */
    public function sequence(array $conditions) {
      $range = new Collection();
      foreach ($conditions as $value) {
        $range[] = $this->checkFromSequence($value);
      }

      return $range;
    }


    /**
     * @param string|int|StrategyInterface $value
     * @return Token
     */
    private function checkFromSequence($value) {
      if ($value instanceof StrategyInterface) {
        $query = $value;
      } else {
        $query = $this->buildStrategyCondition($value, Strict::create());
      }

      $token = $this->process($query);
      return $token;
    }


    /**
     * @inheritdoc
     */
    public function process(StrategyInterface $strategy) {

      if ($this->isValid() === false) {
        return new Token();
      }

      $result = $strategy->process($this->collection, $this->getPosition());

      if ($result->isValid() === false) {
        $this->setValid(false);
        return new Token();
      }

      $position = $result->getNexTokenIndex();
      $this->setPosition($position);

      $token = $result->getToken();
      if ($token === null) {
        $token = new Token();
      }

      if ($this->skipWhitespaces and isset($this->collection[$position]) and $this->collection[$position]->getType() === T_WHITESPACE) {
        # skip whitespaces in next check
        $this->setPosition(($position + 1));
      }

      return $token;
    }


    /**
     *
     * @param StrategyInterface|string|int $value
     * @param QueryStrategy $defaultStrategy
     * @return QueryStrategy
     */
    private function buildStrategyCondition($value, QueryStrategy $defaultStrategy) {

      if (is_object($value) and get_class($value) == get_class($defaultStrategy)) {
        return $value;
      }

      $query = $defaultStrategy;

      if (is_string($value) or $value === null) {
        $query->valueIs($value);
        return $query;
      }

      if (is_int($value)) {
        $query->typeIs($value);
        return $query;
      }


      throw new InvalidArgumentException("Invalid token condition. Expect string or int or StrategyInterface");
    }


    /**
     * @param boolean $valid
     * @return $this
     */
    public function setValid($valid) {
      if (!is_bool($valid)) {
        throw new InvalidArgumentException("Invalid flag. Expect boolean. Given:" . gettype($valid));
      }
      $this->valid = $valid;
      return $this;
    }


    /**
     * @return Token
     */
    public function getToken() {
      $position = $this->getPosition();
      $token = $this->getCollection()->offsetGet($position);

      if ($token !== null) {
        return $token;
      }

      return new Token();
    }


    /**
     * Indicate state of all conditions
     *
     * @return bool
     */
    public function isValid() {
      return ($this->valid === true);
    }


    /**
     * @param boolean $skipWhitespaces
     * @return $this
     */
    public function setSkipWhitespaces($skipWhitespaces) {
      $this->skipWhitespaces = $skipWhitespaces;
      return $this;
    }

  }

1		<?php
2
3		namespace Funivan\PhpTokenizer\QuerySequence;
4
5		use Funivan\PhpTokenizer\Collection;
6		use Funivan\PhpTokenizer\Exception\InvalidArgumentException;
7		use Funivan\PhpTokenizer\Strategy\Move;
8		use Funivan\PhpTokenizer\Strategy\Possible;
9		use Funivan\PhpTokenizer\Strategy\QueryStrategy;
10		use Funivan\PhpTokenizer\Strategy\Search;
11		use Funivan\PhpTokenizer\Strategy\StrategyInterface;
12		use Funivan\PhpTokenizer\Strategy\Strict;
13		use Funivan\PhpTokenizer\Token;
14
15		/**
16		* Start from specific position and check token from this position according to strategies
17		*/
18		class QuerySequence implements QuerySequenceInterface {
19
20		/**
21		* @var bool
22		*/
23		private $valid = true;
24
25		/**
26		* @var int
27		*/
28		private $position = 0;
29
30		/**
31		* @var Collection
32		*/
33		private $collection;
34
35		/**
36		* @var
37		*/
38		private $skipWhitespaces = false;
39
40
41		/**
42		* @inheritdoc
43		*/
44	281	public function __construct(Collection $collection, $initialPosition = 0) {
45	281	$this->collection = $collection;
46	281	$this->position = $initialPosition;
47	281	}
48
49
50		/**
51		* @return Collection
52		*/
53	24	public function getCollection() {
54	24	return $this->collection;
55		}
56
57
58		/**
59		* @param int $position
60		* @return QuerySequence
61		*/
62	230	public function setPosition($position) {
63	230	$this->position = $position;
64	230	return $this;
65		}
66
67
68		/**
69		* @return int
70		*/
71	239	public function getPosition() {
72	239	return $this->position;
73		}
74
75
76		/**
77		* Strict validation of condition
78		*
79		* @param int\|string\|Strict $condition
80		* @return Token
81		*/
82	176	public function strict($condition) {
83	176	$query = $this->buildStrategyCondition($condition, Strict::create());
84	167	return $this->process($query);
85		}
86
87
88		/**
89		* Check if token possible valid for our condition
90		*
91		* @param int\|string\|Possible $condition
92		* @return Token
93		*/
94	113	public function possible($condition) {
95	113	$query = $this->buildStrategyCondition($condition, Possible::create());
96	101	return $this->process($query);
97		}
98
99
100		/**
101		* @param string $start
102		* @param string $end
103		* @return Collection
104		*/
105	98	public function section($start, $end) {
106
107	98	$token = $this->strict($start);
108	98	if (!$token->isValid()) {
109		# cant find start position
110	98	return new Collection();
111		}
112
113	89	$this->moveToToken($token);
114
115	89	$section = new \Funivan\PhpTokenizer\Strategy\Section();
116	89	$section->setDelimiters($start, $end);
117	89	$lastToken = $this->process($section);
118	89	if (!$lastToken->isValid()) {
119		return new Collection();
120		}
121
122	89	return $this->collection->extractByTokens($token, $lastToken);
123		}
124
125
126		/**
127		* By default we search forward
128		*
129		* @param int\|string\|Search $condition
130		* @param null $direction
131		* @return Token
132		*/
133	65	public function search($condition, $direction = null) {
134	65	$strategy = Search::create();
135	65	if ($direction !== null) {
136	3	$strategy->setDirection($direction);
137	3	}
138	65	$query = $this->buildStrategyCondition($condition, $strategy);
139	65	return $this->process($query);
140		}
141
142
143		/**
144		* Relative move
145		* +10 move forward 10 tokens
146		* -5 move backward 5 tokens
147		*
148		* @param int $steps
149		* @return Token
150		*/
151	3	public function move($steps) {
152	3	return $this->process(Move::create($steps));
153		}
154
155
156		/**
157		* Move to specific position
158		*
159		* @param Token $token
160		* @return Token\|null
161		*/
162	98	public function moveToToken(Token $token) {
163
164	98	if (!$token->isValid()) {
165	50	$this->setValid(false);
166	50	return new Token();
167		}
168
169	95	$tokenIndex = $token->getIndex();
170
171
172	95	foreach ($this->collection as $index => $collectionToken) {
173	95	if ($collectionToken->getIndex() == $tokenIndex) {
174	95	$this->setPosition($index);
175	95	return $collectionToken;
176		}
177	95	}
178
179	3	$this->setValid(false);
180	3	return new Token();
181		}
182
183
184		/**
185		* Array may contain Int, String or any StrategyInterface object
186		*
187		* @param array $conditions
188		* @return Collection
189		*/
190	75	public function sequence(array $conditions) {
191	75	$range = new Collection();
192	75	foreach ($conditions as $value) {
193	75	$range[] = $this->checkFromSequence($value);
194	75	}
195
196	75	return $range;
197		}
198
199
200		/**
201		* @param string\|int\|StrategyInterface $value
202		* @return Token
203		*/
204	75	private function checkFromSequence($value) {
205	75	if ($value instanceof StrategyInterface) {
206	51	$query = $value;
207	51	} else {
208	45	$query = $this->buildStrategyCondition($value, Strict::create());
209		}
210
211	75	$token = $this->process($query);
212	75	return $token;
213		}
214
215
216		/**
217		* @inheritdoc
218		*/
219	239	public function process(StrategyInterface $strategy) {
220
221	239	if ($this->isValid() === false) {
222	185	return new Token();
223		}
224
225	239	$result = $strategy->process($this->collection, $this->getPosition());
226
227	239	if ($result->isValid() === false) {
228	209	$this->setValid(false);
229	209	return new Token();
230		}
231
232	224	$position = $result->getNexTokenIndex();
233	224	$this->setPosition($position);
234
235	224	$token = $result->getToken();
236	224	if ($token === null) {
237	128	$token = new Token();
238	128	}
239
240	224	if ($this->skipWhitespaces and isset($this->collection[$position]) and $this->collection[$position]->getType() === T_WHITESPACE) {
241		# skip whitespaces in next check
242	39	$this->setPosition(($position + 1));
243	39	}
244
245	224	return $token;
246		}
247
248
249		/**
250		*
251		* @param StrategyInterface\|string\|int $value
252		* @param QueryStrategy $defaultStrategy
253		* @return QueryStrategy
254		*/
255	224	private function buildStrategyCondition($value, QueryStrategy $defaultStrategy) {
256
257	224	if (is_object($value) and get_class($value) == get_class($defaultStrategy)) {
258	21	return $value;
259		}
260
261	212	$query = $defaultStrategy;
262
263	212	if (is_string($value) or $value === null) {
264	179	$query->valueIs($value);
265	179	return $query;
266		}
267
268	155	if (is_int($value)) {
269	134	$query->typeIs($value);
270	134	return $query;
271		}
272
273
274	21	throw new InvalidArgumentException("Invalid token condition. Expect string or int or StrategyInterface");
275		}
276
277
278		/**
279		* @param boolean $valid
280		* @return $this
281		*/
282	218	public function setValid($valid) {
283	218	if (!is_bool($valid)) {
284	3	throw new InvalidArgumentException("Invalid flag. Expect boolean. Given:" . gettype($valid));
285		}
286	215	$this->valid = $valid;
287	215	return $this;
288		}
289
290
291		/**
292		* @return Token
293		*/
294		public function getToken() {
295		$position = $this->getPosition();
296		$token = $this->getCollection()->offsetGet($position);
297
298		if ($token !== null) {
299		return $token;
300		}
301
302		return new Token();
303		}
304
305
306		/**
307		* Indicate state of all conditions
308		*
309		* @return bool
310		*/
311	245	public function isValid() {
312	245	return ($this->valid === true);
313		}
314
315
316		/**
317		* @param boolean $skipWhitespaces
318		* @return $this
319		*/
320	42	public function setSkipWhitespaces($skipWhitespaces) {
321	42	$this->skipWhitespaces = $skipWhitespaces;
322	42	return $this;
323		}
324
325		}

funivan / PhpTokenizer

Push — master ( 7d7c0f...5ee576 )

QuerySequence::buildStrategyCondition() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like