ServiceProvider.php
TLDR
This file defines an abstract class ServiceProvider in the Illuminate\Support namespace. It provides methods for registering and booting service providers, merging configurations, loading routes, views, and translations, registering migrations and factories, publishing files, and managing commands.
Methods
register
This method is used to register any application services. It is empty by default and should be overridden in child classes.
booting
This method is used to register a booting callback to be run before the boot method is called. It takes a single parameter: a closure representing the booting callback.
booted
This method is used to register a booted callback to be run after the boot method is called. It takes a single parameter: a closure representing the booted callback.
callBootingCallbacks
This method is used to call the registered booting callbacks. It iterates over the booting callbacks array and calls each callback using the application instance.
callBootedCallbacks
This method is used to call the registered booted callbacks. It iterates over the booted callbacks array and calls each callback using the application instance.
mergeConfigFrom
This method is used to merge the given configuration with the existing configuration. It takes two parameters: the path to the configuration file, and the configuration key.
loadRoutesFrom
This method is used to load the given routes file if routes are not already cached. It takes a single parameter: the path to the routes file.
loadViewsFrom
This method is used to register a view file namespace. It takes two parameters: the path to the views directory, and the namespace.
loadViewComponentsAs
This method is used to register the given view components with a custom prefix. It takes two parameters: the prefix to use for the components, and an array of components.
loadTranslationsFrom
This method is used to register a translation file namespace. It takes two parameters: the path to the translations directory, and the namespace.
loadJsonTranslationsFrom
This method is used to register a JSON translation file path. It takes a single parameter: the path to the translation file.
loadMigrationsFrom
This method is used to register database migration paths. It takes a single parameter: an array or string of migration paths.
loadFactoriesFrom
This method is used to register Eloquent model factory paths. It is deprecated and will be removed in a future Laravel version. It takes a single parameter: an array or string of factory paths.
callAfterResolving
This method is used to setup an after resolving listener, or fire immediately if already resolved. It takes two parameters: the name of the service to listen to, and a callable callback function.
publishesMigrations
This method is used to register migration paths to be published by the publish command. It takes two parameters: an array of migration paths, and an optional parameter specifying the groups to include.
publishes
This method is used to register paths to be published by the publish command. It takes two parameters: an array of paths, and an optional parameter specifying the groups to include.
ensurePublishArrayInitialized
This method is used to ensure the publish array for the service provider is initialized. It takes a single parameter: the class name of the service provider.
addPublishGroup
This method is used to add a publish group or tag to the service provider. It takes two parameters: the group name, and an array of paths.
pathsToPublish
This method is used to get the paths to publish. It takes two optional parameters: the provider name and the group name. If both parameters are provided, it returns the paths for the specified provider and group. If only the group parameter is provided, it returns the paths for the specified group. If only the provider parameter is provided, it returns the paths for the specified provider. If neither parameter is provided, it returns all paths to be published.
pathsForProviderOrGroup
This method is used to get the paths for the provider or group (or both). It takes two parameters: the provider name and the group name. It returns an array of paths.
pathsForProviderAndGroup
This method is used to get the paths for the provider and group. It takes two parameters: the provider name and the group name. It returns an array of paths.
publishableProviders
This method is used to get the service providers available for publishing. It returns an array of provider names.
publishableMigrationPaths
This method is used to get the migration paths available for publishing. It returns an array of migration paths.
publishableGroups
This method is used to get the groups available for publishing. It returns an array of group names.
commands
This method is used to register the package's custom Artisan commands. It takes an array or multiple arguments of command names.
provides
This method is used to get the services provided by the provider. It returns an empty array by default and should be overridden in child classes.
when
This method is used to get the events that trigger this service provider to register. It returns an empty array by default and should be overridden in child classes.
isDeferred
This method is used to determine if the provider is deferred. It returns a boolean value.
defaultProviders
This method is used to get the default providers for a Laravel application. It returns a new instance of DefaultProviders.
addProviderToBootstrapFile
This static method is used to add the given provider to the application's provider bootstrap file. It takes two parameters: the provider name and the path to the bootstrap file. It returns a boolean value indicating whether the provider was successfully added to the file.
Classes
This file does not define any additional classes.
<?php
namespace Illuminate\Support;
use Closure;
use Illuminate\Console\Application as Artisan;
use Illuminate\Contracts\Foundation\CachesConfiguration;
use Illuminate\Contracts\Foundation\CachesRoutes;
use Illuminate\Contracts\Support\DeferrableProvider;
use Illuminate\Database\Eloquent\Factory as ModelFactory;
use Illuminate\View\Compilers\BladeCompiler;
abstract class ServiceProvider
{
/**
* The application instance.
*
* @var \Illuminate\Contracts\Foundation\Application
*/
protected $app;
/**
* All of the registered booting callbacks.
*
* @var array
*/
protected $bootingCallbacks = [];
/**
* All of the registered booted callbacks.
*
* @var array
*/
protected $bootedCallbacks = [];
/**
* The paths that should be published.
*
* @var array
*/
public static $publishes = [];
/**
* The paths that should be published by group.
*
* @var array
*/
public static $publishGroups = [];
/**
* The migration paths available for publishing.
*
* @var array
*/
protected static $publishableMigrationPaths = [];
/**
* Create a new service provider instance.
*
* @param \Illuminate\Contracts\Foundation\Application $app
* @return void
*/
public function __construct($app)
{
$this->app = $app;
}
/**
* Register any application services.
*
* @return void
*/
public function register()
{
//
}
/**
* Register a booting callback to be run before the "boot" method is called.
*
* @param \Closure $callback
* @return void
*/
public function booting(Closure $callback)
{
$this->bootingCallbacks[] = $callback;
}
/**
* Register a booted callback to be run after the "boot" method is called.
*
* @param \Closure $callback
* @return void
*/
public function booted(Closure $callback)
{
$this->bootedCallbacks[] = $callback;
}
/**
* Call the registered booting callbacks.
*
* @return void
*/
public function callBootingCallbacks()
{
$index = 0;
while ($index < count($this->bootingCallbacks)) {
$this->app->call($this->bootingCallbacks[$index]);
$index++;
}
}
/**
* Call the registered booted callbacks.
*
* @return void
*/
public function callBootedCallbacks()
{
$index = 0;
while ($index < count($this->bootedCallbacks)) {
$this->app->call($this->bootedCallbacks[$index]);
$index++;
}
}
/**
* Merge the given configuration with the existing configuration.
*
* @param string $path
* @param string $key
* @return void
*/
protected function mergeConfigFrom($path, $key)
{
if (! ($this->app instanceof CachesConfiguration && $this->app->configurationIsCached())) {
$config = $this->app->make('config');
$config->set($key, array_merge(
require $path, $config->get($key, [])
));
}
}
/**
* Load the given routes file if routes are not already cached.
*
* @param string $path
* @return void
*/
protected function loadRoutesFrom($path)
{
if (! ($this->app instanceof CachesRoutes && $this->app->routesAreCached())) {
require $path;
}
}
/**
* Register a view file namespace.
*
* @param string|array $path
* @param string $namespace
* @return void
*/
protected function loadViewsFrom($path, $namespace)
{
$this->callAfterResolving('view', function ($view) use ($path, $namespace) {
if (isset($this->app->config['view']['paths']) &&
is_array($this->app->config['view']['paths'])) {
foreach ($this->app->config['view']['paths'] as $viewPath) {
if (is_dir($appPath = $viewPath.'/vendor/'.$namespace)) {
$view->addNamespace($namespace, $appPath);
}
}
}
$view->addNamespace($namespace, $path);
});
}
/**
* Register the given view components with a custom prefix.
*
* @param string $prefix
* @param array $components
* @return void
*/
protected function loadViewComponentsAs($prefix, array $components)
{
$this->callAfterResolving(BladeCompiler::class, function ($blade) use ($prefix, $components) {
foreach ($components as $alias => $component) {
$blade->component($component, is_string($alias) ? $alias : null, $prefix);
}
});
}
/**
* Register a translation file namespace.
*
* @param string $path
* @param string $namespace
* @return void
*/
protected function loadTranslationsFrom($path, $namespace)
{
$this->callAfterResolving('translator', function ($translator) use ($path, $namespace) {
$translator->addNamespace($namespace, $path);
});
}
/**
* Register a JSON translation file path.
*
* @param string $path
* @return void
*/
protected function loadJsonTranslationsFrom($path)
{
$this->callAfterResolving('translator', function ($translator) use ($path) {
$translator->addJsonPath($path);
});
}
/**
* Register database migration paths.
*
* @param array|string $paths
* @return void
*/
protected function loadMigrationsFrom($paths)
{
$this->callAfterResolving('migrator', function ($migrator) use ($paths) {
foreach ((array) $paths as $path) {
$migrator->path($path);
}
});
}
/**
* Register Eloquent model factory paths.
*
* @deprecated Will be removed in a future Laravel version.
*
* @param array|string $paths
* @return void
*/
protected function loadFactoriesFrom($paths)
{
$this->callAfterResolving(ModelFactory::class, function ($factory) use ($paths) {
foreach ((array) $paths as $path) {
$factory->load($path);
}
});
}
/**
* Setup an after resolving listener, or fire immediately if already resolved.
*
* @param string $name
* @param callable $callback
* @return void
*/
protected function callAfterResolving($name, $callback)
{
$this->app->afterResolving($name, $callback);
if ($this->app->resolved($name)) {
$callback($this->app->make($name), $this->app);
}
}
/**
* Register migration paths to be published by the publish command.
*
* @param array $paths
* @param mixed $groups
* @return void
*/
protected function publishesMigrations(array $paths, $groups = null)
{
$this->publishes($paths, $groups);
if ($this->app->config->get('database.migrations.update_date_on_publish', false)) {
static::$publishableMigrationPaths = array_unique(array_merge(static::$publishableMigrationPaths, array_keys($paths)));
}
}
/**
* Register paths to be published by the publish command.
*
* @param array $paths
* @param mixed $groups
* @return void
*/
protected function publishes(array $paths, $groups = null)
{
$this->ensurePublishArrayInitialized($class = static::class);
static::$publishes[$class] = array_merge(static::$publishes[$class], $paths);
foreach ((array) $groups as $group) {
$this->addPublishGroup($group, $paths);
}
}
/**
* Ensure the publish array for the service provider is initialized.
*
* @param string $class
* @return void
*/
protected function ensurePublishArrayInitialized($class)
{
if (! array_key_exists($class, static::$publishes)) {
static::$publishes[$class] = [];
}
}
/**
* Add a publish group / tag to the service provider.
*
* @param string $group
* @param array $paths
* @return void
*/
protected function addPublishGroup($group, $paths)
{
if (! array_key_exists($group, static::$publishGroups)) {
static::$publishGroups[$group] = [];
}
static::$publishGroups[$group] = array_merge(
static::$publishGroups[$group], $paths
);
}
/**
* Get the paths to publish.
*
* @param string|null $provider
* @param string|null $group
* @return array
*/
public static function pathsToPublish($provider = null, $group = null)
{
if (! is_null($paths = static::pathsForProviderOrGroup($provider, $group))) {
return $paths;
}
return collect(static::$publishes)->reduce(function ($paths, $p) {
return array_merge($paths, $p);
}, []);
}
/**
* Get the paths for the provider or group (or both).
*
* @param string|null $provider
* @param string|null $group
* @return array
*/
protected static function pathsForProviderOrGroup($provider, $group)
{
if ($provider && $group) {
return static::pathsForProviderAndGroup($provider, $group);
} elseif ($group && array_key_exists($group, static::$publishGroups)) {
return static::$publishGroups[$group];
} elseif ($provider && array_key_exists($provider, static::$publishes)) {
return static::$publishes[$provider];
} elseif ($group || $provider) {
return [];
}
}
/**
* Get the paths for the provider and group.
*
* @param string $provider
* @param string $group
* @return array
*/
protected static function pathsForProviderAndGroup($provider, $group)
{
if (! empty(static::$publishes[$provider]) && ! empty(static::$publishGroups[$group])) {
return array_intersect_key(static::$publishes[$provider], static::$publishGroups[$group]);
}
return [];
}
/**
* Get the service providers available for publishing.
*
* @return array
*/
public static function publishableProviders()
{
return array_keys(static::$publishes);
}
/**
* Get the migration paths available for publishing.
*
* @return array
*/
public static function publishableMigrationPaths()
{
return static::$publishableMigrationPaths;
}
/**
* Get the groups available for publishing.
*
* @return array
*/
public static function publishableGroups()
{
return array_keys(static::$publishGroups);
}
/**
* Register the package's custom Artisan commands.
*
* @param array|mixed $commands
* @return void
*/
public function commands($commands)
{
$commands = is_array($commands) ? $commands : func_get_args();
Artisan::starting(function ($artisan) use ($commands) {
$artisan->resolveCommands($commands);
});
}
/**
* Get the services provided by the provider.
*
* @return array
*/
public function provides()
{
return [];
}
/**
* Get the events that trigger this service provider to register.
*
* @return array
*/
public function when()
{
return [];
}
/**
* Determine if the provider is deferred.
*
* @return bool
*/
public function isDeferred()
{
return $this instanceof DeferrableProvider;
}
/**
* Get the default providers for a Laravel application.
*
* @return \Illuminate\Support\DefaultProviders
*/
public static function defaultProviders()
{
return new DefaultProviders;
}
/**
* Add the given provider to the application's provider bootstrap file.
*
* @param string $provider
* @param string $path
* @return bool
*/
public static function addProviderToBootstrapFile(string $provider, string $path = null)
{
$path ??= app()->getBootstrapProvidersPath();
if (! file_exists($path)) {
return false;
}
$providers = collect(require $path)
->merge([$provider])
->unique()
->sort()
->values()
->map(fn ($p) => ' '.$p.'::class,')
->implode(PHP_EOL);
$content = '<?php
return [
'.$providers.'
];';
file_put_contents($path, $content.PHP_EOL);
return true;
}
}