SnakList::getNewOffset() - Code Metrics - Inspection of "WikibaseDataModel: PHP 7.4 CI fails" - wmde/WikibaseDataModel - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Push — T243590 ( 74daf7 )

unknown

created 2020-05-26 07:15 UTC

SnakList::getNewOffset() A

↳ Parent: SnakList

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	7
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	0

<?php

namespace Wikibase\DataModel\Snak;

use ArrayObject;
use Comparable;
use Hashable;
use InvalidArgumentException;
use Traversable;
use Wikibase\DataModel\Internal\MapValueHasher;

/**
 * List of Snak objects.
 * Indexes the snaks by hash and ensures no more the one snak with the same hash are in the list.
 *
 * @since 0.1
 *
 * @license GPL-2.0-or-later
 * @author Jeroen De Dauw < [email protected] >
 * @author Addshore
 */
class SnakList extends ArrayObject implements Comparable, Hashable {

	/**
	 * Maps snak hashes to their offsets.
	 *
	 * @var array [ snak hash (string) => snak offset (string|int) ]
	 */
	private $offsetHashes = [];

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

	/**
	 * @param Snak[]|Traversable $snaks
	 *
	 * @throws InvalidArgumentException
	 */
	public function __construct( $snaks = [] ) {
		if ( !is_array( $snaks ) && !( $snaks instanceof Traversable ) ) {
			throw new InvalidArgumentException( '$snaks must be an array or an instance of Traversable' );
		}

		foreach ( $snaks as $index => $snak ) {
			$this->setElement( $index, $snak );
		}
	}

	/**
	 * @since 0.1
	 *
	 * @param string $snakHash
	 *
	 * @return boolean
	 */
	public function hasSnakHash( $snakHash ) {
		return array_key_exists( $snakHash, $this->offsetHashes );
	}

	/**
	 * @since 0.1
	 *
	 * @param string $snakHash
	 */
	public function removeSnakHash( $snakHash ) {
		if ( $this->hasSnakHash( $snakHash ) ) {
			$offset = $this->offsetHashes[$snakHash];
			$this->offsetUnset( $offset );
		}
	}

	/**
	 * @since 0.1
	 *
	 * @param Snak $snak
	 *
	 * @return boolean Indicates if the snak was added or not.
	 */
	public function addSnak( Snak $snak ) {
		if ( $this->hasSnak( $snak ) ) {
			return false;
		}

		$this->append( $snak );
		return true;
	}

	/**
	 * @since 0.1
	 *
	 * @param Snak $snak
	 *
	 * @return boolean
	 */
	public function hasSnak( Snak $snak ) {
		return $this->hasSnakHash( $snak->getHash() );
	}

	/**
	 * @since 0.1
	 *
	 * @param Snak $snak
	 */
	public function removeSnak( Snak $snak ) {
		$this->removeSnakHash( $snak->getHash() );
	}

	/**
	 * @since 0.1
	 *
	 * @param string $snakHash
	 *
	 * @return Snak|bool
	 */
	public function getSnak( $snakHash ) {
		if ( !$this->hasSnakHash( $snakHash ) ) {
			return false;
		}

		$offset = $this->offsetHashes[$snakHash];
		return $this->offsetGet( $offset );
	}

	/**
	 * @see Comparable::equals
	 *
	 * The comparison is done purely value based, ignoring the order of the elements in the array.
	 *
	 * @since 0.3
	 *
	 * @param mixed $target
	 *
	 * @return bool
	 */
	public function equals( $target ) {
		if ( $this === $target ) {
			return true;
		}

		return $target instanceof self
			&& $this->getHash() === $target->getHash();
	}

	/**
	 * @see Hashable::getHash
	 *
	 * The hash is purely value based. Order of the elements in the array is not held into account.
	 *
	 * @since 0.1
	 *
	 * @return string
	 */
	public function getHash() {
		$hasher = new MapValueHasher();
		return $hasher->hash( $this );
	}

	/**
	 * Groups snaks by property, and optionally orders them.
	 *
	 * @param string[] $order List of property ID strings to order by. Snaks with other properties
	 *  will also be grouped, but put at the end, in the order each property appeared first in the
	 *  original list.
	 *
	 * @since 0.5
	 */
	public function orderByProperty( array $order = [] ) {
		$byProperty = array_fill_keys( $order, [] );

		/** @var Snak $snak */
		foreach ( $this as $snak ) {
			$byProperty[$snak->getPropertyId()->getSerialization()][] = $snak;
		}

		$ordered = [];
		foreach ( $byProperty as $snaks ) {
			$ordered = array_merge( $ordered, $snaks );
		}

		$this->exchangeArray( $ordered );

		$index = 0;
		foreach ( $ordered as $snak ) {
			$this->offsetHashes[$snak->getHash()] = $index++;
		}
	}

	/**
	 * Finds a new offset for when appending an element.
	 * The base class does this, so it would be better to integrate,
	 * but there does not appear to be any way to do this...
	 *
	 * @return int
	 */
	private function getNewOffset() {
		while ( $this->offsetExists( $this->indexOffset ) ) {
			$this->indexOffset++;
		}

		return $this->indexOffset;
	}

	/**
	 * @see ArrayObject::offsetUnset
	 *
	 * @since 0.1
	 *
	 * @param int|string $index
	 */
	public function offsetUnset( $index ) {
		if ( $this->offsetExists( $index ) ) {
			/**
			 * @var Hashable $element
			 */
			$element = $this->offsetGet( $index );
			$hash = $element->getHash();
			unset( $this->offsetHashes[$hash] );

			parent::offsetUnset( $index );
		}
	}

	/**
	 * @see ArrayObject::append
	 *
	 * @param Snak $value
	 */
	public function append( $value ) {
		$this->setElement( null, $value );
	}

	/**
	 * @see ArrayObject::offsetSet()
	 *
	 * @param int|string $index
	 * @param Snak $value
	 */
	public function offsetSet( $index, $value ) {
		$this->setElement( $index, $value );
	}

	/**
	 * Method that actually sets the element and holds
	 * all common code needed for set operations, including
	 * type checking and offset resolving.
	 *
	 * @param int|string $index
	 * @param Snak $value
	 *
	 * @throws InvalidArgumentException
	 */
	private function setElement( $index, $value ) {
		if ( !( $value instanceof Snak ) ) {
			throw new InvalidArgumentException( '$value must be a Snak' );
		}

		if ( $this->hasSnak( $value ) ) {
			return;
		}

		if ( $index === null ) {
			$index = $this->getNewOffset();
		}

		$hash = $value->getHash();
		$this->offsetHashes[$hash] = $index;
		parent::offsetSet( $index, $value );
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
	}

	/**
	 * @see Serializable::serialize
	 *
	 * @return string
	 */
	public function serialize() {
		return serialize( $this->__serialize() );
	}

	/**
	 * @see Serializable::unserialize
	 *
	 * @param string $serialized
	 */
	public function unserialize( $serialized ) {
		$serializationData = unserialize( $serialized );
		$this->__unserialize($serializationData);
	}

	/**
	 * @see https://wiki.php.net/rfc/custom_object_serialization
	 *
	 * @return array
	 */
	public function __serialize(): array {
		return [
			'data' => $this->getArrayCopy(),
			'index' => $this->indexOffset,
		];
	}

	/**
	 * @see https://wiki.php.net/rfc/custom_object_serialization
	 *
	 * @param array $data
	 */
	public function __unserialize($data) : void {
		foreach ( $data['data'] as $offset => $value ) {
			// Just set the element, bypassing checks and offset resolving,
			// as these elements have already gone through this.
			parent::offsetSet( $offset, $value );
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
		}

		$this->indexOffset = $data['index'];
	}

	/**
	 * Returns if the ArrayObject has no elements.
	 *
	 * @return bool
	 */
	public function isEmpty() {
		return !$this->getIterator()->valid();
	}

}


1			<?php
2
3			namespace Wikibase\DataModel\Snak;
4
5			use ArrayObject;
6			use Comparable;
7			use Hashable;
8			use InvalidArgumentException;
9			use Traversable;
10			use Wikibase\DataModel\Internal\MapValueHasher;
11
12			/**
13			* List of Snak objects.
14			* Indexes the snaks by hash and ensures no more the one snak with the same hash are in the list.
15			*
16			* @since 0.1
17			*
18			* @license GPL-2.0-or-later
19			* @author Jeroen De Dauw < [email protected] >
20			* @author Addshore
21			*/
22			class SnakList extends ArrayObject implements Comparable, Hashable {
23
24			/**
25			* Maps snak hashes to their offsets.
26			*
27			* @var array [ snak hash (string) => snak offset (string\|int) ]
28			*/
29			private $offsetHashes = [];
30
31			/**
32			* @var int
33			*/
34			private $indexOffset = 0;
35
36			/**
37			* @param Snak[]\|Traversable $snaks
38			*
39			* @throws InvalidArgumentException
40			*/
41			public function __construct( $snaks = [] ) {
42			if ( !is_array( $snaks ) && !( $snaks instanceof Traversable ) ) {
43			throw new InvalidArgumentException( '$snaks must be an array or an instance of Traversable' );
44			}
45
46			foreach ( $snaks as $index => $snak ) {
47			$this->setElement( $index, $snak );
48			}
49			}
50
51			/**
52			* @since 0.1
53			*
54			* @param string $snakHash
55			*
56			* @return boolean
57			*/
58			public function hasSnakHash( $snakHash ) {
59			return array_key_exists( $snakHash, $this->offsetHashes );
60			}
61
62			/**
63			* @since 0.1
64			*
65			* @param string $snakHash
66			*/
67			public function removeSnakHash( $snakHash ) {
68			if ( $this->hasSnakHash( $snakHash ) ) {
69			$offset = $this->offsetHashes[$snakHash];
70			$this->offsetUnset( $offset );
71			}
72			}
73
74			/**
75			* @since 0.1
76			*
77			* @param Snak $snak
78			*
79			* @return boolean Indicates if the snak was added or not.
80			*/
81			public function addSnak( Snak $snak ) {
82			if ( $this->hasSnak( $snak ) ) {
83			return false;
84			}
85
86			$this->append( $snak );
87			return true;
88			}
89
90			/**
91			* @since 0.1
92			*
93			* @param Snak $snak
94			*
95			* @return boolean
96			*/
97			public function hasSnak( Snak $snak ) {
98			return $this->hasSnakHash( $snak->getHash() );
99			}
100
101			/**
102			* @since 0.1
103			*
104			* @param Snak $snak
105			*/
106			public function removeSnak( Snak $snak ) {
107			$this->removeSnakHash( $snak->getHash() );
108			}
109
110			/**
111			* @since 0.1
112			*
113			* @param string $snakHash
114			*
115			* @return Snak\|bool
116			*/
117			public function getSnak( $snakHash ) {
118			if ( !$this->hasSnakHash( $snakHash ) ) {
119			return false;
120			}
121
122			$offset = $this->offsetHashes[$snakHash];
123			return $this->offsetGet( $offset );
124			}
125
126			/**
127			* @see Comparable::equals
128			*
129			* The comparison is done purely value based, ignoring the order of the elements in the array.
130			*
131			* @since 0.3
132			*
133			* @param mixed $target
134			*
135			* @return bool
136			*/
137			public function equals( $target ) {
138			if ( $this === $target ) {
139			return true;
140			}
141
142			return $target instanceof self
143			&& $this->getHash() === $target->getHash();
144			}
145
146			/**
147			* @see Hashable::getHash
148			*
149			* The hash is purely value based. Order of the elements in the array is not held into account.
150			*
151			* @since 0.1
152			*
153			* @return string
154			*/
155			public function getHash() {
156			$hasher = new MapValueHasher();
157			return $hasher->hash( $this );
158			}
159
160			/**
161			* Groups snaks by property, and optionally orders them.
162			*
163			* @param string[] $order List of property ID strings to order by. Snaks with other properties
164			* will also be grouped, but put at the end, in the order each property appeared first in the
165			* original list.
166			*
167			* @since 0.5
168			*/
169			public function orderByProperty( array $order = [] ) {
170			$byProperty = array_fill_keys( $order, [] );
171
172			/** @var Snak $snak */
173			foreach ( $this as $snak ) {
174			$byProperty[$snak->getPropertyId()->getSerialization()][] = $snak;
175			}
176
177			$ordered = [];
178			foreach ( $byProperty as $snaks ) {
179			$ordered = array_merge( $ordered, $snaks );
180			}
181
182			$this->exchangeArray( $ordered );
183
184			$index = 0;
185			foreach ( $ordered as $snak ) {
186			$this->offsetHashes[$snak->getHash()] = $index++;
187			}
188			}
189
190			/**
191			* Finds a new offset for when appending an element.
192			* The base class does this, so it would be better to integrate,
193			* but there does not appear to be any way to do this...
194			*
195			* @return int
196			*/
197			private function getNewOffset() {
198			while ( $this->offsetExists( $this->indexOffset ) ) {
199			$this->indexOffset++;
200			}
201
202			return $this->indexOffset;
203			}
204
205			/**
206			* @see ArrayObject::offsetUnset
207			*
208			* @since 0.1
209			*
210			* @param int\|string $index
211			*/
212			public function offsetUnset( $index ) {
213			if ( $this->offsetExists( $index ) ) {
214			/**
215			* @var Hashable $element
216			*/
217			$element = $this->offsetGet( $index );
218			$hash = $element->getHash();
219			unset( $this->offsetHashes[$hash] );
220
221			parent::offsetUnset( $index );
222			}
223			}
224
225			/**
226			* @see ArrayObject::append
227			*
228			* @param Snak $value
229			*/
230			public function append( $value ) {
231			$this->setElement( null, $value );
232			}
233
234			/**
235			* @see ArrayObject::offsetSet()
236			*
237			* @param int\|string $index
238			* @param Snak $value
239			*/
240			public function offsetSet( $index, $value ) {
241			$this->setElement( $index, $value );
242			}
243
244			/**
245			* Method that actually sets the element and holds
246			* all common code needed for set operations, including
247			* type checking and offset resolving.
248			*
249			* @param int\|string $index
250			* @param Snak $value
251			*
252			* @throws InvalidArgumentException
253			*/
254			private function setElement( $index, $value ) {
255			if ( !( $value instanceof Snak ) ) {
256			throw new InvalidArgumentException( '$value must be a Snak' );
257			}
258
259			if ( $this->hasSnak( $value ) ) {
260			return;
261			}
262
263			if ( $index === null ) {
264			$index = $this->getNewOffset();
265			}
266
267			$hash = $value->getHash();
268			$this->offsetHashes[$hash] = $index;
269			parent::offsetSet( $index, $value );
			0 ignored issues – show Comprehensibility Bug introduced 2017-01-05 21:29 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`offsetSet()` instead of `setElement()`). Are you sure this is correct? If so, you might want to change this to `$this->offsetSet()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
270			}
271
272			/**
273			* @see Serializable::serialize
274			*
275			* @return string
276			*/
277			public function serialize() {
278			return serialize( $this->__serialize() );
279			}
280
281			/**
282			* @see Serializable::unserialize
283			*
284			* @param string $serialized
285			*/
286			public function unserialize( $serialized ) {
287			$serializationData = unserialize( $serialized );
288			$this->__unserialize($serializationData);
289			}
290
291			/**
292			* @see https://wiki.php.net/rfc/custom_object_serialization
293			*
294			* @return array
295			*/
296			public function __serialize(): array {
297			return [
298			'data' => $this->getArrayCopy(),
299			'index' => $this->indexOffset,
300			];
301			}
302
303			/**
304			* @see https://wiki.php.net/rfc/custom_object_serialization
305			*
306			* @param array $data
307			*/
308			public function __unserialize($data) : void {
309			foreach ( $data['data'] as $offset => $value ) {
310			// Just set the element, bypassing checks and offset resolving,
311			// as these elements have already gone through this.
312			parent::offsetSet( $offset, $value );
			0 ignored issues – show Comprehensibility Bug introduced 2020-05-26 07:17 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`offsetSet()` instead of `__unserialize()`). Are you sure this is correct? If so, you might want to change this to `$this->offsetSet()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
313			}
314
315			$this->indexOffset = $data['index'];
316			}
317
318			/**
319			* Returns if the ArrayObject has no elements.
320			*
321			* @return bool
322			*/
323			public function isEmpty() {
324			return !$this->getIterator()->valid();
325			}
326
327			}
328

wmde / WikibaseDataModel

Push — T243590 ( 74daf7 )

SnakList::getNewOffset() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like