Spiral\IdeHelper\Locators\DocumentsLocator

Complexity

Total Complexity

16

Size/Duplication

Total Lines	138
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	locate()	0	18	3
A	processFields()	0	16	3
A	processMutators()	0	10	2
B	processCompositions()	0	25	5
A	scan()	0	14	2

<?php
/**
 * Spiral Framework, IDE Helper
 *
 * @author    Dmitry Mironov <dmitry.mironov@spiralscout.com>
 * @licence   MIT
 */

namespace Spiral\IdeHelper\Locators;

use Psr\Log\LoggerInterface;
use Spiral\IdeHelper\Model\ClassDefinition;
use Spiral\IdeHelper\Model\ClassProperty;
use Spiral\ODM\DocumentEntity;
use Spiral\ODM\Entities\DocumentCompositor;
use Spiral\ODM\ODM;
use Spiral\ODM\Schemas\Definitions\CompositionDefinition;
use Spiral\ODM\Schemas\DocumentSchema;

/**
 * Class DocumentsLocator
 *
 * @package Spiral\IdeHelper\Locators
 */
class DocumentsLocator implements LocatorInterface
{
    /**
     * @var \Psr\Log\LoggerInterface
     */
    private $logger;

    /**
     * @var \Spiral\ODM\Schemas\SchemaInterface[]
     */
    private $schemas;

    /**
     * @var \Spiral\ODM\Schemas\SchemaBuilder
     */
    private $builder;

    /**
     * DocumentsLocator constructor.
     *
     * @param LoggerInterface $logger
     * @param ODM             $odm
     */
    public function __construct(LoggerInterface $logger, ODM $odm)
    {
        $this->logger = $logger;

        $this->builder = $odm->schemaBuilder();
        $this->schemas = $this->builder->getSchemas();
    }

    /**
     * @inheritdoc
     */
    public function locate(): array
    {
        $documents = [];

        foreach ($this->schemas as $schema) {
            if ($schema instanceof DocumentSchema) {
                $className = $schema->getClass();
                $members = $this->scan($schema);

                $documents[] = new ClassDefinition($className, $members);
            } else {
                $this->logger->warning("Schema for {$schema->getClass()} is not "
                    . DocumentSchema::class . " instance");
            }
        }

        return $documents;
    }

    /**
     * @param DocumentSchema $schema
     * @return array
     */
    private function scan(DocumentSchema $schema): array
    {
        $fields = $this->processFields($schema->getFields());
        $mutators = $this->processMutators($schema->getMutators());
        $compositions = $this->processCompositions($schema->getCompositions($this->builder));

        $properties = array_merge($fields, $mutators, $compositions);
        $docs = [];
        foreach ($properties as $name => $type) {
            $docs[] = new ClassProperty($name, $type);
        }

        return $docs;
    }

    /**
     * @param array $fields
     * @return array
     */
    private function processFields(array $fields): array
    {
        $results = [];

        foreach ($fields as $name => $definition) {
            if (!is_array($definition)) {
                $class = $definition;
            } else {
                $class = $definition[0] . '[]';
            }

            $results[$name] = $class;
        }

        return $results;
    }

    /**
     * @param array $mutators
     * @return array
     */
    private function processMutators(array $mutators): array
    {
        $results = [];

        foreach ($mutators['accessor'] as $name => $type) {
            $results[$name] = $type;
        }

        return $results;
    }

    /**
     * @param array $compositions
     * @return array
     */
    private function processCompositions(array $compositions): array
    {
        $results = [];

        foreach ($compositions as $name => $definition) {
            if ($definition instanceof CompositionDefinition) {
                switch ($definition->getType()) {
                    case DocumentEntity::ONE:
                        $class = $definition->getClass();
                        break;
                    case DocumentEntity::MANY:
                        $class = $definition->getClass() . '[]';
                        break;
                    default:
                        throw new \RuntimeException('Unknown definition type: '
                            . $definition->getType());
                }

                $types = [DocumentCompositor::class, $class];
                $results[$name] = $types;
            }
        }

        return $results;
    }
}