FM / support

/home/techb158/exp.abdallabala.com/vendor/illuminate/support/

/home/techb158/exp.abdallabala.com/vendor/illuminate/support

Name	Size	Mode	Actions
Facades/	-	0755	rm
Testing/	-	0755	rm
Traits/	-	0755	rm
AggregateServiceProvider.php	995	0644	edit dl rm
Arr.php	15363	0644	edit dl rm
Carbon.php	115	0644	edit dl rm
Collection.php	52954	0644	edit dl rm
composer.json	1487	0644	edit dl rm
Composer.php	2390	0644	edit dl rm
ConfigurationUrlParser.php	4254	0644	edit dl rm
DateFactory.php	8001	0644	edit dl rm
Fluent.php	3883	0644	edit dl rm
helpers.php	32241	0644	edit dl rm
HigherOrderCollectionProxy.php	1408	0644	edit dl rm
HigherOrderTapProxy.php	665	0644	edit dl rm
HtmlString.php	699	0644	edit dl rm
InteractsWithTime.php	1588	0644	edit dl rm
LICENSE.md	1075	0644	edit dl rm
Manager.php	3567	0644	edit dl rm
MessageBag.php	9384	0644	edit dl rm
NamespacedItemResolver.php	3270	0644	edit dl rm
Optional.php	2641	0644	edit dl rm
Pluralizer.php	2522	0644	edit dl rm
ProcessUtils.php	2050	0644	edit dl rm
ServiceProvider.php	7738	0644	edit dl rm
Str.php	25287	0644	edit dl rm
ViewErrorBag.php	2622	0644	edit dl rm

Edit: /home/techb158/exp.abdallabala.com/vendor/illuminate/support/ServiceProvider.php (7738B)

<?php

namespace Illuminate\Support;

use Illuminate\Console\Application as Artisan;
use Illuminate\Contracts\Support\DeferrableProvider;

abstract class ServiceProvider
{
    /**
     * The application instance.
     *
     * @var \Illuminate\Contracts\Foundation\Application
     */
    protected $app;

/**
     * Indicates if loading of the provider is deferred.
     *
     * @deprecated Implement the \Illuminate\Contracts\Support\DeferrableProvider interface instead. Will be removed in Laravel 6.0.
     *
     * @var bool
     */
    protected $defer = false;

/**
     * The paths that should be published.
     *
     * @var array
     */
    public static $publishes = [];

/**
     * The paths that should be published by group.
     *
     * @var array
     */
    public static $publishGroups = [];

/**
     * 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()
    {
        //
    }

/**
     * Merge the given configuration with the existing configuration.
     *
     * @param  string  $path
     * @param  string  $key
     * @return void
     */
    protected function mergeConfigFrom($path, $key)
    {
        $config = $this->app['config']->get($key, []);

$this->app['config']->set($key, array_merge(require $path, $config));
    }

/**
     * Load the given routes file if routes are not already cached.
     *
     * @param  string  $path
     * @return void
     */
    protected function loadRoutesFrom($path)
    {
        if (! $this->app->routesAreCached()) {
            require $path;
        }
    }

/**
     * Register a view file namespace.
     *
     * @param  string|array  $path
     * @param  string  $namespace
     * @return void
     */
    protected function loadViewsFrom($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)) {
                    $this->app['view']->addNamespace($namespace, $appPath);
                }
            }
        }

$this->app['view']->addNamespace($namespace, $path);
    }

/**
     * Register a translation file namespace.
     *
     * @param  string  $path
     * @param  string  $namespace
     * @return void
     */
    protected function loadTranslationsFrom($path, $namespace)
    {
        $this->app['translator']->addNamespace($namespace, $path);
    }

/**
     * Register a JSON translation file path.
     *
     * @param  string  $path
     * @return void
     */
    protected function loadJsonTranslationsFrom($path)
    {
        $this->app['translator']->addJsonPath($path);
    }

/**
     * Register a database migration path.
     *
     * @param  array|string  $paths
     * @return void
     */
    protected function loadMigrationsFrom($paths)
    {
        $this->app->afterResolving('migrator', function ($migrator) use ($paths) {
            foreach ((array) $paths as $path) {
                $migrator->path($path);
            }
        });
    }

/**
     * 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  $provider
     * @param  string  $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 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->defer || $this instanceof DeferrableProvider;
    }
}

cmd: