Schema::required() - Code Metrics - Inspection of "[wip] - add schemas" - sensorario/resources - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#76)

by Simone

created 2016-09-16 10:06 UTC

Schema::required() A

↳ Parent: Schema

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

/**
 * This file is part of sensorario/resources repository
 *
 * (c) Simone Gentili <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sensorario\Resources\Schema;

use RuntimeException;

final class Schema
{
    const PRIMITIVE_ARRAY   = 'array';
    const PRIMITIVE_BOOLEAN = 'boolean';
    const PRIMITIVE_DEFAULT = Schema::PRIMITIVE_NULL;
    const PRIMITIVE_INTEGER = 'integer';
    const PRIMITIVE_NULL    = 'null';
    const PRIMITIVE_NUMBER  = 'number';
    const PRIMITIVE_OBJECT  = 'object';
    const PRIMITIVE_STRING  = 'string';

    private $completeSchema;

    private $schemaNames = [];

    private $required = [];

    private $validTypes = [
        self::PRIMITIVE_ARRAY,
        self::PRIMITIVE_BOOLEAN,
        self::PRIMITIVE_DEFAULT,
        self::PRIMITIVE_INTEGER,
        self::PRIMITIVE_NULL,
        self::PRIMITIVE_NUMBER,
        self::PRIMITIVE_OBJECT,
        self::PRIMITIVE_STRING,
    ];

    private $subSchemaCounter = 0;

    private $properties = [];

    public function __construct(
        Parser $parser,
        $schema
    ) {
        $this->completeSchema = $schema;
        $this->schemaNames[] = 'root';
        $this->parser = $parser;
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->parseSchema($this->completeSchema);
    }

    private function parseSchema($schema)
    {
        $this->parser->setSchema($schema);
        $this->parser->setValidTypes($this->validTypes);
        $this->parser->parseSchema();

        foreach ($schema['properties'] as $name => $def) {
            $this->properties[$name] = $def;
            if (!isset($def['type'])) {
                throw new Exceptions\NoPropertyTypeException();
            }
        }

        if (isset($schema['required'])) {
            $this->required = array_merge(
                $this->required,
                $schema['required']
            );
        }

        foreach ($schema as $key => $value) {
            if (!in_array($key, ['required', 'properties', 'title', 'type'])) {
                $this->schemaNames[] = $key;
                $this->subSchemaCounter++;
                $this->parseSchema($value);
            }
        }
    }

    public function countSubSchemas()
    {
        return $this->subSchemaCounter;
    }

    public function completeSchema()
    {
        return $this->completeSchema;
    }

    public function schemaNames()
    {
        return $this->schemaNames;
    }

    public function getTitle()
    {
        return $this->completeSchema['title'];
    }

    /** @todo move this inside an applipcation service */
    public function validate($json) 
    {
        $jsonAsArray = json_decode($json, true);

        foreach ($jsonAsArray as $name => $property) {
            if (!isset($this->properties()[$name])) {
                throw new Exceptions\NotAllowedPropertyException();
            }
        }

        foreach ($this->required as $requiredProperty) {
            if (!isset($jsonAsArray[$requiredProperty])) {
                throw new Exceptions\MissingPropertyException();
            }
        }

        foreach ($jsonAsArray as $name => $property) {
            $prop = $this->properties()[$name];
            if (gettype($jsonAsArray[$name]) != $prop['type']) {
                if ($prop['type'] == Schema::PRIMITIVE_INTEGER && is_numeric($jsonAsArray[$name])) {
                    continue;
                }

                if ($prop['type'] == Schema::PRIMITIVE_ARRAY) {
                    if (!isset($prop['items'])) {
                        throw new Exceptions\UndefinedArrayItemsTypeException();
                    }
                }

                throw new Exceptions\NotAllowedValueException();
            }
        }

        return json_decode($json);
    }

    public function properties()
    {
        return $this->properties;
    }

    public function required()
    {
        return $this->required;
    }
}


1			<?php
2
3			/**
4			* This file is part of sensorario/resources repository
5			*
6			* (c) Simone Gentili <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Sensorario\Resources\Schema;
13
14			use RuntimeException;
15
16			final class Schema
17			{
18			const PRIMITIVE_ARRAY = 'array';
19			const PRIMITIVE_BOOLEAN = 'boolean';
20			const PRIMITIVE_DEFAULT = Schema::PRIMITIVE_NULL;
21			const PRIMITIVE_INTEGER = 'integer';
22			const PRIMITIVE_NULL = 'null';
23			const PRIMITIVE_NUMBER = 'number';
24			const PRIMITIVE_OBJECT = 'object';
25			const PRIMITIVE_STRING = 'string';
26
27			private $completeSchema;
28
29			private $schemaNames = [];
30
31			private $required = [];
32
33			private $validTypes = [
34			self::PRIMITIVE_ARRAY,
35			self::PRIMITIVE_BOOLEAN,
36			self::PRIMITIVE_DEFAULT,
37			self::PRIMITIVE_INTEGER,
38			self::PRIMITIVE_NULL,
39			self::PRIMITIVE_NUMBER,
40			self::PRIMITIVE_OBJECT,
41			self::PRIMITIVE_STRING,
42			];
43
44			private $subSchemaCounter = 0;
45
46			private $properties = [];
47
48			public function __construct(
49			Parser $parser,
50			$schema
51			) {
52			$this->completeSchema = $schema;
53			$this->schemaNames[] = 'root';
54			$this->parser = $parser;
			0 ignored issues – show Bug introduced 2016-09-09 12:35 UTC by Report Bug Copy Issue Report The property `parser` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
55			$this->parseSchema($this->completeSchema);
56			}
57
58			private function parseSchema($schema)
59			{
60			$this->parser->setSchema($schema);
61			$this->parser->setValidTypes($this->validTypes);
62			$this->parser->parseSchema();
63
64			foreach ($schema['properties'] as $name => $def) {
65			$this->properties[$name] = $def;
66			if (!isset($def['type'])) {
67			throw new Exceptions\NoPropertyTypeException();
68			}
69			}
70
71			if (isset($schema['required'])) {
72			$this->required = array_merge(
73			$this->required,
74			$schema['required']
75			);
76			}
77
78			foreach ($schema as $key => $value) {
79			if (!in_array($key, ['required', 'properties', 'title', 'type'])) {
80			$this->schemaNames[] = $key;
81			$this->subSchemaCounter++;
82			$this->parseSchema($value);
83			}
84			}
85			}
86
87			public function countSubSchemas()
88			{
89			return $this->subSchemaCounter;
90			}
91
92			public function completeSchema()
93			{
94			return $this->completeSchema;
95			}
96
97			public function schemaNames()
98			{
99			return $this->schemaNames;
100			}
101
102			public function getTitle()
103			{
104			return $this->completeSchema['title'];
105			}
106
107			/** @todo move this inside an applipcation service */
108			public function validate($json)
109			{
110			$jsonAsArray = json_decode($json, true);
111
112			foreach ($jsonAsArray as $name => $property) {
113			if (!isset($this->properties()[$name])) {
114			throw new Exceptions\NotAllowedPropertyException();
115			}
116			}
117
118			foreach ($this->required as $requiredProperty) {
119			if (!isset($jsonAsArray[$requiredProperty])) {
120			throw new Exceptions\MissingPropertyException();
121			}
122			}
123
124			foreach ($jsonAsArray as $name => $property) {
125			$prop = $this->properties()[$name];
126			if (gettype($jsonAsArray[$name]) != $prop['type']) {
127			if ($prop['type'] == Schema::PRIMITIVE_INTEGER && is_numeric($jsonAsArray[$name])) {
128			continue;
129			}
130
131			if ($prop['type'] == Schema::PRIMITIVE_ARRAY) {
132			if (!isset($prop['items'])) {
133			throw new Exceptions\UndefinedArrayItemsTypeException();
134			}
135			}
136
137			throw new Exceptions\NotAllowedValueException();
138			}
139			}
140
141			return json_decode($json);
142			}
143
144			public function properties()
145			{
146			return $this->properties;
147			}
148
149			public function required()
150			{
151			return $this->required;
152			}
153			}
154

sensorario / resources

Pull Request — master (#76)

Schema::required() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like