Subversion-Projekte lars-tiefland.laravel_shop

<?php

namespace Illuminate\View;

use Illuminate\Support\ServiceProvider;

use Illuminate\View\Compilers\BladeCompiler;

use Illuminate\View\Engines\CompilerEngine;

use Illuminate\View\Engines\EngineResolver;

use Illuminate\View\Engines\FileEngine;

use Illuminate\View\Engines\PhpEngine;

class ViewServiceProvider extends ServiceProvider

{

    /**

     * Register the service provider.

     *

     * @return void

     */

    public function register()

    {

        $this->registerFactory();

        $this->registerViewFinder();

        $this->registerBladeCompiler();

        $this->registerEngineResolver();

        $this->app->terminating(static function () {

            Component::flushCache();

        });

    }

    /**

     * Register the view environment.

     *

     * @return void

     */

    public function registerFactory()

    {

        $this->app->singleton('view', function ($app) {

            // Next we need to grab the engine resolver instance that will be used by the

            // environment. The resolver will be used by an environment to get each of

            // the various engine implementations such as plain PHP or Blade engine.

            $resolver = $app['view.engine.resolver'];

            $finder = $app['view.finder'];

            $factory = $this->createFactory($resolver, $finder, $app['events']);

            // We will also set the container instance on this view environment since the

            // view composers may be classes registered in the container, which allows

            // for great testable, flexible composers for the application developer.

            $factory->setContainer($app);

            $factory->share('app', $app);

            $app->terminating(static function () {

                Component::forgetFactory();

            });

            return $factory;

        });

    }

    /**

     * Create a new Factory Instance.

     *

     * @param  \Illuminate\View\Engines\EngineResolver  $resolver

     * @param  \Illuminate\View\ViewFinderInterface  $finder

     * @param  \Illuminate\Contracts\Events\Dispatcher  $events

     * @return \Illuminate\View\Factory

     */

    protected function createFactory($resolver, $finder, $events)

    {

        return new Factory($resolver, $finder, $events);

    }

    /**

     * Register the view finder implementation.

     *

     * @return void

     */

    public function registerViewFinder()

    {

        $this->app->bind('view.finder', function ($app) {

            return new FileViewFinder($app['files'], $app['config']['view.paths']);

        });

    }

    /**

     * Register the Blade compiler implementation.

     *

     * @return void

     */

    public function registerBladeCompiler()

    {

        $this->app->singleton('blade.compiler', function ($app) {

            return tap(new BladeCompiler(

                $app['files'],

                $app['config']['view.compiled'],

                $app['config']->get('view.relative_hash', false) ? $app->basePath() : '',

                $app['config']->get('view.cache', true),

                $app['config']->get('view.compiled_extension', 'php'),

            ), function ($blade) {

                $blade->component('dynamic-component', DynamicComponent::class);

            });

        });

    }

    /**

     * Register the engine resolver instance.

     *

     * @return void

     */

    public function registerEngineResolver()

    {

        $this->app->singleton('view.engine.resolver', function () {

            $resolver = new EngineResolver;

            // Next, we will register the various view engines with the resolver so that the

            // environment will resolve the engines needed for various views based on the

            // extension of view file. We call a method for each of the view's engines.

            foreach (['file', 'php', 'blade'] as $engine) {

                $this->{'register'.ucfirst($engine).'Engine'}($resolver);

            }

            return $resolver;

        });

    }

    /**

     * Register the file engine implementation.

     *

     * @param  \Illuminate\View\Engines\EngineResolver  $resolver

     * @return void

     */

    public function registerFileEngine($resolver)

    {

        $resolver->register('file', function () {

            return new FileEngine($this->app['files']);

        });

    }

    /**

     * Register the PHP engine implementation.

     *

     * @param  \Illuminate\View\Engines\EngineResolver  $resolver

     * @return void

     */

    public function registerPhpEngine($resolver)

    {

        $resolver->register('php', function () {

            return new PhpEngine($this->app['files']);

        });

    }

    /**

     * Register the Blade engine implementation.

     *

     * @param  \Illuminate\View\Engines\EngineResolver  $resolver

     * @return void

     */

    public function registerBladeEngine($resolver)

    {

        $resolver->register('blade', function () {

            $compiler = new CompilerEngine($this->app['blade.compiler'], $this->app['files']);

            $this->app->terminating(static function () use ($compiler) {

                $compiler->forgetCompiledOrNotExpired();

            });

            return $compiler;

        });

    }

}