As3\Modlr\Metadata\EntityMetadata

Complexity

Total Complexity

28

Size/Duplication

Total Lines	307
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
B	addMixin()	0	20	6
A	hasMixin()	0	4	1
A	getParentEntityType()	0	4	1
A	isAbstract()	0	4	1
A	isPolymorphic()	0	4	1
A	isSearchEnabled()	0	4	1
A	isChildEntity()	0	4	1
A	merge()	0	18	1
A	setAbstract()	0	5	1
A	setPersistence()	0	5	1
A	setPolymorphic()	0	5	1
A	setSearch()	0	5	1
A	setType()	0	8	3
A	mergeAttributes()	0	7	2
A	mergeMixins()	0	9	3
A	mergeRelationships()	0	7	2

<?php

namespace As3\Modlr\Metadata;

use As3\Modlr\Exception\MetadataException;
use As3\Modlr\Metadata\Interfaces\AttributeInterface;
use As3\Modlr\Metadata\Interfaces\MergeableInterface;
use As3\Modlr\Metadata\Interfaces\RelationshipInterface;
use As3\Modlr\Metadata\Interfaces\StorageLayerInterface;

/**
 * Defines the metadata for an entity (e.g. a database object).
 * Should be loaded using the MetadataFactory, not instantiated directly.
 *
 * @author  Jacob Bare <jacob.bare@gmail.com>
 * @todo    This should be renamed to ModelMetadata, which extends an abstract EntityMetadata class, which MixinMetadata also extends?
 */
class EntityMetadata implements AttributeInterface, RelationshipInterface, MergeableInterface
{
    /**
     * Uses properties (attributes and relationships)
     */
    use Traits\PropertiesTrait;

    /**
     * The id key name and type.
     */
    const ID_KEY  = 'id';
    const ID_TYPE = 'string';

    /**
     * Whether this class is abstract.
     *
     * @var bool
     */
    public $abstract = false;

    /**
     * An array of attribute default values for this model.
     * Keyed by field name.
     *
     * @var array
     */
    public $defaultValues = [];

    /**
     * The entity type this entity extends.
     *
     * @var bool
     */
    public $extends;

    /**
     * All mixins assigned to this entity.
     *
     * @var     MixinMetadata[]
     */
    public $mixins = [];

    /**
     * Child entity types this entity owns.
     * Only used for polymorphic entities.
     *
     * @var array
     */
    public $ownedTypes = [];

    /**
     * The persistence metadata for this entity.
     *
     * @var StorageLayerInterface
     */
    public $persistence;

    /**
     * Whether this class is considered polymorphic.
     *
     * @var bool
     */
    public $polymorphic = false;

    /**
     * The search metadata for this entity.
     *
     * @var StorageLayerInterface
     */
    public $search;

    /**
     * Uniquely defines the type of entity.
     *
     * @var string
     */
    public $type;

    /**
     * Constructor.
     *
     * @param   string  $type   The resource identifier type.
     */
    public function __construct($type)
    {
        $this->setType($type);
    }

    /**
     * Adds a mixin (and its attributes and relationships) to this entity.
     *
     * @param   MixinMetadata   $mixin
     * @return  self
     */
    public function addMixin(MixinMetadata $mixin)
    {
        if (isset($this->mixins[$mixin->name])) {
            return $this;
        }
        foreach ($mixin->getAttributes() as $attribute) {
            if (true === $this->hasAttribute($attribute->key)) {
                throw MetadataException::mixinPropertyExists($this->type, $mixin->name, 'attribute', $attribute->key);
            }
            $this->addAttribute($attribute);
        }
        foreach ($mixin->getRelationships() as $relationship) {
            if (true === $this->hasRelationship($relationship->key)) {
                throw MetadataException::mixinPropertyExists($this->type, $mixin->name, 'relationship', $relationship->key);
            }
            $this->addRelationship($relationship);
        }
        $this->mixins[$mixin->name] = $mixin;
        return $this;
    }

    /**
     * Determines if a mixin exists.
     *
     * @param   string  $mixinName
     * @return  bool
     */
    public function hasMixin($mixinName)
    {
        return isset($this->mixins[$mixinName]);
    }

    /**
     * Gets the parent entity type.
     * For entities that are extended.
     *
     * @return  string|null
     */
    public function getParentEntityType()
    {
        return $this->extends;
    }

    /**
     * Whether this metadata represents an abstract class.
     *
     * @return  bool
     */
    public function isAbstract()
    {
        return (Boolean) $this->abstract;
    }

    /**
     * Whether this metadata represents a polymorphic class.
     *
     * @return  bool
     */
    public function isPolymorphic()
    {
        return (Boolean) $this->polymorphic;
    }

    /**
     * Deteremines whether search is enabled for this model.
     *
     * @return  bool
     */
    public function isSearchEnabled()
    {
        return null !== $this->search;
    }

    /**
     * Determines if this is a child entity of another entity.
     *
     * @return  bool
     */
    public function isChildEntity()
    {
        return null !== $this->getParentEntityType();
    }

    /**
     * {@inheritDoc}
     */
    public function merge(MergeableInterface $metadata)
    {
        $this->setType($metadata->type);

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

        $this->setPolymorphic($metadata->isPolymorphic());
        $this->setAbstract($metadata->isAbstract());
        $this->extends = $metadata->extends;

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

        $this->ownedTypes = $metadata->ownedTypes;

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

        $this->defaultValues = array_merge($this->defaultValues, $metadata->defaultValues);

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

        $this->persistence->merge($metadata->persistence);

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

        $this->search->merge($metadata->search);

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

        $this->mergeAttributes($metadata->getAttributes());
        $this->mergeRelationships($metadata->getRelationships());
        $this->mergeMixins($metadata->mixins);

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

        return $this;
    }

    /**
     * Sets this metadata as representing an abstract class.
     *
     * @param   bool    $bit
     * @return  self
     */
    public function setAbstract($bit = true)
    {
        $this->abstract = (Boolean) $bit;
        return $this;
    }

    /**
     * Sets the persistence metadata for this entity.
     *
     * @param   StorageLayerInterface   $persistence
     * @return  self
     */
    public function setPersistence(StorageLayerInterface $persistence)
    {
        $this->persistence = $persistence;
        return $this;
    }

    /**
     * Sets this metadata as representing a polymorphic class.
     *
     * @param   bool    $bit
     * @return  self
     */
    public function setPolymorphic($bit = true)
    {
        $this->polymorphic = (Boolean) $bit;
        return $this;
    }

    /**
     * Sets the search metadata for this entity.
     *
     * @param   StorageLayerInterface   $search
     * @return  self
     */
    public function setSearch(StorageLayerInterface $search)
    {
        $this->search = $search;
        return $this;
    }

    /**
     * Sets the entity type.
     *
     * @param   string  $type
     * @return  self
     * @throws  MetadataException   If the type is not a string or is empty.
     */
    public function setType($type)
    {
        if (!is_string($type) || empty($type)) {
            throw MetadataException::invalidEntityType($type);
        }
        $this->type = $type;
        return $this;
    }

    /**
     * Merges attributes with this instance's attributes.
     *
     * @param   array   $toAdd
     * @return  self
     */
    private function mergeAttributes(array $toAdd)
    {
        foreach ($toAdd as $attribute) {
            $this->addAttribute($attribute);
        }
        return $this;
    }

    /**
     * Merges mixins with this instance's mixins.
     *
     * @param   array   $toAdd
     * @return  self
     */
    private function mergeMixins(array $toAdd)
    {
        foreach ($toAdd as $mixin) {
            if (!isset($this->mixins[$mixin->name])) {
                $this->mixins[$mixin->name] = $mixin;
            }
        }
        return $this;
    }

    /**
     * Merges relationships with this instance's relationships.
     *
     * @param   array   $toAdd
     * @return  self
     */
    private function mergeRelationships(array $toAdd)
    {
        foreach ($toAdd as $relationship) {
            $this->addRelationship($relationship);
        }
        return $this;
    }
}