ClassStructureTrait::setExtendedPropertySerialization() - Code Metrics - Inspection of "Add additional properties exporting" - swaggest/php-json-schema - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#99)

by Viacheslav

created 2020-01-24 13:48 UTC

setExtendedPropertySerialization() A

↳ Parent: ClassStructureTrait

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

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

<?php

namespace Swaggest\JsonSchema\Structure;

use Swaggest\JsonSchema\Constraint\Properties;
use Swaggest\JsonSchema\Context;
use Swaggest\JsonSchema\Schema;
use Swaggest\JsonSchema\Wrapper;
use Swaggest\JsonSchema\NameMirror;

trait ClassStructureTrait
{
    use ObjectItemTrait;

    /**
     * Serialize additional and pattern properties
     * @var boolean
     */
    protected $extendedPropertySerialization = false;

    /**
     * @return Wrapper
     */
    public static function schema()
    {
        static $schemas = array();
        $className = get_called_class();
        $schemaWrapper = &$schemas[$className];

        if (null === $schemaWrapper) {
            $schema = new Schema();
            $properties = new Properties();
            $schema->properties = $properties;
            $schema->objectItemClass = $className;
            $schemaWrapper = new Wrapper($schema);
            static::setUpProperties($properties, $schema);
            if (null === $schema->getFromRefs()) {
                $schema->setFromRef('#/definitions/' . $className);
            }
            if ($properties->isEmpty()) {
                $schema->properties = null;
            }
            $properties->lock();
        }

        return $schemaWrapper;
    }

    /**
     * @return Properties|static|null
     */
    public static function properties()
    {
        return static::schema()->getProperties();
    }

    /**
     * @param mixed $data
     * @param Context $options
     * @return static|mixed
     * @throws \Swaggest\JsonSchema\Exception
     * @throws \Swaggest\JsonSchema\InvalidValue
     */
    public static function import($data, Context $options = null)
    {
        return static::schema()->in($data, $options);
    }

    /**
     * @param mixed $data
     * @param Context $options
     * @return mixed
     * @throws \Swaggest\JsonSchema\InvalidValue
     * @throws \Exception
     */
    public static function export($data, Context $options = null)
    {
        return static::schema()->out($data, $options);
    }

    /**
     * @param ObjectItemContract $objectItem
     * @return static
     */
    public static function pick(ObjectItemContract $objectItem)
    {
        $className = get_called_class();
        return $objectItem->getNestedObject($className);
    }

    /**
     * @return static
     */
    public static function create()
    {
        return new static;
    }

    protected $__validateOnSet = true; // todo skip validation during import

    /**
     * @return \stdClass
     */
    public function jsonSerialize()
    {
        $result = new \stdClass();
        $schema = static::schema();
        $properties = $schema->getProperties();
        if (null !== $properties) {
            foreach ($properties->getDataKeyMap() as $propertyName => $dataName) {
                $value = $this->$propertyName;
                // Value is exported if exists.
                if (null !== $value || array_key_exists($propertyName, $this->__arrayOfData)) {
                    $result->$dataName = $value;
                    continue;
                }

                // Non-existent value is only exported if belongs to nullable property (having 'null' in type array).
                $property = $schema->getProperty($propertyName);
                if ($property instanceof Schema) {
                    $types = $property->type;
                    if ($types === Schema::NULL || (is_array($types) && in_array(Schema::NULL, $types))) {
                        $result->$dataName = $value;
                    }
                }
            }
        }
        foreach ($schema->getNestedPropertyNames() as $name) {
            /** @var ObjectItem $nested */
            $nested = $this->$name;
            if (null !== $nested) {
                foreach ((array)$nested->jsonSerialize() as $key => $value) {
                    $result->$key = $value;
                }
            }
        }

        if ($this->extendedPropertySerialization) {
            foreach ($this->getAdditionalPropertyNames() as $name) {
                $result->$name = $this->{$name};
            }

            foreach ($this->getAllPatternPropertyNames() as $name) {
                $result->$name = $this->{$name};
            }
        }

        return $result;
    }

    /**
     * @return static|NameMirror
     */
    public static function names()
    {
        static $nameflector = null;
        if (null === $nameflector) {
            $nameflector = new NameMirror();
        }
        return $nameflector;
    }

    public function __set($name, $column) // todo nested schemas
    {
        if ($this->__validateOnSet) {
            if ($property = static::schema()->getProperty($name)) {
                $property->out($column);
            }
        }
        $this->__arrayOfData[$name] = $column;
        return $this;
    }

    public static function className()
    {
        return get_called_class();
    }

    /**
     * @throws \Exception
     * @throws \Swaggest\JsonSchema\InvalidValue
     */
    public function validate()
    {
        static::schema()->out($this);
    }

    /**
     * Setter for $extendedPropertySerialization
     * @param boolean $extend
     * @return self
     */
    public function setExtendedPropertySerialization($extend = true)
    {
        $this->extendedPropertySerialization = $extend;
        return $this;
    }
}


1		<?php
2
3		namespace Swaggest\JsonSchema\Structure;
4
5		use Swaggest\JsonSchema\Constraint\Properties;
6		use Swaggest\JsonSchema\Context;
7		use Swaggest\JsonSchema\Schema;
8		use Swaggest\JsonSchema\Wrapper;
9		use Swaggest\JsonSchema\NameMirror;
10
11		trait ClassStructureTrait
12		{
13		use ObjectItemTrait;
14
15		/**
16		* Serialize additional and pattern properties
17		* @var boolean
18	3252	*/
19		protected $extendedPropertySerialization = false;
20	3252
21	3252	/**
22	3252	* @return Wrapper
23		*/
24	3252	public static function schema()
25	10	{
26	10	static $schemas = array();
27	10	$className = get_called_class();
28	10	$schemaWrapper = &$schemas[$className];
29	10
30	10	if (null === $schemaWrapper) {
31	10	$schema = new Schema();
32	8	$properties = new Properties();
33		$schema->properties = $properties;
34	10	$schema->objectItemClass = $className;
35	1	$schemaWrapper = new Wrapper($schema);
36		static::setUpProperties($properties, $schema);
37	10	if (null === $schema->getFromRefs()) {
38		$schema->setFromRef('#/definitions/' . $className);
39		}
40	3252	if ($properties->isEmpty()) {
41		$schema->properties = null;
42		}
43		$properties->lock();
44		}
45
46	2	return $schemaWrapper;
47		}
48	2
49		/**
50		* @return Properties\|static\|null
51		*/
52		public static function properties()
53		{
54		return static::schema()->getProperties();
55		}
56
57		/**
58	3235	* @param mixed $data
59		* @param Context $options
60	3235	* @return static\|mixed
61		* @throws \Swaggest\JsonSchema\Exception
62		* @throws \Swaggest\JsonSchema\InvalidValue
63		*/
64		public static function import($data, Context $options = null)
65		{
66		return static::schema()->in($data, $options);
67		}
68
69		/**
70	18	* @param mixed $data
71		* @param Context $options
72	18	* @return mixed
73		* @throws \Swaggest\JsonSchema\InvalidValue
74		* @throws \Exception
75		*/
76		public static function export($data, Context $options = null)
77		{
78		return static::schema()->out($data, $options);
79	2	}
80
81	2	/**
82	2	* @param ObjectItemContract $objectItem
83		* @return static
84		*/
85		public static function pick(ObjectItemContract $objectItem)
86		{
87		$className = get_called_class();
88	6	return $objectItem->getNestedObject($className);
89		}
90	6
91		/**
92		* @return static
93		*/
94		public static function create()
95	97	{
96		return new static;
97	97	}
98	97
99	97	protected $__validateOnSet = true; // todo skip validation during import
100	97
101	97	/**
102	57	* @return \stdClass
103		*/
104		public function jsonSerialize()
105	97	{
106		$result = new \stdClass();
107	4	$schema = static::schema();
108	4	$properties = $schema->getProperties();
109	2	if (null !== $properties) {
110	2	foreach ($properties->getDataKeyMap() as $propertyName => $dataName) {
111		$value = $this->$propertyName;
112		// Value is exported if exists.
113		if (null !== $value \|\| array_key_exists($propertyName, $this->__arrayOfData)) {
114		$result->$dataName = $value;
115	97	continue;
116		}
117
118		// Non-existent value is only exported if belongs to nullable property (having 'null' in type array).
119		$property = $schema->getProperty($propertyName);
120		if ($property instanceof Schema) {
121	4	$types = $property->type;
122		if ($types === Schema::NULL \|\| (is_array($types) && in_array(Schema::NULL, $types))) {
123	4	$result->$dataName = $value;
124	4	}
125	4	}
126		}
127	4	}
128		foreach ($schema->getNestedPropertyNames() as $name) {
129		/** @var ObjectItem $nested */
130	249	$nested = $this->$name;
131		if (null !== $nested) {
132	249	foreach ((array)$nested->jsonSerialize() as $key => $value) {
133	5	$result->$key = $value;
134	4	}
135		}
136		}
137	248
138	248	if ($this->extendedPropertySerialization) {
139		foreach ($this->getAdditionalPropertyNames() as $name) {
140		$result->$name = $this->{$name};
141		}
142
143		foreach ($this->getAllPatternPropertyNames() as $name) {
144		$result->$name = $this->{$name};
145		}
146		}
147
148		return $result;
149		}
150	1
151		/**
152	1	* @return static\|NameMirror
153	1	*/
154		public static function names()
155		{
156		static $nameflector = null;
157		if (null === $nameflector) {
158		$nameflector = new NameMirror();
159		}
160		return $nameflector;
161		}
162
163		public function __set($name, $column) // todo nested schemas
164		{
165		if ($this->__validateOnSet) {
166		if ($property = static::schema()->getProperty($name)) {
167		$property->out($column);
168		}
169		}
170		$this->__arrayOfData[$name] = $column;
171		return $this;
172		}
173
174		public static function className()
175		{
176		return get_called_class();
177		}
178
179		/**
180		* @throws \Exception
181		* @throws \Swaggest\JsonSchema\InvalidValue
182		*/
183		public function validate()
184		{
185		static::schema()->out($this);
186		}
187
188		/**
189		* Setter for $extendedPropertySerialization
190		* @param boolean $extend
191		* @return self
192		*/
193		public function setExtendedPropertySerialization($extend = true)
194		{
195		$this->extendedPropertySerialization = $extend;
196		return $this;
197		}
198		}
199

swaggest / php-json-schema

Pull Request — master (#99)

setExtendedPropertySerialization() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like