FieldCollection::__toString() - Code Metrics - RocketPropelledTortoise/Core - Measure and Improve Code Quality continuously with Scrutinizer

FieldCollection::__toString() A
last analyzed 2020-04-19 15:33 UTC

↳ Parent: FieldCollection

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

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

<?php
/**
 * A FieldCollection is a Collection that wraps all values in their Field models.
 *
 * It will also return the actual value but not the Field model.
 */
namespace Rocket\Entities;

use Illuminate\Support\Collection;
use Rocket\Entities\Exceptions\InvalidFieldTypeException;
use Rocket\Entities\Exceptions\ItemCountException;
use Rocket\Entities\Exceptions\NullValueException;

/**
 * Smart Collection for entities
 */
class FieldCollection extends \Illuminate\Support\Collection
{
    /**
     * @var int The max items this collection can hold
     */
    protected $maxItems = 1;

    /**
     * @var array The Collection configuration
     */
    protected $configuration = [];

    /**
     * @var string The type of this collection
     */
    protected $type;

    /**
     * @var array An array of fields that were deleted
     */
    protected $deleted = [];

    /**
     * Initialize a collection with the configuration
     *
     * @param array $configuration
     * @throws InvalidFieldTypeException
     * @return static
     */
    public static function initField($configuration = [])
    {
        if (!array_key_exists('type', $configuration) || !class_exists($configuration['type'])) {
            throw new InvalidFieldTypeException('You did not specify a type on this class.');
        }

        $collection = new static();
        $collection->configuration = $configuration;
        $collection->type = $configuration['type'];

        if (array_key_exists('max_items', $configuration)) {
            $collection->maxItems = $configuration['max_items'];
        }

        return $collection;
    }

    /**
     * Validate input of OffsetSet
     *
     * @param $key
     * @param $value
     * @throws ItemCountException
     * @throws NullValueException
     */
    protected function validateSet($key, $value)
    {
        $maxItems = $this->getMaxItems();
        if ((is_null($key) || !array_key_exists($key, $this->items)) && $maxItems != 0 && $this->count() >= $maxItems) {
            throw new ItemCountException('The maximum number of items has been reached on this field.');
        }

        if (is_null($key) && is_null($value)) {
            throw new NullValueException('You cannot add a null value');
        }
    }

    /**
     * Get a field from a value
     *
     * @param Field|mixed $value
     * @return Field
     */
    protected function getFieldInstance($value)
    {
        if ($value instanceof Field) {
            return $value;
        }

        $container = new $this->type();
        $container->value = $value;

        return $container;
    }

    /**
     * Set the item at a given offset.
     *
     * @param  mixed  $key
     * @param  mixed  $value
     * @return void
     */
    public function offsetSet($key, $value)
    {
        $this->validateSet($key, $value);

        if (is_null($value)) {
            $this->offsetUnset($key);

            return;
        }

        if (is_null($key)) {
            $this->items[] = $this->getFieldInstance($value);

            return;
        }

        if ($value instanceof Field && $this->has($key)) {
            $this->deleted[] = $this->items[$key];
        }

        $this->items[$key] = $this->getFieldInstance($value);
    }

    /**
     * Get an item at a given offset.
     *
     * @param  mixed  $key
     * @return mixed
     */
    public function offsetGet($key)
    {
        return parent::offsetGet($key)->value;
    }

    /**
     * Unset the item at a given offset.
     *
     * @param  string  $key
     * @return void
     */
    public function offsetUnset($key)
    {
        if ($this->offsetExists($key)) {
            $this->deleted[] = $this->items[$key];
        }
        parent::offsetUnset($key);
    }

    /**
     * Get all deleted fields
     *
     * @return Collection
     */
    public function deleted()
    {
        return new Collection(array_diff($this->deleted, $this->items));
    }

    /**
     * Mark the content as current and saved
     */
    public function syncOriginal()
    {
        $this->deleted = [];
    }

    /**
     * Remove all items in this collection
     *
     * @return void
     */
    public function clear()
    {
        foreach ($this->items as $item) {
            $this->deleted[] = $item;
        }

        $this->items = [];
    }

    /**
     * Get the number of items possible in this collection.
     *
     * @return int
     */
    public function getMaxItems()
    {
        return $this->maxItems;
    }

    /**
     * As we use a field collection even if we have only one value, we use it that way.
     *
     * @return array|mixed|null
     */
    public function toArray()
    {
        if ($this->getMaxItems() != 1) {
            return parent::toArray();
        }

        if (!array_key_exists(0, $this->items)) {
            return null;
        }

        return $this->get(0)->toArray();
    }

    /**
     * Convert the collection to its string representation.
     *
     * @return string
     */
    public function __toString()
    {
        if ($this->getMaxItems() == 1) {
            return $this->items[0]->value;
        }

        return 'Array';
    }
}


1		<?php
2		/**
3		* A FieldCollection is a Collection that wraps all values in their Field models.
4		*
5		* It will also return the actual value but not the Field model.
6		*/
7		namespace Rocket\Entities;
8
9		use Illuminate\Support\Collection;
10		use Rocket\Entities\Exceptions\InvalidFieldTypeException;
11		use Rocket\Entities\Exceptions\ItemCountException;
12		use Rocket\Entities\Exceptions\NullValueException;
13
14		/**
15		* Smart Collection for entities
16		*/
17		class FieldCollection extends \Illuminate\Support\Collection
18		{
19		/**
20		* @var int The max items this collection can hold
21		*/
22		protected $maxItems = 1;
23
24		/**
25		* @var array The Collection configuration
26		*/
27		protected $configuration = [];
28
29		/**
30		* @var string The type of this collection
31		*/
32		protected $type;
33
34		/**
35		* @var array An array of fields that were deleted
36		*/
37		protected $deleted = [];
38
39		/**
40		* Initialize a collection with the configuration
41		*
42		* @param array $configuration
43		* @throws InvalidFieldTypeException
44		* @return static
45		*/
46	159	public static function initField($configuration = [])
47		{
48	159	if (!array_key_exists('type', $configuration) \|\| !class_exists($configuration['type'])) {
49	3	throw new InvalidFieldTypeException('You did not specify a type on this class.');
50		}
51
52	156	$collection = new static();
53	156	$collection->configuration = $configuration;
54	156	$collection->type = $configuration['type'];
55
56	156	if (array_key_exists('max_items', $configuration)) {
57	141	$collection->maxItems = $configuration['max_items'];
58	141	}
59
60	156	return $collection;
61		}
62
63		/**
64		* Validate input of OffsetSet
65		*
66		* @param $key
67		* @param $value
68		* @throws ItemCountException
69		* @throws NullValueException
70		*/
71	129	protected function validateSet($key, $value)
72		{
73	129	$maxItems = $this->getMaxItems();
74	129	if ((is_null($key) \|\| !array_key_exists($key, $this->items)) && $maxItems != 0 && $this->count() >= $maxItems) {
75	3	throw new ItemCountException('The maximum number of items has been reached on this field.');
76		}
77
78	129	if (is_null($key) && is_null($value)) {
79	3	throw new NullValueException('You cannot add a null value');
80		}
81	126	}
82
83		/**
84		* Get a field from a value
85		*
86		* @param Field\|mixed $value
87		* @return Field
88		*/
89	126	protected function getFieldInstance($value)
90		{
91	126	if ($value instanceof Field) {
92	39	return $value;
93		}
94
95	126	$container = new $this->type();
96	126	$container->value = $value;
97
98	126	return $container;
99		}
100
101		/**
102		* Set the item at a given offset.
103		*
104		* @param mixed $key
105		* @param mixed $value
106		* @return void
107		*/
108	129	public function offsetSet($key, $value)
109		{
110	129	$this->validateSet($key, $value);
111
112	126	if (is_null($value)) {
113	6	$this->offsetUnset($key);
114
115	6	return;
116		}
117
118	126	if (is_null($key)) {
119	96	$this->items[] = $this->getFieldInstance($value);
120
121	96	return;
122		}
123
124	66	if ($value instanceof Field && $this->has($key)) {
125	9	$this->deleted[] = $this->items[$key];
126	9	}
127
128	66	$this->items[$key] = $this->getFieldInstance($value);
129	66	}
130
131		/**
132		* Get an item at a given offset.
133		*
134		* @param mixed $key
135		* @return mixed
136		*/
137	9	public function offsetGet($key)
138		{
139	9	return parent::offsetGet($key)->value;
140		}
141
142		/**
143		* Unset the item at a given offset.
144		*
145		* @param string $key
146		* @return void
147		*/
148	33	public function offsetUnset($key)
149		{
150	33	if ($this->offsetExists($key)) {
151	33	$this->deleted[] = $this->items[$key];
152	33	}
153	33	parent::offsetUnset($key);
154	33	}
155
156		/**
157		* Get all deleted fields
158		*
159		* @return Collection
160		*/
161	63	public function deleted()
162		{
163	63	return new Collection(array_diff($this->deleted, $this->items));
164		}
165
166		/**
167		* Mark the content as current and saved
168		*/
169	60	public function syncOriginal()
170		{
171	60	$this->deleted = [];
172	60	}
173
174		/**
175		* Remove all items in this collection
176		*
177		* @return void
178		*/
179	28	public function clear()
180		{
181	28	foreach ($this->items as $item) {
182	13	$this->deleted[] = $item;
183	28	}
184
185	28	$this->items = [];
186	28	}
187
188		/**
189		* Get the number of items possible in this collection.
190		*
191		* @return int
192		*/
193	138	public function getMaxItems()
194		{
195	138	return $this->maxItems;
196		}
197
198		/**
199		* As we use a field collection even if we have only one value, we use it that way.
200		*
201		* @return array\|mixed\|null
202		*/
203	57	public function toArray()
204		{
205	57	if ($this->getMaxItems() != 1) {
206	45	return parent::toArray();
207		}
208
209	39	if (!array_key_exists(0, $this->items)) {
210	27	return null;
211		}
212
213	18	return $this->get(0)->toArray();
214		}
215
216		/**
217		* Convert the collection to its string representation.
218		*
219		* @return string
220		*/
221	3	public function __toString()
222		{
223	3	if ($this->getMaxItems() == 1) {
224	3	return $this->items[0]->value;
225		}
226
227	3	return 'Array';
228		}
229		}
230

RocketPropelledTortoise / Core

FieldCollection::__toString() A last analyzed 2020-04-19 15:33 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

FieldCollection::__toString() A
last analyzed 2020-04-19 15:33 UTC