Cubiche\Core\Metadata\Driver\AbstractAnnotationDriver

Complexity

Total Complexity

15

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	addPaths()	0	4	1
A	addExcludePaths()	0	4	1
A	excludePaths()	0	4	1
A	setFileExtension()	0	4	1
C	getAllClassNames()	0	53	10

<?php
/**
 * This file is part of the Cubiche package.
 *
 * Copyright (c) Cubiche
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Cubiche\Core\Metadata\Driver;

use Cubiche\Core\Metadata\Exception\MappingException;
use Cubiche\Tests\Generator\ClassUtils;
use Doctrine\Common\Annotations\Reader;

/**
 * AbstractAnnotationDriver class.
 *
 * @author Ivannis Suárez Jerez <ivannis.suarez@gmail.com>
 */
abstract class AbstractAnnotationDriver implements DriverInterface
{
    /**
     * @var Reader
     */
    protected $reader;

    /**
     * The paths where to look for mapping files.
     *
     * @var array
     */
    protected $paths = [];

    /**
     * The paths excluded from path where to look for mapping files.
     *
     * @var array
     */
    protected $excludePaths = [];

    /**
     * The file extension of mapping documents.
     *
     * @var string
     */
    protected $fileExtension = '.php';

    /**
     * @var array|null
     */
    protected $classNames;

    /**
     * AbstractAnnotationDriver constructor.
     *
     * @param Reader $reader
     * @param array  $paths
     */
    public function __construct(Reader $reader, array $paths = array())
    {
        $this->reader = $reader;
        $this->addPaths($paths);
    }

    /**
     * @param array $paths
     */
    public function addPaths(array $paths)
    {
        $this->paths = array_unique(array_merge($this->paths, $paths));
    }

    /**
     * @param array $paths
     */
    public function addExcludePaths(array $paths)
    {
        $this->excludePaths = array_unique(array_merge($this->excludePaths, $paths));
    }

    /**
     * @return array
     */
    public function excludePaths()
    {
        return $this->excludePaths;
    }

    /**
     * @param string $fileExtension
     */
    public function setFileExtension($fileExtension)
    {
        $this->fileExtension = $fileExtension;
    }

    /**
     * {@inheritdoc}
     */
    public function getAllClassNames()
    {
        if ($this->classNames !== null) {
            return $this->classNames;
        }

        if (!$this->paths) {

The expression $this->paths of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using empty($expr) instead to make it clear that you intend to check for an array without elements.

            throw MappingException::pathRequired();
        }

        $includedFiles = [];
        foreach ($this->paths as $path) {
            if (!is_dir($path)) {
                throw MappingException::invalidDirectory($path);
            }

            $iterator = new \RegexIterator(
                new \RecursiveIteratorIterator(
                    new \RecursiveDirectoryIterator($path, \FilesystemIterator::SKIP_DOTS),
                    \RecursiveIteratorIterator::LEAVES_ONLY
                ),
                '/^.+'.preg_quote($this->fileExtension).'$/i',
                \RecursiveRegexIterator::GET_MATCH
            );

            foreach ($iterator as $file) {
                $sourceFile = $file[0];

                if (!preg_match('(^phar:)i', $sourceFile)) {
                    $sourceFile = realpath($sourceFile);
                }

                foreach ($this->excludePaths as $excludePath) {
                    $exclude = str_replace('\\', '/', realpath($excludePath));
                    $current = str_replace('\\', '/', $sourceFile);

                    if (strpos($current, $exclude) !== false) {
                        continue 2;
                    }
                }

                require_once $sourceFile;
                $includedFiles[] = $sourceFile;
            }
        }

        $this->classNames = [];
        foreach ($includedFiles as $includedFile) {
            $this->classNames = array_merge($this->classNames, ClassUtils::getClassesInFile($includedFile));
        }

        return $this->classNames;
    }
}