File Manager

X7ROOT File Manager

Current Path: /home/gfecatvj/sites/vendor/illuminate/support/Facades

home / gfecatvj / sites / vendor / illuminate / support / Facades /

📁 ..
📄 App.php(2.34 KB)
📄 Artisan.php(1.06 KB)
📄 Auth.php(2.37 KB)
📄 Blade.php(1.57 KB)
📄 Broadcast.php(740 B)
📄 Bus.php(1.78 KB)
📄 Cache.php(1.6 KB)
📄 Config.php(557 B)
📄 Cookie.php(973 B)
📄 Crypt.php(718 B)
📄 DB.php(1.65 KB)
📄 Date.php(5.46 KB)
📄 Event.php(2.53 KB)
📄 Facade.php(5.96 KB)
📄 File.php(2.6 KB)
📄 Gate.php(1.67 KB)
📄 Hash.php(585 B)
📄 Http.php(3.04 KB)
📄 Lang.php(668 B)
📄 Log.php(1.05 KB)
📄 Mail.php(1.94 KB)
📄 Notification.php(2.01 KB)
📄 Password.php(1.11 KB)
📄 Queue.php(1.9 KB)
📄 Redirect.php(2 KB)
📄 Redis.php(625 B)
📄 Request.php(4.96 KB)
📄 Response.php(2.35 KB)
📄 Route.php(3.19 KB)
📄 Schema.php(1.59 KB)
📄 Session.php(1.37 KB)
📄 Storage.php(3.51 KB)
📄 URL.php(1.4 KB)
📄 Validator.php(733 B)
📄 View.php(1.12 KB)

Editing: Facade.php

<?php

namespace Illuminate\Support\Facades;

use Closure;
use Mockery;
use Mockery\MockInterface;
use RuntimeException;

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

/**
     * The resolved object instances.
     *
     * @var array
     */
    protected static $resolvedInstance;

/**
     * Run a Closure when the facade has been resolved.
     *
     * @param  \Closure  $callback
     * @return void
     */
    public static function resolved(Closure $callback)
    {
        $accessor = static::getFacadeAccessor();

if (static::$app->resolved($accessor) === true) {
            $callback(static::getFacadeRoot());
        }

static::$app->afterResolving($accessor, function ($service) use ($callback) {
            $callback($service);
        });
    }

/**
     * Convert the facade into a Mockery spy.
     *
     * @return \Mockery\MockInterface
     */
    public static function spy()
    {
        if (! static::isMock()) {
            $class = static::getMockableClass();

return tap($class ? Mockery::spy($class) : Mockery::spy(), function ($spy) {
                static::swap($spy);
            });
        }
    }

/**
     * Initiate a partial mock on the facade.
     *
     * @return \Mockery\MockInterface
     */
    public static function partialMock()
    {
        $name = static::getFacadeAccessor();

$mock = static::isMock()
            ? static::$resolvedInstance[$name]
            : static::createFreshMockInstance();

return $mock->makePartial();
    }

/**
     * Initiate a mock expectation on the facade.
     *
     * @return \Mockery\Expectation
     */
    public static function shouldReceive()
    {
        $name = static::getFacadeAccessor();

$mock = static::isMock()
                    ? static::$resolvedInstance[$name]
                    : static::createFreshMockInstance();

return $mock->shouldReceive(...func_get_args());
    }

/**
     * Create a fresh mock instance for the given class.
     *
     * @return \Mockery\MockInterface
     */
    protected static function createFreshMockInstance()
    {
        return tap(static::createMock(), function ($mock) {
            static::swap($mock);

$mock->shouldAllowMockingProtectedMethods();
        });
    }

/**
     * Create a fresh mock instance for the given class.
     *
     * @return \Mockery\MockInterface
     */
    protected static function createMock()
    {
        $class = static::getMockableClass();

return $class ? Mockery::mock($class) : Mockery::mock();
    }

/**
     * Determines whether a mock is set as the instance of the facade.
     *
     * @return bool
     */
    protected static function isMock()
    {
        $name = static::getFacadeAccessor();

return isset(static::$resolvedInstance[$name]) &&
               static::$resolvedInstance[$name] instanceof MockInterface;
    }

/**
     * Get the mockable class for the bound instance.
     *
     * @return string|null
     */
    protected static function getMockableClass()
    {
        if ($root = static::getFacadeRoot()) {
            return get_class($root);
        }
    }

/**
     * Hotswap the underlying instance behind the facade.
     *
     * @param  mixed  $instance
     * @return void
     */
    public static function swap($instance)
    {
        static::$resolvedInstance[static::getFacadeAccessor()] = $instance;

if (isset(static::$app)) {
            static::$app->instance(static::getFacadeAccessor(), $instance);
        }
    }

/**
     * Get the root object behind the facade.
     *
     * @return mixed
     */
    public static function getFacadeRoot()
    {
        return static::resolveFacadeInstance(static::getFacadeAccessor());
    }

/**
     * Get the registered name of the component.
     *
     * @return string
     *
     * @throws \RuntimeException
     */
    protected static function getFacadeAccessor()
    {
        throw new RuntimeException('Facade does not implement getFacadeAccessor method.');
    }

/**
     * Resolve the facade root instance from the container.
     *
     * @param  object|string  $name
     * @return mixed
     */
    protected static function resolveFacadeInstance($name)
    {
        if (is_object($name)) {
            return $name;
        }

if (isset(static::$resolvedInstance[$name])) {
            return static::$resolvedInstance[$name];
        }

if (static::$app) {
            return static::$resolvedInstance[$name] = static::$app[$name];
        }
    }

/**
     * Clear a resolved facade instance.
     *
     * @param  string  $name
     * @return void
     */
    public static function clearResolvedInstance($name)
    {
        unset(static::$resolvedInstance[$name]);
    }

/**
     * Clear all of the resolved instances.
     *
     * @return void
     */
    public static function clearResolvedInstances()
    {
        static::$resolvedInstance = [];
    }

/**
     * Get the application instance behind the facade.
     *
     * @return \Illuminate\Contracts\Foundation\Application
     */
    public static function getFacadeApplication()
    {
        return static::$app;
    }

/**
     * Set the application instance.
     *
     * @param  \Illuminate\Contracts\Foundation\Application  $app
     * @return void
     */
    public static function setFacadeApplication($app)
    {
        static::$app = $app;
    }

/**
     * Handle dynamic, static calls to the object.
     *
     * @param  string  $method
     * @param  array  $args
     * @return mixed
     *
     * @throws \RuntimeException
     */
    public static function __callStatic($method, $args)
    {
        $instance = static::getFacadeRoot();

if (! $instance) {
            throw new RuntimeException('A facade root has not been set.');
        }

return $instance->$method(...$args);
    }
}

X7ROOT File Manager

Editing: Facade.php

Upload File

Create Folder