Kick off the build

@return void
160994
public function make() {
        if (!$this->createTargetDirectory()) {
            throw new Garp_Gumball_Exception_CannotWriteTargetDirectory();
        }

        if (!$this->copySourceFilesToTargetDirectory()) {
            throw new Garp_Gumball_Exception_CannotCopySourceFiles();
        }

        // Create database dump of given environment
        if (!$this->createDataDump()) {
            throw new Garp_Gumball_Exception_DatadumpFailed();
        }

        // Create VERSION file
        $this->addVersionFile();

        // Create Under Construction index.html in public that's used when unpacking the gumball
        $this->addUnderConstructionLock();

        // Create config file which can be read @ restore time
        $this->addSettingsFile();

        // Zip target folder
        $this->createZipArchive();

        // Remove target folder
        $this->_removeTargetDirectory();
    }
877609
public function boot()
    {
        $root = __DIR__.'/../../';
        // Load views
        $this->loadViewsFrom($root . 'resources/views', 'gbrock');

        // Publish views
        $this->publishes([
            $root . 'resources/views' => base_path('resources/views/vendor/gbrock'),
        ]);

        // Publish configuration
        $this->publishes([
            $root . 'config/tables.php' => config_path('gbrock-tables.php'),
        ]);

        // Merge user config, passing in our defaults
        $this->mergeConfigFrom(
            $root . 'config/tables.php', 'gbrock-tables'
        );

        // Publish assets
//        $this->publishes([
//            $root . 'build/assets' => public_path('vendor/gbrock/tables'),
//        ], 'public');
    }
888391
public function boot()
  {
    if (!is_dir(Remember::$tokensDir)) {
      mkdir(Remember::$tokensDir, 0777, true);
    }

    $this->hasTokens();
    $this->configure();
    $this->start();
  }
1336099
public function boot()
    {
        $this->loader->loadManifest();

        foreach ($this->extensions as $extension) {
            try {
                $this->eventDispatcher->dispatch(new Booted($extension));

                $name = $extension->getPackage()->getName();

                $this->eventDispatcher->dispatch('extension.started', [$name, []]);
                $this->eventDispatcher->dispatch('extension.started: {$name}', [[]]);
                $this->eventDispatcher->dispatch(new ComponentStarted($name));

                $this->eventDispatcher->dispatch('extension.booted', [$name, []]);
                $this->eventDispatcher->dispatch('extension.booted: {$name}', [[]]);
                $this->eventDispatcher->dispatch(new ComponentBooted($name));
            } catch (Exception $e) {
                throw $e;
            }
        }

        $this->eventDispatcher->dispatch(new BootedAll());
        $this->eventDispatcher->dispatch('antares.extension: booted');
        $this->eventDispatcher->dispatch(new ComponentsBooted());

        $this->loader->writeManifest();
        $this->booted = true;
    }
282749
public function build()
    {
        $this->debug->groupCollapsed(__METHOD__);
        $this->debug->groupUncollapse();
        $str = '';
        $cfg = $this->form->cfg;
        $status = $this->form->status;
        // $printOpts   = $cfg['output'];
        // $this->debug->log('cfg', $cfg);
        $this->debug->log('status', $status);
        $strAlerts = \is_callable($cfg['buildAlerts'])
            ? \call_user_func_array($cfg['buildAlerts'], array($this->form))
            : '';
        if ($status['error']) {
            $str = $strAlerts
                .$cfg['messages']['error'];
        } elseif ($status['completed']) {
            $str = $strAlerts
                .$cfg['messages']['completed'];
        } elseif ($cfg['buildOutput']) {
            // $this->debug->warn('have buildOutput');
            $this->outputSetup();
            if (\is_callable($cfg['buildOutput'])) {
                $str = \call_user_func_array($cfg['buildOutput'], array($this->form));
            }
            if (empty($str)) {
                $this->debug->info('buildOutput callback didn\'t generate anything');
                $str = $this->buildOutput($this->form);
            }
            $str = $strAlerts
                .$this->buildHiddenFields()
                .$str;
            $str = $this->form->eventManager->publish(
                'form.buildOutput',
                $this->form,
                array('output'=>$str)
            )->getValue('output');
            if ($cfg['output']['formWrap']) {
                $attribs = $cfg['attribs'];
                if (empty($attribs['action'])) {
                    $attribs['action'] = Html::getSelfUrl();
                }
                if ($status['multipart']) {
                    $attribs['enctype'] = 'multipart/form-data';
                }
                if (\strtolower($attribs['method']) == 'get') {
                    $urlParts = \parse_url(\html_entity_decode($attribs['action']));
                    $attribs['action'] = $urlParts['path'];
                }
                #$this->debug->log('form attribs', $attribs);
                $str = '<form'.Html::buildAttribString($attribs).'>'."\n"
                    .$str
                    .'</form>'."\n";
            }
            if ($cfg['output']['filepathScript'] && \file_exists($cfg['output']['filepathScript'])) {
                $str .= '<script type="text/javascript">'
                    .\file_get_contents($cfg['output']['filepathScript'])
                    .'</script>';
            }
            if ($cfg['output']['reqDepJs']) {
                $outputScript = new OutputScript($this->form);
                $str .= $outputScript->build()."\n";
            }
        }
        $this->debug->groupEnd();
        return $str;
    }
571682
private function startup()
    {
        $this->registerSigHandlers();
        $this->pruneDeadWorkers();
        Event::trigger('beforeFirstFork', $this);
        $this->registerWorker();
    }
265506
protected function bootApplication()
    {
        $this->fireAppCallbacks($this->bootingCallbacks);

        $this->booted = true;

        $this->fireAppCallbacks($this->bootedCallbacks);
    }
359762
public function boot()
    {
        // Load configs files and publish them
        $path = __DIR__ . '/../../config';
        $this->loadYamlFrom($path, $this->namespace, $this->publish);

        // Load more configs and aliases
        parent::boot();
    }
845073
public function boot()
	{
		require $this->flyphp['path'].'/start/flyconsole.php';

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

		return $this;
	}
173733
public function boot()
    {
        $this->initMigrations();
        $this->initPermissions();
        $this->initMiddlewares();
        $this->initDirectives();
        $this->initUserObserver();
        $this->initCommands();
    }
914271
public function build()
    {
        $files = $this->filesystem->listFiles($this->directory, $this->recursive);

        $this->cache->clear();

        foreach ($files as $file) {
            $entity = $this->parseFile($file);
            if ($entity != null) $this->cache->put($entity->getIdentifier(), $entity);
        }
        
        $this->cache->persist();
    }
1054836
public function execute()
    {
        // Update the build in the database, ping any external services.
        $this->build->setStatus(Build::STATUS_RUNNING);
        $this->build->setStarted(new \DateTime());
        $this->store->save($this->build);
        $this->build->sendStatusPostback();
        $success = true;

        $previous_build = $this->build->getProject()->getPreviousBuild($this->build->getBranch());

        $previous_state = Build::STATUS_NEW;

        if ($previous_build) {
            $previous_state = $previous_build->getStatus();
        }

        try {
            // Set up the build:
            $this->setupBuild();

            // Run the core plugin stages:
            foreach (array('setup', 'test') as $stage) {
                $success &= $this->pluginExecutor->executePlugins($this->config, $stage);
            }

            // Set the status so this can be used by complete, success and failure
            // stages.
            if ($success) {
                $this->build->setStatus(Build::STATUS_SUCCESS);
            } else {
                $this->build->setStatus(Build::STATUS_FAILED);
            }


            if ($success) {
                $this->pluginExecutor->executePlugins($this->config, 'success');

                if ($previous_state == Build::STATUS_FAILED) {
                    $this->pluginExecutor->executePlugins($this->config, 'fixed');
                }

                $this->buildLogger->logSuccess(Lang::get('build_success'));
            } else {
                $this->pluginExecutor->executePlugins($this->config, 'failure');

                if ($previous_state == Build::STATUS_SUCCESS || $previous_state == Build::STATUS_NEW) {
                    $this->pluginExecutor->executePlugins($this->config, 'broken');
                }

                $this->buildLogger->logFailure(Lang::get('build_failed'));
            }
        } catch (\Exception $ex) {
            $this->build->setStatus(Build::STATUS_FAILED);
            $this->buildLogger->logFailure(Lang::get('exception') . $ex->getMessage());
        }finally{
            // Complete stage plugins are always run
            $this->pluginExecutor->executePlugins($this->config, 'complete');
        }


        // Update the build in the database, ping any external services, etc.
        $this->build->sendStatusPostback();
        $this->build->setFinished(new \DateTime());

        // Clean up:
        $this->buildLogger->log(Lang::get('removing_build'));
        $this->build->removeBuildDirectory();

        $this->store->save($this->build);
    }
1030352
public function boot()
    {
        if ($this->app instanceof Laravel && $this->app->runningInConsole()) {
            $this->bootLaravelApplication();

        } elseif ($this->app instanceof Lumen) {
            $this->bootLumenApplication();
        }

        $this->mergeConfigFrom(__DIR__ . '/../resources/config/responder.php', 'responder');

        $this->commands([
            MakeTransformer::class
        ]);

        include __DIR__ . '/helpers.php';
    }
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();
        }
    }
582247
public function boot() {

		if (!$this->booted) {

			if(!isset($this['debug'])) {
				$this['debug'] = false;
			}

			if(!isset($this['salt'])) {
				$this['salt'] = md5(__DIR__);
			}

			date_default_timezone_set($this['timezone']);

			$this->initialize();

		}

		parent::boot();
	}
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;
	}
1002512
public static function boot() : void
    {
        $container = self::getContainer();
        $container->singleton('app', $container);

        Facade::setFacadeApplication($container);
    }