ClassMetadata::serialize() - Code Metrics - Inspection of "Fixing serialization" - dontdrinkandroot/rest-bundle.php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c49eb0...d6cf83 )

by Philip

created 2017-03-06 12:44 UTC

ClassMetadata::serialize() A

↳ Parent: ClassMetadata

Complexity

Conditions	1
Paths	1

Size

Total Lines	19
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	19
ccs	14
cts	14
cp	1
rs	9.4285
c	0
b	0
f	0
cc	1
eloc	14
nc	1
nop	0
crap	1

<?php

namespace Dontdrinkandroot\RestBundle\Metadata;

use Doctrine\Common\Inflector\Inflector;
use Dontdrinkandroot\RestBundle\Metadata\Annotation\Method;
use Metadata\MergeableClassMetadata;
use Metadata\MergeableInterface;

class ClassMetadata extends MergeableClassMetadata
{
    /**
     * @var bool
     */
    public $restResource;

    /**
     * @var string
     */
    public $namePrefix;

    /**
     * @var string
     */
    public $pathPrefix;

    /**
     * @var string
     */
    public $idField;

    /**
     * @var string
     */
    public $service;

    /**
     * @var string
     */
    public $controller;

    /**
     * @var Method[]|null
     */
    public $methods;

    public function __construct($name)
    {
        parent::__construct($name);

        $this->namePrefix = Inflector::tableize($this->reflection->getShortName());
        $this->pathPrefix = Inflector::pluralize(strtolower($this->reflection->getShortName()));
    }

    /**
     * {@inheritdoc}
     */
    public function merge(MergeableInterface $object)
    {
        assert($object instanceof ClassMetadata);

        $this->name = $object->name;
        $this->reflection = $object->reflection;
        $this->methodMetadata = array_merge($this->methodMetadata, $object->methodMetadata);
        $this->propertyMetadata = $this->mergePropertyMetadata($object);
        $this->fileResources = array_merge($this->fileResources, $object->fileResources);

        if ($object->createdAt < $this->createdAt) {
            $this->createdAt = $object->createdAt;
        }

        /** @var ClassMetadata $object */
        $this->restResource = $this->mergeField($this->restResource, $object->restResource);
        $this->idField = $this->mergeField($this->idField, $object->idField);
        $this->methods = $this->mergeField($this->methods, $object->methods);
        $this->namePrefix = $this->mergeField($this->namePrefix, $object->namePrefix);
        $this->pathPrefix = $this->mergeField($this->pathPrefix, $object->pathPrefix);
        $this->service = $this->mergeField($this->service, $object->service);
        $this->controller = $this->mergeField($this->controller, $object->controller);
    }

    /**
     * @param bool $restResource
     */
    public function setRestResource($restResource)
    {
        $this->restResource = $restResource;
    }

    /**
     * @return boolean
     */
    public function isRestResource()
    {
        return $this->restResource;
    }

    /**
     * @return string
     */
    public function getNamePrefix()
    {
        return $this->namePrefix;
    }

    /**
     * @param string $namePrefix
     */
    public function setNamePrefix($namePrefix)
    {
        $this->namePrefix = $namePrefix;
    }

    /**
     * @return string
     */
    public function getPathPrefix()
    {
        return $this->pathPrefix;
    }

    /**
     * @param string $pathPrefix
     */
    public function setPathPrefix(string $pathPrefix)
    {
        $this->pathPrefix = $pathPrefix;
    }

    /**
     * @return string
     */
    public function getController()
    {
        return $this->controller;
    }

    /**
     * @param string $controller
     */
    public function setController($controller)
    {
        $this->controller = $controller;
    }

    /**
     * @return string
     */
    public function getService()
    {
        return $this->service;
    }

    /**
     * @param string $service
     */
    public function setService($service)
    {
        $this->service = $service;
    }

    /**
     * @return Method[]|null
     */
    public function getMethods()
    {
        return $this->methods;
    }

    /**
     * @param Method[]|null $methods
     */
    public function setMethods($methods)
    {
        $this->methods = $methods;
    }

    public function getPropertyMetadata(string $property): ?PropertyMetadata
    {
        if (array_key_exists($property, $this->propertyMetadata)) {
            return $this->propertyMetadata[$property];
        }

        return null;
    }

    /**
     * @param MergeableInterface $object
     *
     * @return array
     */
    protected function mergePropertyMetadata(MergeableInterface $object): array
    {
        assert($object instanceof ClassMetadata);

        /** @var ClassMetadata $object */
        /** @var PropertyMetadata[] $mergedMetadata */
        $mergedMetadata = $this->propertyMetadata;

        foreach ($object->propertyMetadata as $otherMetadata) {
            /** @var PropertyMetadata $otherMetadata */
            if (array_key_exists($otherMetadata->name, $mergedMetadata)) {
                $mergedMetadata[$otherMetadata->name] = $mergedMetadata[$otherMetadata->name]->merge($otherMetadata);
            } else {
                $mergedMetadata[$otherMetadata->name] = $otherMetadata;
            }
        }

        return $mergedMetadata;
    }

    public function getMethod(string $methodName): ?Method
    {
        if (null === $this->methods) {
            return null;
        }

        foreach ($this->methods as $method) {
            if ($methodName === $method->name) {
                return $method;
            }
        }

        return null;
    }

    public function hasMethod($methodName)
    {
        return null !== $this->getMethod($methodName);
    }

    private function mergeField($existing, $toMerge)
    {
        if (null !== $toMerge) {
            return $toMerge;
        }

        return $existing;
    }

    public function getIdField(string $default = 'id'): string
    {
        if (null !== $this->idField) {
            return $this->idField;
        }

        return $default;
    }

    /**
     * {@inheritdoc}
     */
    public function serialize()
    {
        return serialize(
            [
                $this->name,
                $this->methodMetadata,
                $this->propertyMetadata,
                $this->fileResources,
                $this->createdAt,
                $this->restResource,
                $this->namePrefix,
                $this->pathPrefix,
                $this->idField,
                $this->service,
                $this->controller,
                $this->methods
            ]
        );
    }

    /**
     * {@inheritdoc}
     */
    public function unserialize($str)
    {
        list(
            $this->name,
            $this->methodMetadata,
            $this->propertyMetadata,
            $this->fileResources,
            $this->createdAt,
            $this->restResource,
            $this->namePrefix,
            $this->pathPrefix,
            $this->idField,
            $this->service,
            $this->controller,
            $this->methods
            ) = unserialize($str);

        $this->reflection = new \ReflectionClass($this->name);
    }
}


1		<?php
2
3		namespace Dontdrinkandroot\RestBundle\Metadata;
4
5		use Doctrine\Common\Inflector\Inflector;
6		use Dontdrinkandroot\RestBundle\Metadata\Annotation\Method;
7		use Metadata\MergeableClassMetadata;
8		use Metadata\MergeableInterface;
9
10		class ClassMetadata extends MergeableClassMetadata
11		{
12		/**
13		* @var bool
14		*/
15		public $restResource;
16
17		/**
18		* @var string
19		*/
20		public $namePrefix;
21
22		/**
23		* @var string
24		*/
25		public $pathPrefix;
26
27		/**
28		* @var string
29		*/
30		public $idField;
31
32		/**
33		* @var string
34		*/
35		public $service;
36
37		/**
38		* @var string
39		*/
40		public $controller;
41
42		/**
43		* @var Method[]\|null
44		*/
45		public $methods;
46
47	88	public function __construct($name)
48		{
49	88	parent::__construct($name);
50
51	88	$this->namePrefix = Inflector::tableize($this->reflection->getShortName());
52	88	$this->pathPrefix = Inflector::pluralize(strtolower($this->reflection->getShortName()));
53	88	}
54
55		/**
56		* {@inheritdoc}
57		*/
58	14	public function merge(MergeableInterface $object)
59		{
60	14	assert($object instanceof ClassMetadata);
61
62	14	$this->name = $object->name;
63	14	$this->reflection = $object->reflection;
64	14	$this->methodMetadata = array_merge($this->methodMetadata, $object->methodMetadata);
65	14	$this->propertyMetadata = $this->mergePropertyMetadata($object);
66	14	$this->fileResources = array_merge($this->fileResources, $object->fileResources);
67
68	14	if ($object->createdAt < $this->createdAt) {
69		$this->createdAt = $object->createdAt;
70		}
71
72		/** @var ClassMetadata $object */
73	14	$this->restResource = $this->mergeField($this->restResource, $object->restResource);
74	14	$this->idField = $this->mergeField($this->idField, $object->idField);
75	14	$this->methods = $this->mergeField($this->methods, $object->methods);
76	14	$this->namePrefix = $this->mergeField($this->namePrefix, $object->namePrefix);
77	14	$this->pathPrefix = $this->mergeField($this->pathPrefix, $object->pathPrefix);
78	14	$this->service = $this->mergeField($this->service, $object->service);
79	14	$this->controller = $this->mergeField($this->controller, $object->controller);
80	14	}
81
82		/**
83		* @param bool $restResource
84		*/
85	88	public function setRestResource($restResource)
86		{
87	88	$this->restResource = $restResource;
88	88	}
89
90		/**
91		* @return boolean
92		*/
93	64	public function isRestResource()
94		{
95	64	return $this->restResource;
96		}
97
98		/**
99		* @return string
100		*/
101	12	public function getNamePrefix()
102		{
103	12	return $this->namePrefix;
104		}
105
106		/**
107		* @param string $namePrefix
108		*/
109		public function setNamePrefix($namePrefix)
110		{
111		$this->namePrefix = $namePrefix;
112		}
113
114		/**
115		* @return string
116		*/
117	12	public function getPathPrefix()
118		{
119	12	return $this->pathPrefix;
120		}
121
122		/**
123		* @param string $pathPrefix
124		*/
125	42	public function setPathPrefix(string $pathPrefix)
126		{
127	42	$this->pathPrefix = $pathPrefix;
128	42	}
129
130		/**
131		* @return string
132		*/
133	12	public function getController()
134		{
135	12	return $this->controller;
136		}
137
138		/**
139		* @param string $controller
140		*/
141		public function setController($controller)
142		{
143		$this->controller = $controller;
144		}
145
146		/**
147		* @return string
148		*/
149	12	public function getService()
150		{
151	12	return $this->service;
152		}
153
154		/**
155		* @param string $service
156		*/
157		public function setService($service)
158		{
159		$this->service = $service;
160		}
161
162		/**
163		* @return Method[]\|null
164		*/
165	2	public function getMethods()
166		{
167	2	return $this->methods;
168		}
169
170		/**
171		* @param Method[]\|null $methods
172		*/
173	88	public function setMethods($methods)
174		{
175	88	$this->methods = $methods;
176	88	}
177
178	88	public function getPropertyMetadata(string $property): ?PropertyMetadata
179		{
180	88	if (array_key_exists($property, $this->propertyMetadata)) {
181	88	return $this->propertyMetadata[$property];
182		}
183
184	68	return null;
185		}
186
187		/**
188		* @param MergeableInterface $object
189		*
190		* @return array
191		*/
192	14	protected function mergePropertyMetadata(MergeableInterface $object): array
193		{
194	14	assert($object instanceof ClassMetadata);
195
196		/** @var ClassMetadata $object */
197		/** @var PropertyMetadata[] $mergedMetadata */
198	14	$mergedMetadata = $this->propertyMetadata;
199
200	14	foreach ($object->propertyMetadata as $otherMetadata) {
201		/** @var PropertyMetadata $otherMetadata */
202	14	if (array_key_exists($otherMetadata->name, $mergedMetadata)) {
203	12	$mergedMetadata[$otherMetadata->name] = $mergedMetadata[$otherMetadata->name]->merge($otherMetadata);
204		} else {
205	14	$mergedMetadata[$otherMetadata->name] = $otherMetadata;
206		}
207		}
208
209	14	return $mergedMetadata;
210		}
211
212	78	public function getMethod(string $methodName): ?Method
213		{
214	78	if (null === $this->methods) {
215		return null;
216		}
217
218	78	foreach ($this->methods as $method) {
219	78	if ($methodName === $method->name) {
220	78	return $method;
221		}
222		}
223
224	22	return null;
225		}
226
227	62	public function hasMethod($methodName)
228		{
229	62	return null !== $this->getMethod($methodName);
230		}
231
232	14	private function mergeField($existing, $toMerge)
233		{
234	14	if (null !== $toMerge) {
235	14	return $toMerge;
236		}
237
238	14	return $existing;
239		}
240
241	2	public function getIdField(string $default = 'id'): string
242		{
243	2	if (null !== $this->idField) {
244		return $this->idField;
245		}
246
247	2	return $default;
248		}
249
250		/**
251		* {@inheritdoc}
252		*/
253	4	public function serialize()
254		{
255	4	return serialize(
256		[
257	4	$this->name,
258	4	$this->methodMetadata,
259	4	$this->propertyMetadata,
260	4	$this->fileResources,
261	4	$this->createdAt,
262	4	$this->restResource,
263	4	$this->namePrefix,
264	4	$this->pathPrefix,
265	4	$this->idField,
266	4	$this->service,
267	4	$this->controller,
268	4	$this->methods
269		]
270		);
271		}
272
273		/**
274		* {@inheritdoc}
275		*/
276	4	public function unserialize($str)
277		{
278		list(
279	4	$this->name,
280	4	$this->methodMetadata,
281	4	$this->propertyMetadata,
282	4	$this->fileResources,
283	4	$this->createdAt,
284	4	$this->restResource,
285	4	$this->namePrefix,
286	4	$this->pathPrefix,
287	4	$this->idField,
288	4	$this->service,
289	4	$this->controller,
290	4	$this->methods
291	4	) = unserialize($str);
292
293	4	$this->reflection = new \ReflectionClass($this->name);
294	4	}
295		}
296

dontdrinkandroot / rest-bundle.php

Push — master ( c49eb0...d6cf83 )

ClassMetadata::serialize() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like