Boot the Console application.

@return $this
506446
public function boot()
	{
		$path = $this->laravel['path'].'/config/wel.php';

		if (file_exists($path))
		{
			require $path;
		}

		// If the event dispatcher is set on the application, we will fire an event
		// with the Artisan instance to provide each listener the opportunity to
		// register their commands on this application before it gets started.
		if (isset($this->laravel['events']))
		{
			$this->laravel['events']
				->fire('artisan.start', array($this));
		}

		return $this;
	}
429676
public function boot()
    {
        // Lumen is limited, so always add the preflight.
        if ($this->isLumen()) {
            $this->app->middleware([HandlePreflight::class]);
        } else {
            $this->publishes([$this->configPath() => config_path('cors.php')]);

            /** @var \Illuminate\Foundation\Http\Kernel $kernel */
            $kernel = $this->app->make(Kernel::class);

            // When the HandleCors middleware is not attached globally, add the PreflightCheck
            if (! $kernel->hasMiddleware(HandleCors::class)) {
                $kernel->prependMiddleware(HandlePreflight::class);
            }
        }
    }
120438
public function boot() {
		Filesystem::macro('getFileName', function ($name) {
			return array_last(explode('\\', $name));
		});
		Filesystem::macro('getNamespaceFromLocation', function ($location) {
			return ucfirst(str_replace('/', '\\', $location));
		});
		Filesystem::macro('transformNamespaceToLocation', function ($location) {
            $location = str_replace('\\', '/', $location);
            $filename = array_last(explode('/', $location));
            return str_replace('/' . $filename, '', $location);
		});
		$this->app->singleton(Manager::class, function () {
			return new Manager();
		});
		$this->app->when(DatabaseAdapter::class)->needs('$connection')->give(config('database.default'));
		$this->app->singleton(DatabaseFactory::class, function () {
			return new DatabaseFactory(app(DatabaseAdapter::class));
		});
		$this->app->singleton(DatabaseManager::class, function () {
			return new DatabaseManager(app(BaseDatabaseManager::class), app(DatabaseFactory::class));
		});
		\Event::listen(TenantIdentified::class, RegisterTenant::class);
	}
1071274
public function boot()
    {
        $app = $this->app;

        $this->bootConfig();

        $app['validator']->extend('captcha', function ($attribute, $value) use ($app) {
            return $app['captcha']->verifyResponse($value, $app['request']->getClientIp());
        });

        if ($app->bound('form')) {
            $app['form']->macro('captcha', function ($attributes = []) use ($app) {
                return $app['captcha']->display($attributes, $app->getLocale());
            });
        }
    }
315611
public function boot()
    {
        // load translation files
        $this->loadTranslationsFrom(
            __DIR__.'/../../lang',
            'validation'
        );

        // registering intervention validator extension
        $this->app['validator']->resolver(function($translator, $data, $rules, $messages, $customAttributes) {

            // set the validation error messages
            foreach (get_class_methods('Intervention\Validation\Validator') as $method) {
                $key = $this->getTranslationKeyFromMethodName($method);
                $messages[$key] = $this->getErrorMessage($translator, $messages, $key);
            }

            return new ValidatorExtension($translator, $data, $rules, $messages, $customAttributes);
        });
    }
242884
public function boot()
    {
        $app = $this->app;

        // Listen to log messages.
        $app['log']->listen(function ($level, $message, $context) use ($app) {
            $app['rollbar.handler']->log($level, $message, $context);
        });
    }
1226985
public function boot()
    {
        Cache::extend('redis', function ($app, $config) {
            $store = new RedisStore(
                $app['redis'],
                Arr::get($config, 'prefix', $this->app['config']['cache.prefix']),
                Arr::get($config, 'connection', 'default')
            );

            $repository = new Repository($store);

            if ($app->bound('Illuminate\Contracts\Events\Dispatcher')) {
                $repository->setEventDispatcher(
                    $app['Illuminate\Contracts\Events\Dispatcher']
                );
            }

            return $repository;
        });
    }
614913
public function boot()
    {

        $me = $this;

        $this->app['validator']->resolver(function ($translator, $data, $rules, $messages, $attributes) use ($me) {
            $messages += $me->getMessages();

            return new Validator($translator, $data, $rules, $messages, $attributes);
        });
    }
1222689
public function bootstrap(): self
    {
        if (!$this->info->installMode()) {
            $this->getApplicationInitializer()->init($this);
            $this->emit('system.init');

            return $this;
        }

        $manager = $this->moduleManager();

        /** @var Module|null $installer */
        $installer = null;

        foreach ($manager->modules() as $module) {
            if ($module->isApplicationInstaller()) {
                if ($installer !== null) {
                    $formatText = '%s was defined as an application installer before %s';
                    $formatArgs = [$installer->name(), $module->name()];
                    throw new \RuntimeException(vsprintf($formatText, $formatArgs));
                }

                $installer = $module;
            }
        }

        if ($installer === null) {
            throw new \RuntimeException("No application installer was found");
        }

        $enabled = [$installer->name() => Module::ENABLED];

        foreach ($manager->recursiveDependencies($installer) as $module) {
            $enabled[$module->name()] = Module::ENABLED;
        }

        $this->getApplicationInitializer()->init($this);
        $manager->setStatusList($enabled);

        $this->emit('system.init');

        return $this;
    }
152521
protected function booting()
    {
        $this->setInstance();

        $this->bind('Sun\Contracts\Container\Container', $this->getContainer());

        $this->bind('Sun\Contracts\Application', $this);

        $this->config = $this->make('Sun\Support\Config');
    }
515703
private function boot() {
		list( $locations, $config ) = $this->get_engine_config();

		$loader = new Twig_Loader_Filesystem( $locations );
		$env    = new Twig_Environment( $loader, $config );

		if ( defined( 'WP_DEBUG' ) && WP_DEBUG ) {
			$env->addExtension( new Twig_Extension_Debug() );
		}

		return $env;
	}
4515
protected function boot()
    {
        try {
            Kernel::boot();
//            Kernel::debug();

            // the actual manifest
            if (true===file_exists(Kernel::getPath('app_manifest_filepath'))) {
                $manifest_data = FilesystemHelper::parseJson(Kernel::getPath('app_manifest_filepath'));
                if ($manifest_data) {
                    Kernel::setConfig($manifest_data, 'manifest');
                } else {
                    throw new \Exception(
                        sprintf('Can not parse app manifest "%s" JSON content!', Kernel::getPath('app_manifest_filepath', true))
                    );
                }
            } else {
                throw new \Exception(
                    sprintf('App manifest "%s" not found or is empty!', Kernel::getPath('app_manifest_filepath', true))
                );
            }

        } catch (\Exception $e) {
            // hard die for startup errors
            header('Content-Type: text/plain');
            echo PHP_EOL.'[WebDocBook startup error] : '.PHP_EOL;
            echo PHP_EOL."\t".$e->getMessage().PHP_EOL;
            echo PHP_EOL.'-------------------------'.PHP_EOL;
            echo 'For more info, see the documentation online at <http://webdocbook.com/>.'.PHP_EOL;
            exit(1);
        }
    }
265506
protected function bootApplication()
    {
        $this->fireAppCallbacks($this->bootingCallbacks);

        $this->booted = true;

        $this->fireAppCallbacks($this->bootedCallbacks);
    }
1195616
public function boot()
    {
        $this->app->when(PlivoChannel::class)
            ->needs(Plivo::class)
            ->give(function () {
                return new Plivo(config('services.plivo'));
            });
    }
753407
public function boot()
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                ManageIndexes::class,
            ]);
        }

        $this->app->make(EngineManager::class)->extend('mysql', function () {
            return new MySQLEngine(app(ModeContainer::class));
        });
    }
653574
public function engineReboot()
    {
        $this->executeCommandHook(__FUNCTION__, 'before');
        $this->executeExistingCommand('env:reboot');
        $this->executeCommandHook(__FUNCTION__, 'after');

        return $this;
    }
767485
public function boot()
    {
        if ($this->booted) {
            return;
        }

        array_walk($this->loadedProviders, function ($p) {
            $this->bootProvider($p);
        });

        $this->booted = true;
    }