Resolve application boot middleware.
775027
protected function bootMiddleWares()
    {
        if (isset($this->middleWares['boot']) && count($this->middleWares['boot'])) {
            foreach ($this->middleWares['boot'] as $middleware => $handler) {
                $this->container->call([$this->container->make($middleware), $handler]);
            }

            return [];
        }

        /**
         * Framework development mood.
         */
        $CSRFProtection = $this->container->make(CSRFProtection::class);

        return $this->container->call([$CSRFProtection, 'handle']);
    }
439384
public function bootstrap()
    {
        $this->router = $this->app['router'];
        $this->middlewareGroups = array_merge([], $this->middlewareGroups, config('routing.middlewareGroups', []));
        $this->routeMiddleware = array_merge([], $this->routeMiddleware, config('routing.routeMiddleware', []));

        foreach ($this->middlewareGroups as $key => $middleware) {
            $this->router->middlewareGroup($key, $middleware);
        }

        foreach ($this->routeMiddleware as $key => $middleware) {
            $this->router->middleware($key, $middleware);
        }
    }
172566
public function boot(Application $app)
    {
        // Register Monolog error handler for fatal errors here because Symfony's handler overrides it
        $monologErrorHandler = new MonologErrorHandler($app['log']);

        $monologErrorHandler->registerErrorHandler();
        $monologErrorHandler->registerFatalHandler();
    }
1002512
public static function boot() : void
    {
        $container = self::getContainer();
        $container->singleton('app', $container);

        Facade::setFacadeApplication($container);
    }
259875
protected void boot(final BootContext context) throws ConfigurationPersistenceException {
        List<ModelNode> bootOps = configurationPersister.load();
        ModelNode op = registerModelControllerServiceInitializationBootStep(context);
        if (op != null) {
            bootOps.add(op);
        }
        boot(bootOps, false);
        finishBoot();
    }
1303205
public function boot(Application $app)
    {
        $app->on(KernelEvents::EXCEPTION, function (GetResponseForExceptionEvent $event) {
            $e = $event->getException();
            if ($e instanceof MethodNotAllowedHttpException && $e->getHeaders()["Allow"] === "OPTIONS") {
                $event->setException(new NotFoundHttpException("No route found for \"{$event->getRequest()->getMethod()} {$event->getRequest()->getPathInfo()}\""));
            }
        });
    }
969625
public function boot()
    {
        $this->publishes([
            __DIR__.'/../../config/config.php' => config_path('image.php')
        ]);

        // setup intervention/imagecache if package is installed
        $this->cacheIsInstalled() ? $this->bootstrapImageCache() : null;
    }
351388
def resolve(cls, full_path):
        """"""
        mod_path, _, app_path = full_path.partition(':')
        app = getattr(import_module(mod_path), app_path or 'application')

        with contextlib.suppress(TypeError):
            if issubclass(app, server.Gateway):
                return GatewayYo(app)

        return cls(app)
734960
public function boot()
    {
        $this->setResponseStaticInstances();

        Request::setAcceptParser($this->app[\Dingo\Api\Http\Parser\Accept::class]);

        $this->app->rebinding('api.routes', function ($app, $routes) {
            $app['api.url']->setRouteCollections($routes);
        });
    }
823208
public function boot()
    {
        $configFile = realpath(__DIR__ . '/../config/json-api.php');

        $this->mergeConfigFrom($configFile, 'json-api');
        $this->publishes([
            $configFile => config_path('json-api.php'),
        ]);

        if (config('json-api.routes.configure', false)) {
            if (!$this->app->routesAreCached()) {
                Route::group([], function (Router $router) {
                    require __DIR__ . '/../routes/api.php';
                });
            }
        }
    }
47951
public function boot()
	{
		$this->package('redbaron76/googlavel');

		// Facade alias
		$this->aliasLoader = AliasLoader::getInstance();

		$this->app->booting(function()
		{
			$this->aliasLoader->alias('Googlavel', 'Redbaron76\Googlavel\Support\Facades\Googlavel');
		});
	}
114113
public function boot()
    {
        require __DIR__.'/../permissions.php';
        require __DIR__.'/../composers.php';
        require __DIR__.'/../helpers.php';
        require __DIR__.'/../observers.php';
        require __DIR__.'/../menus.php';
        require __DIR__.'/../routes.php';

        if (file_exists($path = app_path('menus.php'))) {
            require $path;
        }
    }
511531
protected function _boot() {

			// Start the session
			session_start();

			// Create local inflector
			static::$inflector = Inflector::instance();

			// Create configuration
			$this->_configure();

			// Configure session :)
			session_set_cookie_params($this->config->sessionCookieExpireTime);
			if ($this->config->sessionRegenerateId) {
				session_regenerate_id();
			}
			
			// Apply Application's namespace
			AutoLoad::autoLoadNamespace($this->config->applicationNamespace, APP_PATH);

			// Auto load modules?
			if ($this->config->autoLoadModules == true) {
				$this->_loadModules();
			}

			// Create request
			$this->_request = new Request();
			
			// Check if static file exists?
			if ($this->config->staticThroughChickenWire && $this->_request->rawUri != '') {
			
				// In application?
				$filename = PUBLIC_PATH . $this->_request->rawUri;
				if (file_exists($filename)) {
					
					// Mime available?
					$mime = Mime::byFile($filename);
					
					// Send header
					Http::sendMimeType($mime);
					echo file_get_contents($filename);
					die;

				}

				// In modules
				foreach (Module::all() as $module) {

					// In this module?
					$regex = '/^' . preg_quote($module->urlPrefix, '/') . '\/(?<url>.+)$/';
					if (preg_match($regex, $this->_request->rawUri, $matches)) {

						// Does the file exist?
						$filename = $module->path . "/Public/" . $matches['url'];
						if (file_exists($filename)) {
							
							// Mime available?
							$mime = Mime::byFile($filename);
							
							// Send header
							Http::sendMimeType($mime);
							echo file_get_contents($filename);
							die;

						}

					} 

				}

			}

			// Try to route!
			$this->_matchRoute();

		}
685568
public function boot()
    {
        $path = realpath(__DIR__ . '/../');
        $this->loadViewsFrom("{$path}/resources/views", 'datatables-helpers');
        $this->mergeConfigFrom("{$path}/resources/config/config.php", 'datatables-config');


        $this->app->make('antares.app')->namespaced(null, function (Router $router) {
            require __DIR__ . DIRECTORY_SEPARATOR . 'backend.php';
        });
    }
761907
public function boot()
	{
		if ($this->booted) return;

		array_walk($this->serviceProviders, function($p) { $p->boot(); });

		$this->bootApplication();
	}
1325455
public function boot()
    {
        $source = realpath($raw = __DIR__ . '/Config.php') ?: $raw;

        if ($this->app instanceof LaravelApplication && $this->app->runningInConsole()) {
            $this->publishes([$source => config_path('mutex.php')]);
        } elseif ($this->app instanceof LumenApplication) {
            $this->app->configure('mutex');
        }

        $this->mergeConfigFrom($source, 'mutex');
    }
855106
public function boot()
    {
        $this->app->afterResolving(ValidatesWhenResolved::class, function ($resolved) {
            $resolved->validateResolved();
        });

        $this->app->resolving(AbstractValidateDataProvider::class, function (AbstractValidateDataProvider $dataProvider, $app) {
            $dataProvider->setObject($this->resolveRequestData($app['request']));
        });
    }