StorageMetadataFactory::validateSchemata() - Code Metrics - Inspection of "Merge pull request #16 from solocommand/schema-man..." - as3io/modlr-persister-mongodb - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 30ce3b...274fc3 )

by Jacob

created 2016-09-27 17:36 UTC

StorageMetadataFactory::validateSchemata() A

↳ Parent: StorageMetadataFactory

Complexity

Conditions	4
Paths	3

Size

Total Lines	10
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace As3\Modlr\Persister\MongoDb;

use As3\Modlr\Exception\MetadataException;
use As3\Modlr\Metadata\EntityMetadata;
use As3\Modlr\Metadata\Interfaces\StorageMetadataFactoryInterface;
use As3\Modlr\Util\EntityUtility;

/**
 * Creates MongoDb storage Metadata instances for use with metadata drivers.
 * Is also responsible for validating storage objects.
 *
 * @author Jacob Bare <[email protected]>
 */
final class StorageMetadataFactory implements StorageMetadataFactoryInterface
{
    /**
     * @var EntityUtility
     */
    private $entityUtil;

    /**
     * Constructor.
     *
     * @param   EntityUtility   $entityUtil
     */
    public function __construct(EntityUtility $entityUtil)
    {
        $this->entityUtil = $entityUtil;
    }

    /**
     * {@inheritDoc}
     */
    public function createInstance(array $mapping)
    {
        $persistence = new StorageMetadata();

        if (isset($mapping['db'])) {
            $persistence->db = $mapping['db'];
        }

        if (isset($mapping['collection'])) {
            $persistence->collection = $mapping['collection'];
        }

        if (isset($mapping['schemata'])) {
            $persistence->schemata = $this->rksort($mapping['schemata']);
        }
        return $persistence;
    }

    /**
     * {@inheritDoc}
     */
    public function handleLoad(EntityMetadata $metadata)
    {
        if (null === $metadata->persistence->collection) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            $metadata->persistence->collection = $metadata->type;
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }
    }

    /**
     * {@inheritDoc}
     */
    public function handleValidate(EntityMetadata $metadata)
    {
        $this->validateIdStrategy($metadata);
        $this->validateDatabase($metadata);
        $this->validateCollectionNaming($metadata);
        $this->validateSchemata($metadata);
    }

    /**
     * Recursively ksorts an array
     * @param   array
     * @return  array
     */
    private function rksort(array $array)
    {
        ksort($array);
        foreach ($array as $k => $v) {
            if (is_array($v)) {
                $array[$k] = $this->rksort($v);
            }
        }
        return $array;
    }

    /**
     * Validates that the collection naming is correct, based on entity format config.
     *
     * @param   EntityMetadata  $metadata
     * @throws  MetadataException
     */
    private function validateCollectionNaming(EntityMetadata $metadata)
    {
        $persistence = $metadata->persistence;
        if (false === $this->entityUtil->isEntityTypeValid($persistence->collection)) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            throw MetadataException::invalidMetadata(
                $metadata->type,
                sprintf('The entity persistence collection "%s" is invalid based on the configured name format "%s"',
                        $persistence->collection,
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
                        $this->entityUtil->getRestConfig()->getEntityFormat()
                )
            );
        }
    }

    /**
     * Validates that the proper database properties are set.
     *
     * @param   EntityMetadata  $metadata
     * @throws  MetadataException
     */
    private function validateDatabase(EntityMetadata $metadata)
    {
        $persistence = $metadata->persistence;
        if (false === $metadata->isChildEntity() && (empty($persistence->db) || empty($persistence->collection))) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            throw MetadataException::invalidMetadata($metadata->type, 'The persistence database and collection names cannot be empty.');
        }
    }

    /**
     * Validates the proper id strategy.
     *
     * @param   EntityMetadata  $metadata
     * @throws  MetadataException
     */
    private function validateIdStrategy(EntityMetadata $metadata)
    {
        $persistence = $metadata->persistence;
        $validIdStrategies = ['object'];
        if (!in_array($persistence->idStrategy, $validIdStrategies)) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            throw MetadataException::invalidMetadata($metadata->type, sprintf('The persistence id strategy "%s" is invalid. Valid types are "%s"', $persistence->idStrategy, implode('", "', $validIdStrategies)));
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }
    }

    /**
     * Validates the schema definitions
     *
     * @param   EntityMetadata  $metadata
     * @throws  MetadataException
     */
    private function validateSchemata(EntityMetadata $metadata)
    {
        $persistence = $metadata->persistence;
        foreach ($persistence->schemata as $k => $schema) {
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
            if (!isset($schema['keys']) || empty($schema['keys'])) {
                throw MetadataException::invalidMetadata($metadata->type, 'At least one key must be specified to define an index.');
            }
            $persistence->schemata[$k]['options']['name'] = sprintf('modlr_%s', md5(json_encode($schema)));
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        }
    }
}


1			<?php
2
3			namespace As3\Modlr\Persister\MongoDb;
4
5			use As3\Modlr\Exception\MetadataException;
6			use As3\Modlr\Metadata\EntityMetadata;
7			use As3\Modlr\Metadata\Interfaces\StorageMetadataFactoryInterface;
8			use As3\Modlr\Util\EntityUtility;
9
10			/**
11			* Creates MongoDb storage Metadata instances for use with metadata drivers.
12			* Is also responsible for validating storage objects.
13			*
14			* @author Jacob Bare <[email protected]>
15			*/
16			final class StorageMetadataFactory implements StorageMetadataFactoryInterface
17			{
18			/**
19			* @var EntityUtility
20			*/
21			private $entityUtil;
22
23			/**
24			* Constructor.
25			*
26			* @param EntityUtility $entityUtil
27			*/
28			public function __construct(EntityUtility $entityUtil)
29			{
30			$this->entityUtil = $entityUtil;
31			}
32
33			/**
34			* {@inheritDoc}
35			*/
36			public function createInstance(array $mapping)
37			{
38			$persistence = new StorageMetadata();
39
40			if (isset($mapping['db'])) {
41			$persistence->db = $mapping['db'];
42			}
43
44			if (isset($mapping['collection'])) {
45			$persistence->collection = $mapping['collection'];
46			}
47
48			if (isset($mapping['schemata'])) {
49			$persistence->schemata = $this->rksort($mapping['schemata']);
50			}
51			return $persistence;
52			}
53
54			/**
55			* {@inheritDoc}
56			*/
57			public function handleLoad(EntityMetadata $metadata)
58			{
59			if (null === $metadata->persistence->collection) {
			0 ignored issues – show Bug introduced 2016-03-14 15:48 UTC by Report Bug Copy Issue Report Accessing `collection` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
60			$metadata->persistence->collection = $metadata->type;
			0 ignored issues – show Bug introduced 2016-03-14 15:48 UTC by Report Bug Copy Issue Report Accessing `collection` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
61			}
62			}
63
64			/**
65			* {@inheritDoc}
66			*/
67			public function handleValidate(EntityMetadata $metadata)
68			{
69			$this->validateIdStrategy($metadata);
70			$this->validateDatabase($metadata);
71			$this->validateCollectionNaming($metadata);
72			$this->validateSchemata($metadata);
73			}
74
75			/**
76			* Recursively ksorts an array
77			* @param array
78			* @return array
79			*/
80			private function rksort(array $array)
81			{
82			ksort($array);
83			foreach ($array as $k => $v) {
84			if (is_array($v)) {
85			$array[$k] = $this->rksort($v);
86			}
87			}
88			return $array;
89			}
90
91			/**
92			* Validates that the collection naming is correct, based on entity format config.
93			*
94			* @param EntityMetadata $metadata
95			* @throws MetadataException
96			*/
97			private function validateCollectionNaming(EntityMetadata $metadata)
98			{
99			$persistence = $metadata->persistence;
100			if (false === $this->entityUtil->isEntityTypeValid($persistence->collection)) {
			0 ignored issues – show Bug introduced 2016-03-14 15:48 UTC by Report Bug Copy Issue Report Accessing `collection` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
101			throw MetadataException::invalidMetadata(
102			$metadata->type,
103			sprintf('The entity persistence collection "%s" is invalid based on the configured name format "%s"',
104			$persistence->collection,
			0 ignored issues – show Bug introduced 2016-03-14 15:48 UTC by Report Bug Copy Issue Report Accessing `collection` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
105			$this->entityUtil->getRestConfig()->getEntityFormat()
106			)
107			);
108			}
109			}
110
111			/**
112			* Validates that the proper database properties are set.
113			*
114			* @param EntityMetadata $metadata
115			* @throws MetadataException
116			*/
117			private function validateDatabase(EntityMetadata $metadata)
118			{
119			$persistence = $metadata->persistence;
120			if (false === $metadata->isChildEntity() && (empty($persistence->db) \|\| empty($persistence->collection))) {
			0 ignored issues – show Bug introduced 2016-03-14 15:48 UTC by Report Bug Copy Issue Report Accessing `db` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history... Bug introduced 2016-03-14 15:48 UTC by Report Bug Copy Issue Report Accessing `collection` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
121			throw MetadataException::invalidMetadata($metadata->type, 'The persistence database and collection names cannot be empty.');
122			}
123			}
124
125			/**
126			* Validates the proper id strategy.
127			*
128			* @param EntityMetadata $metadata
129			* @throws MetadataException
130			*/
131			private function validateIdStrategy(EntityMetadata $metadata)
132			{
133			$persistence = $metadata->persistence;
134			$validIdStrategies = ['object'];
135			if (!in_array($persistence->idStrategy, $validIdStrategies)) {
			0 ignored issues – show Bug introduced 2016-03-14 15:48 UTC by Report Bug Copy Issue Report Accessing `idStrategy` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
136			throw MetadataException::invalidMetadata($metadata->type, sprintf('The persistence id strategy "%s" is invalid. Valid types are "%s"', $persistence->idStrategy, implode('", "', $validIdStrategies)));
			0 ignored issues – show Bug introduced 2016-03-14 15:48 UTC by Report Bug Copy Issue Report Accessing `idStrategy` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
137			}
138			}
139
140			/**
141			* Validates the schema definitions
142			*
143			* @param EntityMetadata $metadata
144			* @throws MetadataException
145			*/
146			private function validateSchemata(EntityMetadata $metadata)
147			{
148			$persistence = $metadata->persistence;
149			foreach ($persistence->schemata as $k => $schema) {
			0 ignored issues – show Bug introduced 2016-09-27 16:48 UTC by Report Bug Copy Issue Report Accessing `schemata` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
150			if (!isset($schema['keys']) \|\| empty($schema['keys'])) {
151			throw MetadataException::invalidMetadata($metadata->type, 'At least one key must be specified to define an index.');
152			}
153			$persistence->schemata[$k]['options']['name'] = sprintf('modlr_%s', md5(json_encode($schema)));
			0 ignored issues – show Bug introduced 2016-09-27 16:48 UTC by Report Bug Copy Issue Report Accessing `schemata` on the interface `As3\Modlr\Metadata\Inter...s\StorageLayerInterface` suggest that you code against a concrete implementation. How about adding an `instanceof` check? If you access a property on an interface, you most likely code against a concrete implementation of the interface. Available Fixes Adding an additional type check: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeInterface $object) { if ($object instanceof SomeClass) { $a = $object->a; } } Changing the type hint: interface SomeInterface { } class SomeClass implements SomeInterface { public $a; } function someFunction(SomeClass $object) { $a = $object->a; } Loading history...
154			}
155			}
156			}
157

as3io / modlr-persister-mongodb

Push — master ( 30ce3b...274fc3 )

StorageMetadataFactory::validateSchemata() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like