phpDocumentor\Parser\ServiceProvider

Complexity

Total Complexity

13

Size/Duplication

Total Lines	170
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	27

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	62	2
B	validateDocBlocks()	0	34	5
A	loadConfiguration()	0	11	1
B	loadConfigurationByElement()	0	22	5

<?php
/**
 * phpDocumentor
 *
 * PHP Version 5.3
 *
 * @copyright 2010-2014 Mike van Riel / Naenius (http://www.naenius.com)
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      http://phpdoc.org
 */

namespace phpDocumentor\Parser;

use Cilex\Application;
use Cilex\ServiceProviderInterface;
use phpDocumentor\Fileset\Collection;
use phpDocumentor\Parser\Command\Project\ParseCommand;
use phpDocumentor\Parser\Middleware\CacheMiddleware;
use phpDocumentor\Parser\Middleware\ErrorHandlingMiddleware;
use phpDocumentor\Parser\Middleware\StopwatchMiddleware;
use phpDocumentor\Parser\Middleware\EmittingMiddleware;
use phpDocumentor\Plugin\Core\Descriptor\Validator\ValidatorAbstract;
use phpDocumentor\Reflection\DocBlockFactory;
use phpDocumentor\Reflection\Event\PostDocBlockExtractionEvent;
use phpDocumentor\Reflection\Php\Factory as Factory;
use phpDocumentor\Reflection\Php\NodesFactory;
use phpDocumentor\Reflection\Php\ProjectFactory;
use phpDocumentor\Reflection\PrettyPrinter;
use phpDocumentor\Translator\Translator;
use Stash\Driver\FileSystem;
use Stash\Pool;

/**
 * This provider is responsible for registering the parser component with the given Application.
 */
class ServiceProvider implements ServiceProviderInterface

The class ServiceProvider has a coupling between objects value of 28. Consider to reduce the number of dependencies under 13.

{
    /**
     * Registers services on the given app.
     *
     * @param Application $app An Application instance
     *
     * @throws Exception\MissingDependencyException if the Descriptor Builder is not present.
     * @throws \Stash\Exception\RuntimeException
     *
     * @return void
     *
     */
    public function register(Application $app)
    {
        if (!isset($app['descriptor.builder'])) {
            throw new Exception\MissingDependencyException(
                'The builder object that is used to construct the ProjectDescriptor is missing'
            );
        }

        $app['parser'] = $app->share(
            function ($app) {
                $stopWatch = $app['kernel.stopwatch'];

                $adapter = new FileSystem(['path' => 'build/api-cache']);
                $cachePool = new Pool($adapter);

                $strategies = [
                    new Factory\Argument(new PrettyPrinter()),
                    new Factory\Class_(),
                    new Factory\Constant(new PrettyPrinter()),
                    new Factory\DocBlock(DocBlockFactory::createInstance()),
                    new Factory\Function_(),
                    new Factory\Interface_(),
                    new Factory\Method(),
                    new Factory\Property(new PrettyPrinter()),
                    new Factory\Trait_(),
                    new Factory\File(
                        NodesFactory::createInstance(),
                        [
                            new EmittingMiddleware(),
                            new StopwatchMiddleware(
                                $stopWatch
                            ),
                            new CacheMiddleware(
                                $cachePool
                            ),
                            new ErrorHandlingMiddleware()
                        ]
                    )
                ];

                $parser = new Parser(
                    new ProjectFactory($strategies),
                    $stopWatch
                );

                return $parser;
            }
        );

        $app['markdown'] = $app->share(
            function () {
                return \Parsedown::instance();
            }
        );

        /** @var Translator $translator  */
        $translator = $app['translator'];
        $translator->addTranslationFolder(__DIR__ . DIRECTORY_SEPARATOR . 'Messages');

        $app['parser.files'] = new Collection();
        $app->command(new ParseCommand($app['descriptor.builder'], $app['parser'], $translator, $app['parser.files']));
    }

    /**
     * Checks all phpDocumentor whether they match the given rules.
     *
     * @param PostDocBlockExtractionEvent $data Event object containing the parameters.
     *
     * @todo convert this method to the new style validators; this method is not invoked anymore
     *
     * @return void
     */
    public function validateDocBlocks($data)
    {
        /** @var \phpDocumentor\Reflection\BaseReflector $element */
        $element = $data->getSubject();

        /** @var \phpDocumentor\Reflection\DocBlock $docblock */
        $docblock = $data->getDocblock();

        // get the type of element
        $type = substr(
            get_class($element),
            strrpos(get_class($element), '\\') + 1,
            -9 // Reflector
        );

        // no docblock, or docblock should be ignored, so no reason to validate
        if ($docblock && $docblock->hasTag('ignore')) {
            return;
        }

        $validatorOptions = $this->loadConfiguration();

        foreach (array('Deprecated', 'Required', $type) as $validator) {

Blank line found at start of control structure

            // todo: move to a factory or builder class
            $class = 'phpDocumentor\Plugin\Core\Parser\DocBlock\Validator\\' . $validator . 'Validator';
            if (class_exists($class)) {
                /** @var ValidatorAbstract $val */
                $val = new $class($element->getName(), $docblock, $element);
                $val->setOptions($validatorOptions);
                $val->isValid($element);
            }
        }
    }

    /**
     * Load the configuration from the plugin.xml file
     *
     * @todo restore required/deprecated validators
     *
     * @return array
     */
    protected function loadConfiguration()
    {
        //$configOptions = $this->plugin->getOptions();
        $validatorOptions = array();

        //foreach (array('deprecated', 'required') as $tag) {
        //    $validatorOptions[$tag] = $this->loadConfigurationByElement($configOptions, $tag);
        //}

        return $validatorOptions;
    }

    /**
     * Load the configuration for given element (deprecated/required)
     *
     * @param array  $configOptions The configuration from the plugin.xml file
     * @param string $configType    Required/Deprecated for the time being
     *
     * @return array
     */
    protected function loadConfigurationByElement($configOptions, $configType)
    {
        $validatorOptions = array();

        if (isset($configOptions[$configType]->tag)) {

Blank line found at start of control structure

            foreach ($configOptions[$configType]->tag as $tag) {
                $tagName = (string) $tag['name'];

                if (isset($tag->element)) {
                    foreach ($tag->element as $type) {
                        $typeName = (string) $type;
                        $validatorOptions[$typeName][] = $tagName;
                    }
                } else {
                    $validatorOptions['__ALL__'][] = $tagName;
                }
            }
        }

        return $validatorOptions;
    }
}