JsonDefinitionHash::getJsonDefinition() - Code Metrics - Inspection of "fix test expectations in regard to validation outp..." - libgraviton/graviton - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — feature/other-validation ( c4ebdf...a3189f )

by Narcotic

created 2016-06-27 14:30 UTC

JsonDefinitionHash::getJsonDefinition() C

↳ Parent: JsonDefinitionHash

Complexity

Conditions	7
Paths	9

Size

Total Lines	23
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	19
CRAP Score	7

Importance

Changes

Metric	Value
dl	0
loc	23
ccs	19
cts	19
cp	1
rs	6.7272
c	0
b	0
f	0
cc	7
eloc	15
nc	9
nop	0
crap	7

<?php
namespace Graviton\GeneratorBundle\Definition;
use Graviton\GeneratorBundle\Definition\Schema\Field;

/**
 * Represents a hash of fields as defined in the JSON format
 *
 * @author   List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
 * @license  http://opensource.org/licenses/gpl-license.php GNU Public License
 * @link     http://swisscom.ch
 */
class JsonDefinitionHash implements DefinitionElementInterface
{
    /**
     * @var string Name of this hash
     */
    private $name;
    /**
     * @var JsonDefinition
     */
    private $parent;
    /**
     * @var DefinitionElementInterface[] Array of fields..
     */
    private $fields = [];
    /**
     * @var Schema\Field Field definition
     */
    private $definition;

    /**
     * Constructor
     *
     * @param string                       $name       Name of this hash
     * @param JsonDefinition               $parent     Parent definiton
     * @param DefinitionElementInterface[] $fields     Fields of the hash
     * @param Schema\Field                 $definition Field definition

     */
    public function __construct($name, JsonDefinition $parent, array $fields, Schema\Field $definition = null)
    {
        $this->name = $name;
        $this->parent = $parent;
        $this->fields = $fields;
        $this->definition = $definition;
    }

    /**
     * Returns the hash name
     *
     * @return string Name
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Returns the definition as array..
     *
     * @return array the definition
     */
    public function getDefAsArray()
    {
        return array_replace(
            [
                'name'              => $this->getName(),
                'type'              => $this->getType(),
                'exposedName'       => $this->getName(),
                'doctrineType'      => $this->getTypeDoctrine(),
                'serializerType'    => $this->getTypeSerializer(),
                'relType'           => self::REL_TYPE_EMBED,
                'isClassType'       => true,
                'constraints'       => [],
                'required'          => false,
                'searchable'        => false,
            ],
            $this->definition === null ? [
                'required'          => $this->getRequired()
            ] : [
                'exposedName'       => $this->definition->getExposeAs() ?: $this->getName(),
                'title'             => $this->definition->getTitle(),
                'description'       => $this->definition->getDescription(),
                'readOnly'          => $this->definition->getReadOnly(),
                'required'          => $this->definition->getRequired(),
                'searchable'        => $this->definition->getSearchable(),
                'constraints'       => array_map(
                    [Utils\ConstraintNormalizer::class, 'normalize'],
                    $this->definition->getConstraints()
                ),
            ]
        );
    }

    /**
     * {@inheritDoc}
     *
     * @return string type
     */
    public function getType()
    {
        return self::TYPE_HASH;
    }

    /**
     * Whether this hash is anonymous, so has no own field definition (properly only defined
     * by definitions such as "object.field", not an own definition)
     *
     * @return bool true if yes, false otherwise
     */
    public function isAnonymous()
    {
        return ($this->definition === null);
    }

    /**
     * in an 'anonymous' hash situation, we will check if any children are required
     *
     * @return bool if required or not
     */
    public function getRequired()

    {
        $isRequired = false;

        // see if on the first level of fields we have a required=true in the definition
        foreach ($this->fields as $field) {
            if ($field instanceof JsonDefinitionField &&
                $field->getDef() instanceof Field &&
                $field->getDef()->getRequired() === true
            ) {
                $isRequired = true;
            }
        }

        return $isRequired;
    }

    /**
     * {@inheritDoc}
     *
     * @return string type
     */
    public function getTypeDoctrine()
    {
        return $this->getClassName(true);
    }

    /**
     * Returns the field type in a serializer-understandable way..
     *
     * @return string Type
     */
    public function getTypeSerializer()
    {
        return $this->getClassName(true);
    }

    /**
     * Returns the field definition of this hash from "local perspective",
     * meaning that we only include fields inside this hash BUT with all
     * the stuff from the json file. this is needed to generate a Document/Model
     * from this hash (generate a json file again)
     *
     * @return JsonDefinition the definition of this hash in a standalone array ready to be json_encoded()
     */
    public function getJsonDefinition()
    {
        $definition = (new Schema\Definition())
            ->setId($this->getClassName())
            ->setDescription($this->definition === null ? null : $this->definition->getDescription())
            ->setTitle($this->definition === null ? null : $this->definition->getTitle())
            ->setIsSubDocument(true)
            ->setTarget(new Schema\Target());

        foreach ($this->fields as $field) {
            foreach ($this->processFieldDefinitionsRecursive($field) as $definitions) {
                $definition->getTarget()->addField($definitions);
            }
        }
        foreach ($this->parent->getRelations() as $relation) {
            $relation = $this->processParentRelation($relation);
            if ($relation !== null) {
                $definition->getTarget()->addRelation($relation);
            }
        }

        return new JsonDefinition($definition);
    }

    /**
     * Method getFieldDefinitionsRecursive
     *
     * @param DefinitionElementInterface $field
     * @return Schema\Field[]
     */
    private function processFieldDefinitionsRecursive(DefinitionElementInterface $field)
    {
        if ($field instanceof JsonDefinitionField) {
            return [$this->cloneFieldDefinition($field->getDef())];
        } elseif ($field instanceof JsonDefinitionArray) {
            return $this->processFieldDefinitionsRecursive($field->getElement());
        } elseif ($field instanceof JsonDefinitionHash) {
            return array_reduce(
                $field->fields,
                function (array $subfields, DefinitionElementInterface $subfield) {
                    return array_merge($subfields, $this->processFieldDefinitionsRecursive($subfield));
                },
                $field->definition === null ? [] : [$this->cloneFieldDefinition($field->definition)]
            );
        }

        throw new \InvalidArgumentException(sprintf('Unknown field type "%s"', get_class($field)));
    }

    /**
     * Clone field definition
     *
     * @param Schema\Field $field Field
     * @return Schema\Field
     */
    private function cloneFieldDefinition(Schema\Field $field)
    {
        $clone = clone $field;
        $clone->setName(preg_replace('/^'.preg_quote($this->name, '/').'\.(\d+\.)*/', '', $clone->getName()));
        return $clone;
    }

    /**
     * Process parent relation
     *
     * @param Schema\Relation $relation Parent relation
     * @return Schema\Relation|null
     */
    private function processParentRelation(Schema\Relation $relation)
    {
        $prefixRegex = '/^'.preg_quote($this->name, '/').'\.(\d+\.)*(?P<sub>.*)/';
        if (!preg_match($prefixRegex, $relation->getLocalProperty(), $matches)) {
            return null;
        }

        $clone = clone $relation;
        $clone->setLocalProperty($matches['sub']);
        return $clone;
    }

    /**
     * Returns the class name of this hash, possibly
     * taking the parent element into the name. this
     * string here results in the name of the generated Document.
     *
     * @param boolean $fq if true, we'll return the class name full qualified
     *
     * @return string
     */
    private function getClassName($fq = false)
    {
        $className = ucfirst($this->parent->getId()).ucfirst($this->getName());
        if ($fq) {
            $className = $this->parent->getNamespace().'\\Document\\'.$className;
        }

        return $className;
    }
}


1		<?php
2		namespace Graviton\GeneratorBundle\Definition;
3		use Graviton\GeneratorBundle\Definition\Schema\Field;
4
5		/**
6		* Represents a hash of fields as defined in the JSON format
7		*
8		* @author List of contributors <https://github.com/libgraviton/graviton/graphs/contributors>
9		* @license http://opensource.org/licenses/gpl-license.php GNU Public License
10		* @link http://swisscom.ch
11		*/
12		class JsonDefinitionHash implements DefinitionElementInterface
13		{
14		/**
15		* @var string Name of this hash
16		*/
17		private $name;
18		/**
19		* @var JsonDefinition
20		*/
21		private $parent;
22		/**
23		* @var DefinitionElementInterface[] Array of fields..
24		*/
25		private $fields = [];
26		/**
27		* @var Schema\Field Field definition
28		*/
29		private $definition;
30
31		/**
32		* Constructor
33		*
34		* @param string $name Name of this hash
35		* @param JsonDefinition $parent Parent definiton
36		* @param DefinitionElementInterface[] $fields Fields of the hash
37		* @param Schema\Field $definition Field definition
		0 ignored issues – show Documentation introduced 2016-06-27 12:25 UTC by Report Bug Copy Issue Report Should the type for parameter `$definition` not be `null\|Field`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
38		*/
39	42	public function __construct($name, JsonDefinition $parent, array $fields, Schema\Field $definition = null)
40		{
41	42	$this->name = $name;
42	42	$this->parent = $parent;
43	42	$this->fields = $fields;
44	42	$this->definition = $definition;
45	42	}
46
47		/**
48		* Returns the hash name
49		*
50		* @return string Name
51		*/
52	22	public function getName()
53		{
54	22	return $this->name;
55		}
56
57		/**
58		* Returns the definition as array..
59		*
60		* @return array the definition
61		*/
62	6	public function getDefAsArray()
63		{
64	6	return array_replace(
65		[
66	6	'name' => $this->getName(),
67	6	'type' => $this->getType(),
68	6	'exposedName' => $this->getName(),
69	6	'doctrineType' => $this->getTypeDoctrine(),
70	6	'serializerType' => $this->getTypeSerializer(),
71	6	'relType' => self::REL_TYPE_EMBED,
72	3	'isClassType' => true,
73	3	'constraints' => [],
74	3	'required' => false,
75	3	'searchable' => false,
76	3	],
77	6	$this->definition === null ? [
78	4	'required' => $this->getRequired()
79	2	] : [
80	2	'exposedName' => $this->definition->getExposeAs() ?: $this->getName(),
81	2	'title' => $this->definition->getTitle(),
82	2	'description' => $this->definition->getDescription(),
83	2	'readOnly' => $this->definition->getReadOnly(),
84	2	'required' => $this->definition->getRequired(),
85	2	'searchable' => $this->definition->getSearchable(),
86	2	'constraints' => array_map(
87	2	[Utils\ConstraintNormalizer::class, 'normalize'],
88	4	$this->definition->getConstraints()
89	1	),
90		]
91	3	);
92		}
93
94		/**
95		* {@inheritDoc}
96		*
97		* @return string type
98		*/
99	8	public function getType()
100		{
101	8	return self::TYPE_HASH;
102		}
103
104		/**
105		* Whether this hash is anonymous, so has no own field definition (properly only defined
106		* by definitions such as "object.field", not an own definition)
107		*
108		* @return bool true if yes, false otherwise
109		*/
110	4	public function isAnonymous()
111		{
112	4	return ($this->definition === null);
113		}
114
115		/**
116		* in an 'anonymous' hash situation, we will check if any children are required
117		*
118		* @return bool if required or not
119		*/
120	4	public function getRequired()
		0 ignored issues – show Coding Style introduced 2016-06-27 12:25 UTC by Report Bug Copy Issue Report `function getRequired()` does not seem to conform to the naming convention (`^(?:is\|has\|should\|may\|supports)`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
121		{
122	4	$isRequired = false;
123
124		// see if on the first level of fields we have a required=true in the definition
125	4	foreach ($this->fields as $field) {
126	2	if ($field instanceof JsonDefinitionField &&
127	2	$field->getDef() instanceof Field &&
128	2	$field->getDef()->getRequired() === true
129	1	) {
130	2	$isRequired = true;
131	1	}
132	2	}
133
134	4	return $isRequired;
135		}
136
137		/**
138		* {@inheritDoc}
139		*
140		* @return string type
141		*/
142	8	public function getTypeDoctrine()
143		{
144	8	return $this->getClassName(true);
145		}
146
147		/**
148		* Returns the field type in a serializer-understandable way..
149		*
150		* @return string Type
151		*/
152	8	public function getTypeSerializer()
153		{
154	8	return $this->getClassName(true);
155		}
156
157		/**
158		* Returns the field definition of this hash from "local perspective",
159		* meaning that we only include fields inside this hash BUT with all
160		* the stuff from the json file. this is needed to generate a Document/Model
161		* from this hash (generate a json file again)
162		*
163		* @return JsonDefinition the definition of this hash in a standalone array ready to be json_encoded()
164		*/
165	10	public function getJsonDefinition()
166		{
167	10	$definition = (new Schema\Definition())
168	10	->setId($this->getClassName())
169	10	->setDescription($this->definition === null ? null : $this->definition->getDescription())
170	10	->setTitle($this->definition === null ? null : $this->definition->getTitle())
171	10	->setIsSubDocument(true)
172	10	->setTarget(new Schema\Target());
173
174	10	foreach ($this->fields as $field) {
175	10	foreach ($this->processFieldDefinitionsRecursive($field) as $definitions) {
176	10	$definition->getTarget()->addField($definitions);
177	5	}
178	5	}
179	10	foreach ($this->parent->getRelations() as $relation) {
180	4	$relation = $this->processParentRelation($relation);
181	4	if ($relation !== null) {
182	4	$definition->getTarget()->addRelation($relation);
183	2	}
184	5	}
185
186	10	return new JsonDefinition($definition);
187		}
188
189		/**
190		* Method getFieldDefinitionsRecursive
191		*
192		* @param DefinitionElementInterface $field
193		* @return Schema\Field[]
194		*/
195	10	private function processFieldDefinitionsRecursive(DefinitionElementInterface $field)
196		{
197	10	if ($field instanceof JsonDefinitionField) {
198	10	return [$this->cloneFieldDefinition($field->getDef())];
199	4	} elseif ($field instanceof JsonDefinitionArray) {
200	8	return $this->processFieldDefinitionsRecursive($field->getElement());
201	2	} elseif ($field instanceof JsonDefinitionHash) {
202	4	return array_reduce(
203	4	$field->fields,
204	4	function (array $subfields, DefinitionElementInterface $subfield) {
205	4	return array_merge($subfields, $this->processFieldDefinitionsRecursive($subfield));
206	4	},
207	4	$field->definition === null ? [] : [$this->cloneFieldDefinition($field->definition)]
208	2	);
209		}
210
211		throw new \InvalidArgumentException(sprintf('Unknown field type "%s"', get_class($field)));
212		}
213
214		/**
215		* Clone field definition
216		*
217		* @param Schema\Field $field Field
218		* @return Schema\Field
219		*/
220	10	private function cloneFieldDefinition(Schema\Field $field)
221		{
222	10	$clone = clone $field;
223	10	$clone->setName(preg_replace('/^'.preg_quote($this->name, '/').'\.(\d+\.)*/', '', $clone->getName()));
224	10	return $clone;
225		}
226
227		/**
228		* Process parent relation
229		*
230		* @param Schema\Relation $relation Parent relation
231		* @return Schema\Relation\|null
232		*/
233	4	private function processParentRelation(Schema\Relation $relation)
234		{
235	4	$prefixRegex = '/^'.preg_quote($this->name, '/').'\.(\d+\.)(?P<sub>.)/';
236	4	if (!preg_match($prefixRegex, $relation->getLocalProperty(), $matches)) {
237	2	return null;
238		}
239
240	4	$clone = clone $relation;
241	4	$clone->setLocalProperty($matches['sub']);
242	4	return $clone;
243		}
244
245		/**
246		* Returns the class name of this hash, possibly
247		* taking the parent element into the name. this
248		* string here results in the name of the generated Document.
249		*
250		* @param boolean $fq if true, we'll return the class name full qualified
251		*
252		* @return string
253		*/
254	20	private function getClassName($fq = false)
255		{
256	20	$className = ucfirst($this->parent->getId()).ucfirst($this->getName());
257	20	if ($fq) {
258	10	$className = $this->parent->getNamespace().'\\Document\\'.$className;
259	5	}
260
261	20	return $className;
262		}
263		}
264

libgraviton / graviton

Push — feature/other-validation ( c4ebdf...a3189f )

JsonDefinitionHash::getJsonDefinition() C

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like