JsonSchemas::__construct() - Code Metrics - limoncello-php-dist/flute - Measure and Improve Code Quality continuously with Scrutinizer

JsonSchemas::__construct() A
last analyzed 2019-06-17 07:44 UTC

↳ Parent: JsonSchemas

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	11
ccs	4
cts	4
cp	1
rs	9.9
c	0
b	0
f	0
cc	1
nc	1
nop	4
crap	1

<?php declare (strict_types = 1);

namespace Limoncello\Flute\Schema;

/**
 * Copyright 2015-2019 [email protected]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use Limoncello\Common\Reflection\ClassIsTrait;
use Limoncello\Contracts\Data\ModelSchemaInfoInterface;
use Limoncello\Flute\Contracts\Schema\JsonSchemasInterface;
use Limoncello\Flute\Contracts\Schema\SchemaInterface;
use Neomerx\JsonApi\Contracts\Factories\FactoryInterface;
use Neomerx\JsonApi\Contracts\Schema\SchemaInterface as JsonSchemaInterface;
use function array_key_exists;
use function assert;
use function get_class;
use function is_object;

/**
 * @package Limoncello\Flute
 */
class JsonSchemas implements JsonSchemasInterface
{
    use ClassIsTrait;

    /**
     * @var FactoryInterface
     */
    private $factory;

    /**
     * @var array
     */
    private $modelToSchemaMap;

    /**
     * @var array
     */
    private $typeToSchemaMap;

    /**
     * @var array
     */
    private $schemaInstances = [];

    /**
     * @var ModelSchemaInfoInterface
     */
    private $modelSchemas;

    /**
     * @param FactoryInterface         $factory
     * @param array                    $modelToSchemaMap
     * @param array                    $typeToSchemaMap
     * @param ModelSchemaInfoInterface $modelSchemas
     */
    public function __construct(
        FactoryInterface $factory,
        array $modelToSchemaMap,
        array $typeToSchemaMap,
        ModelSchemaInfoInterface $modelSchemas
    ) {
        $this->factory          = $factory;
        $this->modelToSchemaMap = $modelToSchemaMap;
        $this->typeToSchemaMap  = $typeToSchemaMap;
        $this->modelSchemas     = $modelSchemas;
    }

    /**
     * @inheritdoc
     */
    public function getSchema($resourceObject): JsonSchemaInterface
    {
        assert($this->hasSchema($resourceObject));

        return $this->getSchemaByModelClass($this->getResourceClass($resourceObject));
    }

    /**
     * @inheritdoc
     */
    public function hasSchema($resourceObject): bool
    {
        return is_object($resourceObject) === true &&
            array_key_exists($this->getResourceClass($resourceObject), $this->modelToSchemaMap);
    }

    /**
     * @inheritdoc
     */
    public function hasRelationshipSchema(string $schemaClass, string $relationshipName): bool
    {
        assert(static::classImplements($schemaClass, SchemaInterface::class));

        /** @var SchemaInterface $schemaClass */

        $hasRel = $schemaClass::getMappings()[SchemaInterface::SCHEMA_RELATIONSHIPS][$relationshipName] ?? false;

        assert($hasRel === false || $this->getRelationshipSchema($schemaClass, $relationshipName) !== null);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        return $hasRel !== false;
    }

    /**
     * @inheritdoc
     */
    public function getRelationshipSchema(string $schemaClass, string $relationshipName): SchemaInterface
    {
        assert(static::classImplements($schemaClass, SchemaInterface::class));

        /** @var SchemaInterface $schemaClass */

        $modelRelName = $schemaClass::getMappings()[SchemaInterface::SCHEMA_RELATIONSHIPS][$relationshipName];
        $targetSchema = $this->getModelRelationshipSchema($schemaClass::MODEL, $modelRelName);

        return $targetSchema;
    }

    /**
     * @inheritdoc
     */
    public function getModelRelationshipSchema(string $modelClass, string $relationshipName): SchemaInterface
    {
        $reverseModelClass = $this->getModelSchemas()->getReverseModelClass($modelClass, $relationshipName);

        /** @var SchemaInterface $targetSchema */
        $targetSchema = $this->getSchemaByModelClass($reverseModelClass);

        return $targetSchema;
    }

    /**
     * @inheritdoc
     */
    public function getSchemaByResourceType(string $resourceType): SchemaInterface
    {
        assert(array_key_exists($resourceType, $this->typeToSchemaMap));

        $schemaClass = $this->typeToSchemaMap[$resourceType];

        return $this->getSchemaByClass($schemaClass);
    }

    /**
     * @return FactoryInterface
     */
    private function getFactory(): FactoryInterface
    {
        return $this->factory;
    }

    /**
     * @return ModelSchemaInfoInterface
     */
    private function getModelSchemas(): ModelSchemaInfoInterface
    {
        return $this->modelSchemas;
    }

    /**
     * @param mixed $resource
     *
     * @return string
     */
    private function getResourceClass($resource): string
    {
        assert(
            is_object($resource) === true,
            'Unable to get a type of the resource as it is not an object.'
        );

        return get_class($resource);
    }

    /**
     * @inheritdoc
     */
    private function getSchemaByModelClass(string $modelClass): JsonSchemaInterface
    {
        assert(array_key_exists($modelClass, $this->modelToSchemaMap));

        $schemaClass = $this->modelToSchemaMap[$modelClass];

        return $this->getSchemaByClass($schemaClass);
    }

    /**
     * @param string $schemaClass
     *
     * @return SchemaInterface
     */
    private function getSchemaByClass(string $schemaClass): JsonSchemaInterface
    {
        assert(static::classImplements($schemaClass, JsonSchemaInterface::class));

        if (array_key_exists($schemaClass, $this->schemaInstances) === false) {
            $this->schemaInstances[$schemaClass] =
                ($schema = new $schemaClass($this->getFactory(), $this, $this->getModelSchemas()));

            return $schema;
        }

        return $this->schemaInstances[$schemaClass];
    }
}


1		<?php declare (strict_types = 1);
2
3		namespace Limoncello\Flute\Schema;
4
5		/**
6		* Copyright 2015-2019 [email protected]
7		*
8		* Licensed under the Apache License, Version 2.0 (the "License");
9		* you may not use this file except in compliance with the License.
10		* You may obtain a copy of the License at
11		*
12		* http://www.apache.org/licenses/LICENSE-2.0
13		*
14		* Unless required by applicable law or agreed to in writing, software
15		* distributed under the License is distributed on an "AS IS" BASIS,
16		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17		* See the License for the specific language governing permissions and
18		* limitations under the License.
19		*/
20
21		use Limoncello\Common\Reflection\ClassIsTrait;
22		use Limoncello\Contracts\Data\ModelSchemaInfoInterface;
23		use Limoncello\Flute\Contracts\Schema\JsonSchemasInterface;
24		use Limoncello\Flute\Contracts\Schema\SchemaInterface;
25		use Neomerx\JsonApi\Contracts\Factories\FactoryInterface;
26		use Neomerx\JsonApi\Contracts\Schema\SchemaInterface as JsonSchemaInterface;
27		use function array_key_exists;
28		use function assert;
29		use function get_class;
30		use function is_object;
31
32		/**
33		* @package Limoncello\Flute
34		*/
35		class JsonSchemas implements JsonSchemasInterface
36		{
37		use ClassIsTrait;
38
39		/**
40		* @var FactoryInterface
41		*/
42		private $factory;
43
44		/**
45		* @var array
46		*/
47		private $modelToSchemaMap;
48
49		/**
50		* @var array
51		*/
52		private $typeToSchemaMap;
53
54		/**
55		* @var array
56		*/
57		private $schemaInstances = [];
58
59		/**
60		* @var ModelSchemaInfoInterface
61		*/
62		private $modelSchemas;
63
64		/**
65		* @param FactoryInterface $factory
66	58	* @param array $modelToSchemaMap
67		* @param array $typeToSchemaMap
68		* @param ModelSchemaInfoInterface $modelSchemas
69		*/
70		public function __construct(
71		FactoryInterface $factory,
72	58	array $modelToSchemaMap,
73	58	array $typeToSchemaMap,
74	58	ModelSchemaInfoInterface $modelSchemas
75	58	) {
76		$this->factory = $factory;
77		$this->modelToSchemaMap = $modelToSchemaMap;
78		$this->typeToSchemaMap = $typeToSchemaMap;
79		$this->modelSchemas = $modelSchemas;
80		}
81	17
82		/**
83	17	* @inheritdoc
84		*/
85	17	public function getSchema($resourceObject): JsonSchemaInterface
86		{
87		assert($this->hasSchema($resourceObject));
88
89		return $this->getSchemaByModelClass($this->getResourceClass($resourceObject));
90		}
91	17
92		/**
93	17	* @inheritdoc
94	17	*/
95		public function hasSchema($resourceObject): bool
96		{
97		return is_object($resourceObject) === true &&
98		array_key_exists($this->getResourceClass($resourceObject), $this->modelToSchemaMap);
99		}
100	5
101		/**
102	5	* @inheritdoc
103		*/
104		public function hasRelationshipSchema(string $schemaClass, string $relationshipName): bool
105		{
106	5	assert(static::classImplements($schemaClass, SchemaInterface::class));
107
108	5	/** @var SchemaInterface $schemaClass */
109
110	5	$hasRel = $schemaClass::getMappings()[SchemaInterface::SCHEMA_RELATIONSHIPS][$relationshipName] ?? false;
111
112		assert($hasRel === false \|\| $this->getRelationshipSchema($schemaClass, $relationshipName) !== null);
		0 ignored issues – show Documentation introduced 2017-10-25 13:55 UTC by Report Bug Copy Issue Report `$schemaClass` is of type `object<Limoncello\Flute\...Schema\SchemaInterface>`, but the function expects a `string`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
113
114		return $hasRel !== false;
115		}
116	20
117		/**
118	20	* @inheritdoc
119		*/
120		public function getRelationshipSchema(string $schemaClass, string $relationshipName): SchemaInterface
121		{
122	20	assert(static::classImplements($schemaClass, SchemaInterface::class));
123	20
124		/** @var SchemaInterface $schemaClass */
125	20
126		$modelRelName = $schemaClass::getMappings()[SchemaInterface::SCHEMA_RELATIONSHIPS][$relationshipName];
127		$targetSchema = $this->getModelRelationshipSchema($schemaClass::MODEL, $modelRelName);
128
129		return $targetSchema;
130		}
131	20
132		/**
133	20	* @inheritdoc
134		*/
135		public function getModelRelationshipSchema(string $modelClass, string $relationshipName): SchemaInterface
136	20	{
137		$reverseModelClass = $this->getModelSchemas()->getReverseModelClass($modelClass, $relationshipName);
138	20
139		/** @var SchemaInterface $targetSchema */
140		$targetSchema = $this->getSchemaByModelClass($reverseModelClass);
141
142		return $targetSchema;
143		}
144	25
145		/**
146	25	* @inheritdoc
147		*/
148	25	public function getSchemaByResourceType(string $resourceType): SchemaInterface
149		{
150	25	assert(array_key_exists($resourceType, $this->typeToSchemaMap));
151
152		$schemaClass = $this->typeToSchemaMap[$resourceType];
153
154		return $this->getSchemaByClass($schemaClass);
155		}
156	28
157		/**
158	28	* @return FactoryInterface
159		*/
160		private function getFactory(): FactoryInterface
161		{
162		return $this->factory;
163		}
164	28
165		/**
166	28	* @return ModelSchemaInfoInterface
167		*/
168		private function getModelSchemas(): ModelSchemaInfoInterface
169		{
170		return $this->modelSchemas;
171		}
172
173		/**
174	17	* @param mixed $resource
175		*
176	17	* @return string
177	17	*/
178	17	private function getResourceClass($resource): string
179		{
180		assert(
181	17	is_object($resource) === true,
182		'Unable to get a type of the resource as it is not an object.'
183		);
184
185		return get_class($resource);
186		}
187	22
188		/**
189	22	* @inheritdoc
190		*/
191	22	private function getSchemaByModelClass(string $modelClass): JsonSchemaInterface
192		{
193	22	assert(array_key_exists($modelClass, $this->modelToSchemaMap));
194
195		$schemaClass = $this->modelToSchemaMap[$modelClass];
196
197		return $this->getSchemaByClass($schemaClass);
198		}
199
200		/**
201	28	* @param string $schemaClass
202		*
203	28	* @return SchemaInterface
204		*/
205	28	private function getSchemaByClass(string $schemaClass): JsonSchemaInterface
206	28	{
207	28	assert(static::classImplements($schemaClass, JsonSchemaInterface::class));
208
209	28	if (array_key_exists($schemaClass, $this->schemaInstances) === false) {
210		$this->schemaInstances[$schemaClass] =
211		($schema = new $schemaClass($this->getFactory(), $this, $this->getModelSchemas()));
212	20
213		return $schema;
214		}
215
216		return $this->schemaInstances[$schemaClass];
217		}
218		}
219

limoncello-php-dist / flute

JsonSchemas::__construct() A last analyzed 2019-06-17 07:44 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

JsonSchemas::__construct() A
last analyzed 2019-06-17 07:44 UTC