Enter a bootstrap environment context.

@return void
359160
public function enterContext(): void
    {
        if (Input::get('act') === 'edit') {
            $model = GridModel::findByPk(Input::get('id'));

            if ($model) {
                $this->environment->enterContext(ThemeContext::forTheme((int) $model->pid));
            }
        }
    }
67826
protected function bootstrap()
    {
        foreach (static::$bootstrappers as $bootstrapper) {
            try{
                $bootstrapper($this);
            }catch (\Exception $e){
                echo $e->getMessage();
            }
        }
    }
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;
        }
    }
953379
public function boot() : void {
		$this->publishes([
			__DIR__ . '/../config/config.php' => config_path('basset.php')
		]);

		// If debugging is disabled we'll use a null handler to essentially send all logged
		// messages into a blackhole.
		if ( ! $this->app['config']->get('basset.debug', false)) {
			$handler = new NullHandler(MonologLogger::WARNING);

			$this->app['basset.log']->getMonolog()->pushHandler($handler);
		}

		$this->app->instance('basset.path.build', $this->app['path.public'].'/'.$this->app['config']->get('basset.build_path'));

		$this->registerBladeExtensions();

		// Collections can be defined as an array in the configuration file. We'll register
		// this array of collections with the environment.
		$this->app['basset']->collections($this->app['config']->get('basset.collections', []));

		// Load the local manifest that contains the fingerprinted paths to both production
		// and development builds.
		$this->app['basset.manifest']->load();
	}
281458
public function bootstrap()
    {
        $this->services = $this->app->config('provider');

        if(!is_null($services = $this->services)) {
            foreach($services as $service) {
                $this->app->make($service)->bootstrap();
            }
        }
    }
157750
public function boot()
    {
        $configPath = __DIR__.'/../../config/config.php';
        $configKey = 'localization-js';

        // Determines Laravel major version.
        $app = $this->app;
        $laravelMajorVersion = (int) $app::VERSION;

        // Publishes Laravel-JS-Localization package files and merge user and
        // package configurations.
        if ($laravelMajorVersion === 4) {
            $config = $this->app['config']->get($configKey, []);
            $this->app['config']->set($configKey, array_merge(require $configPath, $config));
        } elseif ($laravelMajorVersion === 5) {
            $this->publishes([
                $configPath => config_path("$configKey.php"),
            ]);
            $this->mergeConfigFrom(
                $configPath, $configKey
            );
        }
    }
423756
public function boot()
    {

        // If we are in debug mode, listen to database events
        // and log queries to the log file.
        if (env('DB_DEBUG', false)) {

            DB::listen(function ($query) {

                $positional = 0;
                $full_query = '';

                foreach (str_split($query->sql) as $char) {

                    if ($char === '?') {

                        $value = $query->bindings[$positional];

                        if (is_scalar($value))
                            $full_query = $full_query . '"' . $value . '"';
                        else
                            $full_query = $full_query . '[' . gettype($value) . ']';

                        $positional++;

                    } else {

                        $full_query = $full_query . $char;

                    }
                }

                logger()->debug(' ---> QUERY DEBUG: ' . $full_query . ' <---');

            });
        }

        // Inform Laravel how to load migrations
        $this->add_migrations();
    }
419278
def bootstrap_pex_env(entry_point):
  """"""
  pex_info = _bootstrap(entry_point)

  from .environment import PEXEnvironment
  PEXEnvironment(entry_point, pex_info).activate()
713999
public function boot()
    {
        $configPath = config_path('admin.php');

        $this->publishes([
            __DIR__.'/../../config/config.php' => $configPath,
        ], 'config');

        $this->publishes([
            __DIR__.'/../../../public/' => public_path('packages/pingpong/admin/'),
        ], 'assets');

        $viewPath = base_path('resources/views/vendor/pingpong/admin/');

        $this->publishes([
            __DIR__.'/../../views/' => $viewPath,
        ], 'views');

        if (file_exists($configPath)) {
            $this->mergeConfigFrom($configPath, 'admin');
        }

        $this->loadViewsFrom([$viewPath, __DIR__.'/../../views'], 'admin');

        $langPath = base_path('resources/lang/en/admin.php');

        $this->publishes([
            __DIR__.'/../../lang/admin.php' => $langPath,
        ], 'lang');
    }
1090260
public function boot()
	{
		// Register the package namespace
		//$this->package('stolz/tidy', 'tidy'); // Only valid if config file is at src/config/config.php
		$this->app->config->package('stolz/tidy', __DIR__, 'tidy');

		// Read settings from config file
		$config = $this->app->config->get('tidy::config', []);

		// Apply config settings
		$this->app['stolz.tidy']->config($config);
	}
407622
public function boot()
    {
        $this->commands([
            AdminUIInstall::class,
        ]);

        $this->loadTranslationsFrom(__DIR__ . '/../resources/lang', 'brackets/admin-ui');
        $this->loadViewsFrom(__DIR__ . '/../resources/views', 'brackets/admin-ui');
        $this->loadRoutesFrom(__DIR__ . '/../routes/web.php');

        if ($this->app->runningInConsole()) {
            $this->publishes([
                __DIR__.'/../install-stubs/resources/js/admin' => resource_path('js/admin'),
                __DIR__.'/../install-stubs/resources/sass/admin' => resource_path('sass/admin')
            ], 'assets');

            $this->publishes([
                __DIR__.'/../install-stubs/resources/views' => resource_path('views')
            ], 'views');

            $this->publishes([
                __DIR__ . '/../install-stubs/config/wysiwyg-media.php' => config_path('wysiwyg-media.php'),
            ], 'config');

            if (!glob(base_path('database/migrations/*_create_wysiwyg_media_table.php'))) {
                $this->publishes([
                    __DIR__ . '/../install-stubs/database/migrations/create_wysiwyg_media_table.php' => database_path('migrations').'/2018_07_18_000000_create_wysiwyg_media_table.php',
                ], 'migrations');
            }
        }
    }
401524
protected function execute()
    {
        $this->bootstrap();

        $environment = $this->getOption('environment');
        $version = $this->getOption('target');
        $date = $this->getOption('date');
        $force = (bool) $this->getOption('force');
        $output = $this->getOutput();

        $config = $this->getConfig();

        if (null === $environment) {
            $environment = $config->getDefaultEnvironment();
            $output->writeln('<comment>warning</comment> no environment specified, defaulting to: ' . $environment);
        } else {
            $output->writeln('<info>using environment</info> ' . $environment);
        }

        $envOptions = $config->getEnvironment($environment);
        if (isset($envOptions['adapter'])) {
            $output->writeln('<info>using adapter</info> ' . $envOptions['adapter']);
        }

        if (isset($envOptions['wrapper'])) {
            $output->writeln('<info>using wrapper</info> ' . $envOptions['wrapper']);
        }

        if (isset($envOptions['name'])) {
            $output->writeln('<info>using database</info> ' . $envOptions['name']);
        }

        $versionOrder = $this->getConfig()->getVersionOrder();
        $output->writeln('<info>ordering by </info>' . $versionOrder . " time");

        // rollback the specified environment
        if (null === $date) {
            $targetMustMatchVersion = true;
            $target = $version;
        } else {
            $targetMustMatchVersion = false;
            $target = $date->format('YmdHis');
        }

        $start = microtime(true);
        $this->getManager()->rollback($environment, $target, $force, $targetMustMatchVersion);
        $end = microtime(true);

        $output->newline();
        $output->writeln('<comment>All Done. Took ' . sprintf('%.4fs', $end - $start) . '</comment>');
    }
217540
public function boot()
    {
        if ($this->booted) {
            return;
        }

        // Version check
        if (PHP_VERSION_ID < 50600) {
            exit('Please use PHP 5.6 or later.');
        }

        $this->bootTraits($this);

        $this->mode = $this->loadMode();

        $this->loadConfiguration($this->config);

        $this->registerProviders();

        // Set some default objects
        if ($this->container->exists('dispatcher')) {
            $this->dispatcher = $this->container->get('dispatcher');
        } else {
            $this->dispatcher = new NullObject();
        }

        $this->logger = $this->container->get('logger');

        $this->registerListeners();

        $this->registerPackages();

        $this->triggerEvent('onAfterInitialise', ['app' => $this]);

        $this->booted = true;
    }
513392
public function bootstrap()
    {

        // setup autoloader
        require SERVER_AUTOLOADER;

        // enable garbage collection
        gc_enable();

        // synchronize the application instance and register the class loaders
        $application = $this->getApplication();
        $application->registerClassLoaders();

        // register the applications annotation registries
        $application->registerAnnotationRegistries();

        // try to load the profile logger
        if ($this->profileLogger = $this->getApplication()->getInitialContext()->getLogger(LoggerUtils::PROFILE)) {
            $this->profileLogger->appendThreadContext('startup-bean-task-garbage-collector');
        }
    }
261804
public function boot()
	{
		$this->package('wardrobe/core');
		$this->setConnection();
		$this->bindRepositories();
		$this->bootCommands();

		require_once __DIR__.'/../../themeHelpers.php';
		require_once __DIR__.'/../../routes.php';
		require_once __DIR__.'/../../filters.php';
	}
96153
public function bootstrap()
    {
        $config = Zilf::$container->getShare('config');

        $this->loadConfigurationFiles($config);

        Zilf::$app->environment = $config->get('app.app_env');

        date_default_timezone_set($config->get('app.timezone', 'UTC'));

        mb_internal_encoding('UTF-8');
    }
786891
public function boot()
	{
		// Set up the framework core

		$this->initialize();

		// Configure

		$this->configure();

		// Register services in the IoC injection container

		$this->registerServices();

		// Register class aliases

		$this->registerClassAliases();

		// Load the application bootstrap file

		$this->bootstrap();

		// Boot packages

		$this->bootPackages();

		// Return application instnace

		return $this;
	}