AbstractResource::hasTransformer() - Code Metrics - rexlabsio/smokescreen-php - Measure and Improve Code Quality continuously with Scrutinizer

AbstractResource::hasTransformer() A
last analyzed 2023-12-19 05:56 UTC

↳ Parent: AbstractResource

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

<?php

namespace Rexlabs\Smokescreen\Resource;

use Rexlabs\Smokescreen\Exception\InvalidSerializerException;
use Rexlabs\Smokescreen\Exception\InvalidTransformerException;
use Rexlabs\Smokescreen\Serializer\SerializerInterface;
use Rexlabs\Smokescreen\Transformer\TransformerInterface;

abstract class AbstractResource implements ResourceInterface
{
    /**
     * The data to process with the transformer.
     *
     * @var array|\ArrayIterator|mixed
     */
    protected $data;

    /**
     * Array of meta data.
     *
     * @var array
     */
    protected $meta = [];

    /**
     * The resource key.
     *
     * @var string
     */
    protected $resourceKey;

    /**
     * A transformer or callable to process the data attached to this resource.
     *
     * @var callable|TransformerInterface|null
     */
    protected $transformer;

    /**
     * Provide a custom serializer for this resource.
     *
     * @var callable|SerializerInterface|false|null
     */
    protected $serializer;

    /**
     * Create a new resource instance.
     *
     * @param mixed                              $data
     * @param callable|TransformerInterface|null $transformer
     * @param string                             $resourceKey
     *
     * @throws \Rexlabs\Smokescreen\Exception\InvalidTransformerException
     */
    public function __construct($data = null, $transformer = null, $resourceKey = null)
    {
        $this->setData($data);
        $this->setTransformer($transformer);
        $this->setResourceKey($resourceKey);
    }

    /**
     * Get the data.
     *
     * @return mixed
     */
    public function getData()
    {
        return $this->data;
    }

    /**
     * Set the data.
     *
     * @param mixed $data
     *
     * @return $this
     */
    public function setData($data)
    {
        $this->data = $data;

        return $this;
    }

    /**
     * Get the meta data.
     *
     * @return array
     */
    public function getMeta()
    {
        return $this->meta;
    }

    /**
     * Set the meta data.
     *
     * @param array $meta
     *
     * @return $this
     */
    public function setMeta(array $meta)
    {
        $this->meta = $meta;

        return $this;
    }

    /**
     * Get the meta data.
     *
     * @param string $metaKey
     *
     * @return array
     */
    public function getMetaValue($metaKey)
    {
        return $this->meta[$metaKey];
    }

    /**
     * Get the resource key.
     *
     * @return string|null
     */
    public function getResourceKey()
    {
        return $this->resourceKey;
    }

    /**
     * Set the resource key.
     *
     * @param string|null $resourceKey
     *
     * @return $this
     */
    public function setResourceKey($resourceKey)
    {
        $this->resourceKey = $resourceKey;

        return $this;
    }

    /**
     * Set the meta data.
     *
     * @param string $metaKey
     * @param mixed  $metaValue
     *
     * @return $this
     */
    public function setMetaValue(string $metaKey, $metaValue)
    {
        $this->meta[$metaKey] = $metaValue;

        return $this;
    }

    /**
     * Get a list of relationships from the transformer
     * Only applicable when the transformer is an instance of the TransformerInterface (eg. AbstractTransformer).
     *
     * @return array
     */
    public function getRelationships(): array
    {
        $relationships = [];
        if ($this->hasTransformer()) {
            if (($transformer = $this->getTransformer()) instanceof TransformerInterface) {
                $relationships = $transformer->getRelationships();
            }
        }

        return $relationships;
    }

    /**
     * @return bool
     */
    public function hasTransformer(): bool
    {
        return $this->transformer !== null;
    }

    /**
     * Get the transformer.
     *
     * @return callable|TransformerInterface|null
     */
    public function getTransformer()
    {
        return $this->transformer;
    }

    /**
     * Set the transformer.
     *
     * @param callable|TransformerInterface|null $transformer
     *
     * @throws InvalidTransformerException
     *
     * @return $this
     */
    public function setTransformer($transformer)
    {
        if ($transformer !== null) {
            if (!$this->isValidTransformer($transformer)) {
                throw new InvalidTransformerException('Transformer must be a callable or implement TransformerInterface');
            }
        }

        $this->transformer = $transformer;

        return $this;
    }

    /**
     * Determines if the given argument is a valid transformer.
     *
     * @param mixed $transformer
     *
     * @return bool
     */
    public function isValidTransformer($transformer): bool
    {
        if ($transformer instanceof TransformerInterface) {
            return true;
        }

        if (\is_callable($transformer)) {
            return true;
        }

        return false;
    }

    /**
     * @return bool
     */
    public function hasSerializer(): bool
    {
        return $this->serializer !== null;
    }

    /**
     * @return SerializerInterface|callable|false|null
     */
    public function getSerializer()
    {
        return $this->serializer;
    }

    /**
     * Sets a custom serializer to be used for this resource
     * - Usually you will set this to an instance of SerializerInterface.
     * - Set to false to force no serialization on this resource.
     * - When set to null the default serializer will be used.
     * - Optionally set a closure/callback to be used for serialization.
     *
     * @param SerializerInterface|callable|false|null $serializer
     *
     * @throws InvalidSerializerException
     *
     * @return $this
     */
    public function setSerializer($serializer)
    {
        if ($serializer !== null) {
            if (!$this->isValidSerializer($serializer)) {
                throw new InvalidSerializerException('Serializer must be one of: callable, SerializerInterface, false or null');
            }
        }
        $this->serializer = $serializer;

        return $this;
    }

    /**
     * @param mixed $serializer
     *
     * @return bool
     */
    public function isValidSerializer($serializer): bool
    {
        if ($serializer === false) {
            // False is a valid value (forces serialization to be off)
            return true;
        }
        if ($serializer instanceof SerializerInterface) {
            return true;
        }
        if (\is_callable($serializer)) {
            return true;
        }

        return false;
    }
}


1		<?php
2
3		namespace Rexlabs\Smokescreen\Resource;
4
5		use Rexlabs\Smokescreen\Exception\InvalidSerializerException;
6		use Rexlabs\Smokescreen\Exception\InvalidTransformerException;
7		use Rexlabs\Smokescreen\Serializer\SerializerInterface;
8		use Rexlabs\Smokescreen\Transformer\TransformerInterface;
9
10		abstract class AbstractResource implements ResourceInterface
11		{
12		/**
13		* The data to process with the transformer.
14		*
15		* @var array\|\ArrayIterator\|mixed
16		*/
17		protected $data;
18
19		/**
20		* Array of meta data.
21		*
22		* @var array
23		*/
24		protected $meta = [];
25
26		/**
27		* The resource key.
28		*
29		* @var string
30		*/
31		protected $resourceKey;
32
33		/**
34		* A transformer or callable to process the data attached to this resource.
35		*
36		* @var callable\|TransformerInterface\|null
37		*/
38		protected $transformer;
39
40		/**
41		* Provide a custom serializer for this resource.
42		*
43		* @var callable\|SerializerInterface\|false\|null
44		*/
45		protected $serializer;
46
47		/**
48		* Create a new resource instance.
49		*
50		* @param mixed $data
51		* @param callable\|TransformerInterface\|null $transformer
52		* @param string $resourceKey
53		*
54		* @throws \Rexlabs\Smokescreen\Exception\InvalidTransformerException
55		*/
56	35	public function __construct($data = null, $transformer = null, $resourceKey = null)
57		{
58	35	$this->setData($data);
59	35	$this->setTransformer($transformer);
60	34	$this->setResourceKey($resourceKey);
61		}
62
63		/**
64		* Get the data.
65		*
66		* @return mixed
67		*/
68	16	public function getData()
69		{
70	16	return $this->data;
71		}
72
73		/**
74		* Set the data.
75		*
76		* @param mixed $data
77		*
78		* @return $this
79		*/
80	35	public function setData($data)
81		{
82	35	$this->data = $data;
83
84	35	return $this;
85		}
86
87		/**
88		* Get the meta data.
89		*
90		* @return array
91		*/
92	1	public function getMeta()
93		{
94	1	return $this->meta;
95		}
96
97		/**
98		* Set the meta data.
99		*
100		* @param array $meta
101		*
102		* @return $this
103		*/
104	1	public function setMeta(array $meta)
105		{
106	1	$this->meta = $meta;
107
108	1	return $this;
109		}
110
111		/**
112		* Get the meta data.
113		*
114		* @param string $metaKey
115		*
116		* @return array
117		*/
118	1	public function getMetaValue($metaKey)
119		{
120	1	return $this->meta[$metaKey];
121		}
122
123		/**
124		* Get the resource key.
125		*
126		* @return string\|null
127		*/
128	14	public function getResourceKey()
129		{
130	14	return $this->resourceKey;
131		}
132
133		/**
134		* Set the resource key.
135		*
136		* @param string\|null $resourceKey
137		*
138		* @return $this
139		*/
140	34	public function setResourceKey($resourceKey)
141		{
142	34	$this->resourceKey = $resourceKey;
143
144	34	return $this;
145		}
146
147		/**
148		* Set the meta data.
149		*
150		* @param string $metaKey
151		* @param mixed $metaValue
152		*
153		* @return $this
154		*/
155	1	public function setMetaValue(string $metaKey, $metaValue)
156		{
157	1	$this->meta[$metaKey] = $metaValue;
158
159	1	return $this;
160		}
161
162		/**
163		* Get a list of relationships from the transformer
164		* Only applicable when the transformer is an instance of the TransformerInterface (eg. AbstractTransformer).
165		*
166		* @return array
167		*/
168	1	public function getRelationships(): array
169		{
170	1	$relationships = [];
171	1	if ($this->hasTransformer()) {
172	1	if (($transformer = $this->getTransformer()) instanceof TransformerInterface) {
173	1	$relationships = $transformer->getRelationships();
174		}
175		}
176
177	1	return $relationships;
178		}
179
180		/**
181		* @return bool
182		*/
183	16	public function hasTransformer(): bool
184		{
185	16	return $this->transformer !== null;
186		}
187
188		/**
189		* Get the transformer.
190		*
191		* @return callable\|TransformerInterface\|null
192		*/
193	21	public function getTransformer()
194		{
195	21	return $this->transformer;
196		}
197
198		/**
199		* Set the transformer.
200		*
201		* @param callable\|TransformerInterface\|null $transformer
202		*
203		* @throws InvalidTransformerException
204		*
205		* @return $this
206		*/
207	35	public function setTransformer($transformer)
208		{
209	35	if ($transformer !== null) {
210	14	if (!$this->isValidTransformer($transformer)) {
211	1	throw new InvalidTransformerException('Transformer must be a callable or implement TransformerInterface');
212		}
213		}
214
215	34	$this->transformer = $transformer;
216
217	34	return $this;
218		}
219
220		/**
221		* Determines if the given argument is a valid transformer.
222		*
223		* @param mixed $transformer
224		*
225		* @return bool
226		*/
227	14	public function isValidTransformer($transformer): bool
228		{
229	14	if ($transformer instanceof TransformerInterface) {
230	11	return true;
231		}
232
233	5	if (\is_callable($transformer)) {
234	4	return true;
235		}
236
237	1	return false;
238		}
239
240		/**
241		* @return bool
242		*/
243	1	public function hasSerializer(): bool
244		{
245	1	return $this->serializer !== null;
246		}
247
248		/**
249		* @return SerializerInterface\|callable\|false\|null
250		*/
251	17	public function getSerializer()
252		{
253	17	return $this->serializer;
254		}
255
256		/**
257		* Sets a custom serializer to be used for this resource
258		* - Usually you will set this to an instance of SerializerInterface.
259		* - Set to false to force no serialization on this resource.
260		* - When set to null the default serializer will be used.
261		* - Optionally set a closure/callback to be used for serialization.
262		*
263		* @param SerializerInterface\|callable\|false\|null $serializer
264		*
265		* @throws InvalidSerializerException
266		*
267		* @return $this
268		*/
269	8	public function setSerializer($serializer)
270		{
271	8	if ($serializer !== null) {
272	7	if (!$this->isValidSerializer($serializer)) {
273	1	throw new InvalidSerializerException('Serializer must be one of: callable, SerializerInterface, false or null');
274		}
275		}
276	7	$this->serializer = $serializer;
277
278	7	return $this;
279		}
280
281		/**
282		* @param mixed $serializer
283		*
284		* @return bool
285		*/
286	7	public function isValidSerializer($serializer): bool
287		{
288	7	if ($serializer === false) {
289		// False is a valid value (forces serialization to be off)
290	1	return true;
291		}
292	6	if ($serializer instanceof SerializerInterface) {
293	2	return true;
294		}
295	4	if (\is_callable($serializer)) {
296	3	return true;
297		}
298
299	1	return false;
300		}
301		}
302

rexlabsio / smokescreen-php

AbstractResource::hasTransformer() A last analyzed 2023-12-19 05:56 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

AbstractResource::hasTransformer() A
last analyzed 2023-12-19 05:56 UTC