Файл: vendor/laravel/framework/src/Illuminate/Foundation/Configuration/ApplicationBuilder.php
Строк: 610
<?php
namespace IlluminateFoundationConfiguration;
use Closure;
use IlluminateConsoleApplication as Artisan;
use IlluminateConsoleSchedulingSchedule;
use IlluminateContractsConsoleKernel as ConsoleKernel;
use IlluminateContractsHttpKernel as HttpKernel;
use IlluminateFoundationApplication;
use IlluminateFoundationBootstrapRegisterProviders;
use IlluminateFoundationEventsDiagnosingHealth;
use IlluminateFoundationHttpMiddlewarePreventRequestsDuringMaintenance;
use IlluminateFoundationSupportProvidersEventServiceProvider as AppEventServiceProvider;
use IlluminateFoundationSupportProvidersRouteServiceProvider as AppRouteServiceProvider;
use IlluminateHttpMiddlewarePrefersJsonResponses;
use IlluminateHttpRequest;
use IlluminateSupportCollection;
use IlluminateSupportFacadesBroadcast;
use IlluminateSupportFacadesEvent;
use IlluminateSupportFacadesRoute;
use IlluminateSupportFacadesView;
use LaravelFolioFolio;
class ApplicationBuilder
{
/**
* The service provider that are marked for registration.
*
* @var array
*/
protected array $pendingProviders = [];
/**
* Any additional routing callbacks that should be invoked while registering routes.
*
* @var array
*/
protected array $additionalRoutingCallbacks = [];
/**
* The Folio / page middleware that have been defined by the user.
*
* @var array
*/
protected array $pageMiddleware = [];
/**
* Create a new application builder instance.
*/
public function __construct(protected Application $app)
{
}
/**
* Register the standard kernel classes for the application.
*
* @return $this
*/
public function withKernels()
{
$this->app->singleton(
IlluminateContractsHttpKernel::class,
IlluminateFoundationHttpKernel::class,
);
$this->app->singleton(
IlluminateContractsConsoleKernel::class,
IlluminateFoundationConsoleKernel::class,
);
return $this;
}
/**
* Register additional service providers.
*
* @param array $providers
* @param bool $withBootstrapProviders
* @return $this
*/
public function withProviders(array $providers = [], bool $withBootstrapProviders = true)
{
RegisterProviders::merge(
$providers,
$withBootstrapProviders
? $this->app->getBootstrapProvidersPath()
: null
);
return $this;
}
/**
* Register the core event service provider for the application.
*
* @param iterable<int, string>|bool $discover
* @return $this
*/
public function withEvents(iterable|bool $discover = true)
{
if (is_iterable($discover)) {
AppEventServiceProvider::setEventDiscoveryPaths($discover);
}
if ($discover === false) {
AppEventServiceProvider::disableEventDiscovery();
}
if (! isset($this->pendingProviders[AppEventServiceProvider::class])) {
$this->app->booting(function () {
$this->app->register(AppEventServiceProvider::class);
});
}
$this->pendingProviders[AppEventServiceProvider::class] = true;
return $this;
}
/**
* Register the broadcasting services for the application.
*
* @param string $channels
* @param array $attributes
* @return $this
*/
public function withBroadcasting(string $channels, array $attributes = [])
{
$this->app->booted(function () use ($channels, $attributes) {
Broadcast::routes(! empty($attributes) ? $attributes : null);
if (file_exists($channels)) {
require $channels;
}
});
return $this;
}
/**
* Register the routing services for the application.
*
* @param Closure|null $using
* @param array|string|null $web
* @param array|string|null $api
* @param string|null $commands
* @param string|null $channels
* @param string|null $pages
* @param string|null $health
* @param string $apiPrefix
* @param callable|null $then
* @return $this
*/
public function withRouting(?Closure $using = null,
array|string|null $web = null,
array|string|null $api = null,
?string $commands = null,
?string $channels = null,
?string $pages = null,
?string $health = null,
string $apiPrefix = 'api',
?callable $then = null)
{
if (is_null($using) && (is_string($web) || is_array($web) || is_string($api) || is_array($api) || is_string($pages) || is_string($health)) || is_callable($then)) {
$using = $this->buildRoutingCallback($web, $api, $pages, $health, $apiPrefix, $then);
if (is_string($health)) {
PreventRequestsDuringMaintenance::except($health);
}
}
AppRouteServiceProvider::loadRoutesUsing($using);
$this->app->booting(function () {
$this->app->register(AppRouteServiceProvider::class, force: true);
});
if (is_string($commands) && realpath($commands) !== false) {
$this->withCommands([$commands]);
}
if (is_string($channels) && realpath($channels) !== false) {
$this->withBroadcasting($channels);
}
return $this;
}
/**
* Create the routing callback for the application.
*
* @param array|string|null $web
* @param array|string|null $api
* @param string|null $pages
* @param string|null $health
* @param string $apiPrefix
* @param callable|null $then
* @return Closure
*
* @throws Throwable
*/
protected function buildRoutingCallback(array|string|null $web,
array|string|null $api,
?string $pages,
?string $health,
string $apiPrefix,
?callable $then)
{
return function () use ($web, $api, $pages, $health, $apiPrefix, $then) {
if (is_string($api) || is_array($api)) {
if (is_array($api)) {
foreach ($api as $apiRoute) {
if (realpath($apiRoute) !== false) {
Route::middleware('api')->prefix($apiPrefix)->group($apiRoute);
}
}
} else {
Route::middleware('api')->prefix($apiPrefix)->group($api);
}
}
if (is_string($health)) {
Route::get($health, function (Request $request) {
$exception = null;
try {
Event::dispatch(new DiagnosingHealth);
} catch (Throwable $e) {
if (app()->hasDebugModeEnabled()) {
throw $e;
}
report($e);
$exception = $e->getMessage();
}
$status = $exception ? 500 : 200;
if ($request->expectsJson()) {
return response()->json([
'status' => $exception ? 'down' : 'up',
], $status);
}
return response(View::file(__DIR__.'/../resources/health-up.blade.php', [
'exception' => $exception,
]), status: $status);
});
}
if (is_string($web) || is_array($web)) {
if (is_array($web)) {
foreach ($web as $webRoute) {
if (realpath($webRoute) !== false) {
Route::middleware('web')->group($webRoute);
}
}
} else {
Route::middleware('web')->group($web);
}
}
foreach ($this->additionalRoutingCallbacks as $callback) {
$callback();
}
if (is_string($pages) &&
realpath($pages) !== false &&
class_exists(Folio::class)) {
Folio::route($pages, middleware: $this->pageMiddleware);
}
if (is_callable($then)) {
$then($this->app);
}
};
}
/**
* Register the global middleware, middleware groups, and middleware aliases for the application.
*
* @param callable|null $callback
* @return $this
*/
public function withMiddleware(?callable $callback = null)
{
$this->app->afterResolving(HttpKernel::class, function ($kernel) use ($callback) {
$middleware = (new Middleware)
->redirectGuestsTo(fn () => route('login'));
if (! is_null($callback)) {
$callback($middleware);
}
$this->pageMiddleware = $middleware->getPageMiddleware();
$kernel->setGlobalMiddleware($middleware->getGlobalMiddleware());
$kernel->setMiddlewareGroups($middleware->getMiddlewareGroups());
$kernel->setMiddlewareAliases($middleware->getMiddlewareAliases());
if ($priorities = $middleware->getMiddlewarePriority()) {
$kernel->setMiddlewarePriority($priorities);
}
if ($priorityAppends = $middleware->getMiddlewarePriorityAppends()) {
foreach ($priorityAppends as $newMiddleware => $after) {
$kernel->addToMiddlewarePriorityAfter($after, $newMiddleware);
}
}
if ($priorityPrepends = $middleware->getMiddlewarePriorityPrepends()) {
foreach ($priorityPrepends as $newMiddleware => $before) {
$kernel->addToMiddlewarePriorityBefore($before, $newMiddleware);
}
}
});
$this->app->afterResolving(ConsoleKernel::class, function () use ($callback) {
if (! is_null($callback)) {
$callback(new Middleware);
}
});
return $this;
}
/**
* Register additional Artisan commands with the application.
*
* @param array $commands
* @return $this
*/
public function withCommands(array $commands = [])
{
if (empty($commands)) {
$commands = [$this->app->path('Console/Commands')];
}
$this->app->afterResolving(ConsoleKernel::class, function ($kernel) use ($commands) {
[$commands, $paths] = (new Collection($commands))->partition(fn ($command) => class_exists($command));
[$routes, $paths] = $paths->partition(fn ($path) => is_file($path));
$this->app->booted(static function () use ($kernel, $commands, $paths, $routes) {
$kernel->addCommands($commands->all());
$kernel->addCommandPaths($paths->all());
$kernel->addCommandRoutePaths($routes->all());
});
});
return $this;
}
/**
* Register additional Artisan route paths.
*
* @param array $paths
* @return $this
*/
protected function withCommandRouting(array $paths)
{
$this->app->afterResolving(ConsoleKernel::class, function ($kernel) use ($paths) {
$this->app->booted(fn () => $kernel->addCommandRoutePaths($paths));
});
return $this;
}
/**
* Register the scheduled tasks for the application.
*
* @param callable(IlluminateConsoleSchedulingSchedule $schedule): void $callback
* @return $this
*/
public function withSchedule(callable $callback)
{
Artisan::starting(function () use ($callback) {
$this->app->afterResolving(Schedule::class, fn ($schedule) => $callback($schedule));
if ($this->app->resolved(Schedule::class)) {
$callback($this->app->make(Schedule::class));
}
});
return $this;
}
/**
* Register and configure the application's exception handler.
*
* @param callable(IlluminateFoundationConfigurationExceptions)|null $using
* @return $this
*/
public function withExceptions(?callable $using = null)
{
$this->app->singleton(
IlluminateContractsDebugExceptionHandler::class,
IlluminateFoundationExceptionsHandler::class
);
if ($using !== null) {
$this->app->afterResolving(
IlluminateFoundationExceptionsHandler::class,
fn ($handler) => $using(new Exceptions($handler)),
);
}
return $this;
}
/**
* Register an array of container bindings to be bound when the application is booting.
*
* @param array $bindings
* @return $this
*/
public function withBindings(array $bindings)
{
return $this->registered(function ($app) use ($bindings) {
foreach ($bindings as $abstract => $concrete) {
$app->bind($abstract, $concrete);
}
});
}
/**
* Register an array of singleton container bindings to be bound when the application is booting.
*
* @param array $singletons
* @return $this
*/
public function withSingletons(array $singletons)
{
return $this->registered(function ($app) use ($singletons) {
foreach ($singletons as $abstract => $concrete) {
if (is_string($abstract)) {
$app->singleton($abstract, $concrete);
} else {
$app->singleton($concrete);
}
}
});
}
/**
* Register an array of scoped singleton container bindings to be bound when the application is booting.
*
* @param array $scopedSingletons
* @return $this
*/
public function withScopedSingletons(array $scopedSingletons)
{
return $this->registered(function ($app) use ($scopedSingletons) {
foreach ($scopedSingletons as $abstract => $concrete) {
if (is_string($abstract)) {
$app->scoped($abstract, $concrete);
} else {
$app->scoped($concrete);
}
}
});
}
/**
* Globally prefer JSON responses when the incoming "Accept" header is broad.
*
* @param bool $prefer
* @return $this
*/
public function prefersJsonResponses(bool $prefer = true)
{
if (! $prefer) {
return $this;
}
$this->app->booted(function () {
$this->app->make(HttpKernel::class)->prependMiddleware(PrefersJsonResponses::class);
});
return $this;
}
/**
* Register a callback to be invoked when the application's service providers are registered.
*
* @param callable $callback
* @return $this
*/
public function registered(callable $callback)
{
$this->app->registered($callback);
return $this;
}
/**
* Register a callback to be invoked when the application is "booting".
*
* @param callable $callback
* @return $this
*/
public function booting(callable $callback)
{
$this->app->booting($callback);
return $this;
}
/**
* Register a callback to be invoked when the application is "booted".
*
* @param callable $callback
* @return $this
*/
public function booted(callable $callback)
{
$this->app->booted($callback);
return $this;
}
/**
* Get the application instance.
*
* @return IlluminateFoundationApplication
*/
public function create()
{
return $this->app;
}
}