As3\Modlr\Persister\MongoDb\StorageMetadataFactory

Complexity

Total Complexity

23

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	createInstance()	0	17	4
A	handleLoad()	0	6	2
A	handleValidate()	0	7	1
A	rksort()	0	10	3
A	validateCollectionNaming()	0	13	2
A	validateDatabase()	0	7	4
A	validateIdStrategy()	0	8	2
A	validateSchemata()	0	10	4

<?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 <jacob.bare@gmail.com>
 */
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) {

Accessing collection on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            $metadata->persistence->collection = $metadata->type;

Accessing collection on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
    }

    /**
     * {@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)) {

Accessing collection on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            throw MetadataException::invalidMetadata(
                $metadata->type,
                sprintf('The entity persistence collection "%s" is invalid based on the configured name format "%s"',
                        $persistence->collection,

Accessing collection on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

                        $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))) {

Accessing db on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

Accessing collection on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            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)) {

Accessing idStrategy on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            throw MetadataException::invalidMetadata($metadata->type, sprintf('The persistence id strategy "%s" is invalid. Valid types are "%s"', $persistence->idStrategy, implode('", "', $validIdStrategies)));

Accessing idStrategy on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
    }

    /**
     * Validates the schema definitions
     *
     * @param   EntityMetadata  $metadata
     * @throws  MetadataException
     */
    private function validateSchemata(EntityMetadata $metadata)
    {
        $persistence = $metadata->persistence;
        foreach ($persistence->schemata as $k => $schema) {

Accessing schemata on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

            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)));

Accessing schemata on the interface As3\Modlr\Metadata\Interfaces\StorageLayerInterface suggest that you code against a concrete implementation. How about adding an instanceof check?

        }
    }
}