Facile\MongoDbBundle\Fixtures\MongoFixturesLoader

Complexity

Total Complexity

15

Size/Duplication

Total Lines	126
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

87.5%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	loadFromDirectory()	0	13	2
A	buildFixture()	0	8	2
A	addInstance()	0	8	2
A	loadFromFile()	0	10	2
A	getLoadedClasses()	0	4	1
B	loadFromIterator()	0	34	5

<?php declare(strict_types = 1);

namespace Facile\MongoDbBundle\Fixtures;

use Symfony\Component\DependencyInjection\ContainerInterface;

/**
 * Class MongoFixturesLoader.
 */
final class MongoFixturesLoader
{
    /** @var  array|MongoFixtureInterface[] */
    private $loadedClasses;
    /** @var ContainerInterface */
    private $container;

    /**
     * MongoFixturesLoader constructor.
     *
     * @param ContainerInterface $container
     */
    public function __construct(ContainerInterface $container)
    {
        $this->container = $container;
    }

    /**
     * @param string $dir
     *
     * @return array
     */
    public function loadFromDirectory(string $dir)
    {
        if (!is_dir($dir)) {
            throw new \InvalidArgumentException(sprintf('"%s" does not exist', $dir));
        }

        $iterator = new \RecursiveIteratorIterator(
            new \RecursiveDirectoryIterator($dir),
            \RecursiveIteratorIterator::LEAVES_ONLY
        );

        return $this->loadFromIterator($iterator);
    }

    /**
     * @param \Iterator $iterator
     *
     * @return array
     */
    private function loadFromIterator(\Iterator $iterator)
    {
        $includedFiles = array();
        foreach ($iterator as $file) {
            if ($file->getBasename('.php') == $file->getBasename()) {
                continue;
            }
            $sourceFile = realpath($file->getPathName());
            require_once $sourceFile;
            $includedFiles[] = $sourceFile;
        }

        $declared = get_declared_classes();

        return array_reduce(
            $declared,
            function ($classList, string $className) use ($includedFiles) {
                $reflClass = new \ReflectionClass($className);
                $sourceFile = $reflClass->getFileName();

                if (
                    in_array($sourceFile, $includedFiles) &&
                    in_array(MongoFixtureInterface::class, array_keys($reflClass->getInterfaces()))
                ) {
                    $instance = $this->buildFixture(new $className);
                    $this->addInstance($instance);
                    $classList[] = $instance;
                }

                return $classList;
            },
            []
        );
    }

    /**
     * @param mixed $instance
     *
     * @return MongoFixtureInterface
     */
    private function buildFixture($instance): MongoFixtureInterface
    {
        if ($instance instanceof AbstractContainerAwareFixture) {
            $instance->setContainer($this->container);
        }

        return $instance;
    }

    /**
     * @param MongoFixtureInterface $list
     */
    public function addInstance(MongoFixtureInterface $list)
    {
        $listClass = get_class($list);

        if (!isset($this->loadedClasses[$listClass])) {
            $this->loadedClasses[$listClass] = $list;
        }
    }

    /**
     * @param string $fileName
     *
     * @return array
     */
    public function loadFromFile(string $fileName)
    {
        if (!is_readable($fileName)) {
            throw new \InvalidArgumentException(sprintf('"%s" does not exist or is not readable', $fileName));
        }

        $iterator = new \ArrayIterator(array(new \SplFileInfo($fileName)));

        return $this->loadFromIterator($iterator);
    }

    /**
     * @return array|MongoFixtureInterface[]
     */
    public function getLoadedClasses()
    {
        return $this->loadedClasses;
    }
}