Spiral\ODM\Entities\DocumentInstantiator

Complexity

Total Complexity

10

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	1
B	instantiate()	0	28	4
B	defineClass()	0	26	5

<?php
/**
 * components
 *
 * @author    Wolfy-J
 */
namespace Spiral\ODM\Entities;

use Spiral\ODM\CompositableInterface;
use Spiral\ODM\Document;
use Spiral\ODM\DocumentEntity;
use Spiral\ODM\Exceptions\DefinitionException;
use Spiral\ODM\Exceptions\InstantionException;
use Spiral\ODM\InstantiatorInterface;
use Spiral\ODM\ODMInterface;

/**
 * Provides ability to construct Document and DocumentEntities with inheritance support.
 */
class DocumentInstantiator implements InstantiatorInterface
{
    /**
     * @invisible
     * @var ODMInterface
     */
    private $odm;

    /**
     * Primary instantiation class.
     *
     * @var string
     */
    private $class = '';

    /**
     * Normalized schema delivered by DocumentSchema.
     *
     * @var array
     */
    private $schema = [];

    /**
     * @param ODMInterface $odm
     * @param string       $class
     * @param array        $schema
     */
    public function __construct(ODMInterface $odm, string $class, array $schema)
    {
        $this->odm = $odm;
        $this->class = $class;
        $this->schema = $schema;
    }

    /**
     * {@inheritdoc}
     *
     * @return CompositableInterface|DocumentEntity|Document
     *
     * @throws InstantionException
     */
    public function instantiate($fields, bool $filter = true): CompositableInterface
    {
        $class = $this->defineClass($fields);

        if ($class !== $this->class) {
            //We have to dedicate class creation to external instantiator (possibly children class)
            return $this->odm->instantiate($class, $fields, $filter);
        }

        //Now we can construct needed class, in this case we are following DocumentEntity declaration
        if (!$filter) {
            //No need to filter values, passing directly in constructor
            return new $class($fields, $this->schema, $this->odm);
        } else {
            $entity = new $class($fields, $this->schema, $this->odm);

            if (!$entity instanceof CompositableInterface) {
                throw new InstantionException(
                    "Unable to set filtered values for {$class}, must be instance of CompositableInterface"
                );
            }

            //Must pass value thought all needed filters
            $entity->stateValue($fields);

            return $entity;
        }
    }

    /**
     * Define document class using it's fieldset and definition.
     *
     * @param \ArrayAccess|array $fields
     *
     * @return string
     *
     * @throws DefinitionException
     */
    protected function defineClass($fields)
    {
        //Rule to define class instance
        $definition = $this->schema[DocumentEntity::SH_INSTANTIATION];

        if (is_string($definition)) {
            //Document has no variations
            return $definition;
        }

        if (!is_array($fields)) {
            //Unable to resolve for non array set, using same class as given
            return $this->class;
        }

        $defined = $this->class;
        foreach ($definition as $field => $child) {
            if (array_key_exists($field, $fields)) {
                //Apparently this is child
                $defined = $child;
                break;
            }
        }

        return $defined;
    }
}