Arrilot\BitrixBlade\Blade

Complexity

Total Complexity

9

Size/Duplication

Total Lines	171
Duplicated Lines	0 %

Coupling/Cohesion

Components	3
Dependencies	9

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	1
A	view()	0	4	1
A	registerFilesystem()	0	6	1
A	registerEvents()	0	6	1
A	registerEngineResolver()	0	13	1
A	registerPhpEngine()	0	6	1
A	registerBladeEngine()	0	15	1
A	registerFactory()	0	12	1
A	registerViewFinder()	0	9	1

<?php

namespace Arrilot\BitrixBlade;

use Illuminate\Container\Container;
use Illuminate\Events\Dispatcher;
use Illuminate\Filesystem\Filesystem;
use Illuminate\View\Engines\CompilerEngine;
use Illuminate\View\Engines\EngineResolver;
use Illuminate\View\Engines\PhpEngine;
use Illuminate\View\Factory;

class Blade
{
    /**
     * Array of view base directories.
     *
     * @var array
     */
    protected $viewPaths;

    /**
     * Local path to blade cache storage.
     *
     * @var string
     */
    protected $cachePath;

    /**
     * Service container instance.
     *
     * @var Container
     */
    protected $container;

    /**
     * View factory instance.
     *
     * @var Factory
     */
    protected $viewFactory;

    /**
     * Constructor.
     *
     * @param array     $viewPaths
     * @param string    $cachePath
     * @param Container $container
     */
    public function __construct($viewPaths = [], $cachePath, $container)
    {
        $this->viewPaths = $viewPaths;
        $this->cachePath = $cachePath;
        $this->container = $container;

        $this->registerFilesystem();
        $this->registerEvents();
        $this->registerEngineResolver();
        $this->registerViewFinder();
        $this->registerFactory();
    }

    /**
     * Getter for view factory.
     *
     * @return Factory
     */
    public function view()
    {
        return $this->viewFactory;
    }

    /**
     * Register filesystem in container.
     *
     * @return void
     */
    public function registerFilesystem()
    {
        $this->container->singleton('files', function () {
            return new Filesystem();
        });
    }

    /**
     * Register events in container.
     *
     * @return void
     */
    public function registerEvents()
    {
        $this->container->singleton('events', function () {
            return new Dispatcher();
        });
    }

    /**
     * Register the engine resolver instance.
     *
     * @return void
     */
    public function registerEngineResolver()
    {
        $me = $this;

        $this->container->singleton('view.engine.resolver', function () use ($me) {
            $resolver = new EngineResolver();

            $me->registerPhpEngine($resolver);
            $me->registerBladeEngine($resolver);

            return $resolver;
        });
    }

    /**
     * Register the PHP engine implementation.
     *
     * @param EngineResolver $resolver
     *
     * @return void
     */
    public function registerPhpEngine($resolver)
    {
        $resolver->register('php', function () {
            return new PhpEngine();
        });
    }

    /**
     * Register the Blade engine implementation.
     *
     * @param EngineResolver $resolver
     *
     * @return void
     */
    public function registerBladeEngine($resolver)
    {
        $me = $this;
        $app = $this->container;

        $this->container->singleton('blade.compiler', function ($app) use ($me) {
            $cache = $me->cachePath;

            return new BladeCompiler($app['files'], $cache);
        });

        $resolver->register('blade', function () use ($app) {
            return new CompilerEngine($app['blade.compiler'], $app['files']);

The call to CompilerEngine::__construct() has too many arguments starting with $app['files'].

        });
    }

    /**
     * Register the view factory.
     */
    public function registerFactory()
    {
        $resolver = $this->container['view.engine.resolver'];

        $finder = $this->container['view.finder'];

        $factory = new Factory($resolver, $finder, $this->container['events']);
        $factory->setContainer($this->container);

        //$factory->share('app', $this->container);
        $this->viewFactory = $factory;
    }

    /**
     * Register the view finder implementation.
     *
     * @return void
     */
    public function registerViewFinder()
    {
        $me = $this;
        $this->container->singleton('view.finder', function ($app) use ($me) {
            $paths = $me->viewPaths;

            return new ViewFinder($app['files'], $paths);
        });
    }
}