PropertyList::handleUnknownName() - Code Metrics - Inspection of "Exclude PHPUnit from Scrutinizer check" - jkphl/micrometa - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 95e445...ca4763 )

by Joschi

created 2018-12-25 16:19 UTC

PropertyList::handleUnknownName() A

↳ Parent: PropertyList

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	7
ccs	4
cts	4
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php

/**
 * micrometa
 *
 * @category   Jkphl
 * @package    Jkphl\Micrometa
 * @subpackage Jkphl\Micrometa\Domain\Item
 * @author     Joschi Kuphal <[email protected]> / @jkphl
 * @copyright  Copyright © 2018 Joschi Kuphal <[email protected]> / @jkphl
 * @license    http://opensource.org/licenses/MIT The MIT License (MIT)
 */

/***********************************************************************************
 *  The MIT License (MIT)
 *
 *  Copyright © 2018 Joschi Kuphal <[email protected]> / @jkphl
 *
 *  Permission is hereby granted, free of charge, to any person obtaining a copy of
 *  this software and associated documentation files (the "Software"), to deal in
 *  the Software without restriction, including without limitation the rights to
 *  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 *  the Software, and to permit persons to whom the Software is furnished to do so,
 *  subject to the following conditions:
 *
 *  The above copyright notice and this permission notice shall be included in all
 *  copies or substantial portions of the Software.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 *  FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 *  COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 *  IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 *  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 ***********************************************************************************/

namespace Jkphl\Micrometa\Domain\Item;

use Jkphl\Micrometa\Domain\Exceptions\ErrorException;
use Jkphl\Micrometa\Domain\Exceptions\OutOfBoundsException;
use Jkphl\Micrometa\Domain\Factory\IriFactory;

/**
 * Property list
 *
 * @package    Jkphl\Micrometa
 * @subpackage Jkphl\RdfaLiteMicrodata\Domain
 */
class PropertyList implements PropertyListInterface
{
    /**
     * Property values
     *
     * @var array[]
     */
    protected $values = [];
    /**
     * Property names
     *
     * @var \stdClass[]
     */
    protected $names = [];
    /**
     * Name cursor mapping
     *
     * @var int[]
     */
    protected $nameToCursor = [];
    /**
     * Internal cursor
     *
     * @var int
     */
    protected $cursor = 0;

    /**
     * Unset a property
     *
     * @param \stdClass|string $iri IRI
     *
     * @throws ErrorException
     */
    public function offsetUnset($iri)
    {
        throw new ErrorException(
            sprintf(ErrorException::CANNOT_UNSET_PROPERTY_STR, $iri),
            ErrorException::CANNOT_UNSET_PROPERTY,
            E_WARNING
        );
    }

    /**
     * Return the number of properties
     *
     * @return int Number of properties
     */
    public function count()
    {
        return count($this->values);
    }

    /**
     * Return the current property values
     *
     * @return array Property values
     */
    public function current()
    {
        return $this->values[$this->cursor];
    }

    /**
     * Move forward to next element
     */
    public function next()
    {
        ++$this->cursor;
    }

    /**
     * Return the current IRI key
     *
     * @return \stdClass IRI key
     */
    public function key()
    {
        return $this->names[$this->cursor];
    }

    /**
     * Checks if current position is valid
     *
     * @return boolean The current position is valid
     */
    public function valid()
    {
        return isset($this->values[$this->cursor]);
    }

    /**
     * Rewind the Iterator to the first element
     */
    public function rewind()
    {
        $this->cursor = 0;
    }

    /**
     * Add a property
     *
     * @param \stdClass|Iri $property Property
     */
    public function add($property)
    {
        $iri    = IriFactory::create($property);
        $values = (is_object($property) && isset($property->values)) ? (array)$property->values : [];

        // Create the property values list if necessary
        if (!$this->offsetExists($iri)) {
            $this->offsetSet($iri, $values);

            return;
        }

        $propertyValues =& $this->offsetGet($iri);
        $propertyValues = array_merge($propertyValues, $values);
    }

    /**
     * Return whether a property exists
     *
     * @param \stdClass|Iri|string $iri IRI
     *
     * @return boolean Property exists
     */
    public function offsetExists($iri)
    {
        $iri = IriFactory::create($iri);
        try {
            ($iri->profile !== '') ?
                $this->getProfiledPropertyCursor($iri) : $this->getPropertyCursor($iri->name);

            return true;
        } catch (OutOfBoundsException $exception) {
            return false;
        }
    }

    /**
     * Get a particular property cursor by its profiled name
     *
     * @param Iri $iri IRI
     *
     * @return int Property cursor
     * @throws OutOfBoundsException If the property name is unknown
     */
    protected function getProfiledPropertyCursor($iri)
    {
        $iriStr = strval($iri);

        // If the property name is unknown
        if (!isset($this->nameToCursor[$iriStr])) {
            $this->handleUnknownName($iriStr);
        }

        return $this->nameToCursor[$iriStr];
    }

    /**
     * Handle an unknown property name
     *
     * @param string $name Property name
     *
     * @throws OutOfBoundsException If the property name is unknown
     */
    protected function handleUnknownName($name)
    {
        throw new OutOfBoundsException(
            sprintf(OutOfBoundsException::UNKNOWN_PROPERTY_NAME_STR, $name),
            OutOfBoundsException::UNKNOWN_PROPERTY_NAME
        );
    }

    /**
     * Get a particular property cursor by its name
     *
     * @param string $name Property name
     *
     * @return int Property cursor
     */
    protected function getPropertyCursor($name)
    {
        // Run through all property names
        foreach ($this->names as $cursor => $iri) {
            if (in_array($name, [$iri->name, strval($iri)])) {
                return $cursor;
            }
        }

        return $this->handleUnknownName($name);
    }

    /**
     * Set a particular property
     *
     * @param \stdClass|Iri|string $iri IRI
     * @param array $value              Property values
     */
    public function offsetSet($iri, $value)
    {
        $iri                   = IriFactory::create($iri);
        $iriStr                = strval($iri);
        $cursor                = array_key_exists($iriStr, $this->nameToCursor) ?
            $this->nameToCursor[$iriStr] : ($this->nameToCursor[$iriStr] = count($this->nameToCursor));
        $this->names[$cursor]  = $iri;
        $this->values[$cursor] = $value;
    }

    /**
     * Get a particular property
     *
     * @param \stdClass|Iri|string $iri IRI
     *
     * @return array Property values
     * @throws OutOfBoundsException If the property name is unknown
     */
    public function &offsetGet($iri)
    {
        $iri    = IriFactory::create($iri);
        $cursor = ($iri->profile !== '') ?
            $this->getProfiledPropertyCursor($iri) : $this->getPropertyCursor($iri->name);

        return $this->values[$cursor];
    }
}


1		<?php
2
3		/**
4		* micrometa
5		*
6		* @category Jkphl
7		* @package Jkphl\Micrometa
8		* @subpackage Jkphl\Micrometa\Domain\Item
9		* @author Joschi Kuphal <[email protected]> / @jkphl
10		* @copyright Copyright © 2018 Joschi Kuphal <[email protected]> / @jkphl
11		* @license http://opensource.org/licenses/MIT The MIT License (MIT)
12		*/
13
14		/***********************************************************************************
15		* The MIT License (MIT)
16		*
17		* Copyright © 2018 Joschi Kuphal <[email protected]> / @jkphl
18		*
19		* Permission is hereby granted, free of charge, to any person obtaining a copy of
20		* this software and associated documentation files (the "Software"), to deal in
21		* the Software without restriction, including without limitation the rights to
22		* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
23		* the Software, and to permit persons to whom the Software is furnished to do so,
24		* subject to the following conditions:
25		*
26		* The above copyright notice and this permission notice shall be included in all
27		* copies or substantial portions of the Software.
28		*
29		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
30		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
31		* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
32		* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
33		* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
34		* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
35		***********************************************************************************/
36
37		namespace Jkphl\Micrometa\Domain\Item;
38
39		use Jkphl\Micrometa\Domain\Exceptions\ErrorException;
40		use Jkphl\Micrometa\Domain\Exceptions\OutOfBoundsException;
41		use Jkphl\Micrometa\Domain\Factory\IriFactory;
42
43		/**
44		* Property list
45		*
46		* @package Jkphl\Micrometa
47		* @subpackage Jkphl\RdfaLiteMicrodata\Domain
48		*/
49		class PropertyList implements PropertyListInterface
50		{
51		/**
52		* Property values
53		*
54		* @var array[]
55		*/
56		protected $values = [];
57		/**
58		* Property names
59		*
60		* @var \stdClass[]
61		*/
62		protected $names = [];
63		/**
64		* Name cursor mapping
65		*
66		* @var int[]
67		*/
68		protected $nameToCursor = [];
69		/**
70		* Internal cursor
71		*
72		* @var int
73		*/
74		protected $cursor = 0;
75
76		/**
77		* Unset a property
78		*
79		* @param \stdClass\|string $iri IRI
80		*
81		* @throws ErrorException
82		*/
83	1	public function offsetUnset($iri)
84		{
85	1	throw new ErrorException(
86	1	sprintf(ErrorException::CANNOT_UNSET_PROPERTY_STR, $iri),
87	1	ErrorException::CANNOT_UNSET_PROPERTY,
88	1	E_WARNING
89		);
90		}
91
92		/**
93		* Return the number of properties
94		*
95		* @return int Number of properties
96		*/
97	2	public function count()
98		{
99	2	return count($this->values);
100		}
101
102		/**
103		* Return the current property values
104		*
105		* @return array Property values
106		*/
107	8	public function current()
108		{
109	8	return $this->values[$this->cursor];
110		}
111
112		/**
113		* Move forward to next element
114		*/
115	8	public function next()
116		{
117	8	++$this->cursor;
118	8	}
119
120		/**
121		* Return the current IRI key
122		*
123		* @return \stdClass IRI key
124		*/
125	8	public function key()
126		{
127	8	return $this->names[$this->cursor];
128		}
129
130		/**
131		* Checks if current position is valid
132		*
133		* @return boolean The current position is valid
134		*/
135	17	public function valid()
136		{
137	17	return isset($this->values[$this->cursor]);
138		}
139
140		/**
141		* Rewind the Iterator to the first element
142		*/
143	17	public function rewind()
144		{
145	17	$this->cursor = 0;
146	17	}
147
148		/**
149		* Add a property
150		*
151		* @param \stdClass\|Iri $property Property
152		*/
153	37	public function add($property)
154		{
155	37	$iri = IriFactory::create($property);
156	37	$values = (is_object($property) && isset($property->values)) ? (array)$property->values : [];
157
158		// Create the property values list if necessary
159	37	if (!$this->offsetExists($iri)) {
160	37	$this->offsetSet($iri, $values);
161
162	37	return;
163		}
164
165	2	$propertyValues =& $this->offsetGet($iri);
166	2	$propertyValues = array_merge($propertyValues, $values);
167	2	}
168
169		/**
170		* Return whether a property exists
171		*
172		* @param \stdClass\|Iri\|string $iri IRI
173		*
174		* @return boolean Property exists
175		*/
176	37	public function offsetExists($iri)
177		{
178	37	$iri = IriFactory::create($iri);
179		try {
180	37	($iri->profile !== '') ?
181	37	$this->getProfiledPropertyCursor($iri) : $this->getPropertyCursor($iri->name);
182
183	3	return true;
184	37	} catch (OutOfBoundsException $exception) {
185	37	return false;
186		}
187		}
188
189		/**
190		* Get a particular property cursor by its profiled name
191		*
192		* @param Iri $iri IRI
193		*
194		* @return int Property cursor
195		* @throws OutOfBoundsException If the property name is unknown
196		*/
197	31	protected function getProfiledPropertyCursor($iri)
198		{
199	31	$iriStr = strval($iri);
200
201		// If the property name is unknown
202	31	if (!isset($this->nameToCursor[$iriStr])) {
203	31	$this->handleUnknownName($iriStr);
204		}
205
206	6	return $this->nameToCursor[$iriStr];
207		}
208
209		/**
210		* Handle an unknown property name
211		*
212		* @param string $name Property name
213		*
214		* @throws OutOfBoundsException If the property name is unknown
215		*/
216	40	protected function handleUnknownName($name)
217		{
218	40	throw new OutOfBoundsException(
219	40	sprintf(OutOfBoundsException::UNKNOWN_PROPERTY_NAME_STR, $name),
220	40	OutOfBoundsException::UNKNOWN_PROPERTY_NAME
221		);
222		}
223
224		/**
225		* Get a particular property cursor by its name
226		*
227		* @param string $name Property name
228		*
229		* @return int Property cursor
230		*/
231	10	protected function getPropertyCursor($name)
232		{
233		// Run through all property names
234	10	foreach ($this->names as $cursor => $iri) {
235	5	if (in_array($name, [$iri->name, strval($iri)])) {
236	5	return $cursor;
237		}
238		}
239
240	8	return $this->handleUnknownName($name);
241		}
242
243		/**
244		* Set a particular property
245		*
246		* @param \stdClass\|Iri\|string $iri IRI
247		* @param array $value Property values
248		*/
249	9	public function offsetSet($iri, $value)
250		{
251	9	$iri = IriFactory::create($iri);
252	9	$iriStr = strval($iri);
253	9	$cursor = array_key_exists($iriStr, $this->nameToCursor) ?
254	9	$this->nameToCursor[$iriStr] : ($this->nameToCursor[$iriStr] = count($this->nameToCursor));
255	9	$this->names[$cursor] = $iri;
256	9	$this->values[$cursor] = $value;
257	9	}
258
259		/**
260		* Get a particular property
261		*
262		* @param \stdClass\|Iri\|string $iri IRI
263		*
264		* @return array Property values
265		* @throws OutOfBoundsException If the property name is unknown
266		*/
267	15	public function &offsetGet($iri)
268		{
269	15	$iri = IriFactory::create($iri);
270	15	$cursor = ($iri->profile !== '') ?
271	15	$this->getProfiledPropertyCursor($iri) : $this->getPropertyCursor($iri->name);
272
273	12	return $this->values[$cursor];
274		}
275		}
276

jkphl / micrometa

Push — master ( 95e445...ca4763 )

PropertyList::handleUnknownName() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like