JsonSchemas::getSchemaByResourceType() - Code Metrics - Inspection of "Refactor reading model attributes and relationship..." - limoncello-php-dist/flute - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( dcfc04...697864 )

by Neomerx

created 2019-02-05 17:28 UTC

JsonSchemas::getSchemaByResourceType() A

↳ 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	8
ccs	4
cts	4
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	1
crap	1

<?php namespace Limoncello\Flute\Schema;

/**
 * Copyright 2015-2018 [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;

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

limoncello-php-dist / flute

Push — master ( dcfc04...697864 )

JsonSchemas::getSchemaByResourceType() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like