Boot the extensions
510472
public function boot()
    {
        foreach ($this->registry->getManagers() as $em) {
            $this->em       = $em;
            $this->chain    = new MappingDriverChain();
            $this->evm      = $this->em->getEventManager();
            $this->metadata = $this->em->getConfiguration();
            $this->reader   = method_exists($this->metadata->getMetadataDriverImpl(), 'getReader')
                ? $this->metadata->getMetadataDriverImpl()->getReader()
                : false;

            if ($this->gedmo['enabled']) {
                $this->bootGedmoExtensions($this->gedmo['namespace'], $this->gedmo['all']);
            }

            foreach ($this->extensions as $extenion) {
                $this->bootExtension($extenion);
            }
        }
    }
1111156
public function boot()
    {
        /*Load views*/
        $this->loadViewsFrom(__DIR__ . '/../../resources/views', 'webed-core');
        /*Load translations*/
        $this->loadTranslationsFrom(__DIR__ . '/../../resources/lang', 'webed-core');

        $this->publishes([
            __DIR__ . '/../../resources/views' => config('view.paths')[0] . '/vendor/webed-core',
        ], 'views');
        $this->publishes([
            __DIR__ . '/../../resources/lang' => base_path('resources/lang/vendor/webed-core'),
        ], 'lang');
        $this->publishes([
            __DIR__ . '/../../config' => base_path('config'),
        ], 'config');
        $this->publishes([
            __DIR__ . '/../../resources/assets' => resource_path('assets'),
        ], 'webed-assets');
        $this->publishes([
            __DIR__ . '/../../resources/root' => base_path(),
            __DIR__ . '/../../resources/public' => public_path(),
        ], 'webed-public-assets');
    }
1206026
def install():
    
    from .core.import_hooks import ExtensionImporter
    importer = ExtensionImporter()
    sys.meta_path.append(importer)
63925
public function boot()
    {
        // Get the schedule config
        $config = $this->app->make(AbstractConfig::class);
        $scheduleConfig = $config->scheduleConfig();

        // Run only if schedule is enabled
        if (true === Arr::get($scheduleConfig, 'enabled', false)) {
            // Wait until the app is fully booted
            $this->app->booted(function () use ($scheduleConfig) {
                // Get the scheduler instance
                /** @var Schedule $schedule */
                $schedule = $this->app->make(Schedule::class);

                // Register the clear chunks with custom schedule
                $schedule->command('uploads:clear')
                    ->cron(Arr::get($scheduleConfig, 'cron', '* * * * *'));
            });
        }

        $this->registerHandlers($config->handlers());
    }
776917
public function bootExtensionComponents()
    {
        $path = __DIR__ . '/../';
        $this->addConfigComponent('antares/logger', 'antares/logger', "{$path}/resources/config");
        $this->addLanguageComponent('antares/logger', 'antares/logger', "{$path}/resources/lang");
        $this->addViewComponent('antares/logger', 'antares/logger', "{$path}/resources/views");
        $this->bootMemory();
        $this->app->register('Antares\\Logger\\Providers\\RouteServiceProvider');
        $this->attachMenu(ErrorLogBreadcrumb::class);
        $this->attachMenu(ActivityLogsBreadcrumbMenu::class);
        $this->attachMenu(RequestLogBreadcrumbMenu::class);
        $this->observeLogger();
    }
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;
	}
39213
public function boot()
    {
        $views = __DIR__.'/views';
        $this->loadViewsFrom($views, 'resource-table');

        $this->publishes([
            $views => base_path('resources/views/vendor/msieprawski/resource-table'),
        ]);

        $this->loadTranslationsFrom(__DIR__.'/lang', 'resource-table');
    }
51865
public function boot()
    {
        $config_path = function_exists('config_path') ? config_path('pushnotification.php') : 'pushnotification.php';

        $this->publishes([
            __DIR__.'/../Config/config.php' => $config_path,
            __DIR__.'/../Config/iosCertificates' => config_path('iosCertificates/')
        ], 'config');
    }
474362
public function boot()
    {
        if ($this->isLumen() === false) {
            $this->publishes([
                __DIR__ . '/../../config/moderate.php' => config_path('moderate.php'),
            ]);

            $this->mergeConfigFrom(
                __DIR__ . '/../../config/moderate.php', 'moderate'
            );
        }
    }
1172236
public function boot()
    {
        // Handle config file
        // -- -- Get path
        $config_file = __DIR__ . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . '..' . DIRECTORY_SEPARATOR . 'config' . DIRECTORY_SEPARATOR . 'config.php';
        // -- -- Merge from config
        $this->mergeConfigFrom($config_file, 'potion');
        // -- -- Tell laravel that we publish this file
        $this->publishes([
            $config_file => config_path('potion.php')
        ], 'config');

        // Register blade extensions
        $this->registerBladeExtensions();

    }
579016
public function boot()
    {
        //config
        if (class_exists('Illuminate\Foundation\Application', false)) {
            $this->publishes([ __DIR__ . '/config.php' => config_path('slack-output.php') ]);
        }

        //command
        $this->commands(Command\SlackPost::class, Command\SlackStats::class);
    }
1059125
function startupExtension(done) {
            if (self.closed) return done(null);

            self.extension = new Extension(options, done);
            self.extension.on('error', handlers.relayError);
        }
1098785
public function boot()
    {
        $this->publishes(
            [
                $this->getConfigPath() => config_path('vanilla-integration.php'),
            ],
            'config'
        );
        $this->loadRoutesFrom(__DIR__ . '/../../../routes/routes.php');
        $this->registerHelpers();
    }
663026
public function boot()
    {
        $this->publishes([
            __DIR__.'/notifications.php' => config_path('notifications.php'),
        ], 'config');

        $this->publishes([
            __DIR__.'/../resources/css' => public_path('css'),
            __DIR__.'/../resources/js' => public_path('js'),
        ], 'assets');

        $this->getBladeCompiler()
            ->directive('notifications', function () {
                $expression = 'Gloudemans\Notify\Notifications\Notification';

                return "<?php echo app('{$expression}')->render(); ?>";
            });
    }
981201
public function boot()
    {
        foreach ($this->getFiles() as $filename) {
            $path = $this->path . '/' . $filename;
            
            if (file_exists($path)) {
                require $path;
            };
        }
    }
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;
        }
    }
854918
protected function boot(): void
    {
        // boot extensions
        foreach ($this->extensionManager->getExtensions() as $extension) {
            if ($extension->isActivated()) {
                $extension->boot();
            }
        }

        // boot app
        $this->dispatch(new RoutesWillBeLoaded($this->router));
        $this->dispatch(new RoutesHaveBeenLoaded($this->router));

        // send back responses
        try {
            $response = $this->router->getResponse();
            $response->send();
        } catch (RouteNotFoundException $exception) {
            throw new HttpNotFoundException();
        } catch (ResourceNotFoundException $exception) {
            throw new HttpNotFoundException();
        } catch (MethodNotAllowedException $exception) {
            throw new HttpMethodNotAllowedException();
        }
    }