Cerbere\Cerbere

Complexity

Total Complexity

19

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	5
Bugs	0	Features	2

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	addLoggerListener()	0	6	1
A	getDispatcher()	0	8	2
A	setDispatcher()	0	6	1
A	addParser()	0	6	1
A	getParser()	0	8	2
A	run()	0	20	1
A	getProjectsFromPatterns()	0	10	2
A	getProjectsFromPattern()	0	19	4
A	getFilesFromPattern()	0	12	3
A	getParsers()	0	4	1

<?php

namespace Cerbere;

use Cerbere\Action\ActionInterface;
use Cerbere\Event\CerbereEvents;
use Cerbere\Event\CerbereFileDiscoverEvent;
use Cerbere\Event\CerbereLoggerListener;
use Cerbere\Model\Job;
use Cerbere\Model\Project;
use Cerbere\Parser\ParserInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

/**
 * Class Cerbere
 *
 * @package Cerbere
 */
class Cerbere
{
    /**
     * @var ParserInterface[]
     */
    protected $parsers = array();

    /**
     * @var EventDispatcherInterface
     */
    protected $dispatcher;

    /**
     */
    public function __construct()
    {
    }

    /**
     * @param CerbereLoggerListener $listener
     *
     * @return $this
     */
    public function addLoggerListener(CerbereLoggerListener $listener)
    {
        $this->getDispatcher()->addSubscriber($listener);

        return $this;
    }

    /**
     * Gets the dispatcher used by this library to dispatch events.
     *
     * @return EventDispatcherInterface
     */
    public function getDispatcher()
    {
        if (!isset($this->dispatcher)) {
            $this->dispatcher = new EventDispatcher();
        }

        return $this->dispatcher;
    }

    /**
     * Sets the dispatcher used by this library to dispatch events.
     *
     * @param EventDispatcherInterface $dispatcher
     *   The Symfony event dispatcher object.
     *
     * @return $this
     */
    public function setDispatcher(EventDispatcherInterface $dispatcher)
    {
        $this->dispatcher = $dispatcher;

        return $this;
    }

    /**
     * @param ParserInterface $parser
     *
     * @return $this
     */
    public function addParser(ParserInterface $parser)
    {
        $this->parsers[$parser->getCode()] = $parser;

        return $this;
    }

    /**
     * @param string $code
     *
     * @return ParserInterface|null
     */
    public function getParser($code)
    {
        if (isset($this->parsers[$code])) {
            return $this->parsers[$code];
        }

        return null;
    }

    /**
     * @param Job             $job
     * @param ActionInterface $action
     * @param array           $options
     *
     * @return array
     */
    public function run(Job $job, ActionInterface $action, $options = array())
    {
        // Download remote project if remote.
        $dir = $job->checkoutRepository();

        // Move to project folder.
        $currentDirectory = getcwd();
        chdir($dir);

        // Load projects from repository.
        $projects = $this->getProjectsFromPatterns($job->getPatterns(), $job->isPatternNested());

        // Do cerbere action.
        $report = $action->process($projects, $options);

        // Restore initial directory.
        chdir($currentDirectory);

        return $report;
    }

    /**
     * @param array      $patterns
     * @param bool|false $nested
     *
     * @return Project[]
     */
    public function getProjectsFromPatterns($patterns, $nested = false)
    {
        $projects = array();

        foreach ($patterns as $pattern) {
            $projects = array_merge($projects, $this->getProjectsFromPattern($pattern, $nested));
        }

        return $projects;
    }

    /**
     * @param string     $pattern
     * @param bool|false $nested
     *
     * @return Project[]
     */
    public function getProjectsFromPattern($pattern, $nested = false)
    {
        $projects   = array();
        $dispatcher = $this->getDispatcher();
        $files      = $this->getFilesFromPattern($pattern, $nested);

        foreach ($files as $file) {
            foreach ($this->getParsers() as $parser) {
                if ($parser->supportedFile($file)) {
                    $event = new CerbereFileDiscoverEvent($this, $file, $parser);
                    $dispatcher->dispatch(CerbereEvents::APPLICATION_FILE_DISCOVERED, $event);
                    $parser->processFile($file);
                    $projects = array_merge($projects, $parser->getProjects());
                }
            }
        }

        return $projects;
    }

    /**
     * @param string $pattern
     * @param bool|false $nested
     * @param int $flags
     *
     * @return array
     */
    public function getFilesFromPattern($pattern, $nested = false, $flags = 0)
    {
        $files = glob($pattern, $flags);

        if ($nested) {
            foreach (glob(dirname($pattern) . '/*', GLOB_ONLYDIR | GLOB_NOSORT) as $dir) {
                $files = array_merge($files, $this->getFilesFromPattern($dir . '/' . basename($pattern), $nested, $flags));
            }
        }

        return $files;
    }

    /**
     * @return ParserInterface[]
     */
    public function getParsers()
    {
        return $this->parsers;
    }
}