gravityview / GravityView

vendor_prefixed/illuminate/filesystem/FilesystemAdapter.php

Indentation +522 added lines, -522 removed lines

@@ -29,526 +29,526 @@
  */
 class FilesystemAdapter implements FilesystemContract, CloudFilesystemContract
 {
-    /**
-     * The Flysystem filesystem implementation.
-     *
-     * @var \League\Flysystem\FilesystemInterface
-     */
-    protected $driver;
-
-    /**
-     * Create a new filesystem adapter instance.
-     *
-     * @param  \League\Flysystem\FilesystemInterface  $driver
-     * @return void
-     */
-    public function __construct(FilesystemInterface $driver)
-    {
-        $this->driver = $driver;
-    }
-
-    /**
-     * Assert that the given file exists.
-     *
-     * @param  string  $path
-     * @return void
-     */
-    public function assertExists($path)
-    {
-        PHPUnit::assertTrue(
-            $this->exists($path), "Unable to find a file at path [{$path}]."
-        );
-    }
-
-    /**
-     * Assert that the given file does not exist.
-     *
-     * @param  string  $path
-     * @return void
-     */
-    public function assertMissing($path)
-    {
-        PHPUnit::assertFalse(
-            $this->exists($path), "Found unexpected file at path [{$path}]."
-        );
-    }
-
-    /**
-     * Determine if a file exists.
-     *
-     * @param  string  $path
-     * @return bool
-     */
-    public function exists($path)
-    {
-        return $this->driver->has($path);
-    }
-
-    /**
-     * Get the full path for the file at the given "short" path.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function path($path)
-    {
-        return $this->driver->getAdapter()->getPathPrefix().$path;
-    }
-
-    /**
-     * Get the contents of a file.
-     *
-     * @param  string  $path
-     * @return string
-     *
-     * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\FileNotFoundException
-     */
-    public function get($path)
-    {
-        try {
-            return $this->driver->read($path);
-        } catch (FileNotFoundException $e) {
-            throw new ContractFileNotFoundException($path, $e->getCode(), $e);
-        }
-    }
-
-    /**
-     * Write the contents of a file.
-     *
-     * @param  string  $path
-     * @param  string|resource  $contents
-     * @param  array  $options
-     * @return bool
-     */
-    public function put($path, $contents, $options = [])
-    {
-        if (is_string($options)) {
-            $options = ['visibility' => $options];
-        }
-
-        // If the given contents is actually a file or uploaded file instance than we will
-        // automatically store the file using a stream. This provides a convenient path
-        // for the developer to store streams without managing them manually in code.
-        if ($contents instanceof File ||
-            $contents instanceof UploadedFile) {
-            return $this->putFile($path, $contents, $options);
-        }
-
-        return is_resource($contents)
-                ? $this->driver->putStream($path, $contents, $options)
-                : $this->driver->put($path, $contents, $options);
-    }
-
-    /**
-     * Store the uploaded file on the disk.
-     *
-     * @param  string  $path
-     * @param  \Illuminate\Http\File|\Illuminate\Http\UploadedFile  $file
-     * @param  array  $options
-     * @return string|false
-     */
-    public function putFile($path, $file, $options = [])
-    {
-        return $this->putFileAs($path, $file, $file->hashName(), $options);
-    }
-
-    /**
-     * Store the uploaded file on the disk with a given name.
-     *
-     * @param  string  $path
-     * @param  \Illuminate\Http\File|\Illuminate\Http\UploadedFile  $file
-     * @param  string  $name
-     * @param  array  $options
-     * @return string|false
-     */
-    public function putFileAs($path, $file, $name, $options = [])
-    {
-        $stream = fopen($file->getRealPath(), 'r+');
-
-        // Next, we will format the path of the file and store the file using a stream since
-        // they provide better performance than alternatives. Once we write the file this
-        // stream will get closed automatically by us so the developer doesn't have to.
-        $result = $this->put(
-            $path = trim($path.'/'.$name, '/'), $stream, $options
-        );
-
-        if (is_resource($stream)) {
-            fclose($stream);
-        }
-
-        return $result ? $path : false;
-    }
-
-    /**
-     * Get the visibility for the given path.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function getVisibility($path)
-    {
-        if ($this->driver->getVisibility($path) == AdapterInterface::VISIBILITY_PUBLIC) {
-            return FilesystemContract::VISIBILITY_PUBLIC;
-        }
-
-        return FilesystemContract::VISIBILITY_PRIVATE;
-    }
-
-    /**
-     * Set the visibility for the given path.
-     *
-     * @param  string  $path
-     * @param  string  $visibility
-     * @return void
-     */
-    public function setVisibility($path, $visibility)
-    {
-        return $this->driver->setVisibility($path, $this->parseVisibility($visibility));
-    }
-
-    /**
-     * Prepend to a file.
-     *
-     * @param  string  $path
-     * @param  string  $data
-     * @param  string  $separator
-     * @return int
-     */
-    public function prepend($path, $data, $separator = PHP_EOL)
-    {
-        if ($this->exists($path)) {
-            return $this->put($path, $data.$separator.$this->get($path));
-        }
-
-        return $this->put($path, $data);
-    }
-
-    /**
-     * Append to a file.
-     *
-     * @param  string  $path
-     * @param  string  $data
-     * @param  string  $separator
-     * @return int
-     */
-    public function append($path, $data, $separator = PHP_EOL)
-    {
-        if ($this->exists($path)) {
-            return $this->put($path, $this->get($path).$separator.$data);
-        }
-
-        return $this->put($path, $data);
-    }
-
-    /**
-     * Delete the file at a given path.
-     *
-     * @param  string|array  $paths
-     * @return bool
-     */
-    public function delete($paths)
-    {
-        $paths = is_array($paths) ? $paths : func_get_args();
-
-        $success = true;
-
-        foreach ($paths as $path) {
-            try {
-                if (! $this->driver->delete($path)) {
-                    $success = false;
-                }
-            } catch (FileNotFoundException $e) {
-                $success = false;
-            }
-        }
-
-        return $success;
-    }
-
-    /**
-     * Copy a file to a new location.
-     *
-     * @param  string  $from
-     * @param  string  $to
-     * @return bool
-     */
-    public function copy($from, $to)
-    {
-        return $this->driver->copy($from, $to);
-    }
-
-    /**
-     * Move a file to a new location.
-     *
-     * @param  string  $from
-     * @param  string  $to
-     * @return bool
-     */
-    public function move($from, $to)
-    {
-        return $this->driver->rename($from, $to);
-    }
-
-    /**
-     * Get the file size of a given file.
-     *
-     * @param  string  $path
-     * @return int
-     */
-    public function size($path)
-    {
-        return $this->driver->getSize($path);
-    }
-
-    /**
-     * Get the mime-type of a given file.
-     *
-     * @param  string  $path
-     * @return string|false
-     */
-    public function mimeType($path)
-    {
-        return $this->driver->getMimetype($path);
-    }
-
-    /**
-     * Get the file's last modification time.
-     *
-     * @param  string  $path
-     * @return int
-     */
-    public function lastModified($path)
-    {
-        return $this->driver->getTimestamp($path);
-    }
-
-    /**
-     * Get the URL for the file at the given path.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function url($path)
-    {
-        $adapter = $this->driver->getAdapter();
-
-        if (method_exists($adapter, 'getUrl')) {
-            return $adapter->getUrl($path);
-        } elseif ($adapter instanceof AwsS3Adapter) {
-            return $this->getAwsUrl($adapter, $path);
-        } elseif ($adapter instanceof LocalAdapter) {
-            return $this->getLocalUrl($path);
-        } else {
-            throw new RuntimeException('This driver does not support retrieving URLs.');
-        }
-    }
-
-    /**
-     * Get the URL for the file at the given path.
-     *
-     * @param  \League\Flysystem\AwsS3v3\AwsS3Adapter  $adapter
-     * @param  string  $path
-     * @return string
-     */
-    protected function getAwsUrl($adapter, $path)
-    {
-        return $adapter->getClient()->getObjectUrl(
-            $adapter->getBucket(), $adapter->getPathPrefix().$path
-        );
-    }
-
-    /**
-     * Get the URL for the file at the given path.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    protected function getLocalUrl($path)
-    {
-        $config = $this->driver->getConfig();
-
-        // If an explicit base URL has been set on the disk configuration then we will use
-        // it as the base URL instead of the default path. This allows the developer to
-        // have full control over the base path for this filesystem's generated URLs.
-        if ($config->has('url')) {
-            return rtrim($config->get('url'), '/').'/'.ltrim($path, '/');
-        }
-
-        $path = '/storage/'.$path;
-
-        // If the path contains "storage/public", it probably means the developer is using
-        // the default disk to generate the path instead of the "public" disk like they
-        // are really supposed to use. We will remove the public from this path here.
-        if (Str::contains($path, '/storage/public/')) {
-            return Str::replaceFirst('/public/', '/', $path);
-        } else {
-            return $path;
-        }
-    }
-
-    /**
-     * Get a temporary URL for the file at the given path.
-     *
-     * @param  string  $path
-     * @param  \DateTimeInterface  $expiration
-     * @param  array  $options
-     * @return string
-     */
-    public function temporaryUrl($path, $expiration, array $options = [])
-    {
-        $adapter = $this->driver->getAdapter();
-
-        if (method_exists($adapter, 'getTemporaryUrl')) {
-            return $adapter->getTemporaryUrl($path, $expiration, $options);
-        } elseif (! $adapter instanceof AwsS3Adapter) {
-            throw new RuntimeException('This driver does not support creating temporary URLs.');
-        }
-
-        $client = $adapter->getClient();
-
-        $command = $client->getCommand('GetObject', array_merge([
-            'Bucket' => $adapter->getBucket(),
-            'Key' => $adapter->getPathPrefix().$path,
-        ], $options));
-
-        return (string) $client->createPresignedRequest(
-            $command, $expiration
-        )->getUri();
-    }
-
-    /**
-     * Get an array of all files in a directory.
-     *
-     * @param  string|null  $directory
-     * @param  bool  $recursive
-     * @return array
-     */
-    public function files($directory = null, $recursive = false)
-    {
-        $contents = $this->driver->listContents($directory, $recursive);
-
-        return $this->filterContentsByType($contents, 'file');
-    }
-
-    /**
-     * Get all of the files from the given directory (recursive).
-     *
-     * @param  string|null  $directory
-     * @return array
-     */
-    public function allFiles($directory = null)
-    {
-        return $this->files($directory, true);
-    }
-
-    /**
-     * Get all of the directories within a given directory.
-     *
-     * @param  string|null  $directory
-     * @param  bool  $recursive
-     * @return array
-     */
-    public function directories($directory = null, $recursive = false)
-    {
-        $contents = $this->driver->listContents($directory, $recursive);
-
-        return $this->filterContentsByType($contents, 'dir');
-    }
-
-    /**
-     * Get all (recursive) of the directories within a given directory.
-     *
-     * @param  string|null  $directory
-     * @return array
-     */
-    public function allDirectories($directory = null)
-    {
-        return $this->directories($directory, true);
-    }
-
-    /**
-     * Create a directory.
-     *
-     * @param  string  $path
-     * @return bool
-     */
-    public function makeDirectory($path)
-    {
-        return $this->driver->createDir($path);
-    }
-
-    /**
-     * Recursively delete a directory.
-     *
-     * @param  string  $directory
-     * @return bool
-     */
-    public function deleteDirectory($directory)
-    {
-        return $this->driver->deleteDir($directory);
-    }
-
-    /**
-     * Get the Flysystem driver.
-     *
-     * @return \League\Flysystem\FilesystemInterface
-     */
-    public function getDriver()
-    {
-        return $this->driver;
-    }
-
-    /**
-     * Filter directory contents by type.
-     *
-     * @param  array  $contents
-     * @param  string  $type
-     * @return array
-     */
-    protected function filterContentsByType($contents, $type)
-    {
-        return Collection::make($contents)
-            ->where('type', $type)
-            ->pluck('path')
-            ->values()
-            ->all();
-    }
-
-    /**
-     * Parse the given visibility value.
-     *
-     * @param  string|null  $visibility
-     * @return string|null
-     *
-     * @throws \InvalidArgumentException
-     */
-    protected function parseVisibility($visibility)
-    {
-        if (is_null($visibility)) {
-            return;
-        }
-
-        switch ($visibility) {
-            case FilesystemContract::VISIBILITY_PUBLIC:
-                return AdapterInterface::VISIBILITY_PUBLIC;
-            case FilesystemContract::VISIBILITY_PRIVATE:
-                return AdapterInterface::VISIBILITY_PRIVATE;
-        }
-
-        throw new InvalidArgumentException('Unknown visibility: '.$visibility);
-    }
-
-    /**
-     * Pass dynamic methods call onto Flysystem.
-     *
-     * @param  string  $method
-     * @param  array  $parameters
-     * @return mixed
-     *
-     * @throws \BadMethodCallException
-     */
-    public function __call($method, array $parameters)
-    {
-        return call_user_func_array([$this->driver, $method], $parameters);
-    }
+	/**
+	 * The Flysystem filesystem implementation.
+	 *
+	 * @var \League\Flysystem\FilesystemInterface
+	 */
+	protected $driver;
+
+	/**
+	 * Create a new filesystem adapter instance.
+	 *
+	 * @param  \League\Flysystem\FilesystemInterface  $driver
+	 * @return void
+	 */
+	public function __construct(FilesystemInterface $driver)
+	{
+		$this->driver = $driver;
+	}
+
+	/**
+	 * Assert that the given file exists.
+	 *
+	 * @param  string  $path
+	 * @return void
+	 */
+	public function assertExists($path)
+	{
+		PHPUnit::assertTrue(
+			$this->exists($path), "Unable to find a file at path [{$path}]."
+		);
+	}
+
+	/**
+	 * Assert that the given file does not exist.
+	 *
+	 * @param  string  $path
+	 * @return void
+	 */
+	public function assertMissing($path)
+	{
+		PHPUnit::assertFalse(
+			$this->exists($path), "Found unexpected file at path [{$path}]."
+		);
+	}
+
+	/**
+	 * Determine if a file exists.
+	 *
+	 * @param  string  $path
+	 * @return bool
+	 */
+	public function exists($path)
+	{
+		return $this->driver->has($path);
+	}
+
+	/**
+	 * Get the full path for the file at the given "short" path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function path($path)
+	{
+		return $this->driver->getAdapter()->getPathPrefix().$path;
+	}
+
+	/**
+	 * Get the contents of a file.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 *
+	 * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\FileNotFoundException
+	 */
+	public function get($path)
+	{
+		try {
+			return $this->driver->read($path);
+		} catch (FileNotFoundException $e) {
+			throw new ContractFileNotFoundException($path, $e->getCode(), $e);
+		}
+	}
+
+	/**
+	 * Write the contents of a file.
+	 *
+	 * @param  string  $path
+	 * @param  string|resource  $contents
+	 * @param  array  $options
+	 * @return bool
+	 */
+	public function put($path, $contents, $options = [])
+	{
+		if (is_string($options)) {
+			$options = ['visibility' => $options];
+		}
+
+		// If the given contents is actually a file or uploaded file instance than we will
+		// automatically store the file using a stream. This provides a convenient path
+		// for the developer to store streams without managing them manually in code.
+		if ($contents instanceof File ||
+			$contents instanceof UploadedFile) {
+			return $this->putFile($path, $contents, $options);
+		}
+
+		return is_resource($contents)
+				? $this->driver->putStream($path, $contents, $options)
+				: $this->driver->put($path, $contents, $options);
+	}
+
+	/**
+	 * Store the uploaded file on the disk.
+	 *
+	 * @param  string  $path
+	 * @param  \Illuminate\Http\File|\Illuminate\Http\UploadedFile  $file
+	 * @param  array  $options
+	 * @return string|false
+	 */
+	public function putFile($path, $file, $options = [])
+	{
+		return $this->putFileAs($path, $file, $file->hashName(), $options);
+	}
+
+	/**
+	 * Store the uploaded file on the disk with a given name.
+	 *
+	 * @param  string  $path
+	 * @param  \Illuminate\Http\File|\Illuminate\Http\UploadedFile  $file
+	 * @param  string  $name
+	 * @param  array  $options
+	 * @return string|false
+	 */
+	public function putFileAs($path, $file, $name, $options = [])
+	{
+		$stream = fopen($file->getRealPath(), 'r+');
+
+		// Next, we will format the path of the file and store the file using a stream since
+		// they provide better performance than alternatives. Once we write the file this
+		// stream will get closed automatically by us so the developer doesn't have to.
+		$result = $this->put(
+			$path = trim($path.'/'.$name, '/'), $stream, $options
+		);
+
+		if (is_resource($stream)) {
+			fclose($stream);
+		}
+
+		return $result ? $path : false;
+	}
+
+	/**
+	 * Get the visibility for the given path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function getVisibility($path)
+	{
+		if ($this->driver->getVisibility($path) == AdapterInterface::VISIBILITY_PUBLIC) {
+			return FilesystemContract::VISIBILITY_PUBLIC;
+		}
+
+		return FilesystemContract::VISIBILITY_PRIVATE;
+	}
+
+	/**
+	 * Set the visibility for the given path.
+	 *
+	 * @param  string  $path
+	 * @param  string  $visibility
+	 * @return void
+	 */
+	public function setVisibility($path, $visibility)
+	{
+		return $this->driver->setVisibility($path, $this->parseVisibility($visibility));
+	}
+
+	/**
+	 * Prepend to a file.
+	 *
+	 * @param  string  $path
+	 * @param  string  $data
+	 * @param  string  $separator
+	 * @return int
+	 */
+	public function prepend($path, $data, $separator = PHP_EOL)
+	{
+		if ($this->exists($path)) {
+			return $this->put($path, $data.$separator.$this->get($path));
+		}
+
+		return $this->put($path, $data);
+	}
+
+	/**
+	 * Append to a file.
+	 *
+	 * @param  string  $path
+	 * @param  string  $data
+	 * @param  string  $separator
+	 * @return int
+	 */
+	public function append($path, $data, $separator = PHP_EOL)
+	{
+		if ($this->exists($path)) {
+			return $this->put($path, $this->get($path).$separator.$data);
+		}
+
+		return $this->put($path, $data);
+	}
+
+	/**
+	 * Delete the file at a given path.
+	 *
+	 * @param  string|array  $paths
+	 * @return bool
+	 */
+	public function delete($paths)
+	{
+		$paths = is_array($paths) ? $paths : func_get_args();
+
+		$success = true;
+
+		foreach ($paths as $path) {
+			try {
+				if (! $this->driver->delete($path)) {
+					$success = false;
+				}
+			} catch (FileNotFoundException $e) {
+				$success = false;
+			}
+		}
+
+		return $success;
+	}
+
+	/**
+	 * Copy a file to a new location.
+	 *
+	 * @param  string  $from
+	 * @param  string  $to
+	 * @return bool
+	 */
+	public function copy($from, $to)
+	{
+		return $this->driver->copy($from, $to);
+	}
+
+	/**
+	 * Move a file to a new location.
+	 *
+	 * @param  string  $from
+	 * @param  string  $to
+	 * @return bool
+	 */
+	public function move($from, $to)
+	{
+		return $this->driver->rename($from, $to);
+	}
+
+	/**
+	 * Get the file size of a given file.
+	 *
+	 * @param  string  $path
+	 * @return int
+	 */
+	public function size($path)
+	{
+		return $this->driver->getSize($path);
+	}
+
+	/**
+	 * Get the mime-type of a given file.
+	 *
+	 * @param  string  $path
+	 * @return string|false
+	 */
+	public function mimeType($path)
+	{
+		return $this->driver->getMimetype($path);
+	}
+
+	/**
+	 * Get the file's last modification time.
+	 *
+	 * @param  string  $path
+	 * @return int
+	 */
+	public function lastModified($path)
+	{
+		return $this->driver->getTimestamp($path);
+	}
+
+	/**
+	 * Get the URL for the file at the given path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function url($path)
+	{
+		$adapter = $this->driver->getAdapter();
+
+		if (method_exists($adapter, 'getUrl')) {
+			return $adapter->getUrl($path);
+		} elseif ($adapter instanceof AwsS3Adapter) {
+			return $this->getAwsUrl($adapter, $path);
+		} elseif ($adapter instanceof LocalAdapter) {
+			return $this->getLocalUrl($path);
+		} else {
+			throw new RuntimeException('This driver does not support retrieving URLs.');
+		}
+	}
+
+	/**
+	 * Get the URL for the file at the given path.
+	 *
+	 * @param  \League\Flysystem\AwsS3v3\AwsS3Adapter  $adapter
+	 * @param  string  $path
+	 * @return string
+	 */
+	protected function getAwsUrl($adapter, $path)
+	{
+		return $adapter->getClient()->getObjectUrl(
+			$adapter->getBucket(), $adapter->getPathPrefix().$path
+		);
+	}
+
+	/**
+	 * Get the URL for the file at the given path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	protected function getLocalUrl($path)
+	{
+		$config = $this->driver->getConfig();
+
+		// If an explicit base URL has been set on the disk configuration then we will use
+		// it as the base URL instead of the default path. This allows the developer to
+		// have full control over the base path for this filesystem's generated URLs.
+		if ($config->has('url')) {
+			return rtrim($config->get('url'), '/').'/'.ltrim($path, '/');
+		}
+
+		$path = '/storage/'.$path;
+
+		// If the path contains "storage/public", it probably means the developer is using
+		// the default disk to generate the path instead of the "public" disk like they
+		// are really supposed to use. We will remove the public from this path here.
+		if (Str::contains($path, '/storage/public/')) {
+			return Str::replaceFirst('/public/', '/', $path);
+		} else {
+			return $path;
+		}
+	}
+
+	/**
+	 * Get a temporary URL for the file at the given path.
+	 *
+	 * @param  string  $path
+	 * @param  \DateTimeInterface  $expiration
+	 * @param  array  $options
+	 * @return string
+	 */
+	public function temporaryUrl($path, $expiration, array $options = [])
+	{
+		$adapter = $this->driver->getAdapter();
+
+		if (method_exists($adapter, 'getTemporaryUrl')) {
+			return $adapter->getTemporaryUrl($path, $expiration, $options);
+		} elseif (! $adapter instanceof AwsS3Adapter) {
+			throw new RuntimeException('This driver does not support creating temporary URLs.');
+		}
+
+		$client = $adapter->getClient();
+
+		$command = $client->getCommand('GetObject', array_merge([
+			'Bucket' => $adapter->getBucket(),
+			'Key' => $adapter->getPathPrefix().$path,
+		], $options));
+
+		return (string) $client->createPresignedRequest(
+			$command, $expiration
+		)->getUri();
+	}
+
+	/**
+	 * Get an array of all files in a directory.
+	 *
+	 * @param  string|null  $directory
+	 * @param  bool  $recursive
+	 * @return array
+	 */
+	public function files($directory = null, $recursive = false)
+	{
+		$contents = $this->driver->listContents($directory, $recursive);
+
+		return $this->filterContentsByType($contents, 'file');
+	}
+
+	/**
+	 * Get all of the files from the given directory (recursive).
+	 *
+	 * @param  string|null  $directory
+	 * @return array
+	 */
+	public function allFiles($directory = null)
+	{
+		return $this->files($directory, true);
+	}
+
+	/**
+	 * Get all of the directories within a given directory.
+	 *
+	 * @param  string|null  $directory
+	 * @param  bool  $recursive
+	 * @return array
+	 */
+	public function directories($directory = null, $recursive = false)
+	{
+		$contents = $this->driver->listContents($directory, $recursive);
+
+		return $this->filterContentsByType($contents, 'dir');
+	}
+
+	/**
+	 * Get all (recursive) of the directories within a given directory.
+	 *
+	 * @param  string|null  $directory
+	 * @return array
+	 */
+	public function allDirectories($directory = null)
+	{
+		return $this->directories($directory, true);
+	}
+
+	/**
+	 * Create a directory.
+	 *
+	 * @param  string  $path
+	 * @return bool
+	 */
+	public function makeDirectory($path)
+	{
+		return $this->driver->createDir($path);
+	}
+
+	/**
+	 * Recursively delete a directory.
+	 *
+	 * @param  string  $directory
+	 * @return bool
+	 */
+	public function deleteDirectory($directory)
+	{
+		return $this->driver->deleteDir($directory);
+	}
+
+	/**
+	 * Get the Flysystem driver.
+	 *
+	 * @return \League\Flysystem\FilesystemInterface
+	 */
+	public function getDriver()
+	{
+		return $this->driver;
+	}
+
+	/**
+	 * Filter directory contents by type.
+	 *
+	 * @param  array  $contents
+	 * @param  string  $type
+	 * @return array
+	 */
+	protected function filterContentsByType($contents, $type)
+	{
+		return Collection::make($contents)
+			->where('type', $type)
+			->pluck('path')
+			->values()
+			->all();
+	}
+
+	/**
+	 * Parse the given visibility value.
+	 *
+	 * @param  string|null  $visibility
+	 * @return string|null
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	protected function parseVisibility($visibility)
+	{
+		if (is_null($visibility)) {
+			return;
+		}
+
+		switch ($visibility) {
+			case FilesystemContract::VISIBILITY_PUBLIC:
+				return AdapterInterface::VISIBILITY_PUBLIC;
+			case FilesystemContract::VISIBILITY_PRIVATE:
+				return AdapterInterface::VISIBILITY_PRIVATE;
+		}
+
+		throw new InvalidArgumentException('Unknown visibility: '.$visibility);
+	}
+
+	/**
+	 * Pass dynamic methods call onto Flysystem.
+	 *
+	 * @param  string  $method
+	 * @param  array  $parameters
+	 * @return mixed
+	 *
+	 * @throws \BadMethodCallException
+	 */
+	public function __call($method, array $parameters)
+	{
+		return call_user_func_array([$this->driver, $method], $parameters);
+	}
 }

vendor_prefixed/illuminate/filesystem/FilesystemManager.php

Indentation +321 added lines, -321 removed lines

@@ -27,325 +27,325 @@
  */
 class FilesystemManager implements FactoryContract
 {
-    /**
-     * The application instance.
-     *
-     * @var \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Foundation\Application
-     */
-    protected $app;
-
-    /**
-     * The array of resolved filesystem drivers.
-     *
-     * @var array
-     */
-    protected $disks = [];
-
-    /**
-     * The registered custom driver creators.
-     *
-     * @var array
-     */
-    protected $customCreators = [];
-
-    /**
-     * Create a new filesystem manager instance.
-     *
-     * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Foundation\Application  $app
-     * @return void
-     */
-    public function __construct($app)
-    {
-        $this->app = $app;
-    }
-
-    /**
-     * Get a filesystem instance.
-     *
-     * @param  string  $name
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
-     */
-    public function drive($name = null)
-    {
-        return $this->disk($name);
-    }
-
-    /**
-     * Get a filesystem instance.
-     *
-     * @param  string  $name
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
-     */
-    public function disk($name = null)
-    {
-        $name = $name ?: $this->getDefaultDriver();
-
-        return $this->disks[$name] = $this->get($name);
-    }
-
-    /**
-     * Get a default cloud filesystem instance.
-     *
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
-     */
-    public function cloud()
-    {
-        $name = $this->getDefaultCloudDriver();
-
-        return $this->disks[$name] = $this->get($name);
-    }
-
-    /**
-     * Attempt to get the disk from the local cache.
-     *
-     * @param  string  $name
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
-     */
-    protected function get($name)
-    {
-        return isset($this->disks[$name]) ? $this->disks[$name] : $this->resolve($name);
-    }
-
-    /**
-     * Resolve the given disk.
-     *
-     * @param  string  $name
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
-     *
-     * @throws \InvalidArgumentException
-     */
-    protected function resolve($name)
-    {
-        $config = $this->getConfig($name);
-
-        if (isset($this->customCreators[$config['driver']])) {
-            return $this->callCustomCreator($config);
-        }
-
-        $driverMethod = 'create'.ucfirst($config['driver']).'Driver';
-
-        if (method_exists($this, $driverMethod)) {
-            return $this->{$driverMethod}($config);
-        } else {
-            throw new InvalidArgumentException("Driver [{$config['driver']}] is not supported.");
-        }
-    }
-
-    /**
-     * Call a custom driver creator.
-     *
-     * @param  array  $config
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
-     */
-    protected function callCustomCreator(array $config)
-    {
-        $driver = $this->customCreators[$config['driver']]($this->app, $config);
-
-        if ($driver instanceof FilesystemInterface) {
-            return $this->adapt($driver);
-        }
-
-        return $driver;
-    }
-
-    /**
-     * Create an instance of the local driver.
-     *
-     * @param  array  $config
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
-     */
-    public function createLocalDriver(array $config)
-    {
-        $permissions = isset($config['permissions']) ? $config['permissions'] : [];
-
-        $links = Arr::get($config, 'links') === 'skip'
-            ? LocalAdapter::SKIP_LINKS
-            : LocalAdapter::DISALLOW_LINKS;
-
-        return $this->adapt($this->createFlysystem(new LocalAdapter(
-            $config['root'], LOCK_EX, $links, $permissions
-        ), $config));
-    }
-
-    /**
-     * Create an instance of the ftp driver.
-     *
-     * @param  array  $config
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
-     */
-    public function createFtpDriver(array $config)
-    {
-        $ftpConfig = Arr::only($config, [
-            'host', 'username', 'password', 'port', 'root', 'passive', 'ssl', 'timeout',
-        ]);
-
-        return $this->adapt($this->createFlysystem(
-            new FtpAdapter($ftpConfig), $config
-        ));
-    }
-
-    /**
-     * Create an instance of the Amazon S3 driver.
-     *
-     * @param  array  $config
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Cloud
-     */
-    public function createS3Driver(array $config)
-    {
-        $s3Config = $this->formatS3Config($config);
-
-        $root = isset($s3Config['root']) ? $s3Config['root'] : null;
-
-        $options = isset($config['options']) ? $config['options'] : [];
-
-        return $this->adapt($this->createFlysystem(
-            new S3Adapter(new S3Client($s3Config), $s3Config['bucket'], $root, $options), $config
-        ));
-    }
-
-    /**
-     * Format the given S3 configuration with the default options.
-     *
-     * @param  array  $config
-     * @return array
-     */
-    protected function formatS3Config(array $config)
-    {
-        $config += ['version' => 'latest'];
-
-        if ($config['key'] && $config['secret']) {
-            $config['credentials'] = Arr::only($config, ['key', 'secret']);
-        }
-
-        return $config;
-    }
-
-    /**
-     * Create an instance of the Rackspace driver.
-     *
-     * @param  array  $config
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Cloud
-     */
-    public function createRackspaceDriver(array $config)
-    {
-        $client = new Rackspace($config['endpoint'], [
-            'username' => $config['username'], 'apiKey' => $config['key'],
-        ]);
-
-        $root = isset($config['root']) ? $config['root'] : null;
-
-        return $this->adapt($this->createFlysystem(
-            new RackspaceAdapter($this->getRackspaceContainer($client, $config), $root), $config
-        ));
-    }
-
-    /**
-     * Get the Rackspace Cloud Files container.
-     *
-     * @param  \OpenCloud\Rackspace  $client
-     * @param  array  $config
-     * @return \OpenCloud\ObjectStore\Resource\Container
-     */
-    protected function getRackspaceContainer(Rackspace $client, array $config)
-    {
-        $urlType = Arr::get($config, 'url_type');
-
-        $store = $client->objectStoreService('cloudFiles', $config['region'], $urlType);
-
-        return $store->getContainer($config['container']);
-    }
-
-    /**
-     * Create a Flysystem instance with the given adapter.
-     *
-     * @param  \League\Flysystem\AdapterInterface  $adapter
-     * @param  array  $config
-     * @return \League\Flysystem\FlysystemInterface
-     */
-    protected function createFlysystem(AdapterInterface $adapter, array $config)
-    {
-        $config = Arr::only($config, ['visibility', 'disable_asserts', 'url']);
-
-        return new Flysystem($adapter, count($config) > 0 ? $config : null);
-    }
-
-    /**
-     * Adapt the filesystem implementation.
-     *
-     * @param  \League\Flysystem\FilesystemInterface  $filesystem
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
-     */
-    protected function adapt(FilesystemInterface $filesystem)
-    {
-        return new FilesystemAdapter($filesystem);
-    }
-
-    /**
-     * Set the given disk instance.
-     *
-     * @param  string  $name
-     * @param  mixed  $disk
-     * @return void
-     */
-    public function set($name, $disk)
-    {
-        $this->disks[$name] = $disk;
-    }
-
-    /**
-     * Get the filesystem connection configuration.
-     *
-     * @param  string  $name
-     * @return array
-     */
-    protected function getConfig($name)
-    {
-        return $this->app['config']["filesystems.disks.{$name}"];
-    }
-
-    /**
-     * Get the default driver name.
-     *
-     * @return string
-     */
-    public function getDefaultDriver()
-    {
-        return $this->app['config']['filesystems.default'];
-    }
-
-    /**
-     * Get the default cloud driver name.
-     *
-     * @return string
-     */
-    public function getDefaultCloudDriver()
-    {
-        return $this->app['config']['filesystems.cloud'];
-    }
-
-    /**
-     * Register a custom driver creator Closure.
-     *
-     * @param  string    $driver
-     * @param  \Closure  $callback
-     * @return $this
-     */
-    public function extend($driver, Closure $callback)
-    {
-        $this->customCreators[$driver] = $callback;
-
-        return $this;
-    }
-
-    /**
-     * Dynamically call the default driver instance.
-     *
-     * @param  string  $method
-     * @param  array   $parameters
-     * @return mixed
-     */
-    public function __call($method, $parameters)
-    {
-        return $this->disk()->$method(...$parameters);
-    }
+	/**
+	 * The application instance.
+	 *
+	 * @var \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Foundation\Application
+	 */
+	protected $app;
+
+	/**
+	 * The array of resolved filesystem drivers.
+	 *
+	 * @var array
+	 */
+	protected $disks = [];
+
+	/**
+	 * The registered custom driver creators.
+	 *
+	 * @var array
+	 */
+	protected $customCreators = [];
+
+	/**
+	 * Create a new filesystem manager instance.
+	 *
+	 * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Foundation\Application  $app
+	 * @return void
+	 */
+	public function __construct($app)
+	{
+		$this->app = $app;
+	}
+
+	/**
+	 * Get a filesystem instance.
+	 *
+	 * @param  string  $name
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
+	 */
+	public function drive($name = null)
+	{
+		return $this->disk($name);
+	}
+
+	/**
+	 * Get a filesystem instance.
+	 *
+	 * @param  string  $name
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
+	 */
+	public function disk($name = null)
+	{
+		$name = $name ?: $this->getDefaultDriver();
+
+		return $this->disks[$name] = $this->get($name);
+	}
+
+	/**
+	 * Get a default cloud filesystem instance.
+	 *
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
+	 */
+	public function cloud()
+	{
+		$name = $this->getDefaultCloudDriver();
+
+		return $this->disks[$name] = $this->get($name);
+	}
+
+	/**
+	 * Attempt to get the disk from the local cache.
+	 *
+	 * @param  string  $name
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
+	 */
+	protected function get($name)
+	{
+		return isset($this->disks[$name]) ? $this->disks[$name] : $this->resolve($name);
+	}
+
+	/**
+	 * Resolve the given disk.
+	 *
+	 * @param  string  $name
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	protected function resolve($name)
+	{
+		$config = $this->getConfig($name);
+
+		if (isset($this->customCreators[$config['driver']])) {
+			return $this->callCustomCreator($config);
+		}
+
+		$driverMethod = 'create'.ucfirst($config['driver']).'Driver';
+
+		if (method_exists($this, $driverMethod)) {
+			return $this->{$driverMethod}($config);
+		} else {
+			throw new InvalidArgumentException("Driver [{$config['driver']}] is not supported.");
+		}
+	}
+
+	/**
+	 * Call a custom driver creator.
+	 *
+	 * @param  array  $config
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
+	 */
+	protected function callCustomCreator(array $config)
+	{
+		$driver = $this->customCreators[$config['driver']]($this->app, $config);
+
+		if ($driver instanceof FilesystemInterface) {
+			return $this->adapt($driver);
+		}
+
+		return $driver;
+	}
+
+	/**
+	 * Create an instance of the local driver.
+	 *
+	 * @param  array  $config
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
+	 */
+	public function createLocalDriver(array $config)
+	{
+		$permissions = isset($config['permissions']) ? $config['permissions'] : [];
+
+		$links = Arr::get($config, 'links') === 'skip'
+			? LocalAdapter::SKIP_LINKS
+			: LocalAdapter::DISALLOW_LINKS;
+
+		return $this->adapt($this->createFlysystem(new LocalAdapter(
+			$config['root'], LOCK_EX, $links, $permissions
+		), $config));
+	}
+
+	/**
+	 * Create an instance of the ftp driver.
+	 *
+	 * @param  array  $config
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
+	 */
+	public function createFtpDriver(array $config)
+	{
+		$ftpConfig = Arr::only($config, [
+			'host', 'username', 'password', 'port', 'root', 'passive', 'ssl', 'timeout',
+		]);
+
+		return $this->adapt($this->createFlysystem(
+			new FtpAdapter($ftpConfig), $config
+		));
+	}
+
+	/**
+	 * Create an instance of the Amazon S3 driver.
+	 *
+	 * @param  array  $config
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Cloud
+	 */
+	public function createS3Driver(array $config)
+	{
+		$s3Config = $this->formatS3Config($config);
+
+		$root = isset($s3Config['root']) ? $s3Config['root'] : null;
+
+		$options = isset($config['options']) ? $config['options'] : [];
+
+		return $this->adapt($this->createFlysystem(
+			new S3Adapter(new S3Client($s3Config), $s3Config['bucket'], $root, $options), $config
+		));
+	}
+
+	/**
+	 * Format the given S3 configuration with the default options.
+	 *
+	 * @param  array  $config
+	 * @return array
+	 */
+	protected function formatS3Config(array $config)
+	{
+		$config += ['version' => 'latest'];
+
+		if ($config['key'] && $config['secret']) {
+			$config['credentials'] = Arr::only($config, ['key', 'secret']);
+		}
+
+		return $config;
+	}
+
+	/**
+	 * Create an instance of the Rackspace driver.
+	 *
+	 * @param  array  $config
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Cloud
+	 */
+	public function createRackspaceDriver(array $config)
+	{
+		$client = new Rackspace($config['endpoint'], [
+			'username' => $config['username'], 'apiKey' => $config['key'],
+		]);
+
+		$root = isset($config['root']) ? $config['root'] : null;
+
+		return $this->adapt($this->createFlysystem(
+			new RackspaceAdapter($this->getRackspaceContainer($client, $config), $root), $config
+		));
+	}
+
+	/**
+	 * Get the Rackspace Cloud Files container.
+	 *
+	 * @param  \OpenCloud\Rackspace  $client
+	 * @param  array  $config
+	 * @return \OpenCloud\ObjectStore\Resource\Container
+	 */
+	protected function getRackspaceContainer(Rackspace $client, array $config)
+	{
+		$urlType = Arr::get($config, 'url_type');
+
+		$store = $client->objectStoreService('cloudFiles', $config['region'], $urlType);
+
+		return $store->getContainer($config['container']);
+	}
+
+	/**
+	 * Create a Flysystem instance with the given adapter.
+	 *
+	 * @param  \League\Flysystem\AdapterInterface  $adapter
+	 * @param  array  $config
+	 * @return \League\Flysystem\FlysystemInterface
+	 */
+	protected function createFlysystem(AdapterInterface $adapter, array $config)
+	{
+		$config = Arr::only($config, ['visibility', 'disable_asserts', 'url']);
+
+		return new Flysystem($adapter, count($config) > 0 ? $config : null);
+	}
+
+	/**
+	 * Adapt the filesystem implementation.
+	 *
+	 * @param  \League\Flysystem\FilesystemInterface  $filesystem
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\Filesystem
+	 */
+	protected function adapt(FilesystemInterface $filesystem)
+	{
+		return new FilesystemAdapter($filesystem);
+	}
+
+	/**
+	 * Set the given disk instance.
+	 *
+	 * @param  string  $name
+	 * @param  mixed  $disk
+	 * @return void
+	 */
+	public function set($name, $disk)
+	{
+		$this->disks[$name] = $disk;
+	}
+
+	/**
+	 * Get the filesystem connection configuration.
+	 *
+	 * @param  string  $name
+	 * @return array
+	 */
+	protected function getConfig($name)
+	{
+		return $this->app['config']["filesystems.disks.{$name}"];
+	}
+
+	/**
+	 * Get the default driver name.
+	 *
+	 * @return string
+	 */
+	public function getDefaultDriver()
+	{
+		return $this->app['config']['filesystems.default'];
+	}
+
+	/**
+	 * Get the default cloud driver name.
+	 *
+	 * @return string
+	 */
+	public function getDefaultCloudDriver()
+	{
+		return $this->app['config']['filesystems.cloud'];
+	}
+
+	/**
+	 * Register a custom driver creator Closure.
+	 *
+	 * @param  string    $driver
+	 * @param  \Closure  $callback
+	 * @return $this
+	 */
+	public function extend($driver, Closure $callback)
+	{
+		$this->customCreators[$driver] = $callback;
+
+		return $this;
+	}
+
+	/**
+	 * Dynamically call the default driver instance.
+	 *
+	 * @param  string  $method
+	 * @param  array   $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		return $this->disk()->$method(...$parameters);
+	}
 }

vendor_prefixed/illuminate/filesystem/Filesystem.php

Indentation +557 added lines, -557 removed lines

@@ -16,561 +16,561 @@
 
 class Filesystem
 {
-    use Macroable;
-
-    /**
-     * Determine if a file or directory exists.
-     *
-     * @param  string  $path
-     * @return bool
-     */
-    public function exists($path)
-    {
-        return file_exists($path);
-    }
-
-    /**
-     * Get the contents of a file.
-     *
-     * @param  string  $path
-     * @param  bool  $lock
-     * @return string
-     *
-     * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\FileNotFoundException
-     */
-    public function get($path, $lock = false)
-    {
-        if ($this->isFile($path)) {
-            return $lock ? $this->sharedGet($path) : file_get_contents($path);
-        }
-
-        throw new FileNotFoundException("File does not exist at path {$path}");
-    }
-
-    /**
-     * Get contents of a file with shared access.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function sharedGet($path)
-    {
-        $contents = '';
-
-        $handle = fopen($path, 'rb');
-
-        if ($handle) {
-            try {
-                if (flock($handle, LOCK_SH)) {
-                    clearstatcache(true, $path);
-
-                    $contents = fread($handle, $this->size($path) ?: 1);
-
-                    flock($handle, LOCK_UN);
-                }
-            } finally {
-                fclose($handle);
-            }
-        }
-
-        return $contents;
-    }
-
-    /**
-     * Get the returned value of a file.
-     *
-     * @param  string  $path
-     * @return mixed
-     *
-     * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\FileNotFoundException
-     */
-    public function getRequire($path)
-    {
-        if ($this->isFile($path)) {
-            return require $path;
-        }
-
-        throw new FileNotFoundException("File does not exist at path {$path}");
-    }
-
-    /**
-     * Require the given file once.
-     *
-     * @param  string  $file
-     * @return mixed
-     */
-    public function requireOnce($file)
-    {
-        require_once $file;
-    }
-
-    /**
-     * Get the MD5 hash of the file at the given path.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function hash($path)
-    {
-        return md5_file($path);
-    }
-
-    /**
-     * Write the contents of a file.
-     *
-     * @param  string  $path
-     * @param  string  $contents
-     * @param  bool  $lock
-     * @return int
-     */
-    public function put($path, $contents, $lock = false)
-    {
-        return file_put_contents($path, $contents, $lock ? LOCK_EX : 0);
-    }
-
-    /**
-     * Prepend to a file.
-     *
-     * @param  string  $path
-     * @param  string  $data
-     * @return int
-     */
-    public function prepend($path, $data)
-    {
-        if ($this->exists($path)) {
-            return $this->put($path, $data.$this->get($path));
-        }
-
-        return $this->put($path, $data);
-    }
-
-    /**
-     * Append to a file.
-     *
-     * @param  string  $path
-     * @param  string  $data
-     * @return int
-     */
-    public function append($path, $data)
-    {
-        return file_put_contents($path, $data, FILE_APPEND);
-    }
-
-    /**
-     * Get or set UNIX mode of a file or directory.
-     *
-     * @param  string  $path
-     * @param  int  $mode
-     * @return mixed
-     */
-    public function chmod($path, $mode = null)
-    {
-        if ($mode) {
-            return chmod($path, $mode);
-        }
-
-        return substr(sprintf('%o', fileperms($path)), -4);
-    }
-
-    /**
-     * Delete the file at a given path.
-     *
-     * @param  string|array  $paths
-     * @return bool
-     */
-    public function delete($paths)
-    {
-        $paths = is_array($paths) ? $paths : func_get_args();
-
-        $success = true;
-
-        foreach ($paths as $path) {
-            try {
-                if (! @unlink($path)) {
-                    $success = false;
-                }
-            } catch (ErrorException $e) {
-                $success = false;
-            }
-        }
-
-        return $success;
-    }
-
-    /**
-     * Move a file to a new location.
-     *
-     * @param  string  $path
-     * @param  string  $target
-     * @return bool
-     */
-    public function move($path, $target)
-    {
-        return rename($path, $target);
-    }
-
-    /**
-     * Copy a file to a new location.
-     *
-     * @param  string  $path
-     * @param  string  $target
-     * @return bool
-     */
-    public function copy($path, $target)
-    {
-        return copy($path, $target);
-    }
-
-    /**
-     * Create a hard link to the target file or directory.
-     *
-     * @param  string  $target
-     * @param  string  $link
-     * @return void
-     */
-    public function link($target, $link)
-    {
-        if (! windows_os()) {
-            return symlink($target, $link);
-        }
-
-        $mode = $this->isDirectory($target) ? 'J' : 'H';
-
-        exec("mklink /{$mode} \"{$link}\" \"{$target}\"");
-    }
-
-    /**
-     * Extract the file name from a file path.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function name($path)
-    {
-        return pathinfo($path, PATHINFO_FILENAME);
-    }
-
-    /**
-     * Extract the trailing name component from a file path.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function basename($path)
-    {
-        return pathinfo($path, PATHINFO_BASENAME);
-    }
-
-    /**
-     * Extract the parent directory from a file path.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function dirname($path)
-    {
-        return pathinfo($path, PATHINFO_DIRNAME);
-    }
-
-    /**
-     * Extract the file extension from a file path.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function extension($path)
-    {
-        return pathinfo($path, PATHINFO_EXTENSION);
-    }
-
-    /**
-     * Get the file type of a given file.
-     *
-     * @param  string  $path
-     * @return string
-     */
-    public function type($path)
-    {
-        return filetype($path);
-    }
-
-    /**
-     * Get the mime-type of a given file.
-     *
-     * @param  string  $path
-     * @return string|false
-     */
-    public function mimeType($path)
-    {
-        return finfo_file(finfo_open(FILEINFO_MIME_TYPE), $path);
-    }
-
-    /**
-     * Get the file size of a given file.
-     *
-     * @param  string  $path
-     * @return int
-     */
-    public function size($path)
-    {
-        return filesize($path);
-    }
-
-    /**
-     * Get the file's last modification time.
-     *
-     * @param  string  $path
-     * @return int
-     */
-    public function lastModified($path)
-    {
-        return filemtime($path);
-    }
-
-    /**
-     * Determine if the given path is a directory.
-     *
-     * @param  string  $directory
-     * @return bool
-     */
-    public function isDirectory($directory)
-    {
-        return is_dir($directory);
-    }
-
-    /**
-     * Determine if the given path is readable.
-     *
-     * @param  string  $path
-     * @return bool
-     */
-    public function isReadable($path)
-    {
-        return is_readable($path);
-    }
-
-    /**
-     * Determine if the given path is writable.
-     *
-     * @param  string  $path
-     * @return bool
-     */
-    public function isWritable($path)
-    {
-        return is_writable($path);
-    }
-
-    /**
-     * Determine if the given path is a file.
-     *
-     * @param  string  $file
-     * @return bool
-     */
-    public function isFile($file)
-    {
-        return is_file($file);
-    }
-
-    /**
-     * Find path names matching a given pattern.
-     *
-     * @param  string  $pattern
-     * @param  int     $flags
-     * @return array
-     */
-    public function glob($pattern, $flags = 0)
-    {
-        return glob($pattern, $flags);
-    }
-
-    /**
-     * Get an array of all files in a directory.
-     *
-     * @param  string  $directory
-     * @return array
-     */
-    public function files($directory)
-    {
-        $glob = glob($directory.DIRECTORY_SEPARATOR.'*');
-
-        if ($glob === false) {
-            return [];
-        }
-
-        // To get the appropriate files, we'll simply glob the directory and filter
-        // out any "files" that are not truly files so we do not end up with any
-        // directories in our list, but only true files within the directory.
-        return array_filter($glob, function ($file) {
-            return filetype($file) == 'file';
-        });
-    }
-
-    /**
-     * Get all of the files from the given directory (recursive).
-     *
-     * @param  string  $directory
-     * @param  bool  $hidden
-     * @return array
-     */
-    public function allFiles($directory, $hidden = false)
-    {
-        return iterator_to_array(Finder::create()->files()->ignoreDotFiles(! $hidden)->in($directory), false);
-    }
-
-    /**
-     * Get all of the directories within a given directory.
-     *
-     * @param  string  $directory
-     * @return array
-     */
-    public function directories($directory)
-    {
-        $directories = [];
-
-        foreach (Finder::create()->in($directory)->directories()->depth(0) as $dir) {
-            $directories[] = $dir->getPathname();
-        }
-
-        return $directories;
-    }
-
-    /**
-     * Create a directory.
-     *
-     * @param  string  $path
-     * @param  int     $mode
-     * @param  bool    $recursive
-     * @param  bool    $force
-     * @return bool
-     */
-    public function makeDirectory($path, $mode = 0755, $recursive = false, $force = false)
-    {
-        if ($force) {
-            return @mkdir($path, $mode, $recursive);
-        }
-
-        return mkdir($path, $mode, $recursive);
-    }
-
-    /**
-     * Move a directory.
-     *
-     * @param  string  $from
-     * @param  string  $to
-     * @param  bool  $overwrite
-     * @return bool
-     */
-    public function moveDirectory($from, $to, $overwrite = false)
-    {
-        if ($overwrite && $this->isDirectory($to)) {
-            if (! $this->deleteDirectory($to)) {
-                return false;
-            }
-        }
-
-        return @rename($from, $to) === true;
-    }
-
-    /**
-     * Copy a directory from one location to another.
-     *
-     * @param  string  $directory
-     * @param  string  $destination
-     * @param  int     $options
-     * @return bool
-     */
-    public function copyDirectory($directory, $destination, $options = null)
-    {
-        if (! $this->isDirectory($directory)) {
-            return false;
-        }
-
-        $options = $options ?: FilesystemIterator::SKIP_DOTS;
-
-        // If the destination directory does not actually exist, we will go ahead and
-        // create it recursively, which just gets the destination prepared to copy
-        // the files over. Once we make the directory we'll proceed the copying.
-        if (! $this->isDirectory($destination)) {
-            $this->makeDirectory($destination, 0777, true);
-        }
-
-        $items = new FilesystemIterator($directory, $options);
-
-        foreach ($items as $item) {
-            // As we spin through items, we will check to see if the current file is actually
-            // a directory or a file. When it is actually a directory we will need to call
-            // back into this function recursively to keep copying these nested folders.
-            $target = $destination.'/'.$item->getBasename();
-
-            if ($item->isDir()) {
-                $path = $item->getPathname();
-
-                if (! $this->copyDirectory($path, $target, $options)) {
-                    return false;
-                }
-            }
-
-            // If the current items is just a regular file, we will just copy this to the new
-            // location and keep looping. If for some reason the copy fails we'll bail out
-            // and return false, so the developer is aware that the copy process failed.
-            else {
-                if (! $this->copy($item->getPathname(), $target)) {
-                    return false;
-                }
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Recursively delete a directory.
-     *
-     * The directory itself may be optionally preserved.
-     *
-     * @param  string  $directory
-     * @param  bool    $preserve
-     * @return bool
-     */
-    public function deleteDirectory($directory, $preserve = false)
-    {
-        if (! $this->isDirectory($directory)) {
-            return false;
-        }
-
-        $items = new FilesystemIterator($directory);
-
-        foreach ($items as $item) {
-            // If the item is a directory, we can just recurse into the function and
-            // delete that sub-directory otherwise we'll just delete the file and
-            // keep iterating through each file until the directory is cleaned.
-            if ($item->isDir() && ! $item->isLink()) {
-                $this->deleteDirectory($item->getPathname());
-            }
-
-            // If the item is just a file, we can go ahead and delete it since we're
-            // just looping through and waxing all of the files in this directory
-            // and calling directories recursively, so we delete the real path.
-            else {
-                $this->delete($item->getPathname());
-            }
-        }
-
-        if (! $preserve) {
-            @rmdir($directory);
-        }
-
-        return true;
-    }
-
-    /**
-     * Empty the specified directory of all files and folders.
-     *
-     * @param  string  $directory
-     * @return bool
-     */
-    public function cleanDirectory($directory)
-    {
-        return $this->deleteDirectory($directory, true);
-    }
+	use Macroable;
+
+	/**
+	 * Determine if a file or directory exists.
+	 *
+	 * @param  string  $path
+	 * @return bool
+	 */
+	public function exists($path)
+	{
+		return file_exists($path);
+	}
+
+	/**
+	 * Get the contents of a file.
+	 *
+	 * @param  string  $path
+	 * @param  bool  $lock
+	 * @return string
+	 *
+	 * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\FileNotFoundException
+	 */
+	public function get($path, $lock = false)
+	{
+		if ($this->isFile($path)) {
+			return $lock ? $this->sharedGet($path) : file_get_contents($path);
+		}
+
+		throw new FileNotFoundException("File does not exist at path {$path}");
+	}
+
+	/**
+	 * Get contents of a file with shared access.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function sharedGet($path)
+	{
+		$contents = '';
+
+		$handle = fopen($path, 'rb');
+
+		if ($handle) {
+			try {
+				if (flock($handle, LOCK_SH)) {
+					clearstatcache(true, $path);
+
+					$contents = fread($handle, $this->size($path) ?: 1);
+
+					flock($handle, LOCK_UN);
+				}
+			} finally {
+				fclose($handle);
+			}
+		}
+
+		return $contents;
+	}
+
+	/**
+	 * Get the returned value of a file.
+	 *
+	 * @param  string  $path
+	 * @return mixed
+	 *
+	 * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Filesystem\FileNotFoundException
+	 */
+	public function getRequire($path)
+	{
+		if ($this->isFile($path)) {
+			return require $path;
+		}
+
+		throw new FileNotFoundException("File does not exist at path {$path}");
+	}
+
+	/**
+	 * Require the given file once.
+	 *
+	 * @param  string  $file
+	 * @return mixed
+	 */
+	public function requireOnce($file)
+	{
+		require_once $file;
+	}
+
+	/**
+	 * Get the MD5 hash of the file at the given path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function hash($path)
+	{
+		return md5_file($path);
+	}
+
+	/**
+	 * Write the contents of a file.
+	 *
+	 * @param  string  $path
+	 * @param  string  $contents
+	 * @param  bool  $lock
+	 * @return int
+	 */
+	public function put($path, $contents, $lock = false)
+	{
+		return file_put_contents($path, $contents, $lock ? LOCK_EX : 0);
+	}
+
+	/**
+	 * Prepend to a file.
+	 *
+	 * @param  string  $path
+	 * @param  string  $data
+	 * @return int
+	 */
+	public function prepend($path, $data)
+	{
+		if ($this->exists($path)) {
+			return $this->put($path, $data.$this->get($path));
+		}
+
+		return $this->put($path, $data);
+	}
+
+	/**
+	 * Append to a file.
+	 *
+	 * @param  string  $path
+	 * @param  string  $data
+	 * @return int
+	 */
+	public function append($path, $data)
+	{
+		return file_put_contents($path, $data, FILE_APPEND);
+	}
+
+	/**
+	 * Get or set UNIX mode of a file or directory.
+	 *
+	 * @param  string  $path
+	 * @param  int  $mode
+	 * @return mixed
+	 */
+	public function chmod($path, $mode = null)
+	{
+		if ($mode) {
+			return chmod($path, $mode);
+		}
+
+		return substr(sprintf('%o', fileperms($path)), -4);
+	}
+
+	/**
+	 * Delete the file at a given path.
+	 *
+	 * @param  string|array  $paths
+	 * @return bool
+	 */
+	public function delete($paths)
+	{
+		$paths = is_array($paths) ? $paths : func_get_args();
+
+		$success = true;
+
+		foreach ($paths as $path) {
+			try {
+				if (! @unlink($path)) {
+					$success = false;
+				}
+			} catch (ErrorException $e) {
+				$success = false;
+			}
+		}
+
+		return $success;
+	}
+
+	/**
+	 * Move a file to a new location.
+	 *
+	 * @param  string  $path
+	 * @param  string  $target
+	 * @return bool
+	 */
+	public function move($path, $target)
+	{
+		return rename($path, $target);
+	}
+
+	/**
+	 * Copy a file to a new location.
+	 *
+	 * @param  string  $path
+	 * @param  string  $target
+	 * @return bool
+	 */
+	public function copy($path, $target)
+	{
+		return copy($path, $target);
+	}
+
+	/**
+	 * Create a hard link to the target file or directory.
+	 *
+	 * @param  string  $target
+	 * @param  string  $link
+	 * @return void
+	 */
+	public function link($target, $link)
+	{
+		if (! windows_os()) {
+			return symlink($target, $link);
+		}
+
+		$mode = $this->isDirectory($target) ? 'J' : 'H';
+
+		exec("mklink /{$mode} \"{$link}\" \"{$target}\"");
+	}
+
+	/**
+	 * Extract the file name from a file path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function name($path)
+	{
+		return pathinfo($path, PATHINFO_FILENAME);
+	}
+
+	/**
+	 * Extract the trailing name component from a file path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function basename($path)
+	{
+		return pathinfo($path, PATHINFO_BASENAME);
+	}
+
+	/**
+	 * Extract the parent directory from a file path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function dirname($path)
+	{
+		return pathinfo($path, PATHINFO_DIRNAME);
+	}
+
+	/**
+	 * Extract the file extension from a file path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function extension($path)
+	{
+		return pathinfo($path, PATHINFO_EXTENSION);
+	}
+
+	/**
+	 * Get the file type of a given file.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function type($path)
+	{
+		return filetype($path);
+	}
+
+	/**
+	 * Get the mime-type of a given file.
+	 *
+	 * @param  string  $path
+	 * @return string|false
+	 */
+	public function mimeType($path)
+	{
+		return finfo_file(finfo_open(FILEINFO_MIME_TYPE), $path);
+	}
+
+	/**
+	 * Get the file size of a given file.
+	 *
+	 * @param  string  $path
+	 * @return int
+	 */
+	public function size($path)
+	{
+		return filesize($path);
+	}
+
+	/**
+	 * Get the file's last modification time.
+	 *
+	 * @param  string  $path
+	 * @return int
+	 */
+	public function lastModified($path)
+	{
+		return filemtime($path);
+	}
+
+	/**
+	 * Determine if the given path is a directory.
+	 *
+	 * @param  string  $directory
+	 * @return bool
+	 */
+	public function isDirectory($directory)
+	{
+		return is_dir($directory);
+	}
+
+	/**
+	 * Determine if the given path is readable.
+	 *
+	 * @param  string  $path
+	 * @return bool
+	 */
+	public function isReadable($path)
+	{
+		return is_readable($path);
+	}
+
+	/**
+	 * Determine if the given path is writable.
+	 *
+	 * @param  string  $path
+	 * @return bool
+	 */
+	public function isWritable($path)
+	{
+		return is_writable($path);
+	}
+
+	/**
+	 * Determine if the given path is a file.
+	 *
+	 * @param  string  $file
+	 * @return bool
+	 */
+	public function isFile($file)
+	{
+		return is_file($file);
+	}
+
+	/**
+	 * Find path names matching a given pattern.
+	 *
+	 * @param  string  $pattern
+	 * @param  int     $flags
+	 * @return array
+	 */
+	public function glob($pattern, $flags = 0)
+	{
+		return glob($pattern, $flags);
+	}
+
+	/**
+	 * Get an array of all files in a directory.
+	 *
+	 * @param  string  $directory
+	 * @return array
+	 */
+	public function files($directory)
+	{
+		$glob = glob($directory.DIRECTORY_SEPARATOR.'*');
+
+		if ($glob === false) {
+			return [];
+		}
+
+		// To get the appropriate files, we'll simply glob the directory and filter
+		// out any "files" that are not truly files so we do not end up with any
+		// directories in our list, but only true files within the directory.
+		return array_filter($glob, function ($file) {
+			return filetype($file) == 'file';
+		});
+	}
+
+	/**
+	 * Get all of the files from the given directory (recursive).
+	 *
+	 * @param  string  $directory
+	 * @param  bool  $hidden
+	 * @return array
+	 */
+	public function allFiles($directory, $hidden = false)
+	{
+		return iterator_to_array(Finder::create()->files()->ignoreDotFiles(! $hidden)->in($directory), false);
+	}
+
+	/**
+	 * Get all of the directories within a given directory.
+	 *
+	 * @param  string  $directory
+	 * @return array
+	 */
+	public function directories($directory)
+	{
+		$directories = [];
+
+		foreach (Finder::create()->in($directory)->directories()->depth(0) as $dir) {
+			$directories[] = $dir->getPathname();
+		}
+
+		return $directories;
+	}
+
+	/**
+	 * Create a directory.
+	 *
+	 * @param  string  $path
+	 * @param  int     $mode
+	 * @param  bool    $recursive
+	 * @param  bool    $force
+	 * @return bool
+	 */
+	public function makeDirectory($path, $mode = 0755, $recursive = false, $force = false)
+	{
+		if ($force) {
+			return @mkdir($path, $mode, $recursive);
+		}
+
+		return mkdir($path, $mode, $recursive);
+	}
+
+	/**
+	 * Move a directory.
+	 *
+	 * @param  string  $from
+	 * @param  string  $to
+	 * @param  bool  $overwrite
+	 * @return bool
+	 */
+	public function moveDirectory($from, $to, $overwrite = false)
+	{
+		if ($overwrite && $this->isDirectory($to)) {
+			if (! $this->deleteDirectory($to)) {
+				return false;
+			}
+		}
+
+		return @rename($from, $to) === true;
+	}
+
+	/**
+	 * Copy a directory from one location to another.
+	 *
+	 * @param  string  $directory
+	 * @param  string  $destination
+	 * @param  int     $options
+	 * @return bool
+	 */
+	public function copyDirectory($directory, $destination, $options = null)
+	{
+		if (! $this->isDirectory($directory)) {
+			return false;
+		}
+
+		$options = $options ?: FilesystemIterator::SKIP_DOTS;
+
+		// If the destination directory does not actually exist, we will go ahead and
+		// create it recursively, which just gets the destination prepared to copy
+		// the files over. Once we make the directory we'll proceed the copying.
+		if (! $this->isDirectory($destination)) {
+			$this->makeDirectory($destination, 0777, true);
+		}
+
+		$items = new FilesystemIterator($directory, $options);
+
+		foreach ($items as $item) {
+			// As we spin through items, we will check to see if the current file is actually
+			// a directory or a file. When it is actually a directory we will need to call
+			// back into this function recursively to keep copying these nested folders.
+			$target = $destination.'/'.$item->getBasename();
+
+			if ($item->isDir()) {
+				$path = $item->getPathname();
+
+				if (! $this->copyDirectory($path, $target, $options)) {
+					return false;
+				}
+			}
+
+			// If the current items is just a regular file, we will just copy this to the new
+			// location and keep looping. If for some reason the copy fails we'll bail out
+			// and return false, so the developer is aware that the copy process failed.
+			else {
+				if (! $this->copy($item->getPathname(), $target)) {
+					return false;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Recursively delete a directory.
+	 *
+	 * The directory itself may be optionally preserved.
+	 *
+	 * @param  string  $directory
+	 * @param  bool    $preserve
+	 * @return bool
+	 */
+	public function deleteDirectory($directory, $preserve = false)
+	{
+		if (! $this->isDirectory($directory)) {
+			return false;
+		}
+
+		$items = new FilesystemIterator($directory);
+
+		foreach ($items as $item) {
+			// If the item is a directory, we can just recurse into the function and
+			// delete that sub-directory otherwise we'll just delete the file and
+			// keep iterating through each file until the directory is cleaned.
+			if ($item->isDir() && ! $item->isLink()) {
+				$this->deleteDirectory($item->getPathname());
+			}
+
+			// If the item is just a file, we can go ahead and delete it since we're
+			// just looping through and waxing all of the files in this directory
+			// and calling directories recursively, so we delete the real path.
+			else {
+				$this->delete($item->getPathname());
+			}
+		}
+
+		if (! $preserve) {
+			@rmdir($directory);
+		}
+
+		return true;
+	}
+
+	/**
+	 * Empty the specified directory of all files and folders.
+	 *
+	 * @param  string  $directory
+	 * @return bool
+	 */
+	public function cleanDirectory($directory)
+	{
+		return $this->deleteDirectory($directory, true);
+	}
 }

vendor_prefixed/illuminate/container/Container.php

Indentation +1207 added lines, -1207 removed lines

@@ -18,1211 +18,1211 @@
 
 class Container implements ArrayAccess, ContainerContract
 {
-    /**
-     * The current globally available container (if any).
-     *
-     * @var static
-     */
-    protected static $instance;
-
-    /**
-     * An array of the types that have been resolved.
-     *
-     * @var array
-     */
-    protected $resolved = [];
-
-    /**
-     * The container's bindings.
-     *
-     * @var array
-     */
-    protected $bindings = [];
-
-    /**
-     * The container's method bindings.
-     *
-     * @var array
-     */
-    protected $methodBindings = [];
-
-    /**
-     * The container's shared instances.
-     *
-     * @var array
-     */
-    protected $instances = [];
-
-    /**
-     * The registered type aliases.
-     *
-     * @var array
-     */
-    protected $aliases = [];
-
-    /**
-     * The registered aliases keyed by the abstract name.
-     *
-     * @var array
-     */
-    protected $abstractAliases = [];
-
-    /**
-     * The extension closures for services.
-     *
-     * @var array
-     */
-    protected $extenders = [];
-
-    /**
-     * All of the registered tags.
-     *
-     * @var array
-     */
-    protected $tags = [];
-
-    /**
-     * The stack of concretions currently being built.
-     *
-     * @var array
-     */
-    protected $buildStack = [];
-
-    /**
-     * The parameter override stack.
-     *
-     * @var array
-     */
-    protected $with = [];
-
-    /**
-     * The contextual binding map.
-     *
-     * @var array
-     */
-    public $contextual = [];
-
-    /**
-     * All of the registered rebound callbacks.
-     *
-     * @var array
-     */
-    protected $reboundCallbacks = [];
-
-    /**
-     * All of the global resolving callbacks.
-     *
-     * @var array
-     */
-    protected $globalResolvingCallbacks = [];
-
-    /**
-     * All of the global after resolving callbacks.
-     *
-     * @var array
-     */
-    protected $globalAfterResolvingCallbacks = [];
-
-    /**
-     * All of the resolving callbacks by class type.
-     *
-     * @var array
-     */
-    protected $resolvingCallbacks = [];
-
-    /**
-     * All of the after resolving callbacks by class type.
-     *
-     * @var array
-     */
-    protected $afterResolvingCallbacks = [];
-
-    /**
-     * Define a contextual binding.
-     *
-     * @param  string  $concrete
-     * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\ContextualBindingBuilder
-     */
-    public function when($concrete)
-    {
-        return new ContextualBindingBuilder($this, $this->getAlias($concrete));
-    }
-
-    /**
-     * Determine if the given abstract type has been bound.
-     *
-     * @param  string  $abstract
-     * @return bool
-     */
-    public function bound($abstract)
-    {
-        return isset($this->bindings[$abstract]) ||
-               isset($this->instances[$abstract]) ||
-               $this->isAlias($abstract);
-    }
-
-    /**
-     * Determine if the given abstract type has been resolved.
-     *
-     * @param  string  $abstract
-     * @return bool
-     */
-    public function resolved($abstract)
-    {
-        if ($this->isAlias($abstract)) {
-            $abstract = $this->getAlias($abstract);
-        }
-
-        return isset($this->resolved[$abstract]) ||
-               isset($this->instances[$abstract]);
-    }
-
-    /**
-     * Determine if a given type is shared.
-     *
-     * @param  string  $abstract
-     * @return bool
-     */
-    public function isShared($abstract)
-    {
-        return isset($this->instances[$abstract]) ||
-              (isset($this->bindings[$abstract]['shared']) &&
-               $this->bindings[$abstract]['shared'] === true);
-    }
-
-    /**
-     * Determine if a given string is an alias.
-     *
-     * @param  string  $name
-     * @return bool
-     */
-    public function isAlias($name)
-    {
-        return isset($this->aliases[$name]);
-    }
-
-    /**
-     * Register a binding with the container.
-     *
-     * @param  string|array  $abstract
-     * @param  \Closure|string|null  $concrete
-     * @param  bool  $shared
-     * @return void
-     */
-    public function bind($abstract, $concrete = null, $shared = false)
-    {
-        // If no concrete type was given, we will simply set the concrete type to the
-        // abstract type. After that, the concrete type to be registered as shared
-        // without being forced to state their classes in both of the parameters.
-        $this->dropStaleInstances($abstract);
-
-        if (is_null($concrete)) {
-            $concrete = $abstract;
-        }
-
-        // If the factory is not a Closure, it means it is just a class name which is
-        // bound into this container to the abstract type and we will just wrap it
-        // up inside its own Closure to give us more convenience when extending.
-        if (! $concrete instanceof Closure) {
-            $concrete = $this->getClosure($abstract, $concrete);
-        }
-
-        $this->bindings[$abstract] = compact('concrete', 'shared');
-
-        // If the abstract type was already resolved in this container we'll fire the
-        // rebound listener so that any objects which have already gotten resolved
-        // can have their copy of the object updated via the listener callbacks.
-        if ($this->resolved($abstract)) {
-            $this->rebound($abstract);
-        }
-    }
-
-    /**
-     * Get the Closure to be used when building a type.
-     *
-     * @param  string  $abstract
-     * @param  string  $concrete
-     * @return \Closure
-     */
-    protected function getClosure($abstract, $concrete)
-    {
-        return function ($container, $parameters = []) use ($abstract, $concrete) {
-            if ($abstract == $concrete) {
-                return $container->build($concrete);
-            }
-
-            return $container->makeWith($concrete, $parameters);
-        };
-    }
-
-    /**
-     * Determine if the container has a method binding.
-     *
-     * @param  string  $method
-     * @return bool
-     */
-    public function hasMethodBinding($method)
-    {
-        return isset($this->methodBindings[$method]);
-    }
-
-    /**
-     * Bind a callback to resolve with Container::call.
-     *
-     * @param  string  $method
-     * @param  \Closure  $callback
-     * @return void
-     */
-    public function bindMethod($method, $callback)
-    {
-        $this->methodBindings[$method] = $callback;
-    }
-
-    /**
-     * Get the method binding for the given method.
-     *
-     * @param  string  $method
-     * @param  mixed  $instance
-     * @return mixed
-     */
-    public function callMethodBinding($method, $instance)
-    {
-        return call_user_func($this->methodBindings[$method], $instance, $this);
-    }
-
-    /**
-     * Add a contextual binding to the container.
-     *
-     * @param  string  $concrete
-     * @param  string  $abstract
-     * @param  \Closure|string  $implementation
-     * @return void
-     */
-    public function addContextualBinding($concrete, $abstract, $implementation)
-    {
-        $this->contextual[$concrete][$this->getAlias($abstract)] = $implementation;
-    }
-
-    /**
-     * Register a binding if it hasn't already been registered.
-     *
-     * @param  string  $abstract
-     * @param  \Closure|string|null  $concrete
-     * @param  bool  $shared
-     * @return void
-     */
-    public function bindIf($abstract, $concrete = null, $shared = false)
-    {
-        if (! $this->bound($abstract)) {
-            $this->bind($abstract, $concrete, $shared);
-        }
-    }
-
-    /**
-     * Register a shared binding in the container.
-     *
-     * @param  string|array  $abstract
-     * @param  \Closure|string|null  $concrete
-     * @return void
-     */
-    public function singleton($abstract, $concrete = null)
-    {
-        $this->bind($abstract, $concrete, true);
-    }
-
-    /**
-     * "Extend" an abstract type in the container.
-     *
-     * @param  string    $abstract
-     * @param  \Closure  $closure
-     * @return void
-     *
-     * @throws \InvalidArgumentException
-     */
-    public function extend($abstract, Closure $closure)
-    {
-        $abstract = $this->getAlias($abstract);
-
-        if (isset($this->instances[$abstract])) {
-            $this->instances[$abstract] = $closure($this->instances[$abstract], $this);
-
-            $this->rebound($abstract);
-        } else {
-            $this->extenders[$abstract][] = $closure;
-
-            if ($this->resolved($abstract)) {
-                $this->rebound($abstract);
-            }
-        }
-    }
-
-    /**
-     * Register an existing instance as shared in the container.
-     *
-     * @param  string  $abstract
-     * @param  mixed   $instance
-     * @return void
-     */
-    public function instance($abstract, $instance)
-    {
-        $this->removeAbstractAlias($abstract);
-
-        $isBound = $this->bound($abstract);
-
-        unset($this->aliases[$abstract]);
-
-        // We'll check to determine if this type has been bound before, and if it has
-        // we will fire the rebound callbacks registered with the container and it
-        // can be updated with consuming classes that have gotten resolved here.
-        $this->instances[$abstract] = $instance;
-
-        if ($isBound) {
-            $this->rebound($abstract);
-        }
-    }
-
-    /**
-     * Remove an alias from the contextual binding alias cache.
-     *
-     * @param  string  $searched
-     * @return void
-     */
-    protected function removeAbstractAlias($searched)
-    {
-        if (! isset($this->aliases[$searched])) {
-            return;
-        }
-
-        foreach ($this->abstractAliases as $abstract => $aliases) {
-            foreach ($aliases as $index => $alias) {
-                if ($alias == $searched) {
-                    unset($this->abstractAliases[$abstract][$index]);
-                }
-            }
-        }
-    }
-
-    /**
-     * Assign a set of tags to a given binding.
-     *
-     * @param  array|string  $abstracts
-     * @param  array|mixed   ...$tags
-     * @return void
-     */
-    public function tag($abstracts, $tags)
-    {
-        $tags = is_array($tags) ? $tags : array_slice(func_get_args(), 1);
-
-        foreach ($tags as $tag) {
-            if (! isset($this->tags[$tag])) {
-                $this->tags[$tag] = [];
-            }
-
-            foreach ((array) $abstracts as $abstract) {
-                $this->tags[$tag][] = $abstract;
-            }
-        }
-    }
-
-    /**
-     * Resolve all of the bindings for a given tag.
-     *
-     * @param  string  $tag
-     * @return array
-     */
-    public function tagged($tag)
-    {
-        $results = [];
-
-        if (isset($this->tags[$tag])) {
-            foreach ($this->tags[$tag] as $abstract) {
-                $results[] = $this->make($abstract);
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Alias a type to a different name.
-     *
-     * @param  string  $abstract
-     * @param  string  $alias
-     * @return void
-     */
-    public function alias($abstract, $alias)
-    {
-        $this->aliases[$alias] = $abstract;
-
-        $this->abstractAliases[$abstract][] = $alias;
-    }
-
-    /**
-     * Bind a new callback to an abstract's rebind event.
-     *
-     * @param  string    $abstract
-     * @param  \Closure  $callback
-     * @return mixed
-     */
-    public function rebinding($abstract, Closure $callback)
-    {
-        $this->reboundCallbacks[$abstract = $this->getAlias($abstract)][] = $callback;
-
-        if ($this->bound($abstract)) {
-            return $this->make($abstract);
-        }
-    }
-
-    /**
-     * Refresh an instance on the given target and method.
-     *
-     * @param  string  $abstract
-     * @param  mixed   $target
-     * @param  string  $method
-     * @return mixed
-     */
-    public function refresh($abstract, $target, $method)
-    {
-        return $this->rebinding($abstract, function ($app, $instance) use ($target, $method) {
-            $target->{$method}($instance);
-        });
-    }
-
-    /**
-     * Fire the "rebound" callbacks for the given abstract type.
-     *
-     * @param  string  $abstract
-     * @return void
-     */
-    protected function rebound($abstract)
-    {
-        $instance = $this->make($abstract);
-
-        foreach ($this->getReboundCallbacks($abstract) as $callback) {
-            call_user_func($callback, $this, $instance);
-        }
-    }
-
-    /**
-     * Get the rebound callbacks for a given type.
-     *
-     * @param  string  $abstract
-     * @return array
-     */
-    protected function getReboundCallbacks($abstract)
-    {
-        if (isset($this->reboundCallbacks[$abstract])) {
-            return $this->reboundCallbacks[$abstract];
-        }
-
-        return [];
-    }
-
-    /**
-     * Wrap the given closure such that its dependencies will be injected when executed.
-     *
-     * @param  \Closure  $callback
-     * @param  array  $parameters
-     * @return \Closure
-     */
-    public function wrap(Closure $callback, array $parameters = [])
-    {
-        return function () use ($callback, $parameters) {
-            return $this->call($callback, $parameters);
-        };
-    }
-
-    /**
-     * Call the given Closure / class@method and inject its dependencies.
-     *
-     * @param  callable|string  $callback
-     * @param  array  $parameters
-     * @param  string|null  $defaultMethod
-     * @return mixed
-     */
-    public function call($callback, array $parameters = [], $defaultMethod = null)
-    {
-        return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
-    }
-
-    /**
-     * Get a closure to resolve the given type from the container.
-     *
-     * @param  string  $abstract
-     * @return \Closure
-     */
-    public function factory($abstract)
-    {
-        return function () use ($abstract) {
-            return $this->make($abstract);
-        };
-    }
-
-    /**
-     * Resolve the given type with the given parameter overrides.
-     *
-     * @param  string  $abstract
-     * @param  array  $parameters
-     * @return mixed
-     */
-    public function makeWith($abstract, array $parameters)
-    {
-        return $this->resolve($abstract, $parameters);
-    }
-
-    /**
-     * Resolve the given type from the container.
-     *
-     * @param  string  $abstract
-     * @return mixed
-     */
-    public function make($abstract)
-    {
-        return $this->resolve($abstract);
-    }
-
-    /**
-     * Resolve the given type from the container.
-     *
-     * @param  string  $abstract
-     * @param  array  $parameters
-     * @return mixed
-     */
-    protected function resolve($abstract, $parameters = [])
-    {
-        $abstract = $this->getAlias($abstract);
-
-        $needsContextualBuild = ! empty($parameters) || ! is_null(
-            $this->getContextualConcrete($abstract)
-        );
-
-        // If an instance of the type is currently being managed as a singleton we'll
-        // just return an existing instance instead of instantiating new instances
-        // so the developer can keep using the same objects instance every time.
-        if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
-            return $this->instances[$abstract];
-        }
-
-        $this->with[] = $parameters;
-
-        $concrete = $this->getConcrete($abstract);
-
-        // We're ready to instantiate an instance of the concrete type registered for
-        // the binding. This will instantiate the types, as well as resolve any of
-        // its "nested" dependencies recursively until all have gotten resolved.
-        if ($this->isBuildable($concrete, $abstract)) {
-            $object = $this->build($concrete);
-        } else {
-            $object = $this->make($concrete);
-        }
-
-        // If we defined any extenders for this type, we'll need to spin through them
-        // and apply them to the object being built. This allows for the extension
-        // of services, such as changing configuration or decorating the object.
-        foreach ($this->getExtenders($abstract) as $extender) {
-            $object = $extender($object, $this);
-        }
-
-        // If the requested type is registered as a singleton we'll want to cache off
-        // the instances in "memory" so we can return it later without creating an
-        // entirely new instance of an object on each subsequent request for it.
-        if ($this->isShared($abstract) && ! $needsContextualBuild) {
-            $this->instances[$abstract] = $object;
-        }
-
-        $this->fireResolvingCallbacks($abstract, $object);
-
-        // Before returning, we will also set the resolved flag to "true" and pop off
-        // the parameter overrides for this build. After those two things are done
-        // we will be ready to return back the fully constructed class instance.
-        $this->resolved[$abstract] = true;
-
-        array_pop($this->with);
-
-        return $object;
-    }
-
-    /**
-     * Get the concrete type for a given abstract.
-     *
-     * @param  string  $abstract
-     * @return mixed   $concrete
-     */
-    protected function getConcrete($abstract)
-    {
-        if (! is_null($concrete = $this->getContextualConcrete($abstract))) {
-            return $concrete;
-        }
-
-        // If we don't have a registered resolver or concrete for the type, we'll just
-        // assume each type is a concrete name and will attempt to resolve it as is
-        // since the container should be able to resolve concretes automatically.
-        if (isset($this->bindings[$abstract])) {
-            return $this->bindings[$abstract]['concrete'];
-        }
-
-        return $abstract;
-    }
-
-    /**
-     * Get the contextual concrete binding for the given abstract.
-     *
-     * @param  string  $abstract
-     * @return string|null
-     */
-    protected function getContextualConcrete($abstract)
-    {
-        if (! is_null($binding = $this->findInContextualBindings($abstract))) {
-            return $binding;
-        }
-
-        // Next we need to see if a contextual binding might be bound under an alias of the
-        // given abstract type. So, we will need to check if any aliases exist with this
-        // type and then spin through them and check for contextual bindings on these.
-        if (empty($this->abstractAliases[$abstract])) {
-            return;
-        }
-
-        foreach ($this->abstractAliases[$abstract] as $alias) {
-            if (! is_null($binding = $this->findInContextualBindings($alias))) {
-                return $binding;
-            }
-        }
-    }
-
-    /**
-     * Find the concrete binding for the given abstract in the contextual binding array.
-     *
-     * @param  string  $abstract
-     * @return string|null
-     */
-    protected function findInContextualBindings($abstract)
-    {
-        if (isset($this->contextual[end($this->buildStack)][$abstract])) {
-            return $this->contextual[end($this->buildStack)][$abstract];
-        }
-    }
-
-    /**
-     * Determine if the given concrete is buildable.
-     *
-     * @param  mixed   $concrete
-     * @param  string  $abstract
-     * @return bool
-     */
-    protected function isBuildable($concrete, $abstract)
-    {
-        return $concrete === $abstract || $concrete instanceof Closure;
-    }
-
-    /**
-     * Instantiate a concrete instance of the given type.
-     *
-     * @param  string  $concrete
-     * @return mixed
-     *
-     * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
-     */
-    public function build($concrete)
-    {
-        // If the concrete type is actually a Closure, we will just execute it and
-        // hand back the results of the functions, which allows functions to be
-        // used as resolvers for more fine-tuned resolution of these objects.
-        if ($concrete instanceof Closure) {
-            return $concrete($this, $this->getLastParameterOverride());
-        }
-
-        $reflector = new ReflectionClass($concrete);
-
-        // If the type is not instantiable, the developer is attempting to resolve
-        // an abstract type such as an Interface of Abstract Class and there is
-        // no binding registered for the abstractions so we need to bail out.
-        if (! $reflector->isInstantiable()) {
-            return $this->notInstantiable($concrete);
-        }
-
-        $this->buildStack[] = $concrete;
-
-        $constructor = $reflector->getConstructor();
-
-        // If there are no constructors, that means there are no dependencies then
-        // we can just resolve the instances of the objects right away, without
-        // resolving any other types or dependencies out of these containers.
-        if (is_null($constructor)) {
-            array_pop($this->buildStack);
-
-            return new $concrete;
-        }
-
-        $dependencies = $constructor->getParameters();
-
-        // Once we have all the constructor's parameters we can create each of the
-        // dependency instances and then use the reflection instances to make a
-        // new instance of this class, injecting the created dependencies in.
-        $instances = $this->resolveDependencies(
-            $dependencies
-        );
-
-        array_pop($this->buildStack);
-
-        return $reflector->newInstanceArgs($instances);
-    }
-
-    /**
-     * Resolve all of the dependencies from the ReflectionParameters.
-     *
-     * @param  array  $dependencies
-     * @return array
-     */
-    protected function resolveDependencies(array $dependencies)
-    {
-        $results = [];
-
-        foreach ($dependencies as $dependency) {
-            // If this dependency has a override for this particular build we will use
-            // that instead as the value. Otherwise, we will continue with this run
-            // of resolutions and let reflection attempt to determine the result.
-            if ($this->hasParameterOverride($dependency)) {
-                $results[] = $this->getParameterOverride($dependency);
-
-                continue;
-            }
-
-            // If the class is null, it means the dependency is a string or some other
-            // primitive type which we can not resolve since it is not a class and
-            // we will just bomb out with an error since we have no-where to go.
-            $results[] = is_null($class = $dependency->getClass())
-                            ? $this->resolvePrimitive($dependency)
-                            : $this->resolveClass($dependency);
-        }
-
-        return $results;
-    }
-
-    /**
-     * Determine if the given dependency has a parameter override from makeWith.
-     *
-     * @param  \ReflectionParameter  $dependency
-     * @return bool
-     */
-    protected function hasParameterOverride($dependency)
-    {
-        return array_key_exists(
-            $dependency->name, $this->getLastParameterOverride()
-        );
-    }
-
-    /**
-     * Get a parameter override for a dependency.
-     *
-     * @param  \ReflectionParameter  $dependency
-     * @return mixed
-     */
-    protected function getParameterOverride($dependency)
-    {
-        return $this->getLastParameterOverride()[$dependency->name];
-    }
-
-    /**
-     * Get the last parameter override.
-     *
-     * @return array
-     */
-    protected function getLastParameterOverride()
-    {
-        return count($this->with) ? end($this->with) : [];
-    }
-
-    /**
-     * Resolve a non-class hinted primitive dependency.
-     *
-     * @param  \ReflectionParameter  $parameter
-     * @return mixed
-     *
-     * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
-     */
-    protected function resolvePrimitive(ReflectionParameter $parameter)
-    {
-        if (! is_null($concrete = $this->getContextualConcrete('$'.$parameter->name))) {
-            return $concrete instanceof Closure ? $concrete($this) : $concrete;
-        }
-
-        if ($parameter->isDefaultValueAvailable()) {
-            return $parameter->getDefaultValue();
-        }
-
-        $this->unresolvablePrimitive($parameter);
-    }
-
-    /**
-     * Resolve a class based dependency from the container.
-     *
-     * @param  \ReflectionParameter  $parameter
-     * @return mixed
-     *
-     * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
-     */
-    protected function resolveClass(ReflectionParameter $parameter)
-    {
-        try {
-            return $this->make($parameter->getClass()->name);
-        }
-
-        // If we can not resolve the class instance, we will check to see if the value
-        // is optional, and if it is we will return the optional parameter value as
-        // the value of the dependency, similarly to how we do this with scalars.
-        catch (BindingResolutionException $e) {
-            if ($parameter->isOptional()) {
-                return $parameter->getDefaultValue();
-            }
-
-            throw $e;
-        }
-    }
-
-    /**
-     * Throw an exception that the concrete is not instantiable.
-     *
-     * @param  string  $concrete
-     * @return void
-     *
-     * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
-     */
-    protected function notInstantiable($concrete)
-    {
-        if (! empty($this->buildStack)) {
-            $previous = implode(', ', $this->buildStack);
-
-            $message = "Target [$concrete] is not instantiable while building [$previous].";
-        } else {
-            $message = "Target [$concrete] is not instantiable.";
-        }
-
-        throw new BindingResolutionException($message);
-    }
-
-    /**
-     * Throw an exception for an unresolvable primitive.
-     *
-     * @param  \ReflectionParameter  $parameter
-     * @return void
-     *
-     * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
-     */
-    protected function unresolvablePrimitive(ReflectionParameter $parameter)
-    {
-        $message = "Unresolvable dependency resolving [$parameter] in class {$parameter->getDeclaringClass()->getName()}";
-
-        throw new BindingResolutionException($message);
-    }
-
-    /**
-     * Register a new resolving callback.
-     *
-     * @param  string    $abstract
-     * @param  \Closure|null  $callback
-     * @return void
-     */
-    public function resolving($abstract, Closure $callback = null)
-    {
-        if (is_string($abstract)) {
-            $abstract = $this->getAlias($abstract);
-        }
-
-        if (is_null($callback) && $abstract instanceof Closure) {
-            $this->globalResolvingCallbacks[] = $abstract;
-        } else {
-            $this->resolvingCallbacks[$abstract][] = $callback;
-        }
-    }
-
-    /**
-     * Register a new after resolving callback for all types.
-     *
-     * @param  string   $abstract
-     * @param  \Closure|null $callback
-     * @return void
-     */
-    public function afterResolving($abstract, Closure $callback = null)
-    {
-        if (is_string($abstract)) {
-            $abstract = $this->getAlias($abstract);
-        }
-
-        if ($abstract instanceof Closure && is_null($callback)) {
-            $this->globalAfterResolvingCallbacks[] = $abstract;
-        } else {
-            $this->afterResolvingCallbacks[$abstract][] = $callback;
-        }
-    }
-
-    /**
-     * Fire all of the resolving callbacks.
-     *
-     * @param  string  $abstract
-     * @param  mixed   $object
-     * @return void
-     */
-    protected function fireResolvingCallbacks($abstract, $object)
-    {
-        $this->fireCallbackArray($object, $this->globalResolvingCallbacks);
-
-        $this->fireCallbackArray(
-            $object, $this->getCallbacksForType($abstract, $object, $this->resolvingCallbacks)
-        );
-
-        $this->fireAfterResolvingCallbacks($abstract, $object);
-    }
-
-    /**
-     * Fire all of the after resolving callbacks.
-     *
-     * @param  string  $abstract
-     * @param  mixed   $object
-     * @return void
-     */
-    protected function fireAfterResolvingCallbacks($abstract, $object)
-    {
-        $this->fireCallbackArray($object, $this->globalAfterResolvingCallbacks);
-
-        $this->fireCallbackArray(
-            $object, $this->getCallbacksForType($abstract, $object, $this->afterResolvingCallbacks)
-        );
-    }
-
-    /**
-     * Get all callbacks for a given type.
-     *
-     * @param  string  $abstract
-     * @param  object  $object
-     * @param  array   $callbacksPerType
-     *
-     * @return array
-     */
-    protected function getCallbacksForType($abstract, $object, array $callbacksPerType)
-    {
-        $results = [];
-
-        foreach ($callbacksPerType as $type => $callbacks) {
-            if ($type === $abstract || $object instanceof $type) {
-                $results = array_merge($results, $callbacks);
-            }
-        }
-
-        return $results;
-    }
-
-    /**
-     * Fire an array of callbacks with an object.
-     *
-     * @param  mixed  $object
-     * @param  array  $callbacks
-     * @return void
-     */
-    protected function fireCallbackArray($object, array $callbacks)
-    {
-        foreach ($callbacks as $callback) {
-            $callback($object, $this);
-        }
-    }
-
-    /**
-     * Get the container's bindings.
-     *
-     * @return array
-     */
-    public function getBindings()
-    {
-        return $this->bindings;
-    }
-
-    /**
-     * Get the alias for an abstract if available.
-     *
-     * @param  string  $abstract
-     * @return string
-     *
-     * @throws \LogicException
-     */
-    public function getAlias($abstract)
-    {
-        if (! isset($this->aliases[$abstract])) {
-            return $abstract;
-        }
-
-        if ($this->aliases[$abstract] === $abstract) {
-            throw new LogicException("[{$abstract}] is aliased to itself.");
-        }
-
-        return $this->getAlias($this->aliases[$abstract]);
-    }
-
-    /**
-     * Get the extender callbacks for a given type.
-     *
-     * @param  string  $abstract
-     * @return array
-     */
-    protected function getExtenders($abstract)
-    {
-        $abstract = $this->getAlias($abstract);
-
-        if (isset($this->extenders[$abstract])) {
-            return $this->extenders[$abstract];
-        }
-
-        return [];
-    }
-
-    /**
-     * Remove all of the extender callbacks for a given type.
-     *
-     * @param  string  $abstract
-     * @return void
-     */
-    public function forgetExtenders($abstract)
-    {
-        unset($this->extenders[$this->getAlias($abstract)]);
-    }
-
-    /**
-     * Drop all of the stale instances and aliases.
-     *
-     * @param  string  $abstract
-     * @return void
-     */
-    protected function dropStaleInstances($abstract)
-    {
-        unset($this->instances[$abstract], $this->aliases[$abstract]);
-    }
-
-    /**
-     * Remove a resolved instance from the instance cache.
-     *
-     * @param  string  $abstract
-     * @return void
-     */
-    public function forgetInstance($abstract)
-    {
-        unset($this->instances[$abstract]);
-    }
-
-    /**
-     * Clear all of the instances from the container.
-     *
-     * @return void
-     */
-    public function forgetInstances()
-    {
-        $this->instances = [];
-    }
-
-    /**
-     * Flush the container of all bindings and resolved instances.
-     *
-     * @return void
-     */
-    public function flush()
-    {
-        $this->aliases = [];
-        $this->resolved = [];
-        $this->bindings = [];
-        $this->instances = [];
-        $this->abstractAliases = [];
-    }
-
-    /**
-     * Set the globally available instance of the container.
-     *
-     * @return static
-     */
-    public static function getInstance()
-    {
-        if (is_null(static::$instance)) {
-            static::$instance = new static;
-        }
-
-        return static::$instance;
-    }
-
-    /**
-     * Set the shared instance of the container.
-     *
-     * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\Container|null  $container
-     * @return static
-     */
-    public static function setInstance(ContainerContract $container = null)
-    {
-        return static::$instance = $container;
-    }
-
-    /**
-     * Determine if a given offset exists.
-     *
-     * @param  string  $key
-     * @return bool
-     */
-    public function offsetExists($key)
-    {
-        return $this->bound($key);
-    }
-
-    /**
-     * Get the value at a given offset.
-     *
-     * @param  string  $key
-     * @return mixed
-     */
-    public function offsetGet($key)
-    {
-        return $this->make($key);
-    }
-
-    /**
-     * Set the value at a given offset.
-     *
-     * @param  string  $key
-     * @param  mixed   $value
-     * @return void
-     */
-    public function offsetSet($key, $value)
-    {
-        $this->bind($key, $value instanceof Closure ? $value : function () use ($value) {
-            return $value;
-        });
-    }
-
-    /**
-     * Unset the value at a given offset.
-     *
-     * @param  string  $key
-     * @return void
-     */
-    public function offsetUnset($key)
-    {
-        unset($this->bindings[$key], $this->instances[$key], $this->resolved[$key]);
-    }
-
-    /**
-     * Dynamically access container services.
-     *
-     * @param  string  $key
-     * @return mixed
-     */
-    public function __get($key)
-    {
-        return $this[$key];
-    }
-
-    /**
-     * Dynamically set container services.
-     *
-     * @param  string  $key
-     * @param  mixed   $value
-     * @return void
-     */
-    public function __set($key, $value)
-    {
-        $this[$key] = $value;
-    }
+	/**
+	 * The current globally available container (if any).
+	 *
+	 * @var static
+	 */
+	protected static $instance;
+
+	/**
+	 * An array of the types that have been resolved.
+	 *
+	 * @var array
+	 */
+	protected $resolved = [];
+
+	/**
+	 * The container's bindings.
+	 *
+	 * @var array
+	 */
+	protected $bindings = [];
+
+	/**
+	 * The container's method bindings.
+	 *
+	 * @var array
+	 */
+	protected $methodBindings = [];
+
+	/**
+	 * The container's shared instances.
+	 *
+	 * @var array
+	 */
+	protected $instances = [];
+
+	/**
+	 * The registered type aliases.
+	 *
+	 * @var array
+	 */
+	protected $aliases = [];
+
+	/**
+	 * The registered aliases keyed by the abstract name.
+	 *
+	 * @var array
+	 */
+	protected $abstractAliases = [];
+
+	/**
+	 * The extension closures for services.
+	 *
+	 * @var array
+	 */
+	protected $extenders = [];
+
+	/**
+	 * All of the registered tags.
+	 *
+	 * @var array
+	 */
+	protected $tags = [];
+
+	/**
+	 * The stack of concretions currently being built.
+	 *
+	 * @var array
+	 */
+	protected $buildStack = [];
+
+	/**
+	 * The parameter override stack.
+	 *
+	 * @var array
+	 */
+	protected $with = [];
+
+	/**
+	 * The contextual binding map.
+	 *
+	 * @var array
+	 */
+	public $contextual = [];
+
+	/**
+	 * All of the registered rebound callbacks.
+	 *
+	 * @var array
+	 */
+	protected $reboundCallbacks = [];
+
+	/**
+	 * All of the global resolving callbacks.
+	 *
+	 * @var array
+	 */
+	protected $globalResolvingCallbacks = [];
+
+	/**
+	 * All of the global after resolving callbacks.
+	 *
+	 * @var array
+	 */
+	protected $globalAfterResolvingCallbacks = [];
+
+	/**
+	 * All of the resolving callbacks by class type.
+	 *
+	 * @var array
+	 */
+	protected $resolvingCallbacks = [];
+
+	/**
+	 * All of the after resolving callbacks by class type.
+	 *
+	 * @var array
+	 */
+	protected $afterResolvingCallbacks = [];
+
+	/**
+	 * Define a contextual binding.
+	 *
+	 * @param  string  $concrete
+	 * @return \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\ContextualBindingBuilder
+	 */
+	public function when($concrete)
+	{
+		return new ContextualBindingBuilder($this, $this->getAlias($concrete));
+	}
+
+	/**
+	 * Determine if the given abstract type has been bound.
+	 *
+	 * @param  string  $abstract
+	 * @return bool
+	 */
+	public function bound($abstract)
+	{
+		return isset($this->bindings[$abstract]) ||
+			   isset($this->instances[$abstract]) ||
+			   $this->isAlias($abstract);
+	}
+
+	/**
+	 * Determine if the given abstract type has been resolved.
+	 *
+	 * @param  string  $abstract
+	 * @return bool
+	 */
+	public function resolved($abstract)
+	{
+		if ($this->isAlias($abstract)) {
+			$abstract = $this->getAlias($abstract);
+		}
+
+		return isset($this->resolved[$abstract]) ||
+			   isset($this->instances[$abstract]);
+	}
+
+	/**
+	 * Determine if a given type is shared.
+	 *
+	 * @param  string  $abstract
+	 * @return bool
+	 */
+	public function isShared($abstract)
+	{
+		return isset($this->instances[$abstract]) ||
+			  (isset($this->bindings[$abstract]['shared']) &&
+			   $this->bindings[$abstract]['shared'] === true);
+	}
+
+	/**
+	 * Determine if a given string is an alias.
+	 *
+	 * @param  string  $name
+	 * @return bool
+	 */
+	public function isAlias($name)
+	{
+		return isset($this->aliases[$name]);
+	}
+
+	/**
+	 * Register a binding with the container.
+	 *
+	 * @param  string|array  $abstract
+	 * @param  \Closure|string|null  $concrete
+	 * @param  bool  $shared
+	 * @return void
+	 */
+	public function bind($abstract, $concrete = null, $shared = false)
+	{
+		// If no concrete type was given, we will simply set the concrete type to the
+		// abstract type. After that, the concrete type to be registered as shared
+		// without being forced to state their classes in both of the parameters.
+		$this->dropStaleInstances($abstract);
+
+		if (is_null($concrete)) {
+			$concrete = $abstract;
+		}
+
+		// If the factory is not a Closure, it means it is just a class name which is
+		// bound into this container to the abstract type and we will just wrap it
+		// up inside its own Closure to give us more convenience when extending.
+		if (! $concrete instanceof Closure) {
+			$concrete = $this->getClosure($abstract, $concrete);
+		}
+
+		$this->bindings[$abstract] = compact('concrete', 'shared');
+
+		// If the abstract type was already resolved in this container we'll fire the
+		// rebound listener so that any objects which have already gotten resolved
+		// can have their copy of the object updated via the listener callbacks.
+		if ($this->resolved($abstract)) {
+			$this->rebound($abstract);
+		}
+	}
+
+	/**
+	 * Get the Closure to be used when building a type.
+	 *
+	 * @param  string  $abstract
+	 * @param  string  $concrete
+	 * @return \Closure
+	 */
+	protected function getClosure($abstract, $concrete)
+	{
+		return function ($container, $parameters = []) use ($abstract, $concrete) {
+			if ($abstract == $concrete) {
+				return $container->build($concrete);
+			}
+
+			return $container->makeWith($concrete, $parameters);
+		};
+	}
+
+	/**
+	 * Determine if the container has a method binding.
+	 *
+	 * @param  string  $method
+	 * @return bool
+	 */
+	public function hasMethodBinding($method)
+	{
+		return isset($this->methodBindings[$method]);
+	}
+
+	/**
+	 * Bind a callback to resolve with Container::call.
+	 *
+	 * @param  string  $method
+	 * @param  \Closure  $callback
+	 * @return void
+	 */
+	public function bindMethod($method, $callback)
+	{
+		$this->methodBindings[$method] = $callback;
+	}
+
+	/**
+	 * Get the method binding for the given method.
+	 *
+	 * @param  string  $method
+	 * @param  mixed  $instance
+	 * @return mixed
+	 */
+	public function callMethodBinding($method, $instance)
+	{
+		return call_user_func($this->methodBindings[$method], $instance, $this);
+	}
+
+	/**
+	 * Add a contextual binding to the container.
+	 *
+	 * @param  string  $concrete
+	 * @param  string  $abstract
+	 * @param  \Closure|string  $implementation
+	 * @return void
+	 */
+	public function addContextualBinding($concrete, $abstract, $implementation)
+	{
+		$this->contextual[$concrete][$this->getAlias($abstract)] = $implementation;
+	}
+
+	/**
+	 * Register a binding if it hasn't already been registered.
+	 *
+	 * @param  string  $abstract
+	 * @param  \Closure|string|null  $concrete
+	 * @param  bool  $shared
+	 * @return void
+	 */
+	public function bindIf($abstract, $concrete = null, $shared = false)
+	{
+		if (! $this->bound($abstract)) {
+			$this->bind($abstract, $concrete, $shared);
+		}
+	}
+
+	/**
+	 * Register a shared binding in the container.
+	 *
+	 * @param  string|array  $abstract
+	 * @param  \Closure|string|null  $concrete
+	 * @return void
+	 */
+	public function singleton($abstract, $concrete = null)
+	{
+		$this->bind($abstract, $concrete, true);
+	}
+
+	/**
+	 * "Extend" an abstract type in the container.
+	 *
+	 * @param  string    $abstract
+	 * @param  \Closure  $closure
+	 * @return void
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function extend($abstract, Closure $closure)
+	{
+		$abstract = $this->getAlias($abstract);
+
+		if (isset($this->instances[$abstract])) {
+			$this->instances[$abstract] = $closure($this->instances[$abstract], $this);
+
+			$this->rebound($abstract);
+		} else {
+			$this->extenders[$abstract][] = $closure;
+
+			if ($this->resolved($abstract)) {
+				$this->rebound($abstract);
+			}
+		}
+	}
+
+	/**
+	 * Register an existing instance as shared in the container.
+	 *
+	 * @param  string  $abstract
+	 * @param  mixed   $instance
+	 * @return void
+	 */
+	public function instance($abstract, $instance)
+	{
+		$this->removeAbstractAlias($abstract);
+
+		$isBound = $this->bound($abstract);
+
+		unset($this->aliases[$abstract]);
+
+		// We'll check to determine if this type has been bound before, and if it has
+		// we will fire the rebound callbacks registered with the container and it
+		// can be updated with consuming classes that have gotten resolved here.
+		$this->instances[$abstract] = $instance;
+
+		if ($isBound) {
+			$this->rebound($abstract);
+		}
+	}
+
+	/**
+	 * Remove an alias from the contextual binding alias cache.
+	 *
+	 * @param  string  $searched
+	 * @return void
+	 */
+	protected function removeAbstractAlias($searched)
+	{
+		if (! isset($this->aliases[$searched])) {
+			return;
+		}
+
+		foreach ($this->abstractAliases as $abstract => $aliases) {
+			foreach ($aliases as $index => $alias) {
+				if ($alias == $searched) {
+					unset($this->abstractAliases[$abstract][$index]);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Assign a set of tags to a given binding.
+	 *
+	 * @param  array|string  $abstracts
+	 * @param  array|mixed   ...$tags
+	 * @return void
+	 */
+	public function tag($abstracts, $tags)
+	{
+		$tags = is_array($tags) ? $tags : array_slice(func_get_args(), 1);
+
+		foreach ($tags as $tag) {
+			if (! isset($this->tags[$tag])) {
+				$this->tags[$tag] = [];
+			}
+
+			foreach ((array) $abstracts as $abstract) {
+				$this->tags[$tag][] = $abstract;
+			}
+		}
+	}
+
+	/**
+	 * Resolve all of the bindings for a given tag.
+	 *
+	 * @param  string  $tag
+	 * @return array
+	 */
+	public function tagged($tag)
+	{
+		$results = [];
+
+		if (isset($this->tags[$tag])) {
+			foreach ($this->tags[$tag] as $abstract) {
+				$results[] = $this->make($abstract);
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Alias a type to a different name.
+	 *
+	 * @param  string  $abstract
+	 * @param  string  $alias
+	 * @return void
+	 */
+	public function alias($abstract, $alias)
+	{
+		$this->aliases[$alias] = $abstract;
+
+		$this->abstractAliases[$abstract][] = $alias;
+	}
+
+	/**
+	 * Bind a new callback to an abstract's rebind event.
+	 *
+	 * @param  string    $abstract
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function rebinding($abstract, Closure $callback)
+	{
+		$this->reboundCallbacks[$abstract = $this->getAlias($abstract)][] = $callback;
+
+		if ($this->bound($abstract)) {
+			return $this->make($abstract);
+		}
+	}
+
+	/**
+	 * Refresh an instance on the given target and method.
+	 *
+	 * @param  string  $abstract
+	 * @param  mixed   $target
+	 * @param  string  $method
+	 * @return mixed
+	 */
+	public function refresh($abstract, $target, $method)
+	{
+		return $this->rebinding($abstract, function ($app, $instance) use ($target, $method) {
+			$target->{$method}($instance);
+		});
+	}
+
+	/**
+	 * Fire the "rebound" callbacks for the given abstract type.
+	 *
+	 * @param  string  $abstract
+	 * @return void
+	 */
+	protected function rebound($abstract)
+	{
+		$instance = $this->make($abstract);
+
+		foreach ($this->getReboundCallbacks($abstract) as $callback) {
+			call_user_func($callback, $this, $instance);
+		}
+	}
+
+	/**
+	 * Get the rebound callbacks for a given type.
+	 *
+	 * @param  string  $abstract
+	 * @return array
+	 */
+	protected function getReboundCallbacks($abstract)
+	{
+		if (isset($this->reboundCallbacks[$abstract])) {
+			return $this->reboundCallbacks[$abstract];
+		}
+
+		return [];
+	}
+
+	/**
+	 * Wrap the given closure such that its dependencies will be injected when executed.
+	 *
+	 * @param  \Closure  $callback
+	 * @param  array  $parameters
+	 * @return \Closure
+	 */
+	public function wrap(Closure $callback, array $parameters = [])
+	{
+		return function () use ($callback, $parameters) {
+			return $this->call($callback, $parameters);
+		};
+	}
+
+	/**
+	 * Call the given Closure / class@method and inject its dependencies.
+	 *
+	 * @param  callable|string  $callback
+	 * @param  array  $parameters
+	 * @param  string|null  $defaultMethod
+	 * @return mixed
+	 */
+	public function call($callback, array $parameters = [], $defaultMethod = null)
+	{
+		return BoundMethod::call($this, $callback, $parameters, $defaultMethod);
+	}
+
+	/**
+	 * Get a closure to resolve the given type from the container.
+	 *
+	 * @param  string  $abstract
+	 * @return \Closure
+	 */
+	public function factory($abstract)
+	{
+		return function () use ($abstract) {
+			return $this->make($abstract);
+		};
+	}
+
+	/**
+	 * Resolve the given type with the given parameter overrides.
+	 *
+	 * @param  string  $abstract
+	 * @param  array  $parameters
+	 * @return mixed
+	 */
+	public function makeWith($abstract, array $parameters)
+	{
+		return $this->resolve($abstract, $parameters);
+	}
+
+	/**
+	 * Resolve the given type from the container.
+	 *
+	 * @param  string  $abstract
+	 * @return mixed
+	 */
+	public function make($abstract)
+	{
+		return $this->resolve($abstract);
+	}
+
+	/**
+	 * Resolve the given type from the container.
+	 *
+	 * @param  string  $abstract
+	 * @param  array  $parameters
+	 * @return mixed
+	 */
+	protected function resolve($abstract, $parameters = [])
+	{
+		$abstract = $this->getAlias($abstract);
+
+		$needsContextualBuild = ! empty($parameters) || ! is_null(
+			$this->getContextualConcrete($abstract)
+		);
+
+		// If an instance of the type is currently being managed as a singleton we'll
+		// just return an existing instance instead of instantiating new instances
+		// so the developer can keep using the same objects instance every time.
+		if (isset($this->instances[$abstract]) && ! $needsContextualBuild) {
+			return $this->instances[$abstract];
+		}
+
+		$this->with[] = $parameters;
+
+		$concrete = $this->getConcrete($abstract);
+
+		// We're ready to instantiate an instance of the concrete type registered for
+		// the binding. This will instantiate the types, as well as resolve any of
+		// its "nested" dependencies recursively until all have gotten resolved.
+		if ($this->isBuildable($concrete, $abstract)) {
+			$object = $this->build($concrete);
+		} else {
+			$object = $this->make($concrete);
+		}
+
+		// If we defined any extenders for this type, we'll need to spin through them
+		// and apply them to the object being built. This allows for the extension
+		// of services, such as changing configuration or decorating the object.
+		foreach ($this->getExtenders($abstract) as $extender) {
+			$object = $extender($object, $this);
+		}
+
+		// If the requested type is registered as a singleton we'll want to cache off
+		// the instances in "memory" so we can return it later without creating an
+		// entirely new instance of an object on each subsequent request for it.
+		if ($this->isShared($abstract) && ! $needsContextualBuild) {
+			$this->instances[$abstract] = $object;
+		}
+
+		$this->fireResolvingCallbacks($abstract, $object);
+
+		// Before returning, we will also set the resolved flag to "true" and pop off
+		// the parameter overrides for this build. After those two things are done
+		// we will be ready to return back the fully constructed class instance.
+		$this->resolved[$abstract] = true;
+
+		array_pop($this->with);
+
+		return $object;
+	}
+
+	/**
+	 * Get the concrete type for a given abstract.
+	 *
+	 * @param  string  $abstract
+	 * @return mixed   $concrete
+	 */
+	protected function getConcrete($abstract)
+	{
+		if (! is_null($concrete = $this->getContextualConcrete($abstract))) {
+			return $concrete;
+		}
+
+		// If we don't have a registered resolver or concrete for the type, we'll just
+		// assume each type is a concrete name and will attempt to resolve it as is
+		// since the container should be able to resolve concretes automatically.
+		if (isset($this->bindings[$abstract])) {
+			return $this->bindings[$abstract]['concrete'];
+		}
+
+		return $abstract;
+	}
+
+	/**
+	 * Get the contextual concrete binding for the given abstract.
+	 *
+	 * @param  string  $abstract
+	 * @return string|null
+	 */
+	protected function getContextualConcrete($abstract)
+	{
+		if (! is_null($binding = $this->findInContextualBindings($abstract))) {
+			return $binding;
+		}
+
+		// Next we need to see if a contextual binding might be bound under an alias of the
+		// given abstract type. So, we will need to check if any aliases exist with this
+		// type and then spin through them and check for contextual bindings on these.
+		if (empty($this->abstractAliases[$abstract])) {
+			return;
+		}
+
+		foreach ($this->abstractAliases[$abstract] as $alias) {
+			if (! is_null($binding = $this->findInContextualBindings($alias))) {
+				return $binding;
+			}
+		}
+	}
+
+	/**
+	 * Find the concrete binding for the given abstract in the contextual binding array.
+	 *
+	 * @param  string  $abstract
+	 * @return string|null
+	 */
+	protected function findInContextualBindings($abstract)
+	{
+		if (isset($this->contextual[end($this->buildStack)][$abstract])) {
+			return $this->contextual[end($this->buildStack)][$abstract];
+		}
+	}
+
+	/**
+	 * Determine if the given concrete is buildable.
+	 *
+	 * @param  mixed   $concrete
+	 * @param  string  $abstract
+	 * @return bool
+	 */
+	protected function isBuildable($concrete, $abstract)
+	{
+		return $concrete === $abstract || $concrete instanceof Closure;
+	}
+
+	/**
+	 * Instantiate a concrete instance of the given type.
+	 *
+	 * @param  string  $concrete
+	 * @return mixed
+	 *
+	 * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
+	 */
+	public function build($concrete)
+	{
+		// If the concrete type is actually a Closure, we will just execute it and
+		// hand back the results of the functions, which allows functions to be
+		// used as resolvers for more fine-tuned resolution of these objects.
+		if ($concrete instanceof Closure) {
+			return $concrete($this, $this->getLastParameterOverride());
+		}
+
+		$reflector = new ReflectionClass($concrete);
+
+		// If the type is not instantiable, the developer is attempting to resolve
+		// an abstract type such as an Interface of Abstract Class and there is
+		// no binding registered for the abstractions so we need to bail out.
+		if (! $reflector->isInstantiable()) {
+			return $this->notInstantiable($concrete);
+		}
+
+		$this->buildStack[] = $concrete;
+
+		$constructor = $reflector->getConstructor();
+
+		// If there are no constructors, that means there are no dependencies then
+		// we can just resolve the instances of the objects right away, without
+		// resolving any other types or dependencies out of these containers.
+		if (is_null($constructor)) {
+			array_pop($this->buildStack);
+
+			return new $concrete;
+		}
+
+		$dependencies = $constructor->getParameters();
+
+		// Once we have all the constructor's parameters we can create each of the
+		// dependency instances and then use the reflection instances to make a
+		// new instance of this class, injecting the created dependencies in.
+		$instances = $this->resolveDependencies(
+			$dependencies
+		);
+
+		array_pop($this->buildStack);
+
+		return $reflector->newInstanceArgs($instances);
+	}
+
+	/**
+	 * Resolve all of the dependencies from the ReflectionParameters.
+	 *
+	 * @param  array  $dependencies
+	 * @return array
+	 */
+	protected function resolveDependencies(array $dependencies)
+	{
+		$results = [];
+
+		foreach ($dependencies as $dependency) {
+			// If this dependency has a override for this particular build we will use
+			// that instead as the value. Otherwise, we will continue with this run
+			// of resolutions and let reflection attempt to determine the result.
+			if ($this->hasParameterOverride($dependency)) {
+				$results[] = $this->getParameterOverride($dependency);
+
+				continue;
+			}
+
+			// If the class is null, it means the dependency is a string or some other
+			// primitive type which we can not resolve since it is not a class and
+			// we will just bomb out with an error since we have no-where to go.
+			$results[] = is_null($class = $dependency->getClass())
+							? $this->resolvePrimitive($dependency)
+							: $this->resolveClass($dependency);
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Determine if the given dependency has a parameter override from makeWith.
+	 *
+	 * @param  \ReflectionParameter  $dependency
+	 * @return bool
+	 */
+	protected function hasParameterOverride($dependency)
+	{
+		return array_key_exists(
+			$dependency->name, $this->getLastParameterOverride()
+		);
+	}
+
+	/**
+	 * Get a parameter override for a dependency.
+	 *
+	 * @param  \ReflectionParameter  $dependency
+	 * @return mixed
+	 */
+	protected function getParameterOverride($dependency)
+	{
+		return $this->getLastParameterOverride()[$dependency->name];
+	}
+
+	/**
+	 * Get the last parameter override.
+	 *
+	 * @return array
+	 */
+	protected function getLastParameterOverride()
+	{
+		return count($this->with) ? end($this->with) : [];
+	}
+
+	/**
+	 * Resolve a non-class hinted primitive dependency.
+	 *
+	 * @param  \ReflectionParameter  $parameter
+	 * @return mixed
+	 *
+	 * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
+	 */
+	protected function resolvePrimitive(ReflectionParameter $parameter)
+	{
+		if (! is_null($concrete = $this->getContextualConcrete('$'.$parameter->name))) {
+			return $concrete instanceof Closure ? $concrete($this) : $concrete;
+		}
+
+		if ($parameter->isDefaultValueAvailable()) {
+			return $parameter->getDefaultValue();
+		}
+
+		$this->unresolvablePrimitive($parameter);
+	}
+
+	/**
+	 * Resolve a class based dependency from the container.
+	 *
+	 * @param  \ReflectionParameter  $parameter
+	 * @return mixed
+	 *
+	 * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
+	 */
+	protected function resolveClass(ReflectionParameter $parameter)
+	{
+		try {
+			return $this->make($parameter->getClass()->name);
+		}
+
+		// If we can not resolve the class instance, we will check to see if the value
+		// is optional, and if it is we will return the optional parameter value as
+		// the value of the dependency, similarly to how we do this with scalars.
+		catch (BindingResolutionException $e) {
+			if ($parameter->isOptional()) {
+				return $parameter->getDefaultValue();
+			}
+
+			throw $e;
+		}
+	}
+
+	/**
+	 * Throw an exception that the concrete is not instantiable.
+	 *
+	 * @param  string  $concrete
+	 * @return void
+	 *
+	 * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
+	 */
+	protected function notInstantiable($concrete)
+	{
+		if (! empty($this->buildStack)) {
+			$previous = implode(', ', $this->buildStack);
+
+			$message = "Target [$concrete] is not instantiable while building [$previous].";
+		} else {
+			$message = "Target [$concrete] is not instantiable.";
+		}
+
+		throw new BindingResolutionException($message);
+	}
+
+	/**
+	 * Throw an exception for an unresolvable primitive.
+	 *
+	 * @param  \ReflectionParameter  $parameter
+	 * @return void
+	 *
+	 * @throws \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\BindingResolutionException
+	 */
+	protected function unresolvablePrimitive(ReflectionParameter $parameter)
+	{
+		$message = "Unresolvable dependency resolving [$parameter] in class {$parameter->getDeclaringClass()->getName()}";
+
+		throw new BindingResolutionException($message);
+	}
+
+	/**
+	 * Register a new resolving callback.
+	 *
+	 * @param  string    $abstract
+	 * @param  \Closure|null  $callback
+	 * @return void
+	 */
+	public function resolving($abstract, Closure $callback = null)
+	{
+		if (is_string($abstract)) {
+			$abstract = $this->getAlias($abstract);
+		}
+
+		if (is_null($callback) && $abstract instanceof Closure) {
+			$this->globalResolvingCallbacks[] = $abstract;
+		} else {
+			$this->resolvingCallbacks[$abstract][] = $callback;
+		}
+	}
+
+	/**
+	 * Register a new after resolving callback for all types.
+	 *
+	 * @param  string   $abstract
+	 * @param  \Closure|null $callback
+	 * @return void
+	 */
+	public function afterResolving($abstract, Closure $callback = null)
+	{
+		if (is_string($abstract)) {
+			$abstract = $this->getAlias($abstract);
+		}
+
+		if ($abstract instanceof Closure && is_null($callback)) {
+			$this->globalAfterResolvingCallbacks[] = $abstract;
+		} else {
+			$this->afterResolvingCallbacks[$abstract][] = $callback;
+		}
+	}
+
+	/**
+	 * Fire all of the resolving callbacks.
+	 *
+	 * @param  string  $abstract
+	 * @param  mixed   $object
+	 * @return void
+	 */
+	protected function fireResolvingCallbacks($abstract, $object)
+	{
+		$this->fireCallbackArray($object, $this->globalResolvingCallbacks);
+
+		$this->fireCallbackArray(
+			$object, $this->getCallbacksForType($abstract, $object, $this->resolvingCallbacks)
+		);
+
+		$this->fireAfterResolvingCallbacks($abstract, $object);
+	}
+
+	/**
+	 * Fire all of the after resolving callbacks.
+	 *
+	 * @param  string  $abstract
+	 * @param  mixed   $object
+	 * @return void
+	 */
+	protected function fireAfterResolvingCallbacks($abstract, $object)
+	{
+		$this->fireCallbackArray($object, $this->globalAfterResolvingCallbacks);
+
+		$this->fireCallbackArray(
+			$object, $this->getCallbacksForType($abstract, $object, $this->afterResolvingCallbacks)
+		);
+	}
+
+	/**
+	 * Get all callbacks for a given type.
+	 *
+	 * @param  string  $abstract
+	 * @param  object  $object
+	 * @param  array   $callbacksPerType
+	 *
+	 * @return array
+	 */
+	protected function getCallbacksForType($abstract, $object, array $callbacksPerType)
+	{
+		$results = [];
+
+		foreach ($callbacksPerType as $type => $callbacks) {
+			if ($type === $abstract || $object instanceof $type) {
+				$results = array_merge($results, $callbacks);
+			}
+		}
+
+		return $results;
+	}
+
+	/**
+	 * Fire an array of callbacks with an object.
+	 *
+	 * @param  mixed  $object
+	 * @param  array  $callbacks
+	 * @return void
+	 */
+	protected function fireCallbackArray($object, array $callbacks)
+	{
+		foreach ($callbacks as $callback) {
+			$callback($object, $this);
+		}
+	}
+
+	/**
+	 * Get the container's bindings.
+	 *
+	 * @return array
+	 */
+	public function getBindings()
+	{
+		return $this->bindings;
+	}
+
+	/**
+	 * Get the alias for an abstract if available.
+	 *
+	 * @param  string  $abstract
+	 * @return string
+	 *
+	 * @throws \LogicException
+	 */
+	public function getAlias($abstract)
+	{
+		if (! isset($this->aliases[$abstract])) {
+			return $abstract;
+		}
+
+		if ($this->aliases[$abstract] === $abstract) {
+			throw new LogicException("[{$abstract}] is aliased to itself.");
+		}
+
+		return $this->getAlias($this->aliases[$abstract]);
+	}
+
+	/**
+	 * Get the extender callbacks for a given type.
+	 *
+	 * @param  string  $abstract
+	 * @return array
+	 */
+	protected function getExtenders($abstract)
+	{
+		$abstract = $this->getAlias($abstract);
+
+		if (isset($this->extenders[$abstract])) {
+			return $this->extenders[$abstract];
+		}
+
+		return [];
+	}
+
+	/**
+	 * Remove all of the extender callbacks for a given type.
+	 *
+	 * @param  string  $abstract
+	 * @return void
+	 */
+	public function forgetExtenders($abstract)
+	{
+		unset($this->extenders[$this->getAlias($abstract)]);
+	}
+
+	/**
+	 * Drop all of the stale instances and aliases.
+	 *
+	 * @param  string  $abstract
+	 * @return void
+	 */
+	protected function dropStaleInstances($abstract)
+	{
+		unset($this->instances[$abstract], $this->aliases[$abstract]);
+	}
+
+	/**
+	 * Remove a resolved instance from the instance cache.
+	 *
+	 * @param  string  $abstract
+	 * @return void
+	 */
+	public function forgetInstance($abstract)
+	{
+		unset($this->instances[$abstract]);
+	}
+
+	/**
+	 * Clear all of the instances from the container.
+	 *
+	 * @return void
+	 */
+	public function forgetInstances()
+	{
+		$this->instances = [];
+	}
+
+	/**
+	 * Flush the container of all bindings and resolved instances.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		$this->aliases = [];
+		$this->resolved = [];
+		$this->bindings = [];
+		$this->instances = [];
+		$this->abstractAliases = [];
+	}
+
+	/**
+	 * Set the globally available instance of the container.
+	 *
+	 * @return static
+	 */
+	public static function getInstance()
+	{
+		if (is_null(static::$instance)) {
+			static::$instance = new static;
+		}
+
+		return static::$instance;
+	}
+
+	/**
+	 * Set the shared instance of the container.
+	 *
+	 * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Contracts\Container\Container|null  $container
+	 * @return static
+	 */
+	public static function setInstance(ContainerContract $container = null)
+	{
+		return static::$instance = $container;
+	}
+
+	/**
+	 * Determine if a given offset exists.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function offsetExists($key)
+	{
+		return $this->bound($key);
+	}
+
+	/**
+	 * Get the value at a given offset.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function offsetGet($key)
+	{
+		return $this->make($key);
+	}
+
+	/**
+	 * Set the value at a given offset.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function offsetSet($key, $value)
+	{
+		$this->bind($key, $value instanceof Closure ? $value : function () use ($value) {
+			return $value;
+		});
+	}
+
+	/**
+	 * Unset the value at a given offset.
+	 *
+	 * @param  string  $key
+	 * @return void
+	 */
+	public function offsetUnset($key)
+	{
+		unset($this->bindings[$key], $this->instances[$key], $this->resolved[$key]);
+	}
+
+	/**
+	 * Dynamically access container services.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		return $this[$key];
+	}
+
+	/**
+	 * Dynamically set container services.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function __set($key, $value)
+	{
+		$this[$key] = $value;
+	}
 }

vendor_prefixed/illuminate/container/ContextualBindingBuilder.php

Indentation +53 added lines, -53 removed lines

@@ -12,63 +12,63 @@
 
 class ContextualBindingBuilder implements ContextualBindingBuilderContract
 {
-    /**
-     * The underlying container instance.
-     *
-     * @var \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container
-     */
-    protected $container;
+	/**
+	 * The underlying container instance.
+	 *
+	 * @var \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container
+	 */
+	protected $container;
 
-    /**
-     * The concrete instance.
-     *
-     * @var string
-     */
-    protected $concrete;
+	/**
+	 * The concrete instance.
+	 *
+	 * @var string
+	 */
+	protected $concrete;
 
-    /**
-     * The abstract target.
-     *
-     * @var string
-     */
-    protected $needs;
+	/**
+	 * The abstract target.
+	 *
+	 * @var string
+	 */
+	protected $needs;
 
-    /**
-     * Create a new contextual binding builder.
-     *
-     * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
-     * @param  string  $concrete
-     * @return void
-     */
-    public function __construct(Container $container, $concrete)
-    {
-        $this->concrete = $concrete;
-        $this->container = $container;
-    }
+	/**
+	 * Create a new contextual binding builder.
+	 *
+	 * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
+	 * @param  string  $concrete
+	 * @return void
+	 */
+	public function __construct(Container $container, $concrete)
+	{
+		$this->concrete = $concrete;
+		$this->container = $container;
+	}
 
-    /**
-     * Define the abstract target that depends on the context.
-     *
-     * @param  string  $abstract
-     * @return $this
-     */
-    public function needs($abstract)
-    {
-        $this->needs = $abstract;
+	/**
+	 * Define the abstract target that depends on the context.
+	 *
+	 * @param  string  $abstract
+	 * @return $this
+	 */
+	public function needs($abstract)
+	{
+		$this->needs = $abstract;
 
-        return $this;
-    }
+		return $this;
+	}
 
-    /**
-     * Define the implementation for the contextual binding.
-     *
-     * @param  \Closure|string  $implementation
-     * @return void
-     */
-    public function give($implementation)
-    {
-        $this->container->addContextualBinding(
-            $this->concrete, $this->needs, $implementation
-        );
-    }
+	/**
+	 * Define the implementation for the contextual binding.
+	 *
+	 * @param  \Closure|string  $implementation
+	 * @return void
+	 */
+	public function give($implementation)
+	{
+		$this->container->addContextualBinding(
+			$this->concrete, $this->needs, $implementation
+		);
+	}
 }

vendor_prefixed/illuminate/container/BoundMethod.php

Indentation +160 added lines, -160 removed lines

@@ -15,164 +15,164 @@
 
 class BoundMethod
 {
-    /**
-     * Call the given Closure / class@method and inject its dependencies.
-     *
-     * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
-     * @param  callable|string  $callback
-     * @param  array  $parameters
-     * @param  string|null  $defaultMethod
-     * @return mixed
-     */
-    public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
-    {
-        if (static::isCallableWithAtSign($callback) || $defaultMethod) {
-            return static::callClass($container, $callback, $parameters, $defaultMethod);
-        }
-
-        return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
-            return call_user_func_array(
-                $callback, static::getMethodDependencies($container, $callback, $parameters)
-            );
-        });
-    }
-
-    /**
-     * Call a string reference to a class using Class@method syntax.
-     *
-     * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
-     * @param  string  $target
-     * @param  array  $parameters
-     * @param  string|null  $defaultMethod
-     * @return mixed
-     *
-     * @throws \InvalidArgumentException
-     */
-    protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
-    {
-        $segments = explode('@', $target);
-
-        // We will assume an @ sign is used to delimit the class name from the method
-        // name. We will split on this @ sign and then build a callable array that
-        // we can pass right back into the "call" method for dependency binding.
-        $method = count($segments) == 2
-                        ? $segments[1] : $defaultMethod;
-
-        if (is_null($method)) {
-            throw new InvalidArgumentException('Method not provided.');
-        }
-
-        return static::call(
-            $container, [$container->make($segments[0]), $method], $parameters
-        );
-    }
-
-    /**
-     * Call a method that has been bound to the container.
-     *
-     * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
-     * @param  callable  $callback
-     * @param  mixed  $default
-     * @return mixed
-     */
-    protected static function callBoundMethod($container, $callback, $default)
-    {
-        if (! is_array($callback)) {
-            return $default instanceof Closure ? $default() : $default;
-        }
-
-        // Here we need to turn the array callable into a Class@method string we can use to
-        // examine the container and see if there are any method bindings for this given
-        // method. If there are, we can call this method binding callback immediately.
-        $method = static::normalizeMethod($callback);
-
-        if ($container->hasMethodBinding($method)) {
-            return $container->callMethodBinding($method, $callback[0]);
-        }
-
-        return $default instanceof Closure ? $default() : $default;
-    }
-
-    /**
-     * Normalize the given callback into a Class@method string.
-     *
-     * @param  callable  $callback
-     * @return string
-     */
-    protected static function normalizeMethod($callback)
-    {
-        $class = is_string($callback[0]) ? $callback[0] : get_class($callback[0]);
-
-        return "{$class}@{$callback[1]}";
-    }
-
-    /**
-     * Get all dependencies for a given method.
-     *
-     * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container
-     * @param  callable|string  $callback
-     * @param  array  $parameters
-     * @return array
-     */
-    protected static function getMethodDependencies($container, $callback, array $parameters = [])
-    {
-        $dependencies = [];
-
-        foreach (static::getCallReflector($callback)->getParameters() as $parameter) {
-            static::addDependencyForCallParameter($container, $parameter, $parameters, $dependencies);
-        }
-
-        return array_merge($dependencies, $parameters);
-    }
-
-    /**
-     * Get the proper reflection instance for the given callback.
-     *
-     * @param  callable|string  $callback
-     * @return \ReflectionFunctionAbstract
-     */
-    protected static function getCallReflector($callback)
-    {
-        if (is_string($callback) && strpos($callback, '::') !== false) {
-            $callback = explode('::', $callback);
-        }
-
-        return is_array($callback)
-                        ? new ReflectionMethod($callback[0], $callback[1])
-                        : new ReflectionFunction($callback);
-    }
-
-    /**
-     * Get the dependency for the given call parameter.
-     *
-     * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
-     * @param  \ReflectionParameter  $parameter
-     * @param  array  $parameters
-     * @param  array  $dependencies
-     * @return mixed
-     */
-    protected static function addDependencyForCallParameter($container, $parameter,
-                                                            array &$parameters, &$dependencies)
-    {
-        if (array_key_exists($parameter->name, $parameters)) {
-            $dependencies[] = $parameters[$parameter->name];
-
-            unset($parameters[$parameter->name]);
-        } elseif ($parameter->getClass()) {
-            $dependencies[] = $container->make($parameter->getClass()->name);
-        } elseif ($parameter->isDefaultValueAvailable()) {
-            $dependencies[] = $parameter->getDefaultValue();
-        }
-    }
-
-    /**
-     * Determine if the given string is in Class@method syntax.
-     *
-     * @param  mixed  $callback
-     * @return bool
-     */
-    protected static function isCallableWithAtSign($callback)
-    {
-        return is_string($callback) && strpos($callback, '@') !== false;
-    }
+	/**
+	 * Call the given Closure / class@method and inject its dependencies.
+	 *
+	 * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
+	 * @param  callable|string  $callback
+	 * @param  array  $parameters
+	 * @param  string|null  $defaultMethod
+	 * @return mixed
+	 */
+	public static function call($container, $callback, array $parameters = [], $defaultMethod = null)
+	{
+		if (static::isCallableWithAtSign($callback) || $defaultMethod) {
+			return static::callClass($container, $callback, $parameters, $defaultMethod);
+		}
+
+		return static::callBoundMethod($container, $callback, function () use ($container, $callback, $parameters) {
+			return call_user_func_array(
+				$callback, static::getMethodDependencies($container, $callback, $parameters)
+			);
+		});
+	}
+
+	/**
+	 * Call a string reference to a class using Class@method syntax.
+	 *
+	 * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
+	 * @param  string  $target
+	 * @param  array  $parameters
+	 * @param  string|null  $defaultMethod
+	 * @return mixed
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	protected static function callClass($container, $target, array $parameters = [], $defaultMethod = null)
+	{
+		$segments = explode('@', $target);
+
+		// We will assume an @ sign is used to delimit the class name from the method
+		// name. We will split on this @ sign and then build a callable array that
+		// we can pass right back into the "call" method for dependency binding.
+		$method = count($segments) == 2
+						? $segments[1] : $defaultMethod;
+
+		if (is_null($method)) {
+			throw new InvalidArgumentException('Method not provided.');
+		}
+
+		return static::call(
+			$container, [$container->make($segments[0]), $method], $parameters
+		);
+	}
+
+	/**
+	 * Call a method that has been bound to the container.
+	 *
+	 * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
+	 * @param  callable  $callback
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	protected static function callBoundMethod($container, $callback, $default)
+	{
+		if (! is_array($callback)) {
+			return $default instanceof Closure ? $default() : $default;
+		}
+
+		// Here we need to turn the array callable into a Class@method string we can use to
+		// examine the container and see if there are any method bindings for this given
+		// method. If there are, we can call this method binding callback immediately.
+		$method = static::normalizeMethod($callback);
+
+		if ($container->hasMethodBinding($method)) {
+			return $container->callMethodBinding($method, $callback[0]);
+		}
+
+		return $default instanceof Closure ? $default() : $default;
+	}
+
+	/**
+	 * Normalize the given callback into a Class@method string.
+	 *
+	 * @param  callable  $callback
+	 * @return string
+	 */
+	protected static function normalizeMethod($callback)
+	{
+		$class = is_string($callback[0]) ? $callback[0] : get_class($callback[0]);
+
+		return "{$class}@{$callback[1]}";
+	}
+
+	/**
+	 * Get all dependencies for a given method.
+	 *
+	 * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container
+	 * @param  callable|string  $callback
+	 * @param  array  $parameters
+	 * @return array
+	 */
+	protected static function getMethodDependencies($container, $callback, array $parameters = [])
+	{
+		$dependencies = [];
+
+		foreach (static::getCallReflector($callback)->getParameters() as $parameter) {
+			static::addDependencyForCallParameter($container, $parameter, $parameters, $dependencies);
+		}
+
+		return array_merge($dependencies, $parameters);
+	}
+
+	/**
+	 * Get the proper reflection instance for the given callback.
+	 *
+	 * @param  callable|string  $callback
+	 * @return \ReflectionFunctionAbstract
+	 */
+	protected static function getCallReflector($callback)
+	{
+		if (is_string($callback) && strpos($callback, '::') !== false) {
+			$callback = explode('::', $callback);
+		}
+
+		return is_array($callback)
+						? new ReflectionMethod($callback[0], $callback[1])
+						: new ReflectionFunction($callback);
+	}
+
+	/**
+	 * Get the dependency for the given call parameter.
+	 *
+	 * @param  \GravityKit\GravityView\Foundation\ThirdParty\Illuminate\Container\Container  $container
+	 * @param  \ReflectionParameter  $parameter
+	 * @param  array  $parameters
+	 * @param  array  $dependencies
+	 * @return mixed
+	 */
+	protected static function addDependencyForCallParameter($container, $parameter,
+															array &$parameters, &$dependencies)
+	{
+		if (array_key_exists($parameter->name, $parameters)) {
+			$dependencies[] = $parameters[$parameter->name];
+
+			unset($parameters[$parameter->name]);
+		} elseif ($parameter->getClass()) {
+			$dependencies[] = $container->make($parameter->getClass()->name);
+		} elseif ($parameter->isDefaultValueAvailable()) {
+			$dependencies[] = $parameter->getDefaultValue();
+		}
+	}
+
+	/**
+	 * Determine if the given string is in Class@method syntax.
+	 *
+	 * @param  mixed  $callback
+	 * @return bool
+	 */
+	protected static function isCallableWithAtSign($callback)
+	{
+		return is_string($callback) && strpos($callback, '@') !== false;
+	}
 }

vendor_prefixed/illuminate/contracts/Logging/Log.php

Indentation +82 added lines, -82 removed lines

@@ -4,95 +4,95 @@
 
 interface Log
 {
-    /**
-     * Log an alert message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function alert($message, array $context = []);
+	/**
+	 * Log an alert message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function alert($message, array $context = []);
 
-    /**
-     * Log a critical message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function critical($message, array $context = []);
+	/**
+	 * Log a critical message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function critical($message, array $context = []);
 
-    /**
-     * Log an error message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function error($message, array $context = []);
+	/**
+	 * Log an error message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function error($message, array $context = []);
 
-    /**
-     * Log a warning message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function warning($message, array $context = []);
+	/**
+	 * Log a warning message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function warning($message, array $context = []);
 
-    /**
-     * Log a notice to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function notice($message, array $context = []);
+	/**
+	 * Log a notice to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function notice($message, array $context = []);
 
-    /**
-     * Log an informational message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function info($message, array $context = []);
+	/**
+	 * Log an informational message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function info($message, array $context = []);
 
-    /**
-     * Log a debug message to the logs.
-     *
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function debug($message, array $context = []);
+	/**
+	 * Log a debug message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function debug($message, array $context = []);
 
-    /**
-     * Log a message to the logs.
-     *
-     * @param  string  $level
-     * @param  string  $message
-     * @param  array  $context
-     * @return void
-     */
-    public function log($level, $message, array $context = []);
+	/**
+	 * Log a message to the logs.
+	 *
+	 * @param  string  $level
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function log($level, $message, array $context = []);
 
-    /**
-     * Register a file log handler.
-     *
-     * @param  string  $path
-     * @param  string  $level
-     * @return void
-     */
-    public function useFiles($path, $level = 'debug');
+	/**
+	 * Register a file log handler.
+	 *
+	 * @param  string  $path
+	 * @param  string  $level
+	 * @return void
+	 */
+	public function useFiles($path, $level = 'debug');
 
-    /**
-     * Register a daily file log handler.
-     *
-     * @param  string  $path
-     * @param  int     $days
-     * @param  string  $level
-     * @return void
-     */
-    public function useDailyFiles($path, $days = 0, $level = 'debug');
+	/**
+	 * Register a daily file log handler.
+	 *
+	 * @param  string  $path
+	 * @param  int     $days
+	 * @param  string  $level
+	 * @return void
+	 */
+	public function useDailyFiles($path, $days = 0, $level = 'debug');
 }

vendor_prefixed/illuminate/contracts/Session/Session.php

Indentation +158 added lines, -158 removed lines

@@ -10,162 +10,162 @@
 
 interface Session
 {
-    /**
-     * Get the name of the session.
-     *
-     * @return string
-     */
-    public function getName();
-
-    /**
-     * Get the current session ID.
-     *
-     * @return string
-     */
-    public function getId();
-
-    /**
-     * Set the session ID.
-     *
-     * @param  string  $id
-     * @return void
-     */
-    public function setId($id);
-
-    /**
-     * Start the session, reading the data from a handler.
-     *
-     * @return bool
-     */
-    public function start();
-
-    /**
-     * Save the session data to storage.
-     *
-     * @return bool
-     */
-    public function save();
-
-    /**
-     * Get all of the session data.
-     *
-     * @return array
-     */
-    public function all();
-
-    /**
-     * Checks if a key exists.
-     *
-     * @param  string|array  $key
-     * @return bool
-     */
-    public function exists($key);
-
-    /**
-     * Checks if an a key is present and not null.
-     *
-     * @param  string|array  $key
-     * @return bool
-     */
-    public function has($key);
-
-    /**
-     * Get an item from the session.
-     *
-     * @param  string  $key
-     * @param  mixed  $default
-     * @return mixed
-     */
-    public function get($key, $default = null);
-
-    /**
-     * Put a key / value pair or array of key / value pairs in the session.
-     *
-     * @param  string|array  $key
-     * @param  mixed       $value
-     * @return void
-     */
-    public function put($key, $value = null);
-
-    /**
-     * Get the CSRF token value.
-     *
-     * @return string
-     */
-    public function token();
-
-    /**
-     * Remove an item from the session, returning its value.
-     *
-     * @param  string  $key
-     * @return mixed
-     */
-    public function remove($key);
-
-    /**
-     * Remove one or many items from the session.
-     *
-     * @param  string|array  $keys
-     * @return void
-     */
-    public function forget($keys);
-
-    /**
-     * Remove all of the items from the session.
-     *
-     * @return void
-     */
-    public function flush();
-
-    /**
-     * Generate a new session ID for the session.
-     *
-     * @param  bool  $destroy
-     * @return bool
-     */
-    public function migrate($destroy = false);
-
-    /**
-     * Determine if the session has been started.
-     *
-     * @return bool
-     */
-    public function isStarted();
-
-    /**
-     * Get the previous URL from the session.
-     *
-     * @return string|null
-     */
-    public function previousUrl();
-
-    /**
-     * Set the "previous" URL in the session.
-     *
-     * @param  string  $url
-     * @return void
-     */
-    public function setPreviousUrl($url);
-
-    /**
-     * Get the session handler instance.
-     *
-     * @return \SessionHandlerInterface
-     */
-    public function getHandler();
-
-    /**
-     * Determine if the session handler needs a request.
-     *
-     * @return bool
-     */
-    public function handlerNeedsRequest();
-
-    /**
-     * Set the request on the handler instance.
-     *
-     * @param  \Illuminate\Http\Request  $request
-     * @return void
-     */
-    public function setRequestOnHandler($request);
+	/**
+	 * Get the name of the session.
+	 *
+	 * @return string
+	 */
+	public function getName();
+
+	/**
+	 * Get the current session ID.
+	 *
+	 * @return string
+	 */
+	public function getId();
+
+	/**
+	 * Set the session ID.
+	 *
+	 * @param  string  $id
+	 * @return void
+	 */
+	public function setId($id);
+
+	/**
+	 * Start the session, reading the data from a handler.
+	 *
+	 * @return bool
+	 */
+	public function start();
+
+	/**
+	 * Save the session data to storage.
+	 *
+	 * @return bool
+	 */
+	public function save();
+
+	/**
+	 * Get all of the session data.
+	 *
+	 * @return array
+	 */
+	public function all();
+
+	/**
+	 * Checks if a key exists.
+	 *
+	 * @param  string|array  $key
+	 * @return bool
+	 */
+	public function exists($key);
+
+	/**
+	 * Checks if an a key is present and not null.
+	 *
+	 * @param  string|array  $key
+	 * @return bool
+	 */
+	public function has($key);
+
+	/**
+	 * Get an item from the session.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $default
+	 * @return mixed
+	 */
+	public function get($key, $default = null);
+
+	/**
+	 * Put a key / value pair or array of key / value pairs in the session.
+	 *
+	 * @param  string|array  $key
+	 * @param  mixed       $value
+	 * @return void
+	 */
+	public function put($key, $value = null);
+
+	/**
+	 * Get the CSRF token value.
+	 *
+	 * @return string
+	 */
+	public function token();
+
+	/**
+	 * Remove an item from the session, returning its value.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function remove($key);
+
+	/**
+	 * Remove one or many items from the session.
+	 *
+	 * @param  string|array  $keys
+	 * @return void
+	 */
+	public function forget($keys);
+
+	/**
+	 * Remove all of the items from the session.
+	 *
+	 * @return void
+	 */
+	public function flush();
+
+	/**
+	 * Generate a new session ID for the session.
+	 *
+	 * @param  bool  $destroy
+	 * @return bool
+	 */
+	public function migrate($destroy = false);
+
+	/**
+	 * Determine if the session has been started.
+	 *
+	 * @return bool
+	 */
+	public function isStarted();
+
+	/**
+	 * Get the previous URL from the session.
+	 *
+	 * @return string|null
+	 */
+	public function previousUrl();
+
+	/**
+	 * Set the "previous" URL in the session.
+	 *
+	 * @param  string  $url
+	 * @return void
+	 */
+	public function setPreviousUrl($url);
+
+	/**
+	 * Get the session handler instance.
+	 *
+	 * @return \SessionHandlerInterface
+	 */
+	public function getHandler();
+
+	/**
+	 * Determine if the session handler needs a request.
+	 *
+	 * @return bool
+	 */
+	public function handlerNeedsRequest();
+
+	/**
+	 * Set the request on the handler instance.
+	 *
+	 * @param  \Illuminate\Http\Request  $request
+	 * @return void
+	 */
+	public function setRequestOnHandler($request);
 }

vendor_prefixed/illuminate/contracts/Queue/Monitor.php

Indentation +21 added lines, -21 removed lines

@@ -4,27 +4,27 @@
 
 interface Monitor
 {
-    /**
-     * Register a callback to be executed on every iteration through the queue loop.
-     *
-     * @param  mixed  $callback
-     * @return void
-     */
-    public function looping($callback);
+	/**
+	 * Register a callback to be executed on every iteration through the queue loop.
+	 *
+	 * @param  mixed  $callback
+	 * @return void
+	 */
+	public function looping($callback);
 
-    /**
-     * Register a callback to be executed when a job fails after the maximum amount of retries.
-     *
-     * @param  mixed  $callback
-     * @return void
-     */
-    public function failing($callback);
+	/**
+	 * Register a callback to be executed when a job fails after the maximum amount of retries.
+	 *
+	 * @param  mixed  $callback
+	 * @return void
+	 */
+	public function failing($callback);
 
-    /**
-     * Register a callback to be executed when a daemon queue is stopping.
-     *
-     * @param  mixed  $callback
-     * @return void
-     */
-    public function stopping($callback);
+	/**
+	 * Register a callback to be executed when a daemon queue is stopping.
+	 *
+	 * @param  mixed  $callback
+	 * @return void
+	 */
+	public function stopping($callback);
 }