Register the StringBlade engine implementation.

@param  \Illuminate\View\Engines\EngineResolver  $resolver
@return void
424588
public function registerStringBladeEngine($resolver)
    {
        $app = $this->app;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $app->singleton('stringblade.compiler', function ($app) {
            $cache = $app['config']['view.compiled'];
            return new StringBladeCompiler($app['files'], $cache);
        });

        $resolver->register('stringblade', function () use ($app) {
            return new CompilerEngine($app['stringblade.compiler']);
        });
    }
933485
public function register()
    {
        $this->app->singleton('Concrete\Core\Url\Resolver\CanonicalUrlResolver');
        $this->app->bind('url/canonical/resolver', '\Concrete\Core\Url\Resolver\CanonicalUrlResolver');

        $this->app->bind('url/canonical', function ($app) {
            return $app->make('Concrete\Core\Url\Resolver\CanonicalUrlResolver')->resolve(array());
        });

        // Share the path url resolver
        $this->app->singleton('Concrete\Core\Url\Resolver\PathUrlResolver');
        $this->app->bind('url/resolver/path', 'Concrete\Core\Url\Resolver\PathUrlResolver');

        // Share the Page url resolver
        $this->app->singleton('Concrete\Core\Url\Resolver\PageUrlResolver');
        $this->app->bind('url/resolver/page', 'Concrete\Core\Url\Resolver\PageUrlResolver');

        // Share the route url resolver
        $this->app->singleton('Concrete\Core\Url\Resolver\RouterUrlResolver');
        $this->app->bind('url/resolver/route', 'Concrete\Core\Url\Resolver\RouterUrlResolver');

        $this->app->bindShared('Concrete\Core\Url\Resolver\Manager\ResolverManager',
            function ($app, $default_handle = '', $default_resolver = null) {
                $manager = new ResolverManager($default_handle ?: 'concrete.path', $default_resolver);

                $manager->addResolver('concrete.path', $app->make('Concrete\Core\Url\Resolver\PathUrlResolver'));
                $manager->addResolver('concrete.page', $app->make('Concrete\Core\Url\Resolver\PageUrlResolver'));
                $manager->addResolver('concrete.route', $app->make('Concrete\Core\Url\Resolver\RouterUrlResolver'));
                $manager->addResolver('concrete.user', $app->make('Concrete\Core\Url\Resolver\UserInfoUrlResolver'));

                return $manager;
            });
        $this->app->bind('Concrete\Core\Url\Resolver\Manager\ResolverManagerInterface', 'Concrete\Core\Url\Resolver\Manager\ResolverManager');
        $this->app->bind('url/manager', 'Concrete\Core\Url\Resolver\Manager\ResolverManager');

        $this->app
            ->when(SeoCanonical::class)
            ->needs('$excludedQuerystringParameters')
            ->give(function($app) {
                $site = $app->make('site')->getSite();
                $config = $site->getConfigRepository();
                return $config->get('seo.canonical_tag.excluded_querystring_parameters');
            });
    }
1280465
public function configureOptions(OptionsResolver $resolver)
    {
        $resolver
            ->setDefaults(array(
                'required'               => false,
                'data_extraction_method' => 'default',
                'reference_type'         => 'one',
                'reference_name'         => null,
            ))
            ->setRequired(array('reference_type'))
            ->setAllowedValues('data_extraction_method', array('default'))
            ->setAllowedValues('reference_type', array('one', 'many'))
        ;
    }
724182
public function registerBladeEngine($resolver)
    {
        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        Zilf::$container->register(
            'blade.compiler', function () {

                return new BladeCompiler(
                    Zilf::$container['files'], Zilf::$app->runtimePath().'/views'
                );

            }
        );

        $resolver->register(
            'blade', function () {
                return new CompilerEngine(Zilf::$container['blade.compiler']);
            }
        );
    }
1065621
public function registerBladeEngine($resolver)
    {
        $me = $this;
        $app = $this->container;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $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']);
        });
    }
232233
protected function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setRequired(
            [
                'family',
            ]
        );
        /** @noinspection PhpUnusedParameterInspection */
        $resolver->setNormalizer(
            'family',
            function (Options $options, $value) {
                if ($value instanceof FamilyInterface) {
                    return $value;
                }

                return $this->familyRegistry->getFamily($value);
            }
        );
        $resolver->setAllowedTypes('family', ['string', FamilyInterface::class]);
    }
555747
protected function configureOptions(OptionsResolver $resolver)
    {
        $resolver->setRequired([
            'content',
            'relation_field',
        ]);

        $resolver->setAllowedTypes('content', SiteContent::class);
        $resolver->setAllowedTypes('relation_field', ['string', 'array']);
        $resolver->setAllowedValues(
            'relation_field',
            function ($fields) {
                if (!is_array($fields)) {
                    return true;
                }

                foreach ($fields as $field) {
                    if (!is_string($field)) {
                        return false;
                    }
                }

                return true;
            }
        );

        $resolver->setDefined('exclude_self');
        $resolver->setAllowedTypes('exclude_self', ['bool']);
        $resolver->setDefaults([
            'exclude_self' => true,
        ]);
    }
907295
protected function registerEngineResolverExtensions()
    {
        $this->app->extend('view.engine.resolver', function ($resolver, $app) {
            $this->registerBladeEngine($resolver);

            $this->registerHandlebarsEngine($resolver);

            return $resolver;
        });
    }
995252
public function registerBladeEngine($resolver)
    {
        $app = $this->app;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $app->singleton('blade.compiler', function ($app) {
            $cache = $app['config']['view.compiled'];

            return new BladeCompiler($app['files'], $cache);
        });
    }
832373
public function registerSwordEngine($resolver)
	{
		$app = $this->app;

		// The Compiler engine requires an instance of the CompilerInterface, which in
		// this case will be the Sword compiler, so we'll first create the compiler
		// instance to pass into the engine so it can compile the views properly.
		$app->bindShared('sword.compiler', function($app)
		{
			$cache = $app['path.storage'].'/views';

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

		$resolver->register('sword', function() use ($app)
		{
			return new CompilerEngine($app['sword.compiler'], $app['files']);
		});
	}
1069681
public function registerMarkdownEngine($resolver)
    {
        $app = $this->app;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Markdown compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $app->bindShared('markdown.compiler', function($app)
        {
            $cachePath = $app['config']['view.compiled'];

            return new MarkdownCompiler($app['files'], $cachePath);
        });

        $resolver->register('markdown', function() use ($app)
        {
            return new CompilerEngine($app['markdown.compiler'], $app['files']);
        });
    }
244565
protected function registerEnvironment()
    {
        // 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 = $this->container['view.engine.resolver'];
        $finder   = $this->container['view.finder'];
        $events   = $this->container['events'];
        $env      = new Environment($resolver, $finder, $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.
        $env->setContainer($this->container);

        return $env;
    }
1180272
protected function registerBladeEngine(EngineResolver $resolver)
    {
        $mySelf    = $this;
        $container = $this->container;

        // The Compiler engine requires an instance of the CompilerInterface, which in
        // this case will be the Blade compiler, so we'll first create the compiler
        // instance to pass into the engine so it can compile the views properly.
        $this->container->bindShared('blade.compiler', function ($container) use ($mySelf) {
            return new BladeCompiler($container['files'], $container['cache.path']);
        });

        // Register the blade view file finder to resolve to template
        $resolver->register('blade', function () use ($container) {
            return new CompilerEngine($container['blade.compiler'], $container['files']);
        });
    }
878000
protected function resolveOptions(OptionsResolver $resolver)
    {
        $resolver->setRequired('directories');
        $resolver->setDefault('baseDirectory', null);
        $resolver->setAllowedTypes('directories', 'array');
    }
4626
public function register(Renderer $renderer) {
        $this->registerTokenRenderer(LinkInlineRule::NAME, 'renderInline', $renderer);
        $this->registerTokenRenderer(LinkReferenceRule::NAME, 'renderReference', $renderer);
        $this->registerTokenRenderer(LinkAutoRule::NAME, 'renderAuto', $renderer);
    }
118218
private function configureProcessProperties(OptionsResolver $resolver)
    {
        $resolver
            ->setRequired('command')
            ->setAllowedTypes('command', 'string');

        $resolver
            ->setDefined('process_name')
            ->setAllowedTypes('process_name', 'string');

        $resolver->setDefined('numprocs')
            ->setAllowedTypes('numprocs', 'int');

        $resolver->setDefined('numprocs_start')
            ->setAllowedTypes('numprocs_start', 'int');

        $resolver->setDefined('priority')
            ->setAllowedTypes('priority', 'int');
    }
102088
public static function injectInstance(Resolver $resolver)
    {
        $sub = $resolver->getResolver('assets');
        return $sub !== null ? new static($sub) : null;
    }