BaseCollection::storeContentHash() - Code Metrics - Inspection of "prepare collection merge" - funivan/PhpTokenizer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f97578...954bd6 )

by Shcherbak

created 2016-09-26 10:54 UTC

BaseCollection::storeContentHash() A

↳ Parent: BaseCollection

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

  namespace Funivan\PhpTokenizer\Collection;

  use Funivan\PhpTokenizer\Token;

  /**
   *
   * @package Fiv\Spl
   */
  class BaseCollection implements \Iterator, \ArrayAccess, \Countable {

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

    /**
     * Array of objects
     *
     * @var array
     */
    protected $items = [];


    /**
     * @var string
     */
    protected $initialContentHash;


    /**
     * @param array $items
     */
    public function __construct(array $items = []) {

      if (!empty($items)) {
        $this->setItems($items);
      }
      $this->storeContentHash();

    }


    /**
     *
     */
    public function __clone() {
      $items = [];
      foreach ($this->items as $item) {
        $items[] = $item;
      }
      $this->setItems($items);
    }


    /**
     * Return number of items in this collection
     *
     * @return int
     */
    public function count() {
      return count($this->items);
    }


    /**
     * Add one item to begin of collection
     * This item is accessible via `$collection->getFirst();`
     *
     * @param $item
     * @return $this
     */
    public function prepend(Token $item) {
      array_unshift($this->items, $item);
      return $this;
    }


    /**
     * Add one item to the end of collection
     * This item is accessible via `$collection->getLast();`
     *
     * @param $item
     * @return $this
     */
    public function append(Token $item) {
      $this->items[] = $item;
      return $this;
    }


    /**
     * @param int $index
     * @param array $items
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function addAfter($index, $items) {
      if (!is_array($items)) {
        throw new \InvalidArgumentException('You can add after only array of items');
      }

      foreach ($items as $item) {
        if (!($item instanceof Token)) {
          throw new \InvalidArgumentException('Expect array of tokens. Token[]');
        }
      }

      if (!is_int($index)) {
        throw new \InvalidArgumentException('Invalid type of index. Must be integer');
      }

      $offset = $index + 1;
      $firstPart = array_slice($this->items, 0, $offset);
      $secondPart = array_slice($this->items, $offset);
      $this->items = array_merge($firstPart, $items, $secondPart);
      return $this;
    }


    /**
     * Truncate current list of items and add new
     *
     * @param array $items
     * @return $this
     */
    public function setItems($items) {
      if (!is_array($items)) {
        throw new \InvalidArgumentException("You can set only array of items");
      }

      foreach ($items as $item) {
        if (!($item instanceof Token)) {
          throw new \InvalidArgumentException('Expect array of tokens. Token[]');
        }
      }

      $this->items = $items;
      $this->rewind();
      return $this;
    }


    /**
     * Remove part of items from collection
     * Works as array_slice
     *
     *
     * @param $offset
     * @param null $length
     * @return $this
     */
    public function slice($offset, $length = null) {
      $this->items = array_slice($this->items, $offset, $length);
      return $this;
    }


    /**
     * Take part of items and return new collection
     * Works as array_slice
     * At this point items in 2 collection is same
     *
     * @param int $offset
     * @param null $length
     * @return self
     */
    public function extractItems($offset, $length = null) {
      $items = array_slice($this->items, $offset, $length);
      $className = get_called_class();
      $collection = new $className();
      /** @var BaseCollection $collection */
      $collection->setItems($items);
      return $collection;
    }


    /**
     * Rewind current collection
     */
    public function rewind() {
      $this->position = 0;
      $this->items = array_values($this->items);
    }


    /**
     * Return last item from collection
     *
     * @return mixed
     */
    public function getLast() {
      return end($this->items);
    }


    /**
     * Return first item from collection
     * @return mixed
     */
    public function getFirst() {
      return reset($this->items);
    }


    /**
     * Return next item from current
     * Also can return item with position from current + $step
     *
     * @param int $step
     * @return mixed
     */
    public function getNext($step = 1) {
      $position = ($this->position + $step);
      return isset($this->items[$position]) ? $this->items[$position] : null;
    }


    /**
     * Return previous item
     * Also can return previous from current position + $step
     *
     * @param int $step
     * @return mixed
     */
    public function getPrevious($step = 1) {
      $position = ($this->position - $step);
      return isset($this->items[$position]) ? $this->items[$position] : null;
    }


    /**
     * Return current item in collection
     *
     * @return object
     */
    public function current() {
      return $this->items[$this->position];
    }


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


    /**
     * Switch to next position
     */
    public function next() {
      ++$this->position;
    }


    /**
     * Check if item exist in current position
     *
     * @return bool
     */
    public function valid() {
      return isset($this->items[$this->position]);
    }


    /**
     * Add item to the end or modify item with given key
     *
     * @param int|null $offset
     * @param object $item
     * @return $this
     */
    public function offsetSet($offset, $item) {
      if (!($item instanceof Token)) {
        throw new \InvalidArgumentException('Expect Token object');
      }

      if (is_null($offset)) {
        $this->append($item);
        return $this;
      }

      if (!is_int($offset)) {
        throw new \InvalidArgumentException('Invalid type of index. Must be integer');
      }
      $this->items[$offset] = $item;

      return $this;
    }


    /**
     * Check if item with given offset exists
     *
     * @param mixed $offset
     * @return bool
     */
    public function offsetExists($offset) {
      return isset($this->items[$offset]);
    }


    /**
     * Remove item from collection
     *
     * @param int $offset
     */
    public function offsetUnset($offset) {
      unset($this->items[$offset]);
    }


    /**
     * Get item from collection
     *
     * @param int $offset
     * @return object
     */
    public function offsetGet($offset) {
      return isset($this->items[$offset]) ? $this->items[$offset] : null;
    }


    /**
     * Return array of items connected to this collection
     *
     * Rewrite this method in you class
     *
     * <code>
     * foreach($collection->getTokens() as $item){
     *  echo get_class($item)."\n;
     * }
     * </code>
     * @return Token[]
     */
    public function getTokens() : array {
      return $this->items;
    }


    public function getItems() {
      trigger_error('Deprecated. See getTokens', E_USER_DEPRECATED);
      return $this->items;
    }


    /**
     * Iterate over objects in collection
     *
     * <code>
     * $collection->each(function($item, $index, $collection){
     *    if ( $index > 0 ) {
     *      $item->remove();
     *    }
     * })
     * </code>
     *
     * @param callable $callback
     * @return $this
     * @throws \InvalidArgumentException
     */
    public function each(callable $callback) : self {

      if (!is_callable($callback)) {
        throw new \InvalidArgumentException('Invalid callback function');
      }

      foreach ($this->getTokens() as $index => $item) {
        call_user_func_array($callback, [$item, $index, $this]);
      }

      $this->rewind();

      return $this;
    }


    public function map(callable $callback) {
      trigger_error('Deprecated. See each', E_USER_DEPRECATED);
      return $this->each($callback);
    }


    /**
     * Remove all tokens in collection
     *
     * @return Collection
     */
    public function remove() {
      foreach ($this as $token) {
        $token->remove();
      }
      return $this;
    }


    /**
     * @param int $index
     */
    protected function validateIndex($index) {


    }


    /**
     * @return $this
     */
    public function storeContentHash() {
      $this->initialContentHash = $this->getContentHash();
      return $this;
    }


    /**
     * @return bool
     */
    public function isChanged() {
      return ($this->getContentHash() !== $this->initialContentHash);
    }


    /**
     * @return string
     */
    private function getContentHash() {
      return md5($this->assemble());
    }


    /**
     * @return string
     */
    public function assemble() {
      $string = '';
      /** @var Token $token */
      foreach ($this as $token) {
        if (!$token->isValid()) {
          continue;
        }
        $string .= $token->getValue();
      }

      return $string;
    }

  }

1			<?php
2
3			namespace Funivan\PhpTokenizer\Collection;
4
5			use Funivan\PhpTokenizer\Token;
6
7			/**
8			*
9			* @package Fiv\Spl
10			*/
11			class BaseCollection implements \Iterator, \ArrayAccess, \Countable {
12
13			/**
14			* @var int
15			*/
16			protected $position = 0;
17
18			/**
19			* Array of objects
20			*
21			* @var array
22			*/
23			protected $items = [];
24
25
26			/**
27			* @var string
28			*/
29			protected $initialContentHash;
30
31
32			/**
33			* @param array $items
34			*/
35			public function __construct(array $items = []) {
36
37			if (!empty($items)) {
38			$this->setItems($items);
39			}
40			$this->storeContentHash();
41
42			}
43
44
45			/**
46			*
47			*/
48			public function __clone() {
49			$items = [];
50			foreach ($this->items as $item) {
51			$items[] = $item;
52			}
53			$this->setItems($items);
54			}
55
56
57			/**
58			* Return number of items in this collection
59			*
60			* @return int
61			*/
62			public function count() {
63			return count($this->items);
64			}
65
66
67			/**
68			* Add one item to begin of collection
69			* This item is accessible via `$collection->getFirst();`
70			*
71			* @param $item
72			* @return $this
73			*/
74			public function prepend(Token $item) {
75			array_unshift($this->items, $item);
76			return $this;
77			}
78
79
80			/**
81			* Add one item to the end of collection
82			* This item is accessible via `$collection->getLast();`
83			*
84			* @param $item
85			* @return $this
86			*/
87			public function append(Token $item) {
88			$this->items[] = $item;
89			return $this;
90			}
91
92
93			/**
94			* @param int $index
95			* @param array $items
96			* @return $this
97			* @throws \InvalidArgumentException
98			*/
99			public function addAfter($index, $items) {
100			if (!is_array($items)) {
101			throw new \InvalidArgumentException('You can add after only array of items');
102			}
103
104			foreach ($items as $item) {
105			if (!($item instanceof Token)) {
106			throw new \InvalidArgumentException('Expect array of tokens. Token[]');
107			}
108			}
109
110			if (!is_int($index)) {
111			throw new \InvalidArgumentException('Invalid type of index. Must be integer');
112			}
113
114			$offset = $index + 1;
115			$firstPart = array_slice($this->items, 0, $offset);
116			$secondPart = array_slice($this->items, $offset);
117			$this->items = array_merge($firstPart, $items, $secondPart);
118			return $this;
119			}
120
121
122			/**
123			* Truncate current list of items and add new
124			*
125			* @param array $items
126			* @return $this
127			*/
128			public function setItems($items) {
129			if (!is_array($items)) {
130			throw new \InvalidArgumentException("You can set only array of items");
131			}
132
133			foreach ($items as $item) {
134			if (!($item instanceof Token)) {
135			throw new \InvalidArgumentException('Expect array of tokens. Token[]');
136			}
137			}
138
139			$this->items = $items;
140			$this->rewind();
141			return $this;
142			}
143
144
145			/**
146			* Remove part of items from collection
147			* Works as array_slice
148			*
149			*
150			* @param $offset
151			* @param null $length
152			* @return $this
153			*/
154			public function slice($offset, $length = null) {
155			$this->items = array_slice($this->items, $offset, $length);
156			return $this;
157			}
158
159
160			/**
161			* Take part of items and return new collection
162			* Works as array_slice
163			* At this point items in 2 collection is same
164			*
165			* @param int $offset
166			* @param null $length
167			* @return self
168			*/
169			public function extractItems($offset, $length = null) {
170			$items = array_slice($this->items, $offset, $length);
171			$className = get_called_class();
172			$collection = new $className();
173			/** @var BaseCollection $collection */
174			$collection->setItems($items);
175			return $collection;
176			}
177
178
179			/**
180			* Rewind current collection
181			*/
182			public function rewind() {
183			$this->position = 0;
184			$this->items = array_values($this->items);
185			}
186
187
188			/**
189			* Return last item from collection
190			*
191			* @return mixed
192			*/
193			public function getLast() {
194			return end($this->items);
195			}
196
197
198			/**
199			* Return first item from collection
200			* @return mixed
201			*/
202			public function getFirst() {
203			return reset($this->items);
204			}
205
206
207			/**
208			* Return next item from current
209			* Also can return item with position from current + $step
210			*
211			* @param int $step
212			* @return mixed
213			*/
214			public function getNext($step = 1) {
215			$position = ($this->position + $step);
216			return isset($this->items[$position]) ? $this->items[$position] : null;
217			}
218
219
220			/**
221			* Return previous item
222			* Also can return previous from current position + $step
223			*
224			* @param int $step
225			* @return mixed
226			*/
227			public function getPrevious($step = 1) {
228			$position = ($this->position - $step);
229			return isset($this->items[$position]) ? $this->items[$position] : null;
230			}
231
232
233			/**
234			* Return current item in collection
235			*
236			* @return object
237			*/
238			public function current() {
239			return $this->items[$this->position];
240			}
241
242
243			/**
244			* Return current position
245			*
246			* @return int
247			*/
248			public function key() {
249			return $this->position;
250			}
251
252
253			/**
254			* Switch to next position
255			*/
256			public function next() {
257			++$this->position;
258			}
259
260
261			/**
262			* Check if item exist in current position
263			*
264			* @return bool
265			*/
266			public function valid() {
267			return isset($this->items[$this->position]);
268			}
269
270
271			/**
272			* Add item to the end or modify item with given key
273			*
274			* @param int\|null $offset
275			* @param object $item
276			* @return $this
277			*/
278			public function offsetSet($offset, $item) {
279			if (!($item instanceof Token)) {
280			throw new \InvalidArgumentException('Expect Token object');
281			}
282
283			if (is_null($offset)) {
284			$this->append($item);
285			return $this;
286			}
287
288			if (!is_int($offset)) {
289			throw new \InvalidArgumentException('Invalid type of index. Must be integer');
290			}
291			$this->items[$offset] = $item;
292
293			return $this;
294			}
295
296
297			/**
298			* Check if item with given offset exists
299			*
300			* @param mixed $offset
301			* @return bool
302			*/
303			public function offsetExists($offset) {
304			return isset($this->items[$offset]);
305			}
306
307
308			/**
309			* Remove item from collection
310			*
311			* @param int $offset
312			*/
313			public function offsetUnset($offset) {
314			unset($this->items[$offset]);
315			}
316
317
318			/**
319			* Get item from collection
320			*
321			* @param int $offset
322			* @return object
323			*/
324			public function offsetGet($offset) {
325			return isset($this->items[$offset]) ? $this->items[$offset] : null;
326			}
327
328
329			/**
330			* Return array of items connected to this collection
331			*
332			* Rewrite this method in you class
333			*
334			* <code>
335			* foreach($collection->getTokens() as $item){
336			* echo get_class($item)."\n;
337			* }
338			* </code>
339			* @return Token[]
340			*/
341			public function getTokens() : array {
342			return $this->items;
343			}
344
345
346			public function getItems() {
347			trigger_error('Deprecated. See getTokens', E_USER_DEPRECATED);
348			return $this->items;
349			}
350
351
352			/**
353			* Iterate over objects in collection
354			*
355			* <code>
356			* $collection->each(function($item, $index, $collection){
357			* if ( $index > 0 ) {
358			* $item->remove();
359			* }
360			* })
361			* </code>
362			*
363			* @param callable $callback
364			* @return $this
365			* @throws \InvalidArgumentException
366			*/
367			public function each(callable $callback) : self {
368
369			if (!is_callable($callback)) {
370			throw new \InvalidArgumentException('Invalid callback function');
371			}
372
373			foreach ($this->getTokens() as $index => $item) {
374			call_user_func_array($callback, [$item, $index, $this]);
375			}
376
377			$this->rewind();
378
379			return $this;
380			}
381
382
383			public function map(callable $callback) {
384			trigger_error('Deprecated. See each', E_USER_DEPRECATED);
385			return $this->each($callback);
386			}
387
388
389			/**
390			* Remove all tokens in collection
391			*
392			* @return Collection
393			*/
394			public function remove() {
395			foreach ($this as $token) {
396			$token->remove();
397			}
398			return $this;
399			}
400
401
402			/**
403			* @param int $index
404			*/
405			protected function validateIndex($index) {
			0 ignored issues – show Unused Code introduced 2016-09-26 12:10 UTC by Report Bug Copy Issue Report The parameter `$index` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
406
407			}
408
409
410			/**
411			* @return $this
412			*/
413			public function storeContentHash() {
414			$this->initialContentHash = $this->getContentHash();
415			return $this;
416			}
417
418
419			/**
420			* @return bool
421			*/
422			public function isChanged() {
423			return ($this->getContentHash() !== $this->initialContentHash);
424			}
425
426
427			/**
428			* @return string
429			*/
430			private function getContentHash() {
431			return md5($this->assemble());
432			}
433
434
435			/**
436			* @return string
437			*/
438			public function assemble() {
439			$string = '';
440			/** @var Token $token */
441			foreach ($this as $token) {
442			if (!$token->isValid()) {
443			continue;
444			}
445			$string .= $token->getValue();
446			}
447
448			return $string;
449			}
450
451			}

funivan / PhpTokenizer

Push — master ( f97578...954bd6 )

BaseCollection::storeContentHash() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like