DataTransferObject::only() - Code Metrics - Inspection of "[DTO] Add arrayOf static helper" - spatie/data-transfer-object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#83)

by Brent

created 2020-01-08 10:45 UTC

DataTransferObject::only() A

↳ Parent: DataTransferObject

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	8
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php

declare(strict_types=1);

namespace Spatie\DataTransferObject;

use ReflectionClass;
use ReflectionProperty;

abstract class DataTransferObject
{
    /** @var bool */
    protected $ignoreMissing = false;

    /** @var array */
    protected $exceptKeys = [];

    /** @var array */
    protected $onlyKeys = [];

    /**
     * @param array $parameters
     *
     * @return \Spatie\DataTransferObject\ImmutableDataTransferObject|static
     */
    public static function immutable(array $parameters = []): ImmutableDataTransferObject
    {
        return new ImmutableDataTransferObject(new static($parameters));
    }

    /**
     * @param array $arrayOfParameters
     *
     * @return \Spatie\DataTransferObject\ImmutableDataTransferObject[]|static[]
     */
    public static function arrayOf(array $arrayOfParameters): array
    {
        return array_map(
            function ($parameters) {
                return new static($parameters);
            },
            $arrayOfParameters
        );
    }

    public function __construct(array $parameters = [])
    {
        $validators = $this->getFieldValidators();

        $valueCaster = new ValueCaster();

        foreach ($validators as $field => $validator) {
            if (
                ! isset($parameters[$field])
                && ! $validator->hasDefaultValue
                && ! $validator->isNullable
            ) {
                throw DataTransferObjectError::uninitialized(
                    static::class,
                    $field
                );
            }

            $value = $parameters[$field] ?? $this->{$field} ?? null;

            if (is_array($value)) {
                $value = $valueCaster->cast($value, $validator);
            }

            if (! $validator->isValidType($value)) {
                throw DataTransferObjectError::invalidType(
                    static::class,
                    $field,
                    $validator->allowedTypes,
                    $value
                );
            }

            $this->{$field} = $value;

            unset($parameters[$field]);
        }

        if (! $this->ignoreMissing && count($parameters)) {
            throw DataTransferObjectError::unknownProperties(array_keys($parameters), static::class);
        }
    }

    public function all(): array

    {
        $data = [];

        $class = new ReflectionClass(static::class);

        $properties = $class->getProperties(ReflectionProperty::IS_PUBLIC);

        foreach ($properties as $reflectionProperty) {
            $data[$reflectionProperty->getName()] = $reflectionProperty->getValue($this);
        }

        return $data;
    }

    /**
     * @param string ...$keys
     *
     * @return static
     */
    public function only(string ...$keys): DataTransferObject
    {
        $valueObject = clone $this;

        $valueObject->onlyKeys = array_merge($this->onlyKeys, $keys);

        return $valueObject;
    }

    /**
     * @param string ...$keys
     *
     * @return static
     */
    public function except(string ...$keys): DataTransferObject
    {
        $valueObject = clone $this;

        $valueObject->exceptKeys = array_merge($this->exceptKeys, $keys);

        return $valueObject;
    }

    public function toArray(): array
    {
        if (count($this->onlyKeys)) {
            $array = Arr::only($this->all(), $this->onlyKeys);
        } else {
            $array = Arr::except($this->all(), $this->exceptKeys);
        }

        $array = $this->parseArray($array);

        return $array;
    }

    protected function parseArray(array $array): array
    {
        foreach ($array as $key => $value) {
            if (
                $value instanceof DataTransferObject
                || $value instanceof DataTransferObjectCollection
            ) {
                $array[$key] = $value->toArray();

                continue;
            }

            if (! is_array($value)) {
                continue;
            }

            $array[$key] = $this->parseArray($value);
        }

        return $array;
    }

    /**
     * @param \ReflectionClass $class
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     *
     * @return \Spatie\DataTransferObject\FieldValidator[]
     */
    private function getFieldValidators(): array
    {
        return DTOCache::resolve(static::class, function () {

            $class = new ReflectionClass(static::class);

            $properties = [];

            foreach ($class->getProperties(ReflectionProperty::IS_PUBLIC) as $reflectionProperty) {
                // Skip static properties
                if ($reflectionProperty->isStatic()) {
                    continue;
                }

                $field = $reflectionProperty->getName();

                $properties[$field] = FieldValidator::fromReflection($reflectionProperty);
            }

            return $properties;
        });
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Spatie\DataTransferObject;
6
7		use ReflectionClass;
8		use ReflectionProperty;
9
10		abstract class DataTransferObject
11		{
12		/** @var bool */
13		protected $ignoreMissing = false;
14
15		/** @var array */
16		protected $exceptKeys = [];
17
18		/** @var array */
19		protected $onlyKeys = [];
20
21		/**
22		* @param array $parameters
23		*
24		* @return \Spatie\DataTransferObject\ImmutableDataTransferObject\|static
25		*/
26		public static function immutable(array $parameters = []): ImmutableDataTransferObject
27		{
28		return new ImmutableDataTransferObject(new static($parameters));
29		}
30
31		/**
32		* @param array $arrayOfParameters
33		*
34		* @return \Spatie\DataTransferObject\ImmutableDataTransferObject[]\|static[]
35		*/
36		public static function arrayOf(array $arrayOfParameters): array
37		{
38		return array_map(
39		function ($parameters) {
40		return new static($parameters);
41		},
42		$arrayOfParameters
43		);
44		}
45
46		public function __construct(array $parameters = [])
47		{
48		$validators = $this->getFieldValidators();
49
50		$valueCaster = new ValueCaster();
51
52		foreach ($validators as $field => $validator) {
53		if (
54		! isset($parameters[$field])
55		&& ! $validator->hasDefaultValue
56		&& ! $validator->isNullable
57		) {
58		throw DataTransferObjectError::uninitialized(
59		static::class,
60		$field
61		);
62		}
63
64		$value = $parameters[$field] ?? $this->{$field} ?? null;
65
66		if (is_array($value)) {
67		$value = $valueCaster->cast($value, $validator);
68		}
69
70		if (! $validator->isValidType($value)) {
71		throw DataTransferObjectError::invalidType(
72		static::class,
73		$field,
74		$validator->allowedTypes,
75		$value
76		);
77		}
78
79		$this->{$field} = $value;
80
81		unset($parameters[$field]);
82		}
83
84		if (! $this->ignoreMissing && count($parameters)) {
85		throw DataTransferObjectError::unknownProperties(array_keys($parameters), static::class);
86		}
87		}
88
89	View Code Duplication	public function all(): array
		0 ignored issues – show Duplication introduced 2019-12-18 08:03 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
90		{
91		$data = [];
92
93		$class = new ReflectionClass(static::class);
94
95		$properties = $class->getProperties(ReflectionProperty::IS_PUBLIC);
96
97		foreach ($properties as $reflectionProperty) {
98		$data[$reflectionProperty->getName()] = $reflectionProperty->getValue($this);
99		}
100
101		return $data;
102		}
103
104		/**
105		* @param string ...$keys
106		*
107		* @return static
108		*/
109		public function only(string ...$keys): DataTransferObject
110		{
111		$valueObject = clone $this;
112
113		$valueObject->onlyKeys = array_merge($this->onlyKeys, $keys);
114
115		return $valueObject;
116		}
117
118		/**
119		* @param string ...$keys
120		*
121		* @return static
122		*/
123		public function except(string ...$keys): DataTransferObject
124		{
125		$valueObject = clone $this;
126
127		$valueObject->exceptKeys = array_merge($this->exceptKeys, $keys);
128
129		return $valueObject;
130		}
131
132		public function toArray(): array
133		{
134		if (count($this->onlyKeys)) {
135		$array = Arr::only($this->all(), $this->onlyKeys);
136		} else {
137		$array = Arr::except($this->all(), $this->exceptKeys);
138		}
139
140		$array = $this->parseArray($array);
141
142		return $array;
143		}
144
145		protected function parseArray(array $array): array
146		{
147		foreach ($array as $key => $value) {
148		if (
149		$value instanceof DataTransferObject
150		\|\| $value instanceof DataTransferObjectCollection
151		) {
152		$array[$key] = $value->toArray();
153
154		continue;
155		}
156
157		if (! is_array($value)) {
158		continue;
159		}
160
161		$array[$key] = $this->parseArray($value);
162		}
163
164		return $array;
165		}
166
167		/**
168		* @param \ReflectionClass $class
		0 ignored issues – show Bug introduced 2019-03-26 17:09 UTC by Report Bug Copy Issue Report There is no parameter named `$class`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
169		*
170		* @return \Spatie\DataTransferObject\FieldValidator[]
171		*/
172		private function getFieldValidators(): array
173		{
174	View Code Duplication	return DTOCache::resolve(static::class, function () {
		0 ignored issues – show Duplication introduced 2019-12-18 08:03 UTC by Report Bug Copy Issue Report This code seems to be duplicated across your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
175		$class = new ReflectionClass(static::class);
176
177		$properties = [];
178
179		foreach ($class->getProperties(ReflectionProperty::IS_PUBLIC) as $reflectionProperty) {
180		// Skip static properties
181		if ($reflectionProperty->isStatic()) {
182		continue;
183		}
184
185		$field = $reflectionProperty->getName();
186
187		$properties[$field] = FieldValidator::fromReflection($reflectionProperty);
188		}
189
190		return $properties;
191		});
192		}
193		}
194

spatie / data-transfer-object

GitHub Access Token became invalid

Pull Request — master (#83)

DataTransferObject::only() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like