update v1.0.3.3

vendor/laravel/framework/src/Illuminate/Auth/AuthManager.php

@@ -0,0 +1,119 @@
+<?php namespace Illuminate\Auth;
+
+use Illuminate\Support\Manager;
+
+class AuthManager extends Manager {
+
+	/**
+	 * Create a new driver instance.
+	 *
+	 * @param  string  $driver
+	 * @return mixed
+	 */
+	protected function createDriver($driver)
+	{
+		$guard = parent::createDriver($driver);
+
+		// When using the remember me functionality of the authentication services we
+		// will need to be set the encryption instance of the guard, which allows
+		// secure, encrypted cookie values to get generated for those cookies.
+		$guard->setCookieJar($this->app['cookie']);
+
+		$guard->setDispatcher($this->app['events']);
+
+		return $guard->setRequest($this->app->refresh('request', $guard, 'setRequest'));
+	}
+
+	/**
+	 * Call a custom driver creator.
+	 *
+	 * @param  string  $driver
+	 * @return \Illuminate\Auth\Guard
+	 */
+	protected function callCustomCreator($driver)
+	{
+		$custom = parent::callCustomCreator($driver);
+
+		if ($custom instanceof Guard)
+		{
+			return $custom;
+		}
+
+		return new Guard($custom, $this->app['session.store']);
+	}
+
+	/**
+	 * Create an instance of the database driver.
+	 *
+	 * @return \Illuminate\Auth\Guard
+	 */
+	public function createDatabaseDriver()
+	{
+		$provider = $this->createDatabaseProvider();
+
+		return new Guard($provider, $this->app['session.store']);
+	}
+
+	/**
+	 * Create an instance of the database user provider.
+	 *
+	 * @return \Illuminate\Auth\DatabaseUserProvider
+	 */
+	protected function createDatabaseProvider()
+	{
+		$connection = $this->app['db']->connection();
+
+		// When using the basic database user provider, we need to inject the table we
+		// want to use, since this is not an Eloquent model we will have no way to
+		// know without telling the provider, so we'll inject the config value.
+		$table = $this->app['config']['auth.table'];
+
+		return new DatabaseUserProvider($connection, $this->app['hash'], $table);
+	}
+
+	/**
+	 * Create an instance of the Eloquent driver.
+	 *
+	 * @return \Illuminate\Auth\Guard
+	 */
+	public function createEloquentDriver()
+	{
+		$provider = $this->createEloquentProvider();
+
+		return new Guard($provider, $this->app['session.store']);
+	}
+
+	/**
+	 * Create an instance of the Eloquent user provider.
+	 *
+	 * @return \Illuminate\Auth\EloquentUserProvider
+	 */
+	protected function createEloquentProvider()
+	{
+		$model = $this->app['config']['auth.model'];
+
+		return new EloquentUserProvider($this->app['hash'], $model);
+	}
+
+	/**
+	 * Get the default authentication driver name.
+	 *
+	 * @return string
+	 */
+	public function getDefaultDriver()
+	{
+		return $this->app['config']['auth.driver'];
+	}
+
+	/**
+	 * Set the default authentication driver name.
+	 *
+	 * @param  string  $name
+	 * @return void
+	 */
+	public function setDefaultDriver($name)
+	{
+		$this->app['config']['auth.driver'] = $name;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/AuthServiceProvider.php

@@ -0,0 +1,73 @@
+<?php namespace Illuminate\Auth;
+
+use Illuminate\Support\ServiceProvider;
+
+class AuthServiceProvider extends ServiceProvider {
+
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->registerAuthenticator();
+
+		$this->registerUserResolver();
+
+		$this->registerRequestRebindHandler();
+	}
+
+	/**
+	 * Register the authenticator services.
+	 *
+	 * @return void
+	 */
+	protected function registerAuthenticator()
+	{
+		$this->app->singleton('auth', function($app)
+		{
+			// Once the authentication service has actually been requested by the developer
+			// we will set a variable in the application indicating such. This helps us
+			// know that we need to set any queued cookies in the after event later.
+			$app['auth.loaded'] = true;
+
+			return new AuthManager($app);
+		});
+
+		$this->app->singleton('auth.driver', function($app)
+		{
+			return $app['auth']->driver();
+		});
+	}
+
+	/**
+	 * Register a resolver for the authenticated user.
+	 *
+	 * @return void
+	 */
+	protected function registerUserResolver()
+	{
+		$this->app->bind('Illuminate\Contracts\Auth\Authenticatable', function($app)
+		{
+			return $app['auth']->user();
+		});
+	}
+
+	/**
+	 * Register a resolver for the authenticated user.
+	 *
+	 * @return void
+	 */
+	protected function registerRequestRebindHandler()
+	{
+		$this->app->rebinding('request', function($app, $request)
+		{
+			$request->setUserResolver(function() use ($app)
+			{
+				return $app['auth']->user();
+			});
+		});
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/Authenticatable.php

@@ -0,0 +1,56 @@
+<?php namespace Illuminate\Auth;
+
+trait Authenticatable {
+
+	/**
+	 * Get the unique identifier for the user.
+	 *
+	 * @return mixed
+	 */
+	public function getAuthIdentifier()
+	{
+		return $this->getKey();
+	}
+
+	/**
+	 * Get the password for the user.
+	 *
+	 * @return string
+	 */
+	public function getAuthPassword()
+	{
+		return $this->password;
+	}
+
+	/**
+	 * Get the token value for the "remember me" session.
+	 *
+	 * @return string
+	 */
+	public function getRememberToken()
+	{
+		return $this->{$this->getRememberTokenName()};
+	}
+
+	/**
+	 * Set the token value for the "remember me" session.
+	 *
+	 * @param  string  $value
+	 * @return void
+	 */
+	public function setRememberToken($value)
+	{
+		$this->{$this->getRememberTokenName()} = $value;
+	}
+
+	/**
+	 * Get the column name for the "remember me" token.
+	 *
+	 * @return string
+	 */
+	public function getRememberTokenName()
+	{
+		return 'remember_token';
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/Console/ClearResetsCommand.php

@@ -0,0 +1,33 @@
+<?php namespace Illuminate\Auth\Console;
+
+use Illuminate\Console\Command;
+
+class ClearResetsCommand extends Command {
+
+	/**
+	 * The console command name.
+	 *
+	 * @var string
+	 */
+	protected $name = 'auth:clear-resets';
+
+	/**
+	 * The console command description.
+	 *
+	 * @var string
+	 */
+	protected $description = 'Flush expired password reset tokens';
+
+	/**
+	 * Execute the console command.
+	 *
+	 * @return void
+	 */
+	public function fire()
+	{
+		$this->laravel['auth.password.tokens']->deleteExpired();
+
+		$this->info('Expired reset tokens cleared!');
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/DatabaseUserProvider.php

@@ -0,0 +1,147 @@
+<?php namespace Illuminate\Auth;
+
+use Illuminate\Contracts\Auth\UserProvider;
+use Illuminate\Database\ConnectionInterface;
+use Illuminate\Contracts\Hashing\Hasher as HasherContract;
+use Illuminate\Contracts\Auth\Authenticatable as UserContract;
+
+class DatabaseUserProvider implements UserProvider {
+
+	/**
+	 * The active database connection.
+	 *
+	 * @var \Illuminate\Database\ConnectionInterface
+	 */
+	protected $conn;
+
+	/**
+	 * The hasher implementation.
+	 *
+	 * @var \Illuminate\Contracts\Hashing\Hasher
+	 */
+	protected $hasher;
+
+	/**
+	 * The table containing the users.
+	 *
+	 * @var string
+	 */
+	protected $table;
+
+	/**
+	 * Create a new database user provider.
+	 *
+	 * @param  \Illuminate\Database\ConnectionInterface  $conn
+	 * @param  \Illuminate\Contracts\Hashing\Hasher  $hasher
+	 * @param  string  $table
+	 * @return void
+	 */
+	public function __construct(ConnectionInterface $conn, HasherContract $hasher, $table)
+	{
+		$this->conn = $conn;
+		$this->table = $table;
+		$this->hasher = $hasher;
+	}
+
+	/**
+	 * Retrieve a user by their unique identifier.
+	 *
+	 * @param  mixed  $identifier
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function retrieveById($identifier)
+	{
+		$user = $this->conn->table($this->table)->find($identifier);
+
+		return $this->getGenericUser($user);
+	}
+
+	/**
+	 * Retrieve a user by their unique identifier and "remember me" token.
+	 *
+	 * @param  mixed  $identifier
+	 * @param  string  $token
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function retrieveByToken($identifier, $token)
+	{
+		$user = $this->conn->table($this->table)
+			->where('id', $identifier)
+			->where('remember_token', $token)
+			->first();
+
+		return $this->getGenericUser($user);
+	}
+
+	/**
+	 * Update the "remember me" token for the given user in storage.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @param  string  $token
+	 * @return void
+	 */
+	public function updateRememberToken(UserContract $user, $token)
+	{
+		$this->conn->table($this->table)
+			->where('id', $user->getAuthIdentifier())
+			->update(['remember_token' => $token]);
+	}
+
+	/**
+	 * Retrieve a user by the given credentials.
+	 *
+	 * @param  array  $credentials
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function retrieveByCredentials(array $credentials)
+	{
+		// First we will add each credential element to the query as a where clause.
+		// Then we can execute the query and, if we found a user, return it in a
+		// generic "user" object that will be utilized by the Guard instances.
+		$query = $this->conn->table($this->table);
+
+		foreach ($credentials as $key => $value)
+		{
+			if ( ! str_contains($key, 'password'))
+			{
+				$query->where($key, $value);
+			}
+		}
+
+		// Now we are ready to execute the query to see if we have an user matching
+		// the given credentials. If not, we will just return nulls and indicate
+		// that there are no matching users for these given credential arrays.
+		$user = $query->first();
+
+		return $this->getGenericUser($user);
+	}
+
+	/**
+	 * Get the generic user.
+	 *
+	 * @param  mixed  $user
+	 * @return \Illuminate\Auth\GenericUser|null
+	 */
+	protected function getGenericUser($user)
+	{
+		if ($user !== null)
+		{
+			return new GenericUser((array) $user);
+		}
+	}
+
+	/**
+	 * Validate a user against the given credentials.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	public function validateCredentials(UserContract $user, array $credentials)
+	{
+		$plain = $credentials['password'];
+
+		return $this->hasher->check($plain, $user->getAuthPassword());
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/EloquentUserProvider.php

@@ -0,0 +1,128 @@
+<?php namespace Illuminate\Auth;
+
+use Illuminate\Contracts\Auth\UserProvider;
+use Illuminate\Contracts\Hashing\Hasher as HasherContract;
+use Illuminate\Contracts\Auth\Authenticatable as UserContract;
+
+class EloquentUserProvider implements UserProvider {
+
+	/**
+	 * The hasher implementation.
+	 *
+	 * @var \Illuminate\Contracts\Hashing\Hasher
+	 */
+	protected $hasher;
+
+	/**
+	 * The Eloquent user model.
+	 *
+	 * @var string
+	 */
+	protected $model;
+
+	/**
+	 * Create a new database user provider.
+	 *
+	 * @param  \Illuminate\Contracts\Hashing\Hasher  $hasher
+	 * @param  string  $model
+	 * @return void
+	 */
+	public function __construct(HasherContract $hasher, $model)
+	{
+		$this->model = $model;
+		$this->hasher = $hasher;
+	}
+
+	/**
+	 * Retrieve a user by their unique identifier.
+	 *
+	 * @param  mixed  $identifier
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function retrieveById($identifier)
+	{
+		return $this->createModel()->newQuery()->find($identifier);
+	}
+
+	/**
+	 * Retrieve a user by their unique identifier and "remember me" token.
+	 *
+	 * @param  mixed  $identifier
+	 * @param  string  $token
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function retrieveByToken($identifier, $token)
+	{
+		$model = $this->createModel();
+
+		return $model->newQuery()
+			->where($model->getKeyName(), $identifier)
+			->where($model->getRememberTokenName(), $token)
+			->first();
+	}
+
+	/**
+	 * Update the "remember me" token for the given user in storage.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @param  string  $token
+	 * @return void
+	 */
+	public function updateRememberToken(UserContract $user, $token)
+	{
+		$user->setRememberToken($token);
+
+		$user->save();
+	}
+
+	/**
+	 * Retrieve a user by the given credentials.
+	 *
+	 * @param  array  $credentials
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function retrieveByCredentials(array $credentials)
+	{
+		// First we will add each credential element to the query as a where clause.
+		// Then we can execute the query and, if we found a user, return it in a
+		// Eloquent User "model" that will be utilized by the Guard instances.
+		$query = $this->createModel()->newQuery();
+
+		foreach ($credentials as $key => $value)
+		{
+			if ( ! str_contains($key, 'password'))
+			{
+				$query->where($key, $value);
+			}
+		}
+
+		return $query->first();
+	}
+
+	/**
+	 * Validate a user against the given credentials.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	public function validateCredentials(UserContract $user, array $credentials)
+	{
+		$plain = $credentials['password'];
+
+		return $this->hasher->check($plain, $user->getAuthPassword());
+	}
+
+	/**
+	 * Create a new instance of the model.
+	 *
+	 * @return \Illuminate\Database\Eloquent\Model
+	 */
+	public function createModel()
+	{
+		$class = '\\'.ltrim($this->model, '\\');
+
+		return new $class;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/GeneratorServiceProvider.php

@@ -0,0 +1,66 @@
+<?php namespace Illuminate\Auth;
+
+use Illuminate\Support\ServiceProvider;
+use Illuminate\Auth\Console\ClearResetsCommand;
+
+class GeneratorServiceProvider extends ServiceProvider {
+
+	/**
+	 * Indicates if loading of the provider is deferred.
+	 *
+	 * @var bool
+	 */
+	protected $defer = true;
+
+	/**
+	 * The commands to be registered.
+	 *
+	 * @var array
+	 */
+	protected $commands = [
+		'ClearResets',
+	];
+
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		foreach ($this->commands as $command)
+		{
+			$this->{"register{$command}Command"}();
+		}
+
+		$this->commands(
+			'command.auth.resets.clear'
+		);
+	}
+
+	/**
+	 * Register the command.
+	 *
+	 * @return void
+	 */
+	protected function registerClearResetsCommand()
+	{
+		$this->app->singleton('command.auth.resets.clear', function()
+		{
+			return new ClearResetsCommand;
+		});
+	}
+
+	/**
+	 * Get the services provided by the provider.
+	 *
+	 * @return array
+	 */
+	public function provides()
+	{
+		return [
+			'command.auth.resets.clear',
+		];
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/GenericUser.php

@@ -0,0 +1,121 @@
+<?php namespace Illuminate\Auth;
+
+use Illuminate\Contracts\Auth\Authenticatable as UserContract;
+
+class GenericUser implements UserContract {
+
+	/**
+	 * All of the user's attributes.
+	 *
+	 * @var array
+	 */
+	protected $attributes;
+
+	/**
+	 * Create a new generic User object.
+	 *
+	 * @param  array  $attributes
+	 * @return void
+	 */
+	public function __construct(array $attributes)
+	{
+		$this->attributes = $attributes;
+	}
+
+	/**
+	 * Get the unique identifier for the user.
+	 *
+	 * @return mixed
+	 */
+	public function getAuthIdentifier()
+	{
+		return $this->attributes['id'];
+	}
+
+	/**
+	 * Get the password for the user.
+	 *
+	 * @return string
+	 */
+	public function getAuthPassword()
+	{
+		return $this->attributes['password'];
+	}
+
+	/**
+	 * Get the "remember me" token value.
+	 *
+	 * @return string
+	 */
+	public function getRememberToken()
+	{
+		return $this->attributes[$this->getRememberTokenName()];
+	}
+
+	/**
+	 * Set the "remember me" token value.
+	 *
+	 * @param  string  $value
+	 * @return void
+	 */
+	public function setRememberToken($value)
+	{
+		$this->attributes[$this->getRememberTokenName()] = $value;
+	}
+
+	/**
+	 * Get the column name for the "remember me" token.
+	 *
+	 * @return string
+	 */
+	public function getRememberTokenName()
+	{
+		return 'remember_token';
+	}
+
+	/**
+	 * Dynamically access the user's attributes.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function __get($key)
+	{
+		return $this->attributes[$key];
+	}
+
+	/**
+	 * Dynamically set an attribute on the user.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function __set($key, $value)
+	{
+		$this->attributes[$key] = $value;
+	}
+
+	/**
+	 * Dynamically check if a value is set on the user.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function __isset($key)
+	{
+		return isset($this->attributes[$key]);
+	}
+
+	/**
+	 * Dynamically unset a value on the user.
+	 *
+	 * @param  string  $key
+	 * @return void
+	 */
+	public function __unset($key)
+	{
+		unset($this->attributes[$key]);
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/Guard.php

@@ -0,0 +1,788 @@
+<?php namespace Illuminate\Auth;
+
+use RuntimeException;
+use Illuminate\Contracts\Events\Dispatcher;
+use Illuminate\Contracts\Auth\UserProvider;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Illuminate\Contracts\Auth\Guard as GuardContract;
+use Illuminate\Contracts\Cookie\QueueingFactory as CookieJar;
+use Illuminate\Contracts\Auth\Authenticatable as UserContract;
+use Symfony\Component\HttpFoundation\Session\SessionInterface;
+
+class Guard implements GuardContract {
+
+	/**
+	 * The currently authenticated user.
+	 *
+	 * @var \Illuminate\Contracts\Auth\Authenticatable
+	 */
+	protected $user;
+
+	/**
+	 * The user we last attempted to retrieve.
+	 *
+	 * @var \Illuminate\Contracts\Auth\Authenticatable
+	 */
+	protected $lastAttempted;
+
+	/**
+	 * Indicates if the user was authenticated via a recaller cookie.
+	 *
+	 * @var bool
+	 */
+	protected $viaRemember = false;
+
+	/**
+	 * The user provider implementation.
+	 *
+	 * @var \Illuminate\Contracts\Auth\UserProvider
+	 */
+	protected $provider;
+
+	/**
+	 * The session used by the guard.
+	 *
+	 * @var \Symfony\Component\HttpFoundation\Session\SessionInterface
+	 */
+	protected $session;
+
+	/**
+	 * The Illuminate cookie creator service.
+	 *
+	 * @var \Illuminate\Contracts\Cookie\QueueingFactory
+	 */
+	protected $cookie;
+
+	/**
+	 * The request instance.
+	 *
+	 * @var \Symfony\Component\HttpFoundation\Request
+	 */
+	protected $request;
+
+	/**
+	 * The event dispatcher instance.
+	 *
+	 * @var \Illuminate\Contracts\Events\Dispatcher
+	 */
+	protected $events;
+
+	/**
+	 * Indicates if the logout method has been called.
+	 *
+	 * @var bool
+	 */
+	protected $loggedOut = false;
+
+	/**
+	 * Indicates if a token user retrieval has been attempted.
+	 *
+	 * @var bool
+	 */
+	protected $tokenRetrievalAttempted = false;
+
+	/**
+	 * Create a new authentication guard.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\UserProvider  $provider
+	 * @param  \Symfony\Component\HttpFoundation\Session\SessionInterface  $session
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @return void
+	 */
+	public function __construct(UserProvider $provider,
+								SessionInterface $session,
+								Request $request = null)
+	{
+		$this->session = $session;
+		$this->request = $request;
+		$this->provider = $provider;
+	}
+
+	/**
+	 * Determine if the current user is authenticated.
+	 *
+	 * @return bool
+	 */
+	public function check()
+	{
+		return ! is_null($this->user());
+	}
+
+	/**
+	 * Determine if the current user is a guest.
+	 *
+	 * @return bool
+	 */
+	public function guest()
+	{
+		return ! $this->check();
+	}
+
+	/**
+	 * Get the currently authenticated user.
+	 *
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function user()
+	{
+		if ($this->loggedOut) return;
+
+		// If we have already retrieved the user for the current request we can just
+		// return it back immediately. We do not want to pull the user data every
+		// request into the method because that would tremendously slow an app.
+		if ( ! is_null($this->user))
+		{
+			return $this->user;
+		}
+
+		$id = $this->session->get($this->getName());
+
+		// First we will try to load the user using the identifier in the session if
+		// one exists. Otherwise we will check for a "remember me" cookie in this
+		// request, and if one exists, attempt to retrieve the user using that.
+		$user = null;
+
+		if ( ! is_null($id))
+		{
+			$user = $this->provider->retrieveById($id);
+		}
+
+		// If the user is null, but we decrypt a "recaller" cookie we can attempt to
+		// pull the user data on that cookie which serves as a remember cookie on
+		// the application. Once we have a user we can return it to the caller.
+		$recaller = $this->getRecaller();
+
+		if (is_null($user) && ! is_null($recaller))
+		{
+			$user = $this->getUserByRecaller($recaller);
+
+			if ($user)
+			{
+				$this->updateSession($user->getAuthIdentifier());
+
+				$this->fireLoginEvent($user, true);
+			}
+		}
+
+		return $this->user = $user;
+	}
+
+	/**
+	 * Get the ID for the currently authenticated user.
+	 *
+	 * @return int|null
+	 */
+	public function id()
+	{
+		if ($this->loggedOut)
+		{
+			return;
+		}
+
+		$id = $this->session->get($this->getName(), $this->getRecallerId());
+
+		if (is_null($id) && $this->user())
+		{
+			$id = $this->user()->getAuthIdentifier();
+		}
+
+		return $id;
+	}
+
+	/**
+	 * Pull a user from the repository by its recaller ID.
+	 *
+	 * @param  string  $recaller
+	 * @return mixed
+	 */
+	protected function getUserByRecaller($recaller)
+	{
+		if ($this->validRecaller($recaller) && ! $this->tokenRetrievalAttempted)
+		{
+			$this->tokenRetrievalAttempted = true;
+
+			list($id, $token) = explode('|', $recaller, 2);
+
+			$this->viaRemember = ! is_null($user = $this->provider->retrieveByToken($id, $token));
+
+			return $user;
+		}
+	}
+
+	/**
+	 * Get the decrypted recaller cookie for the request.
+	 *
+	 * @return string|null
+	 */
+	protected function getRecaller()
+	{
+		return $this->request->cookies->get($this->getRecallerName());
+	}
+
+	/**
+	 * Get the user ID from the recaller cookie.
+	 *
+	 * @return string
+	 */
+	protected function getRecallerId()
+	{
+		if ($this->validRecaller($recaller = $this->getRecaller()))
+		{
+			return head(explode('|', $recaller));
+		}
+	}
+
+	/**
+	 * Determine if the recaller cookie is in a valid format.
+	 *
+	 * @param  string  $recaller
+	 * @return bool
+	 */
+	protected function validRecaller($recaller)
+	{
+		if ( ! is_string($recaller) || ! str_contains($recaller, '|')) return false;
+
+		$segments = explode('|', $recaller);
+
+		return count($segments) == 2 && trim($segments[0]) !== '' && trim($segments[1]) !== '';
+	}
+
+	/**
+	 * Log a user into the application without sessions or cookies.
+	 *
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	public function once(array $credentials = [])
+	{
+		if ($this->validate($credentials))
+		{
+			$this->setUser($this->lastAttempted);
+
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Validate a user's credentials.
+	 *
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	public function validate(array $credentials = [])
+	{
+		return $this->attempt($credentials, false, false);
+	}
+
+	/**
+	 * Attempt to authenticate using HTTP Basic Auth.
+	 *
+	 * @param  string  $field
+	 * @return \Symfony\Component\HttpFoundation\Response|null
+	 */
+	public function basic($field = 'email')
+	{
+		if ($this->check())
+		{
+			return;
+		}
+
+		// If a username is set on the HTTP basic request, we will return out without
+		// interrupting the request lifecycle. Otherwise, we'll need to generate a
+		// request indicating that the given credentials were invalid for login.
+		if ($this->attemptBasic($this->getRequest(), $field))
+		{
+			return;
+		}
+
+		return $this->getBasicResponse();
+	}
+
+	/**
+	 * Perform a stateless HTTP Basic login attempt.
+	 *
+	 * @param  string  $field
+	 * @return \Symfony\Component\HttpFoundation\Response|null
+	 */
+	public function onceBasic($field = 'email')
+	{
+		if ( ! $this->once($this->getBasicCredentials($this->getRequest(), $field)))
+		{
+			return $this->getBasicResponse();
+		}
+	}
+
+	/**
+	 * Attempt to authenticate using basic authentication.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @param  string  $field
+	 * @return bool
+	 */
+	protected function attemptBasic(Request $request, $field)
+	{
+		if ( ! $request->getUser())
+		{
+			return false;
+		}
+
+		return $this->attempt($this->getBasicCredentials($request, $field));
+	}
+
+	/**
+	 * Get the credential array for a HTTP Basic request.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @param  string  $field
+	 * @return array
+	 */
+	protected function getBasicCredentials(Request $request, $field)
+	{
+		return [$field => $request->getUser(), 'password' => $request->getPassword()];
+	}
+
+	/**
+	 * Get the response for basic authentication.
+	 *
+	 * @return \Symfony\Component\HttpFoundation\Response
+	 */
+	protected function getBasicResponse()
+	{
+		$headers = ['WWW-Authenticate' => 'Basic'];
+
+		return new Response('Invalid credentials.', 401, $headers);
+	}
+
+	/**
+	 * Attempt to authenticate a user using the given credentials.
+	 *
+	 * @param  array  $credentials
+	 * @param  bool   $remember
+	 * @param  bool   $login
+	 * @return bool
+	 */
+	public function attempt(array $credentials = [], $remember = false, $login = true)
+	{
+		$this->fireAttemptEvent($credentials, $remember, $login);
+
+		$this->lastAttempted = $user = $this->provider->retrieveByCredentials($credentials);
+
+		// If an implementation of UserInterface was returned, we'll ask the provider
+		// to validate the user against the given credentials, and if they are in
+		// fact valid we'll log the users into the application and return true.
+		if ($this->hasValidCredentials($user, $credentials))
+		{
+			if ($login) $this->login($user, $remember);
+			{
+				return true;
+
+			}
+		}
+
+		return false;
+	}
+
+	/**
+	 * Determine if the user matches the credentials.
+	 *
+	 * @param  mixed  $user
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	protected function hasValidCredentials($user, $credentials)
+	{
+		return ! is_null($user) && $this->provider->validateCredentials($user, $credentials);
+	}
+
+	/**
+	 * Fire the attempt event with the arguments.
+	 *
+	 * @param  array  $credentials
+	 * @param  bool  $remember
+	 * @param  bool  $login
+	 * @return void
+	 */
+	protected function fireAttemptEvent(array $credentials, $remember, $login)
+	{
+		if ($this->events)
+		{
+			$payload = [$credentials, $remember, $login];
+
+			$this->events->fire('auth.attempt', $payload);
+		}
+	}
+
+	/**
+	 * Register an authentication attempt event listener.
+	 *
+	 * @param  mixed  $callback
+	 * @return void
+	 */
+	public function attempting($callback)
+	{
+		if ($this->events)
+		{
+			$this->events->listen('auth.attempt', $callback);
+		}
+	}
+
+	/**
+	 * Log a user into the application.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @param  bool  $remember
+	 * @return void
+	 */
+	public function login(UserContract $user, $remember = false)
+	{
+		$this->updateSession($user->getAuthIdentifier());
+
+		// If the user should be permanently "remembered" by the application we will
+		// queue a permanent cookie that contains the encrypted copy of the user
+		// identifier. We will then decrypt this later to retrieve the users.
+		if ($remember)
+		{
+			$this->createRememberTokenIfDoesntExist($user);
+
+			$this->queueRecallerCookie($user);
+		}
+
+		// If we have an event dispatcher instance set we will fire an event so that
+		// any listeners will hook into the authentication events and run actions
+		// based on the login and logout events fired from the guard instances.
+		$this->fireLoginEvent($user, $remember);
+
+		$this->setUser($user);
+	}
+
+	/**
+	 * Fire the login event if the dispatcher is set.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @param  bool  $remember
+	 * @return void
+	 */
+	protected function fireLoginEvent($user, $remember = false)
+	{
+		if (isset($this->events))
+		{
+			$this->events->fire('auth.login', [$user, $remember]);
+		}
+	}
+
+	/**
+	 * Update the session with the given ID.
+	 *
+	 * @param  string  $id
+	 * @return void
+	 */
+	protected function updateSession($id)
+	{
+		$this->session->set($this->getName(), $id);
+
+		$this->session->migrate(true);
+	}
+
+	/**
+	 * Log the given user ID into the application.
+	 *
+	 * @param  mixed  $id
+	 * @param  bool   $remember
+	 * @return \Illuminate\Contracts\Auth\Authenticatable
+	 */
+	public function loginUsingId($id, $remember = false)
+	{
+		$this->session->set($this->getName(), $id);
+
+		$this->login($user = $this->provider->retrieveById($id), $remember);
+
+		return $user;
+	}
+
+	/**
+	 * Log the given user ID into the application without sessions or cookies.
+	 *
+	 * @param  mixed  $id
+	 * @return bool
+	 */
+	public function onceUsingId($id)
+	{
+		if ( ! is_null($user = $this->provider->retrieveById($id)))
+		{
+			$this->setUser($user);
+
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Queue the recaller cookie into the cookie jar.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @return void
+	 */
+	protected function queueRecallerCookie(UserContract $user)
+	{
+		$value = $user->getAuthIdentifier().'|'.$user->getRememberToken();
+
+		$this->getCookieJar()->queue($this->createRecaller($value));
+	}
+
+	/**
+	 * Create a "remember me" cookie for a given ID.
+	 *
+	 * @param  string  $value
+	 * @return \Symfony\Component\HttpFoundation\Cookie
+	 */
+	protected function createRecaller($value)
+	{
+		return $this->getCookieJar()->forever($this->getRecallerName(), $value);
+	}
+
+	/**
+	 * Log the user out of the application.
+	 *
+	 * @return void
+	 */
+	public function logout()
+	{
+		$user = $this->user();
+
+		// If we have an event dispatcher instance, we can fire off the logout event
+		// so any further processing can be done. This allows the developer to be
+		// listening for anytime a user signs out of this application manually.
+		$this->clearUserDataFromStorage();
+
+		if ( ! is_null($this->user))
+		{
+			$this->refreshRememberToken($user);
+		}
+
+		if (isset($this->events))
+		{
+			$this->events->fire('auth.logout', [$user]);
+		}
+
+		// Once we have fired the logout event we will clear the users out of memory
+		// so they are no longer available as the user is no longer considered as
+		// being signed into this application and should not be available here.
+		$this->user = null;
+
+		$this->loggedOut = true;
+	}
+
+	/**
+	 * Remove the user data from the session and cookies.
+	 *
+	 * @return void
+	 */
+	protected function clearUserDataFromStorage()
+	{
+		$this->session->remove($this->getName());
+
+		$recaller = $this->getRecallerName();
+
+		$this->getCookieJar()->queue($this->getCookieJar()->forget($recaller));
+	}
+
+	/**
+	 * Refresh the "remember me" token for the user.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @return void
+	 */
+	protected function refreshRememberToken(UserContract $user)
+	{
+		$user->setRememberToken($token = str_random(60));
+
+		$this->provider->updateRememberToken($user, $token);
+	}
+
+	/**
+	 * Create a new "remember me" token for the user if one doesn't already exist.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @return void
+	 */
+	protected function createRememberTokenIfDoesntExist(UserContract $user)
+	{
+		$rememberToken = $user->getRememberToken();
+
+		if (empty($rememberToken))
+		{
+			$this->refreshRememberToken($user);
+		}
+	}
+
+	/**
+	 * Get the cookie creator instance used by the guard.
+	 *
+	 * @return \Illuminate\Contracts\Cookie\QueueingFactory
+	 *
+	 * @throws \RuntimeException
+	 */
+	public function getCookieJar()
+	{
+		if ( ! isset($this->cookie))
+		{
+			throw new RuntimeException("Cookie jar has not been set.");
+		}
+
+		return $this->cookie;
+	}
+
+	/**
+	 * Set the cookie creator instance used by the guard.
+	 *
+	 * @param  \Illuminate\Contracts\Cookie\QueueingFactory  $cookie
+	 * @return void
+	 */
+	public function setCookieJar(CookieJar $cookie)
+	{
+		$this->cookie = $cookie;
+	}
+
+	/**
+	 * Get the event dispatcher instance.
+	 *
+	 * @return \Illuminate\Contracts\Events\Dispatcher
+	 */
+	public function getDispatcher()
+	{
+		return $this->events;
+	}
+
+	/**
+	 * Set the event dispatcher instance.
+	 *
+	 * @param  \Illuminate\Contracts\Events\Dispatcher
+	 * @return void
+	 */
+	public function setDispatcher(Dispatcher $events)
+	{
+		$this->events = $events;
+	}
+
+	/**
+	 * Get the session store used by the guard.
+	 *
+	 * @return \Illuminate\Session\Store
+	 */
+	public function getSession()
+	{
+		return $this->session;
+	}
+
+	/**
+	 * Get the user provider used by the guard.
+	 *
+	 * @return \Illuminate\Contracts\Auth\UserProvider
+	 */
+	public function getProvider()
+	{
+		return $this->provider;
+	}
+
+	/**
+	 * Set the user provider used by the guard.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\UserProvider  $provider
+	 * @return void
+	 */
+	public function setProvider(UserProvider $provider)
+	{
+		$this->provider = $provider;
+	}
+
+	/**
+	 * Return the currently cached user.
+	 *
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function getUser()
+	{
+		return $this->user;
+	}
+
+	/**
+	 * Set the current user.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @return void
+	 */
+	public function setUser(UserContract $user)
+	{
+		$this->user = $user;
+
+		$this->loggedOut = false;
+	}
+
+	/**
+	 * Get the current request instance.
+	 *
+	 * @return \Symfony\Component\HttpFoundation\Request
+	 */
+	public function getRequest()
+	{
+		return $this->request ?: Request::createFromGlobals();
+	}
+
+	/**
+	 * Set the current request instance.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request
+	 * @return $this
+	 */
+	public function setRequest(Request $request)
+	{
+		$this->request = $request;
+
+		return $this;
+	}
+
+	/**
+	 * Get the last user we attempted to authenticate.
+	 *
+	 * @return \Illuminate\Contracts\Auth\Authenticatable
+	 */
+	public function getLastAttempted()
+	{
+		return $this->lastAttempted;
+	}
+
+	/**
+	 * Get a unique identifier for the auth session value.
+	 *
+	 * @return string
+	 */
+	public function getName()
+	{
+		return 'login_'.md5(get_class($this));
+	}
+
+	/**
+	 * Get the name of the cookie used to store the "recaller".
+	 *
+	 * @return string
+	 */
+	public function getRecallerName()
+	{
+		return 'remember_'.md5(get_class($this));
+	}
+
+	/**
+	 * Determine if the user was authenticated via "remember me" cookie.
+	 *
+	 * @return bool
+	 */
+	public function viaRemember()
+	{
+		return $this->viaRemember;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/Middleware/AuthenticateWithBasicAuth.php

@@ -0,0 +1,39 @@
+<?php namespace Illuminate\Auth\Middleware;
+
+use Closure;
+use Illuminate\Contracts\Auth\Guard;
+use Illuminate\Contracts\Routing\Middleware;
+
+class AuthenticateWithBasicAuth implements Middleware {
+
+	/**
+	 * The Guard implementation.
+	 *
+	 * @var Guard
+	 */
+	protected $auth;
+
+	/**
+	 * Create a new filter instance.
+	 *
+	 * @param  Guard  $auth
+	 * @return void
+	 */
+	public function __construct(Guard $auth)
+	{
+		$this->auth = $auth;
+	}
+
+	/**
+	 * Handle an incoming request.
+	 *
+	 * @param  \Illuminate\Http\Request  $request
+	 * @param  \Closure  $next
+	 * @return mixed
+	 */
+	public function handle($request, Closure $next)
+	{
+		return $this->auth->basic() ?: $next($request);
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/Passwords/CanResetPassword.php

@@ -0,0 +1,15 @@
+<?php namespace Illuminate\Auth\Passwords;
+
+trait CanResetPassword {
+
+	/**
+	 * Get the e-mail address where password reset links are sent.
+	 *
+	 * @return string
+	 */
+	public function getEmailForPasswordReset()
+	{
+		return $this->email;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/Passwords/DatabaseTokenRepository.php

@@ -0,0 +1,192 @@
+<?php namespace Illuminate\Auth\Passwords;
+
+use Carbon\Carbon;
+use Illuminate\Database\ConnectionInterface;
+use Illuminate\Contracts\Auth\CanResetPassword as CanResetPasswordContract;
+
+class DatabaseTokenRepository implements TokenRepositoryInterface {
+
+	/**
+	 * The database connection instance.
+	 *
+	 * @var \Illuminate\Database\ConnectionInterface
+	 */
+	protected $connection;
+
+	/**
+	 * The token database table.
+	 *
+	 * @var string
+	 */
+	protected $table;
+
+	/**
+	 * The hashing key.
+	 *
+	 * @var string
+	 */
+	protected $hashKey;
+
+	/**
+	 * The number of seconds a token should last.
+	 *
+	 * @var int
+	 */
+	protected $expires;
+
+	/**
+	 * Create a new token repository instance.
+	 *
+	 * @param  \Illuminate\Database\ConnectionInterface  $connection
+	 * @param  string  $table
+	 * @param  string  $hashKey
+	 * @param  int  $expires
+	 * @return void
+	 */
+	public function __construct(ConnectionInterface $connection, $table, $hashKey, $expires = 60)
+	{
+		$this->table = $table;
+		$this->hashKey = $hashKey;
+		$this->expires = $expires * 60;
+		$this->connection = $connection;
+	}
+
+	/**
+	 * Create a new token record.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\CanResetPassword  $user
+	 * @return string
+	 */
+	public function create(CanResetPasswordContract $user)
+	{
+		$email = $user->getEmailForPasswordReset();
+
+		$this->deleteExisting($user);
+
+		// We will create a new, random token for the user so that we can e-mail them
+		// a safe link to the password reset form. Then we will insert a record in
+		// the database so that we can verify the token within the actual reset.
+		$token = $this->createNewToken($user);
+
+		$this->getTable()->insert($this->getPayload($email, $token));
+
+		return $token;
+	}
+
+	/**
+	 * Delete all existing reset tokens from the database.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\CanResetPassword  $user
+	 * @return int
+	 */
+	protected function deleteExisting(CanResetPasswordContract $user)
+	{
+		return $this->getTable()->where('email', $user->getEmailForPasswordReset())->delete();
+	}
+
+	/**
+	 * Build the record payload for the table.
+	 *
+	 * @param  string  $email
+	 * @param  string  $token
+	 * @return array
+	 */
+	protected function getPayload($email, $token)
+	{
+		return ['email' => $email, 'token' => $token, 'created_at' => new Carbon];
+	}
+
+	/**
+	 * Determine if a token record exists and is valid.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\CanResetPassword  $user
+	 * @param  string  $token
+	 * @return bool
+	 */
+	public function exists(CanResetPasswordContract $user, $token)
+	{
+		$email = $user->getEmailForPasswordReset();
+
+		$token = (array) $this->getTable()->where('email', $email)->where('token', $token)->first();
+
+		return $token && ! $this->tokenExpired($token);
+	}
+
+	/**
+	 * Determine if the token has expired.
+	 *
+	 * @param  array  $token
+	 * @return bool
+	 */
+	protected function tokenExpired($token)
+	{
+		$expirationTime = strtotime($token['created_at']) + $this->expires;
+
+		return $expirationTime < $this->getCurrentTime();
+	}
+
+	/**
+	 * Get the current UNIX timestamp.
+	 *
+	 * @return int
+	 */
+	protected function getCurrentTime()
+	{
+		return time();
+	}
+
+	/**
+	 * Delete a token record by token.
+	 *
+	 * @param  string  $token
+	 * @return void
+	 */
+	public function delete($token)
+	{
+		$this->getTable()->where('token', $token)->delete();
+	}
+
+	/**
+	 * Delete expired tokens.
+	 *
+	 * @return void
+	 */
+	public function deleteExpired()
+	{
+		$expiredAt = Carbon::now()->subSeconds($this->expires);
+
+		$this->getTable()->where('created_at', '<', $expiredAt)->delete();
+	}
+
+	/**
+	 * Create a new token for the user.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\CanResetPassword  $user
+	 * @return string
+	 */
+	public function createNewToken(CanResetPasswordContract $user)
+	{
+		return hash_hmac('sha256', str_random(40), $this->hashKey);
+	}
+
+	/**
+	 * Begin a new database query against the table.
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	protected function getTable()
+	{
+		return $this->connection->table($this->table);
+	}
+
+	/**
+	 * Get the database connection instance.
+	 *
+	 * @return \Illuminate\Database\ConnectionInterface
+	 */
+	public function getConnection()
+	{
+		return $this->connection;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/Passwords/PasswordBroker.php

@@ -0,0 +1,260 @@
+<?php namespace Illuminate\Auth\Passwords;
+
+use Closure;
+use UnexpectedValueException;
+use Illuminate\Contracts\Auth\UserProvider;
+use Illuminate\Contracts\Mail\Mailer as MailerContract;
+use Illuminate\Contracts\Auth\PasswordBroker as PasswordBrokerContract;
+use Illuminate\Contracts\Auth\CanResetPassword as CanResetPasswordContract;
+
+class PasswordBroker implements PasswordBrokerContract {
+
+	/**
+	 * The password token repository.
+	 *
+	 * @var \Illuminate\Auth\Passwords\TokenRepositoryInterface
+	 */
+	protected $tokens;
+
+	/**
+	 * The user provider implementation.
+	 *
+	 * @var \Illuminate\Contracts\Auth\UserProvider
+	 */
+	protected $users;
+
+	/**
+	 * The mailer instance.
+	 *
+	 * @var \Illuminate\Contracts\Mail\Mailer
+	 */
+	protected $mailer;
+
+	/**
+	 * The view of the password reset link e-mail.
+	 *
+	 * @var string
+	 */
+	protected $emailView;
+
+	/**
+	 * The custom password validator callback.
+	 *
+	 * @var \Closure
+	 */
+	protected $passwordValidator;
+
+	/**
+	 * Create a new password broker instance.
+	 *
+	 * @param  \Illuminate\Auth\Passwords\TokenRepositoryInterface  $tokens
+	 * @param  \Illuminate\Contracts\Auth\UserProvider  $users
+	 * @param  \Illuminate\Contracts\Mail\Mailer  $mailer
+	 * @param  string  $emailView
+	 * @return void
+	 */
+	public function __construct(TokenRepositoryInterface $tokens,
+                                UserProvider $users,
+                                MailerContract $mailer,
+                                $emailView)
+	{
+		$this->users = $users;
+		$this->mailer = $mailer;
+		$this->tokens = $tokens;
+		$this->emailView = $emailView;
+	}
+
+	/**
+	 * Send a password reset link to a user.
+	 *
+	 * @param  array  $credentials
+	 * @param  \Closure|null  $callback
+	 * @return string
+	 */
+	public function sendResetLink(array $credentials, Closure $callback = null)
+	{
+		// First we will check to see if we found a user at the given credentials and
+		// if we did not we will redirect back to this current URI with a piece of
+		// "flash" data in the session to indicate to the developers the errors.
+		$user = $this->getUser($credentials);
+
+		if (is_null($user))
+		{
+			return PasswordBrokerContract::INVALID_USER;
+		}
+
+		// Once we have the reset token, we are ready to send the message out to this
+		// user with a link to reset their password. We will then redirect back to
+		// the current URI having nothing set in the session to indicate errors.
+		$token = $this->tokens->create($user);
+
+		$this->emailResetLink($user, $token, $callback);
+
+		return PasswordBrokerContract::RESET_LINK_SENT;
+	}
+
+	/**
+	 * Send the password reset link via e-mail.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\CanResetPassword  $user
+	 * @param  string  $token
+	 * @param  \Closure|null  $callback
+	 * @return int
+	 */
+	public function emailResetLink(CanResetPasswordContract $user, $token, Closure $callback = null)
+	{
+		// We will use the reminder view that was given to the broker to display the
+		// password reminder e-mail. We'll pass a "token" variable into the views
+		// so that it may be displayed for an user to click for password reset.
+		$view = $this->emailView;
+
+		return $this->mailer->send($view, compact('token', 'user'), function($m) use ($user, $token, $callback)
+		{
+			$m->to($user->getEmailForPasswordReset());
+
+			if ( ! is_null($callback))
+			{
+				call_user_func($callback, $m, $user, $token);
+			}
+		});
+	}
+
+	/**
+	 * Reset the password for the given token.
+	 *
+	 * @param  array  $credentials
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function reset(array $credentials, Closure $callback)
+	{
+		// If the responses from the validate method is not a user instance, we will
+		// assume that it is a redirect and simply return it from this method and
+		// the user is properly redirected having an error message on the post.
+		$user = $this->validateReset($credentials);
+
+		if ( ! $user instanceof CanResetPasswordContract)
+		{
+			return $user;
+		}
+
+		$pass = $credentials['password'];
+
+		// Once we have called this callback, we will remove this token row from the
+		// table and return the response from this callback so the user gets sent
+		// to the destination given by the developers from the callback return.
+		call_user_func($callback, $user, $pass);
+
+		$this->tokens->delete($credentials['token']);
+
+		return PasswordBrokerContract::PASSWORD_RESET;
+	}
+
+	/**
+	 * Validate a password reset for the given credentials.
+	 *
+	 * @param  array  $credentials
+	 * @return \Illuminate\Contracts\Auth\CanResetPassword
+	 */
+	protected function validateReset(array $credentials)
+	{
+		if (is_null($user = $this->getUser($credentials)))
+		{
+			return PasswordBrokerContract::INVALID_USER;
+		}
+
+		if ( ! $this->validateNewPassword($credentials))
+		{
+			return PasswordBrokerContract::INVALID_PASSWORD;
+		}
+
+		if ( ! $this->tokens->exists($user, $credentials['token']))
+		{
+			return PasswordBrokerContract::INVALID_TOKEN;
+		}
+
+		return $user;
+	}
+
+	/**
+	 * Set a custom password validator.
+	 *
+	 * @param  \Closure  $callback
+	 * @return void
+	 */
+	public function validator(Closure $callback)
+	{
+		$this->passwordValidator = $callback;
+	}
+
+	/**
+	 * Determine if the passwords match for the request.
+	 *
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	public function validateNewPassword(array $credentials)
+	{
+		list($password, $confirm) = [
+			$credentials['password'],
+			$credentials['password_confirmation'],
+		];
+
+		if (isset($this->passwordValidator))
+		{
+			return call_user_func(
+				$this->passwordValidator, $credentials) && $password === $confirm;
+		}
+
+		return $this->validatePasswordWithDefaults($credentials);
+	}
+
+	/**
+	 * Determine if the passwords are valid for the request.
+	 *
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	protected function validatePasswordWithDefaults(array $credentials)
+	{
+		list($password, $confirm) = [
+			$credentials['password'],
+			$credentials['password_confirmation'],
+		];
+
+		return $password === $confirm && mb_strlen($password) >= 6;
+	}
+
+	/**
+	 * Get the user for the given credentials.
+	 *
+	 * @param  array  $credentials
+	 * @return \Illuminate\Contracts\Auth\CanResetPassword
+	 *
+	 * @throws \UnexpectedValueException
+	 */
+	public function getUser(array $credentials)
+	{
+		$credentials = array_except($credentials, ['token']);
+
+		$user = $this->users->retrieveByCredentials($credentials);
+
+		if ($user && ! $user instanceof CanResetPasswordContract)
+		{
+			throw new UnexpectedValueException("User must implement CanResetPassword interface.");
+		}
+
+		return $user;
+	}
+
+	/**
+	 * Get the password reset token repository implementation.
+	 *
+	 * @return \Illuminate\Auth\Passwords\TokenRepositoryInterface
+	 */
+	protected function getRepository()
+	{
+		return $this->tokens;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/Passwords/PasswordResetServiceProvider.php

@@ -0,0 +1,88 @@
+<?php namespace Illuminate\Auth\Passwords;
+
+use Illuminate\Support\ServiceProvider;
+use Illuminate\Auth\Passwords\DatabaseTokenRepository as DbRepository;
+
+class PasswordResetServiceProvider extends ServiceProvider {
+
+	/**
+	 * Indicates if loading of the provider is deferred.
+	 *
+	 * @var bool
+	 */
+	protected $defer = true;
+
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->registerPasswordBroker();
+
+		$this->registerTokenRepository();
+	}
+
+	/**
+	 * Register the password broker instance.
+	 *
+	 * @return void
+	 */
+	protected function registerPasswordBroker()
+	{
+		$this->app->singleton('auth.password', function($app)
+		{
+			// The password token repository is responsible for storing the email addresses
+			// and password reset tokens. It will be used to verify the tokens are valid
+			// for the given e-mail addresses. We will resolve an implementation here.
+			$tokens = $app['auth.password.tokens'];
+
+			$users = $app['auth']->driver()->getProvider();
+
+			$view = $app['config']['auth.password.email'];
+
+			// The password broker uses a token repository to validate tokens and send user
+			// password e-mails, as well as validating that password reset process as an
+			// aggregate service of sorts providing a convenient interface for resets.
+			return new PasswordBroker(
+				$tokens, $users, $app['mailer'], $view
+			);
+		});
+	}
+
+	/**
+	 * Register the token repository implementation.
+	 *
+	 * @return void
+	 */
+	protected function registerTokenRepository()
+	{
+		$this->app->singleton('auth.password.tokens', function($app)
+		{
+			$connection = $app['db']->connection();
+
+			// The database token repository is an implementation of the token repository
+			// interface, and is responsible for the actual storing of auth tokens and
+			// their e-mail addresses. We will inject this table and hash key to it.
+			$table = $app['config']['auth.password.table'];
+
+			$key = $app['config']['app.key'];
+
+			$expire = $app['config']->get('auth.password.expire', 60);
+
+			return new DbRepository($connection, $table, $key, $expire);
+		});
+	}
+
+	/**
+	 * Get the services provided by the provider.
+	 *
+	 * @return array
+	 */
+	public function provides()
+	{
+		return ['auth.password', 'auth.password.tokens'];
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Auth/Passwords/TokenRepositoryInterface.php

@@ -0,0 +1,39 @@
+<?php namespace Illuminate\Auth\Passwords;
+
+use Illuminate\Contracts\Auth\CanResetPassword as CanResetPasswordContract;
+
+interface TokenRepositoryInterface {
+
+	/**
+	 * Create a new token.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\CanResetPassword  $user
+	 * @return string
+	 */
+	public function create(CanResetPasswordContract $user);
+
+	/**
+	 * Determine if a token record exists and is valid.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\CanResetPassword  $user
+	 * @param  string  $token
+	 * @return bool
+	 */
+	public function exists(CanResetPasswordContract $user, $token);
+
+	/**
+	 * Delete a token record.
+	 *
+	 * @param  string  $token
+	 * @return void
+	 */
+	public function delete($token);
+
+	/**
+	 * Delete expired tokens.
+	 *
+	 * @return void
+	 */
+	public function deleteExpired();
+
+}

vendor/laravel/framework/src/Illuminate/Auth/composer.json

@@ -0,0 +1,38 @@
+{
+    "name": "illuminate/auth",
+    "description": "The Illuminate Auth package.",
+    "license": "MIT",
+    "homepage": "http://laravel.com",
+    "support": {
+        "issues": "https://github.com/laravel/framework/issues",
+        "source": "https://github.com/laravel/framework"
+    },
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylorotwell@gmail.com"
+        }
+    ],
+    "require": {
+        "php": ">=5.4.0",
+        "illuminate/contracts": "5.0.*",
+        "illuminate/http": "5.0.*",
+        "illuminate/session": "5.0.*",
+        "illuminate/support": "5.0.*",
+        "nesbot/carbon": "~1.0"
+    },
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Auth\\": ""
+        }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "5.0-dev"
+        }
+    },
+    "suggest": {
+        "illuminate/console": "Required to use the auth:clear-resets command (5.0.*)."
+    },
+    "minimum-stability": "dev"
+}

vendor/laravel/framework/src/Illuminate/Bus/BusServiceProvider.php

@@ -0,0 +1,52 @@
+<?php namespace Illuminate\Bus;
+
+use Illuminate\Support\ServiceProvider;
+
+class BusServiceProvider extends ServiceProvider {
+
+	/**
+	 * Indicates if loading of the provider is deferred.
+	 *
+	 * @var bool
+	 */
+	protected $defer = true;
+
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->app->singleton('Illuminate\Bus\Dispatcher', function($app)
+		{
+			return new Dispatcher($app, function() use ($app)
+			{
+				return $app['Illuminate\Contracts\Queue\Queue'];
+			});
+		});
+
+		$this->app->alias(
+			'Illuminate\Bus\Dispatcher', 'Illuminate\Contracts\Bus\Dispatcher'
+		);
+
+		$this->app->alias(
+			'Illuminate\Bus\Dispatcher', 'Illuminate\Contracts\Bus\QueueingDispatcher'
+		);
+	}
+
+	/**
+	 * Get the services provided by the provider.
+	 *
+	 * @return array
+	 */
+	public function provides()
+	{
+		return [
+			'Illuminate\Bus\Dispatcher',
+			'Illuminate\Contracts\Bus\Dispatcher',
+			'Illuminate\Contracts\Bus\QueueingDispatcher',
+		];
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Bus/Dispatcher.php

@@ -0,0 +1,409 @@
+<?php namespace Illuminate\Bus;
+
+use Closure;
+use ArrayAccess;
+use ReflectionClass;
+use RuntimeException;
+use ReflectionParameter;
+use InvalidArgumentException;
+use Illuminate\Pipeline\Pipeline;
+use Illuminate\Support\Collection;
+use Illuminate\Contracts\Queue\Queue;
+use Illuminate\Contracts\Bus\SelfHandling;
+use Illuminate\Contracts\Container\Container;
+use Illuminate\Contracts\Bus\HandlerResolver;
+use Illuminate\Contracts\Queue\ShouldBeQueued;
+use Illuminate\Contracts\Bus\QueueingDispatcher;
+use Illuminate\Contracts\Bus\Dispatcher as DispatcherContract;
+
+class Dispatcher implements DispatcherContract, QueueingDispatcher, HandlerResolver {
+
+	/**
+	 * The container implementation.
+	 *
+	 * @var \Illuminate\Contracts\Container\Container
+	 */
+	protected $container;
+
+	/**
+	 * The pipeline instance for the bus.
+	 *
+	 * @var \Illuminate\Pipeline\Pipeline
+	 */
+	protected $pipeline;
+
+	/**
+	 * The pipes to send commands through before dispatching.
+	 *
+	 * @var array
+	 */
+	protected $pipes = [];
+
+	/**
+	 * The queue resolver callback.
+	 *
+	 * @var \Closure|null
+	 */
+	protected $queueResolver;
+
+	/**
+	 * All of the command-to-handler mappings.
+	 *
+	 * @var array
+	 */
+	protected $mappings = [];
+
+	/**
+	 * The fallback mapping Closure.
+	 *
+	 * @var \Closure
+	 */
+	protected $mapper;
+
+	/**
+	 * Create a new command dispatcher instance.
+	 *
+	 * @param  \Illuminate\Contracts\Container\Container  $container
+	 * @param  \Closure|null  $queueResolver
+	 * @return void
+	 */
+	public function __construct(Container $container, Closure $queueResolver = null)
+	{
+		$this->container = $container;
+		$this->queueResolver = $queueResolver;
+		$this->pipeline = new Pipeline($container);
+	}
+
+	/**
+	 * Marshal a command and dispatch it to its appropriate handler.
+	 *
+	 * @param  mixed  $command
+	 * @param  array  $array
+	 * @return mixed
+	 */
+	public function dispatchFromArray($command, array $array)
+	{
+		return $this->dispatch($this->marshalFromArray($command, $array));
+	}
+
+	/**
+	 * Marshal a command and dispatch it to its appropriate handler.
+	 *
+	 * @param  mixed  $command
+	 * @param  \ArrayAccess  $source
+	 * @param  array  $extras
+	 * @return mixed
+	 */
+	public function dispatchFrom($command, ArrayAccess $source, array $extras = [])
+	{
+		return $this->dispatch($this->marshal($command, $source, $extras));
+	}
+
+	/**
+	 * Marshal a command from the given array.
+	 *
+	 * @param  string  $command
+	 * @param  array  $array
+	 * @return mixed
+	 */
+	protected function marshalFromArray($command, array $array)
+	{
+		return $this->marshal($command, new Collection, $array);
+	}
+
+	/**
+	 * Marshal a command from the given array accessible object.
+	 *
+	 * @param  string  $command
+	 * @param  \ArrayAccess  $source
+	 * @param  array  $extras
+	 * @return mixed
+	 */
+	protected function marshal($command, ArrayAccess $source, array $extras = [])
+	{
+		$injected = [];
+
+		$reflection = new ReflectionClass($command);
+
+		if ($constructor = $reflection->getConstructor())
+		{
+			$injected = array_map(function($parameter) use ($command, $source, $extras)
+			{
+				return $this->getParameterValueForCommand($command, $source, $parameter, $extras);
+
+			}, $constructor->getParameters());
+		}
+
+		return $reflection->newInstanceArgs($injected);
+	}
+
+	/**
+	 * Get a parameter value for a marshaled command.
+	 *
+	 * @param  string  $command
+	 * @param  \ArrayAccess  $source
+	 * @param  \ReflectionParameter  $parameter
+	 * @param  array  $extras
+	 * @return mixed
+	 */
+	protected function getParameterValueForCommand($command, ArrayAccess $source,
+		ReflectionParameter $parameter, array $extras = array())
+	{
+		if (array_key_exists($parameter->name, $extras))
+		{
+			return $extras[$parameter->name];
+		}
+
+		if (isset($source[$parameter->name]))
+		{
+			return $source[$parameter->name];
+		}
+
+		if ($parameter->isDefaultValueAvailable())
+		{
+			return $parameter->getDefaultValue();
+		}
+
+		MarshalException::whileMapping($command, $parameter);
+	}
+
+	/**
+	 * Dispatch a command to its appropriate handler.
+	 *
+	 * @param  mixed  $command
+	 * @param  \Closure|null  $afterResolving
+	 * @return mixed
+	 */
+	public function dispatch($command, Closure $afterResolving = null)
+	{
+		if ($this->queueResolver && $this->commandShouldBeQueued($command))
+		{
+			return $this->dispatchToQueue($command);
+		}
+		else
+		{
+			return $this->dispatchNow($command, $afterResolving);
+		}
+	}
+
+	/**
+	 * Dispatch a command to its appropriate handler in the current process.
+	 *
+	 * @param  mixed  $command
+	 * @param  \Closure|null  $afterResolving
+	 * @return mixed
+	 */
+	public function dispatchNow($command, Closure $afterResolving = null)
+	{
+		return $this->pipeline->send($command)->through($this->pipes)->then(function($command) use ($afterResolving)
+		{
+			if ($command instanceof SelfHandling)
+			{
+				return $this->container->call([$command, 'handle']);
+			}
+
+			$handler = $this->resolveHandler($command);
+
+			if ($afterResolving)
+			{
+				call_user_func($afterResolving, $handler);
+			}
+
+			return call_user_func(
+				[$handler, $this->getHandlerMethod($command)], $command
+			);
+		});
+
+	}
+
+	/**
+	 * Determine if the given command should be queued.
+	 *
+	 * @param  mixed  $command
+	 * @return bool
+	 */
+	protected function commandShouldBeQueued($command)
+	{
+		if ($command instanceof ShouldBeQueued)
+		{
+			return true;
+		}
+
+		return (new ReflectionClass($this->getHandlerClass($command)))->implementsInterface(
+			'Illuminate\Contracts\Queue\ShouldBeQueued'
+		);
+	}
+
+	/**
+	 * Dispatch a command to its appropriate handler behind a queue.
+	 *
+	 * @param  mixed  $command
+	 * @return mixed
+	 *
+	 * @throws \RuntimeException
+	 */
+	public function dispatchToQueue($command)
+	{
+		$queue = call_user_func($this->queueResolver);
+
+		if ( ! $queue instanceof Queue)
+		{
+			throw new RuntimeException("Queue resolver did not return a Queue implementation.");
+		}
+
+		if (method_exists($command, 'queue'))
+		{
+			$command->queue($queue, $command);
+		}
+		else
+		{
+			$queue->push($command);
+		}
+	}
+
+	/**
+	 * Get the handler instance for the given command.
+	 *
+	 * @param  mixed  $command
+	 * @return mixed
+	 */
+	public function resolveHandler($command)
+	{
+		if ($command instanceof SelfHandling)
+		{
+			return $command;
+		}
+
+		return $this->container->make($this->getHandlerClass($command));
+	}
+
+	/**
+	 * Get the handler class for the given command.
+	 *
+	 * @param  mixed  $command
+	 * @return string
+	 */
+	public function getHandlerClass($command)
+	{
+		if ($command instanceof SelfHandling)
+		{
+			return get_class($command);
+		}
+
+		return $this->inflectSegment($command, 0);
+	}
+
+	/**
+	 * Get the handler method for the given command.
+	 *
+	 * @param  mixed  $command
+	 * @return string
+	 */
+	public function getHandlerMethod($command)
+	{
+		if ($command instanceof SelfHandling)
+		{
+			return 'handle';
+		}
+
+		return $this->inflectSegment($command, 1);
+	}
+
+	/**
+	 * Get the given handler segment for the given command.
+	 *
+	 * @param  mixed  $command
+	 * @param  int  $segment
+	 * @return string
+	 */
+	protected function inflectSegment($command, $segment)
+	{
+		$className = get_class($command);
+
+		if (isset($this->mappings[$className]))
+		{
+			return $this->getMappingSegment($className, $segment);
+		}
+		elseif ($this->mapper)
+		{
+			return $this->getMapperSegment($command, $segment);
+		}
+
+		throw new InvalidArgumentException("No handler registered for command [{$className}]");
+	}
+
+	/**
+	 * Get the given segment from a given class handler.
+	 *
+	 * @param  string  $className
+	 * @param  int  $segment
+	 * @return string
+	 */
+	protected function getMappingSegment($className, $segment)
+	{
+		return explode('@', $this->mappings[$className])[$segment];
+	}
+
+	/**
+	 * Get the given segment from a given class handler using the custom mapper.
+	 *
+	 * @param  mixed  $command
+	 * @param  int  $segment
+	 * @return string
+	 */
+	protected function getMapperSegment($command, $segment)
+	{
+		return explode('@', call_user_func($this->mapper, $command))[$segment];
+	}
+
+	/**
+	 * Register command-to-handler mappings.
+	 *
+	 * @param  array  $commands
+	 * @return void
+	 */
+	public function maps(array $commands)
+	{
+		$this->mappings = array_merge($this->mappings, $commands);
+	}
+
+	/**
+	 * Register a fallback mapper callback.
+	 *
+	 * @param  \Closure  $mapper
+	 * @return void
+	 */
+	public function mapUsing(Closure $mapper)
+	{
+		$this->mapper = $mapper;
+	}
+
+	/**
+	 * Map the command to a handler within a given root namespace.
+	 *
+	 * @param  mixed  $command
+	 * @param  string  $commandNamespace
+	 * @param  string  $handlerNamespace
+	 * @return string
+	 */
+	public static function simpleMapping($command, $commandNamespace, $handlerNamespace)
+	{
+		$command = str_replace($commandNamespace, '', get_class($command));
+
+		return $handlerNamespace.'\\'.trim($command, '\\').'Handler@handle';
+	}
+
+	/**
+	 * Set the pipes through which commands should be piped before dispatching.
+	 *
+	 * @param  array  $pipes
+	 * @return $this
+	 */
+	public function pipeThrough(array $pipes)
+	{
+		$this->pipes = $pipes;
+
+		return $this;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Bus/MarshalException.php

@@ -0,0 +1,20 @@
+<?php namespace Illuminate\Bus;
+
+use RuntimeException;
+use ReflectionParameter;
+
+class MarshalException extends RuntimeException {
+
+	/**
+	 * Throw new a new exception.
+	 *
+	 * @param  string  $command
+	 * @param  \ReflectionParameter  $parameter
+	 * @return void
+	 */
+	public static function whileMapping($command, ReflectionParameter $parameter)
+	{
+		throw new static("Unable to map parameter [{$parameter->name}] to command [{$command}]");
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Bus/composer.json

@@ -0,0 +1,33 @@
+{
+    "name": "illuminate/bus",
+    "description": "The Illuminate Bus package.",
+    "license": "MIT",
+    "homepage": "http://laravel.com",
+    "support": {
+        "issues": "https://github.com/laravel/framework/issues",
+        "source": "https://github.com/laravel/framework"
+    },
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylorotwell@gmail.com"
+        }
+    ],
+    "require": {
+        "php": ">=5.4.0",
+        "illuminate/contracts": "5.0.*",
+        "illuminate/pipeline": "5.0.*",
+        "illuminate/support": "5.0.*"
+    },
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Bus\\": ""
+        }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "5.0-dev"
+        }
+    },
+    "minimum-stability": "dev"
+}

vendor/laravel/framework/src/Illuminate/Cache/ApcStore.php

@@ -0,0 +1,130 @@
+<?php namespace Illuminate\Cache;
+
+use Illuminate\Contracts\Cache\Store;
+
+class ApcStore extends TaggableStore implements Store {
+
+	/**
+	 * The APC wrapper instance.
+	 *
+	 * @var \Illuminate\Cache\ApcWrapper
+	 */
+	protected $apc;
+
+	/**
+	 * A string that should be prepended to keys.
+	 *
+	 * @var string
+	 */
+	protected $prefix;
+
+	/**
+	 * Create a new APC store.
+	 *
+	 * @param  \Illuminate\Cache\ApcWrapper  $apc
+	 * @param  string  $prefix
+	 * @return void
+	 */
+	public function __construct(ApcWrapper $apc, $prefix = '')
+	{
+		$this->apc = $apc;
+		$this->prefix = $prefix;
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		$value = $this->apc->get($this->prefix.$key);
+
+		if ($value !== false)
+		{
+			return $value;
+		}
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		$this->apc->put($this->prefix.$key, $value, $minutes * 60);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function increment($key, $value = 1)
+	{
+		return $this->apc->increment($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Decrement the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function decrement($key, $value = 1)
+	{
+		return $this->apc->decrement($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return array|bool
+	 */
+	public function forever($key, $value)
+	{
+		return $this->put($key, $value, 0);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		return $this->apc->delete($this->prefix.$key);
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		$this->apc->flush();
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return $this->prefix;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/ApcWrapper.php

@@ -0,0 +1,91 @@
+<?php namespace Illuminate\Cache;
+
+class ApcWrapper {
+
+	/**
+	 * Indicates if APCu is supported.
+	 *
+	 * @var bool
+	 */
+	protected $apcu = false;
+
+	/**
+	 * Create a new APC wrapper instance.
+	 *
+	 * @return void
+	 */
+	public function __construct()
+	{
+		$this->apcu = function_exists('apcu_fetch');
+	}
+
+	/**
+	 * Get an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		return $this->apcu ? apcu_fetch($key) : apc_fetch($key);
+	}
+
+	/**
+	 * Store an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $seconds
+	 * @return array|bool
+	 */
+	public function put($key, $value, $seconds)
+	{
+		return $this->apcu ? apcu_store($key, $value, $seconds) : apc_store($key, $value, $seconds);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function increment($key, $value)
+	{
+		return $this->apcu ? apcu_inc($key, $value) : apc_inc($key, $value);
+	}
+
+	/**
+	 * Decrement the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function decrement($key, $value)
+	{
+		return $this->apcu ? apcu_dec($key, $value) : apc_dec($key, $value);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function delete($key)
+	{
+		return $this->apcu ? apcu_delete($key) : apc_delete($key);
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		$this->apcu ? apcu_clear_cache() : apc_clear_cache('user');
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/ArrayStore.php

@@ -0,0 +1,112 @@
+<?php namespace Illuminate\Cache;
+
+use Illuminate\Contracts\Cache\Store;
+
+class ArrayStore extends TaggableStore implements Store {
+
+	/**
+	 * The array of stored values.
+	 *
+	 * @var array
+	 */
+	protected $storage = array();
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		if (array_key_exists($key, $this->storage))
+		{
+			return $this->storage[$key];
+		}
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		$this->storage[$key] = $value;
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function increment($key, $value = 1)
+	{
+		$this->storage[$key] = $this->storage[$key] + $value;
+
+		return $this->storage[$key];
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function decrement($key, $value = 1)
+	{
+		return $this->increment($key, $value * -1);
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		$this->put($key, $value, 0);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		unset($this->storage[$key]);
+
+		return true;
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		$this->storage = array();
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return '';
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/CacheManager.php

@@ -0,0 +1,315 @@
+<?php namespace Illuminate\Cache;
+
+use Closure;
+use InvalidArgumentException;
+use Illuminate\Contracts\Cache\Store;
+use Illuminate\Contracts\Cache\Factory as FactoryContract;
+
+class CacheManager implements FactoryContract {
+
+	/**
+	 * The application instance.
+	 *
+	 * @var \Illuminate\Foundation\Application
+	 */
+	protected $app;
+
+	/**
+	 * The array of resolved cache stores.
+	 *
+	 * @var array
+	 */
+	protected $stores = [];
+
+	/**
+	 * The registered custom driver creators.
+	 *
+	 * @var array
+	 */
+	protected $customCreators = [];
+
+	/**
+	 * Create a new Cache manager instance.
+	 *
+	 * @param  \Illuminate\Foundation\Application  $app
+	 * @return void
+	 */
+	public function __construct($app)
+	{
+		$this->app = $app;
+	}
+
+	/**
+	 * Get a cache store instance by name.
+	 *
+	 * @param  string|null  $name
+	 * @return mixed
+	 */
+	public function store($name = null)
+	{
+		$name = $name ?: $this->getDefaultDriver();
+
+		return $this->stores[$name] = $this->get($name);
+	}
+
+	/**
+	 * Get a cache driver instance.
+	 *
+	 * @param  string  $driver
+	 * @return mixed
+	 */
+	public function driver($driver = null)
+	{
+		return $this->store($driver);
+	}
+
+	/**
+	 * Attempt to get the store from the local cache.
+	 *
+	 * @param  string  $name
+	 * @return \Illuminate\Contracts\Cache\Repository
+	 */
+	protected function get($name)
+	{
+		return isset($this->stores[$name]) ? $this->stores[$name] : $this->resolve($name);
+	}
+
+	/**
+	 * Resolve the given store.
+	 *
+	 * @param  string  $name
+	 * @return \Illuminate\Contracts\Cache\Repository
+	 */
+	protected function resolve($name)
+	{
+		$config = $this->getConfig($name);
+
+		if (is_null($config))
+		{
+			throw new InvalidArgumentException("Cache store [{$name}] is not defined.");
+		}
+
+		if (isset($this->customCreators[$config['driver']]))
+		{
+			return $this->callCustomCreator($config);
+		}
+		else
+		{
+			return $this->{"create".ucfirst($config['driver'])."Driver"}($config);
+		}
+	}
+
+	/**
+	 * Call a custom driver creator.
+	 *
+	 * @param  array  $config
+	 * @return mixed
+	 */
+	protected function callCustomCreator(array $config)
+	{
+		return $this->customCreators[$config['driver']]($this->app, $config);
+	}
+
+	/**
+	 * Create an instance of the APC cache driver.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Cache\ApcStore
+	 */
+	protected function createApcDriver(array $config)
+	{
+		$prefix = $this->getPrefix($config);
+
+		return $this->repository(new ApcStore(new ApcWrapper, $prefix));
+	}
+
+	/**
+	 * Create an instance of the array cache driver.
+	 *
+	 * @return \Illuminate\Cache\ArrayStore
+	 */
+	protected function createArrayDriver()
+	{
+		return $this->repository(new ArrayStore);
+	}
+
+	/**
+	 * Create an instance of the file cache driver.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Cache\FileStore
+	 */
+	protected function createFileDriver(array $config)
+	{
+		return $this->repository(new FileStore($this->app['files'], $config['path']));
+	}
+
+	/**
+	 * Create an instance of the Memcached cache driver.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Cache\MemcachedStore
+	 */
+	protected function createMemcachedDriver(array $config)
+	{
+		$prefix = $this->getPrefix($config);
+
+		$memcached = $this->app['memcached.connector']->connect($config['servers']);
+
+		return $this->repository(new MemcachedStore($memcached, $prefix));
+	}
+
+	/**
+	 * Create an instance of the Null cache driver.
+	 *
+	 * @return \Illuminate\Cache\NullStore
+	 */
+	protected function createNullDriver()
+	{
+		return $this->repository(new NullStore);
+	}
+
+	/**
+	 * Create an instance of the WinCache cache driver.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Cache\WinCacheStore
+	 */
+	protected function createWincacheDriver(array $config)
+	{
+		return $this->repository(new WinCacheStore($this->getPrefix($config)));
+	}
+
+	/**
+	 * Create an instance of the XCache cache driver.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Cache\WinCacheStore
+	 */
+	protected function createXcacheDriver(array $config)
+	{
+		return $this->repository(new XCacheStore($this->getPrefix($config)));
+	}
+
+	/**
+	 * Create an instance of the Redis cache driver.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Cache\RedisStore
+	 */
+	protected function createRedisDriver(array $config)
+	{
+		$redis = $this->app['redis'];
+
+		$connection = array_get($config, 'connection', 'default') ?: 'default';
+
+		return $this->repository(new RedisStore($redis, $this->getPrefix($config), $connection));
+	}
+
+	/**
+	 * Create an instance of the database cache driver.
+	 *
+	 * @param  array  $config
+	 * @return \Illuminate\Cache\DatabaseStore
+	 */
+	protected function createDatabaseDriver(array $config)
+	{
+		$connection = $this->app['db']->connection(array_get($config, 'connection'));
+
+		return $this->repository(
+			new DatabaseStore(
+				$connection, $this->app['encrypter'], $config['table'], $this->getPrefix($config)
+			)
+		);
+	}
+
+	/**
+	 * Create a new cache repository with the given implementation.
+	 *
+	 * @param  \Illuminate\Contracts\Cache\Store  $store
+	 * @return \Illuminate\Cache\Repository
+	 */
+	public function repository(Store $store)
+	{
+		$repository = new Repository($store);
+
+		if ($this->app->bound('Illuminate\Contracts\Events\Dispatcher'))
+		{
+			$repository->setEventDispatcher(
+				$this->app['Illuminate\Contracts\Events\Dispatcher']
+			);
+		}
+
+		return $repository;
+	}
+
+	/**
+	 * Get the cache prefix.
+	 *
+	 * @param  array  $config
+	 * @return string
+	 */
+	protected function getPrefix(array $config)
+	{
+		return array_get($config, 'prefix') ?: $this->app['config']['cache.prefix'];
+	}
+
+	/**
+	 * Get the cache connection configuration.
+	 *
+	 * @param  string  $name
+	 * @return array
+	 */
+	protected function getConfig($name)
+	{
+		return $this->app['config']["cache.stores.{$name}"];
+	}
+
+	/**
+	 * Get the default cache driver name.
+	 *
+	 * @return string
+	 */
+	public function getDefaultDriver()
+	{
+		return $this->app['config']['cache.default'];
+	}
+
+	/**
+	 * Set the default cache driver name.
+	 *
+	 * @param  string  $name
+	 * @return void
+	 */
+	public function setDefaultDriver($name)
+	{
+		$this->app['config']['cache.default'] = $name;
+	}
+
+	/**
+	 * 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 call_user_func_array(array($this->store(), $method), $parameters);
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/CacheServiceProvider.php

@@ -0,0 +1,73 @@
+<?php namespace Illuminate\Cache;
+
+use Illuminate\Support\ServiceProvider;
+use Illuminate\Cache\Console\ClearCommand;
+use Illuminate\Cache\Console\CacheTableCommand;
+
+class CacheServiceProvider extends ServiceProvider {
+
+	/**
+	 * Indicates if loading of the provider is deferred.
+	 *
+	 * @var bool
+	 */
+	protected $defer = true;
+
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->app->singleton('cache', function($app)
+		{
+			return new CacheManager($app);
+		});
+
+		$this->app->singleton('cache.store', function($app)
+		{
+			return $app['cache']->driver();
+		});
+
+		$this->app->singleton('memcached.connector', function()
+		{
+			return new MemcachedConnector;
+		});
+
+		$this->registerCommands();
+	}
+
+	/**
+	 * Register the cache related console commands.
+	 *
+	 * @return void
+	 */
+	public function registerCommands()
+	{
+		$this->app->singleton('command.cache.clear', function($app)
+		{
+			return new ClearCommand($app['cache']);
+		});
+
+		$this->app->singleton('command.cache.table', function($app)
+		{
+			return new CacheTableCommand($app['files'], $app['composer']);
+		});
+
+		$this->commands('command.cache.clear', 'command.cache.table');
+	}
+
+	/**
+	 * Get the services provided by the provider.
+	 *
+	 * @return array
+	 */
+	public function provides()
+	{
+		return [
+			'cache', 'cache.store', 'memcached.connector', 'command.cache.clear', 'command.cache.table',
+		];
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/Console/CacheTableCommand.php

@@ -0,0 +1,80 @@
+<?php namespace Illuminate\Cache\Console;
+
+use Illuminate\Console\Command;
+use Illuminate\Foundation\Composer;
+use Illuminate\Filesystem\Filesystem;
+
+class CacheTableCommand extends Command {
+
+	/**
+	 * The console command name.
+	 *
+	 * @var string
+	 */
+	protected $name = 'cache:table';
+
+	/**
+	 * The console command description.
+	 *
+	 * @var string
+	 */
+	protected $description = 'Create a migration for the cache database table';
+
+	/**
+	 * The filesystem instance.
+	 *
+	 * @var \Illuminate\Filesystem\Filesystem
+	 */
+	protected $files;
+
+	/**
+	 * @var \Illuminate\Foundation\Composer
+	 */
+	protected $composer;
+
+	/**
+	 * Create a new session table command instance.
+	 *
+	 * @param  \Illuminate\Filesystem\Filesystem  $files
+	 * @param  \Illuminate\Foundation\Composer  $composer
+	 * @return void
+	 */
+	public function __construct(Filesystem $files, Composer $composer)
+	{
+		parent::__construct();
+
+		$this->files = $files;
+		$this->composer = $composer;
+	}
+
+	/**
+	 * Execute the console command.
+	 *
+	 * @return void
+	 */
+	public function fire()
+	{
+		$fullPath = $this->createBaseMigration();
+
+		$this->files->put($fullPath, $this->files->get(__DIR__.'/stubs/cache.stub'));
+
+		$this->info('Migration created successfully!');
+
+		$this->composer->dumpAutoloads();
+	}
+
+	/**
+	 * Create a base migration file for the table.
+	 *
+	 * @return string
+	 */
+	protected function createBaseMigration()
+	{
+		$name = 'create_cache_table';
+
+		$path = $this->laravel->databasePath().'/migrations';
+
+		return $this->laravel['migration.creator']->create($name, $path);
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/Console/ClearCommand.php

@@ -0,0 +1,73 @@
+<?php namespace Illuminate\Cache\Console;
+
+use Illuminate\Console\Command;
+use Illuminate\Cache\CacheManager;
+use Symfony\Component\Console\Input\InputArgument;
+
+class ClearCommand extends Command {
+
+	/**
+	 * The console command name.
+	 *
+	 * @var string
+	 */
+	protected $name = 'cache:clear';
+
+	/**
+	 * The console command description.
+	 *
+	 * @var string
+	 */
+	protected $description = "Flush the application cache";
+
+	/**
+	 * The cache manager instance.
+	 *
+	 * @var \Illuminate\Cache\CacheManager
+	 */
+	protected $cache;
+
+	/**
+	 * Create a new cache clear command instance.
+	 *
+	 * @param  \Illuminate\Cache\CacheManager  $cache
+	 * @return void
+	 */
+	public function __construct(CacheManager $cache)
+	{
+		parent::__construct();
+
+		$this->cache = $cache;
+	}
+
+	/**
+	 * Execute the console command.
+	 *
+	 * @return void
+	 */
+	public function fire()
+	{
+		$storeName = $this->argument('store');
+
+		$this->laravel['events']->fire('cache:clearing', [$storeName]);
+
+		$this->cache->store($storeName)->flush();
+
+		$this->laravel['events']->fire('cache:cleared', [$storeName]);
+
+		$this->info('Application cache cleared!');
+	}
+
+	/**
+	 * Get the console command arguments.
+	 *
+	 * @return array
+	 */
+	protected function getArguments()
+	{
+		return [
+			['store', InputArgument::OPTIONAL, 'The name of the store you would like to clear.'],
+		];
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/Console/stubs/cache.stub

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Database\Migrations\Migration;
+
+class CreateCacheTable extends Migration {
+
+	/**
+	 * Run the migrations.
+	 *
+	 * @return void
+	 */
+	public function up()
+	{
+		Schema::create('cache', function(Blueprint $table)
+		{
+			$table->string('key')->unique();
+			$table->text('value');
+			$table->integer('expiration');
+		});
+	}
+
+	/**
+	 * Reverse the migrations.
+	 *
+	 * @return void
+	 */
+	public function down()
+	{
+		Schema::drop('cache');
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/DatabaseStore.php

@@ -0,0 +1,228 @@
+<?php namespace Illuminate\Cache;
+
+use Exception;
+use LogicException;
+use Illuminate\Contracts\Cache\Store;
+use Illuminate\Database\ConnectionInterface;
+use Illuminate\Contracts\Encryption\Encrypter as EncrypterContract;
+
+class DatabaseStore implements Store {
+
+	/**
+	 * The database connection instance.
+	 *
+	 * @var \Illuminate\Database\ConnectionInterface
+	 */
+	protected $connection;
+
+	/**
+	 * The encrypter instance.
+	 *
+	 * @var \Illuminate\Contracts\Encryption\Encrypter
+	 */
+	protected $encrypter;
+
+	/**
+	 * The name of the cache table.
+	 *
+	 * @var string
+	 */
+	protected $table;
+
+	/**
+	 * A string that should be prepended to keys.
+	 *
+	 * @var string
+	 */
+	protected $prefix;
+
+	/**
+	 * Create a new database store.
+	 *
+	 * @param  \Illuminate\Database\ConnectionInterface  $connection
+	 * @param  \Illuminate\Contracts\Encryption\Encrypter  $encrypter
+	 * @param  string  $table
+	 * @param  string  $prefix
+	 * @return void
+	 */
+	public function __construct(ConnectionInterface $connection, EncrypterContract $encrypter, $table, $prefix = '')
+	{
+		$this->table = $table;
+		$this->prefix = $prefix;
+		$this->encrypter = $encrypter;
+		$this->connection = $connection;
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		$prefixed = $this->prefix.$key;
+
+		$cache = $this->table()->where('key', '=', $prefixed)->first();
+
+		// If we have a cache record we will check the expiration time against current
+		// time on the system and see if the record has expired. If it has, we will
+		// remove the records from the database table so it isn't returned again.
+		if ( ! is_null($cache))
+		{
+			if (is_array($cache)) $cache = (object) $cache;
+
+			if (time() >= $cache->expiration)
+			{
+				$this->forget($key);
+
+				return;
+			}
+
+			return $this->encrypter->decrypt($cache->value);
+		}
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		$key = $this->prefix.$key;
+
+		// All of the cached values in the database are encrypted in case this is used
+		// as a session data store by the consumer. We'll also calculate the expire
+		// time and place that on the table so we will check it on our retrieval.
+		$value = $this->encrypter->encrypt($value);
+
+		$expiration = $this->getTime() + ($minutes * 60);
+
+		try
+		{
+			$this->table()->insert(compact('key', 'value', 'expiration'));
+		}
+		catch (Exception $e)
+		{
+			$this->table()->where('key', '=', $key)->update(compact('value', 'expiration'));
+		}
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 *
+	 * @throws \LogicException
+	 */
+	public function increment($key, $value = 1)
+	{
+		throw new LogicException("Increment operations not supported by this driver.");
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 *
+	 * @throws \LogicException
+	 */
+	public function decrement($key, $value = 1)
+	{
+		throw new LogicException("Decrement operations not supported by this driver.");
+	}
+
+	/**
+	 * Get the current system time.
+	 *
+	 * @return int
+	 */
+	protected function getTime()
+	{
+		return time();
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		$this->put($key, $value, 5256000);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		$this->table()->where('key', '=', $this->prefix.$key)->delete();
+
+		return true;
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		$this->table()->delete();
+	}
+
+	/**
+	 * Get a query builder for the cache table.
+	 *
+	 * @return \Illuminate\Database\Query\Builder
+	 */
+	protected function table()
+	{
+		return $this->connection->table($this->table);
+	}
+
+	/**
+	 * Get the underlying database connection.
+	 *
+	 * @return \Illuminate\Database\ConnectionInterface
+	 */
+	public function getConnection()
+	{
+		return $this->connection;
+	}
+
+	/**
+	 * Get the encrypter instance.
+	 *
+	 * @return \Illuminate\Contracts\Encryption\Encrypter
+	 */
+	public function getEncrypter()
+	{
+		return $this->encrypter;
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return $this->prefix;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/FileStore.php

@@ -0,0 +1,256 @@
+<?php namespace Illuminate\Cache;
+
+use Exception;
+use Illuminate\Filesystem\Filesystem;
+use Illuminate\Contracts\Cache\Store;
+
+class FileStore implements Store {
+
+	/**
+	 * The Illuminate Filesystem instance.
+	 *
+	 * @var \Illuminate\Filesystem\Filesystem
+	 */
+	protected $files;
+
+	/**
+	 * The file cache directory.
+	 *
+	 * @var string
+	 */
+	protected $directory;
+
+	/**
+	 * Create a new file cache store instance.
+	 *
+	 * @param  \Illuminate\Filesystem\Filesystem  $files
+	 * @param  string  $directory
+	 * @return void
+	 */
+	public function __construct(Filesystem $files, $directory)
+	{
+		$this->files = $files;
+		$this->directory = $directory;
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		return array_get($this->getPayload($key), 'data');
+	}
+
+	/**
+	 * Retrieve an item and expiry time from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return array
+	 */
+	protected function getPayload($key)
+	{
+		$path = $this->path($key);
+
+		// If the file doesn't exists, we obviously can't return the cache so we will
+		// just return null. Otherwise, we'll get the contents of the file and get
+		// the expiration UNIX timestamps from the start of the file's contents.
+		try
+		{
+			$expire = substr($contents = $this->files->get($path), 0, 10);
+		}
+		catch (Exception $e)
+		{
+			return array('data' => null, 'time' => null);
+		}
+
+		// If the current time is greater than expiration timestamps we will delete
+		// the file and return null. This helps clean up the old files and keeps
+		// this directory much cleaner for us as old files aren't hanging out.
+		if (time() >= $expire)
+		{
+			$this->forget($key);
+
+			return array('data' => null, 'time' => null);
+		}
+
+		$data = unserialize(substr($contents, 10));
+
+		// Next, we'll extract the number of minutes that are remaining for a cache
+		// so that we can properly retain the time for things like the increment
+		// operation that may be performed on the cache. We'll round this out.
+		$time = ceil(($expire - time()) / 60);
+
+		return compact('data', 'time');
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		$value = $this->expiration($minutes).serialize($value);
+
+		$this->createCacheDirectory($path = $this->path($key));
+
+		$this->files->put($path, $value);
+	}
+
+	/**
+	 * Create the file cache directory if necessary.
+	 *
+	 * @param  string  $path
+	 * @return void
+	 */
+	protected function createCacheDirectory($path)
+	{
+		try
+		{
+			$this->files->makeDirectory(dirname($path), 0777, true, true);
+		}
+		catch (Exception $e)
+		{
+			//
+		}
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function increment($key, $value = 1)
+	{
+		$raw = $this->getPayload($key);
+
+		$int = ((int) $raw['data']) + $value;
+
+		$this->put($key, $int, (int) $raw['time']);
+
+		return $int;
+	}
+
+	/**
+	 * Decrement the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function decrement($key, $value = 1)
+	{
+		return $this->increment($key, $value * -1);
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		$this->put($key, $value, 0);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		$file = $this->path($key);
+
+		if ($this->files->exists($file))
+		{
+			return $this->files->delete($file);
+		}
+
+		return false;
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		if ($this->files->isDirectory($this->directory))
+		{
+			foreach ($this->files->directories($this->directory) as $directory)
+			{
+				$this->files->deleteDirectory($directory);
+			}
+		}
+	}
+
+	/**
+	 * Get the full path for the given cache key.
+	 *
+	 * @param  string  $key
+	 * @return string
+	 */
+	protected function path($key)
+	{
+		$parts = array_slice(str_split($hash = md5($key), 2), 0, 2);
+
+		return $this->directory.'/'.implode('/', $parts).'/'.$hash;
+	}
+
+	/**
+	 * Get the expiration time based on the given minutes.
+	 *
+	 * @param  int  $minutes
+	 * @return int
+	 */
+	protected function expiration($minutes)
+	{
+		if ($minutes === 0) return 9999999999;
+
+		return time() + ($minutes * 60);
+	}
+
+	/**
+	 * Get the Filesystem instance.
+	 *
+	 * @return \Illuminate\Filesystem\Filesystem
+	 */
+	public function getFilesystem()
+	{
+		return $this->files;
+	}
+
+	/**
+	 * Get the working directory of the cache.
+	 *
+	 * @return string
+	 */
+	public function getDirectory()
+	{
+		return $this->directory;
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return '';
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/MemcachedConnector.php

@@ -0,0 +1,55 @@
+<?php namespace Illuminate\Cache;
+
+use Memcached;
+use RuntimeException;
+
+class MemcachedConnector {
+
+	/**
+	 * Create a new Memcached connection.
+	 *
+	 * @param  array  $servers
+	 * @return \Memcached
+	 *
+	 * @throws \RuntimeException
+	 */
+	public function connect(array $servers)
+	{
+		$memcached = $this->getMemcached();
+
+		// For each server in the array, we'll just extract the configuration and add
+		// the server to the Memcached connection. Once we have added all of these
+		// servers we'll verify the connection is successful and return it back.
+		foreach ($servers as $server)
+		{
+			$memcached->addServer(
+				$server['host'], $server['port'], $server['weight']
+			);
+		}
+
+		$memcachedStatus = $memcached->getVersion();
+
+		if ( ! is_array($memcachedStatus))
+		{
+			throw new RuntimeException("No Memcached servers added.");
+		}
+
+		if (in_array('255.255.255', $memcachedStatus) && count(array_unique($memcachedStatus)) === 1)
+		{
+			throw new RuntimeException("Could not establish Memcached connection.");
+		}
+
+		return $memcached;
+	}
+
+	/**
+	 * Get a new Memcached instance.
+	 *
+	 * @return \Memcached
+	 */
+	protected function getMemcached()
+	{
+		return new Memcached;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/MemcachedStore.php

@@ -0,0 +1,153 @@
+<?php namespace Illuminate\Cache;
+
+use Illuminate\Contracts\Cache\Store;
+
+class MemcachedStore extends TaggableStore implements Store {
+
+	/**
+	 * The Memcached instance.
+	 *
+	 * @var \Memcached
+	 */
+	protected $memcached;
+
+	/**
+	 * A string that should be prepended to keys.
+	 *
+	 * @var string
+	 */
+	protected $prefix;
+
+	/**
+	 * Create a new Memcached store.
+	 *
+	 * @param  \Memcached  $memcached
+	 * @param  string      $prefix
+	 * @return void
+	 */
+	public function __construct($memcached, $prefix = '')
+	{
+		$this->memcached = $memcached;
+		$this->prefix = strlen($prefix) > 0 ? $prefix.':' : '';
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		$value = $this->memcached->get($this->prefix.$key);
+
+		if ($this->memcached->getResultCode() == 0)
+		{
+			return $value;
+		}
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		$this->memcached->set($this->prefix.$key, $value, $minutes * 60);
+	}
+
+	/**
+	 * Store an item in the cache if the key doesn't exist.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return bool
+	 */
+	public function add($key, $value, $minutes)
+	{
+		return $this->memcached->add($this->prefix.$key, $value, $minutes * 60);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function increment($key, $value = 1)
+	{
+		return $this->memcached->increment($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Decrement the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function decrement($key, $value = 1)
+	{
+		return $this->memcached->decrement($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		$this->put($key, $value, 0);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		return $this->memcached->delete($this->prefix.$key);
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		$this->memcached->flush();
+	}
+
+	/**
+	 * Get the underlying Memcached connection.
+	 *
+	 * @return \Memcached
+	 */
+	public function getMemcached()
+	{
+		return $this->memcached;
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return $this->prefix;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/NullStore.php

@@ -0,0 +1,105 @@
+<?php namespace Illuminate\Cache;
+
+use Illuminate\Contracts\Cache\Store;
+
+class NullStore extends TaggableStore implements Store {
+
+	/**
+	 * The array of stored values.
+	 *
+	 * @var array
+	 */
+	protected $storage = array();
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		//
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		//
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function increment($key, $value = 1)
+	{
+		//
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function decrement($key, $value = 1)
+	{
+		//
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		//
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return void
+	 */
+	public function forget($key)
+	{
+		//
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		//
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return '';
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/RedisStore.php

@@ -0,0 +1,186 @@
+<?php namespace Illuminate\Cache;
+
+use Illuminate\Contracts\Cache\Store;
+use Illuminate\Redis\Database as Redis;
+
+class RedisStore extends TaggableStore implements Store {
+
+	/**
+	 * The Redis database connection.
+	 *
+	 * @var \Illuminate\Redis\Database
+	 */
+	protected $redis;
+
+	/**
+	 * A string that should be prepended to keys.
+	 *
+	 * @var string
+	 */
+	protected $prefix;
+
+	/**
+	 * The Redis connection that should be used.
+	 *
+	 * @var string
+	 */
+	protected $connection;
+
+	/**
+	 * Create a new Redis store.
+	 *
+	 * @param  \Illuminate\Redis\Database  $redis
+	 * @param  string  $prefix
+	 * @param  string  $connection
+	 * @return void
+	 */
+	public function __construct(Redis $redis, $prefix = '', $connection = 'default')
+	{
+		$this->redis = $redis;
+		$this->connection = $connection;
+		$this->prefix = strlen($prefix) > 0 ? $prefix.':' : '';
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		if ( ! is_null($value = $this->connection()->get($this->prefix.$key)))
+		{
+			return is_numeric($value) ? $value : unserialize($value);
+		}
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		$value = is_numeric($value) ? $value : serialize($value);
+
+		$minutes = max(1, $minutes);
+
+		$this->connection()->setex($this->prefix.$key, $minutes * 60, $value);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function increment($key, $value = 1)
+	{
+		return $this->connection()->incrby($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function decrement($key, $value = 1)
+	{
+		return $this->connection()->decrby($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		$value = is_numeric($value) ? $value : serialize($value);
+
+		$this->connection()->set($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		return (bool) $this->connection()->del($this->prefix.$key);
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		$this->connection()->flushdb();
+	}
+
+	/**
+	 * Begin executing a new tags operation.
+	 *
+	 * @param  array|mixed  $names
+	 * @return \Illuminate\Cache\RedisTaggedCache
+	 */
+	public function tags($names)
+	{
+		return new RedisTaggedCache($this, new TagSet($this, is_array($names) ? $names : func_get_args()));
+	}
+
+	/**
+	 * Get the Redis connection instance.
+	 *
+	 * @return \Predis\ClientInterface
+	 */
+	public function connection()
+	{
+		return $this->redis->connection($this->connection);
+	}
+
+	/**
+	 * Set the connection name to be used.
+	 *
+	 * @param  string  $connection
+	 * @return void
+	 */
+	public function setConnection($connection)
+	{
+		$this->connection = $connection;
+	}
+
+	/**
+	 * Get the Redis database instance.
+	 *
+	 * @return \Illuminate\Redis\Database
+	 */
+	public function getRedis()
+	{
+		return $this->redis;
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return $this->prefix;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/RedisTaggedCache.php

@@ -0,0 +1,90 @@
+<?php namespace Illuminate\Cache;
+
+class RedisTaggedCache extends TaggedCache {
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		$this->pushForeverKeys($namespace = $this->tags->getNamespace(), $key);
+
+		$this->store->forever(sha1($namespace).':'.$key, $value);
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		$this->deleteForeverKeys();
+
+		parent::flush();
+	}
+
+	/**
+	 * Store a copy of the full key for each namespace segment.
+	 *
+	 * @param  string  $namespace
+	 * @param  string  $key
+	 * @return void
+	 */
+	protected function pushForeverKeys($namespace, $key)
+	{
+		$fullKey = $this->getPrefix().sha1($namespace).':'.$key;
+
+		foreach (explode('|', $namespace) as $segment)
+		{
+			$this->store->connection()->lpush($this->foreverKey($segment), $fullKey);
+		}
+	}
+
+	/**
+	 * Delete all of the items that were stored forever.
+	 *
+	 * @return void
+	 */
+	protected function deleteForeverKeys()
+	{
+		foreach (explode('|', $this->tags->getNamespace()) as $segment)
+		{
+			$this->deleteForeverValues($segment = $this->foreverKey($segment));
+
+			$this->store->connection()->del($segment);
+		}
+	}
+
+	/**
+	 * Delete all of the keys that have been stored forever.
+	 *
+	 * @param  string  $foreverKey
+	 * @return void
+	 */
+	protected function deleteForeverValues($foreverKey)
+	{
+		$forever = array_unique($this->store->connection()->lrange($foreverKey, 0, -1));
+
+		if (count($forever) > 0)
+		{
+			call_user_func_array(array($this->store->connection(), 'del'), $forever);
+		}
+	}
+
+	/**
+	 * Get the forever reference key for the segment.
+	 *
+	 * @param  string  $segment
+	 * @return string
+	 */
+	protected function foreverKey($segment)
+	{
+		return $this->getPrefix().$segment.':forever';
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/Repository.php

@@ -0,0 +1,369 @@
+<?php namespace Illuminate\Cache;
+
+use Closure;
+use DateTime;
+use ArrayAccess;
+use Carbon\Carbon;
+use Illuminate\Contracts\Cache\Store;
+use Illuminate\Support\Traits\Macroable;
+use Illuminate\Contracts\Events\Dispatcher;
+use Illuminate\Contracts\Cache\Repository as CacheContract;
+
+class Repository implements CacheContract, ArrayAccess {
+
+	use Macroable {
+		__call as macroCall;
+	}
+
+	/**
+	 * The cache store implementation.
+	 *
+	 * @var \Illuminate\Contracts\Cache\Store
+	 */
+	protected $store;
+
+	/**
+	 * The event dispatcher implementation.
+	 *
+	 * @var \Illuminate\Contracts\Events\Dispatcher
+	 */
+	protected $events;
+
+	/**
+	 * The default number of minutes to store items.
+	 *
+	 * @var int
+	 */
+	protected $default = 60;
+
+	/**
+	 * Create a new cache repository instance.
+	 *
+	 * @param  \Illuminate\Contracts\Cache\Store  $store
+	 */
+	public function __construct(Store $store)
+	{
+		$this->store = $store;
+	}
+
+	/**
+	 * Set the event dispatcher instance.
+	 *
+	 * @param  \Illuminate\Contracts\Events\Dispatcher
+	 * @return void
+	 */
+	public function setEventDispatcher(Dispatcher $events)
+	{
+		$this->events = $events;
+	}
+
+	/**
+	 * Fire an event for this cache instance.
+	 *
+	 * @param  string  $event
+	 * @param  array  $payload
+	 * @return void
+	 */
+	protected function fireCacheEvent($event, $payload)
+	{
+		if (isset($this->events))
+		{
+			$this->events->fire('cache.'.$event, $payload);
+		}
+	}
+
+	/**
+	 * Determine if an item exists in the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function has($key)
+	{
+		return ! is_null($this->get($key));
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public function get($key, $default = null)
+	{
+		$value = $this->store->get($key);
+
+		if (is_null($value))
+		{
+			$this->fireCacheEvent('missed', [$key]);
+
+			$value = value($default);
+		}
+		else
+		{
+			$this->fireCacheEvent('hit', [$key, $value]);
+		}
+
+		return $value;
+	}
+
+	/**
+	 * Retrieve an item from the cache and delete it.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public function pull($key, $default = null)
+	{
+		$value = $this->get($key, $default);
+
+		$this->forget($key);
+
+		return $value;
+	}
+
+	/**
+	 * Store an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  \DateTime|int  $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		$minutes = $this->getMinutes($minutes);
+
+		if ( ! is_null($minutes))
+		{
+			$this->store->put($key, $value, $minutes);
+
+			$this->fireCacheEvent('write', [$key, $value, $minutes]);
+		}
+	}
+
+	/**
+	 * Store an item in the cache if the key does not exist.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  \DateTime|int  $minutes
+	 * @return bool
+	 */
+	public function add($key, $value, $minutes)
+	{
+		if (method_exists($this->store, 'add'))
+		{
+			return $this->store->add($key, $value, $minutes);
+		}
+
+		if (is_null($this->get($key)))
+		{
+			$this->put($key, $value, $minutes);
+
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		$this->store->forever($key, $value);
+
+		$this->fireCacheEvent('write', [$key, $value, 0]);
+	}
+
+	/**
+	 * Get an item from the cache, or store the default value.
+	 *
+	 * @param  string  $key
+	 * @param  \DateTime|int  $minutes
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function remember($key, $minutes, Closure $callback)
+	{
+		// If the item exists in the cache we will just return this immediately
+		// otherwise we will execute the given Closure and cache the result
+		// of that execution for the given number of minutes in storage.
+		if ( ! is_null($value = $this->get($key)))
+		{
+			return $value;
+		}
+
+		$this->put($key, $value = $callback(), $minutes);
+
+		return $value;
+	}
+
+	/**
+	 * Get an item from the cache, or store the default value forever.
+	 *
+	 * @param  string   $key
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function sear($key, Closure $callback)
+	{
+		return $this->rememberForever($key, $callback);
+	}
+
+	/**
+	 * Get an item from the cache, or store the default value forever.
+	 *
+	 * @param  string   $key
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function rememberForever($key, Closure $callback)
+	{
+		// If the item exists in the cache we will just return this immediately
+		// otherwise we will execute the given Closure and cache the result
+		// of that execution for the given number of minutes. It's easy.
+		if ( ! is_null($value = $this->get($key)))
+		{
+			return $value;
+		}
+
+		$this->forever($key, $value = $callback());
+
+		return $value;
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		$success = $this->store->forget($key);
+
+		$this->fireCacheEvent('delete', [$key]);
+
+		return $success;
+	}
+
+	/**
+	 * Get the default cache time.
+	 *
+	 * @return int
+	 */
+	public function getDefaultCacheTime()
+	{
+		return $this->default;
+	}
+
+	/**
+	 * Set the default cache time in minutes.
+	 *
+	 * @param  int   $minutes
+	 * @return void
+	 */
+	public function setDefaultCacheTime($minutes)
+	{
+		$this->default = $minutes;
+	}
+
+	/**
+	 * Get the cache store implementation.
+	 *
+	 * @return \Illuminate\Contracts\Cache\Store
+	 */
+	public function getStore()
+	{
+		return $this->store;
+	}
+
+	/**
+	 * Determine if a cached value exists.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function offsetExists($key)
+	{
+		return $this->has($key);
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function offsetGet($key)
+	{
+		return $this->get($key);
+	}
+
+	/**
+	 * Store an item in the cache for the default time.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function offsetSet($key, $value)
+	{
+		$this->put($key, $value, $this->default);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return void
+	 */
+	public function offsetUnset($key)
+	{
+		$this->forget($key);
+	}
+
+	/**
+	 * Calculate the number of minutes with the given duration.
+	 *
+	 * @param  \DateTime|int  $duration
+	 * @return int|null
+	 */
+	protected function getMinutes($duration)
+	{
+		if ($duration instanceof DateTime)
+		{
+			$fromNow = Carbon::instance($duration)->diffInMinutes();
+
+			return $fromNow > 0 ? $fromNow : null;
+		}
+
+		return is_string($duration) ? (int) $duration : $duration;
+	}
+
+	/**
+	 * Handle dynamic calls into macros or pass missing methods to the store.
+	 *
+	 * @param  string  $method
+	 * @param  array   $parameters
+	 * @return mixed
+	 */
+	public function __call($method, $parameters)
+	{
+		if (static::hasMacro($method))
+		{
+			return $this->macroCall($method, $parameters);
+		}
+
+		return call_user_func_array(array($this->store, $method), $parameters);
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/TagSet.php

@@ -0,0 +1,99 @@
+<?php namespace Illuminate\Cache;
+
+use Illuminate\Contracts\Cache\Store;
+
+class TagSet {
+
+	/**
+	 * The cache store implementation.
+	 *
+	 * @var \Illuminate\Contracts\Cache\Store
+	 */
+	protected $store;
+
+	/**
+	 * The tag names.
+	 *
+	 * @var array
+	 */
+	protected $names = array();
+
+	/**
+	 * Create a new TagSet instance.
+	 *
+	 * @param  \Illuminate\Contracts\Cache\Store  $store
+	 * @param  array  $names
+	 * @return void
+	 */
+	public function __construct(Store $store, array $names = array())
+	{
+		$this->store = $store;
+		$this->names = $names;
+	}
+
+	/**
+	 * Reset all tags in the set.
+	 *
+	 * @return void
+	 */
+	public function reset()
+	{
+		array_walk($this->names, array($this, 'resetTag'));
+	}
+
+	/**
+	 * Get the unique tag identifier for a given tag.
+	 *
+	 * @param  string  $name
+	 * @return string
+	 */
+	public function tagId($name)
+	{
+		return $this->store->get($this->tagKey($name)) ?: $this->resetTag($name);
+	}
+
+	/**
+	 * Get an array of tag identifiers for all of the tags in the set.
+	 *
+	 * @return array
+	 */
+	protected function tagIds()
+	{
+		return array_map(array($this, 'tagId'), $this->names);
+	}
+
+	/**
+	 * Get a unique namespace that changes when any of the tags are flushed.
+	 *
+	 * @return string
+	 */
+	public function getNamespace()
+	{
+		return implode('|', $this->tagIds());
+	}
+
+	/**
+	 * Reset the tag and return the new tag identifier.
+	 *
+	 * @param  string  $name
+	 * @return string
+	 */
+	public function resetTag($name)
+	{
+		$this->store->forever($this->tagKey($name), $id = str_replace('.', '', uniqid('', true)));
+
+		return $id;
+	}
+
+	/**
+	 * Get the tag identifier key for a given tag.
+	 *
+	 * @param  string  $name
+	 * @return string
+	 */
+	public function tagKey($name)
+	{
+		return 'tag:'.$name.':key';
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/TaggableStore.php

@@ -0,0 +1,27 @@
+<?php namespace Illuminate\Cache;
+
+abstract class TaggableStore {
+
+	/**
+	 * Begin executing a new tags operation.
+	 *
+	 * @param  string  $name
+	 * @return \Illuminate\Cache\TaggedCache
+	 */
+	public function section($name)
+	{
+		return $this->tags($name);
+	}
+
+	/**
+	 * Begin executing a new tags operation.
+	 *
+	 * @param  array|mixed  $names
+	 * @return \Illuminate\Cache\TaggedCache
+	 */
+	public function tags($names)
+	{
+		return new TaggedCache($this, new TagSet($this, is_array($names) ? $names : func_get_args()));
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/TaggedCache.php

@@ -0,0 +1,247 @@
+<?php namespace Illuminate\Cache;
+
+use Closure;
+use DateTime;
+use Carbon\Carbon;
+use Illuminate\Contracts\Cache\Store;
+
+class TaggedCache implements Store {
+
+	/**
+	 * The cache store implementation.
+	 *
+	 * @var \Illuminate\Contracts\Cache\Store
+	 */
+	protected $store;
+
+	/**
+	 * The tag set instance.
+	 *
+	 * @var \Illuminate\Cache\TagSet
+	 */
+	protected $tags;
+
+	/**
+	 * Create a new tagged cache instance.
+	 *
+	 * @param  \Illuminate\Contracts\Cache\Store  $store
+	 * @param  \Illuminate\Cache\TagSet  $tags
+	 * @return void
+	 */
+	public function __construct(Store $store, TagSet $tags)
+	{
+		$this->tags = $tags;
+		$this->store = $store;
+	}
+
+	/**
+	 * Determine if an item exists in the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function has($key)
+	{
+		return ! is_null($this->get($key));
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public function get($key, $default = null)
+	{
+		$value = $this->store->get($this->taggedItemKey($key));
+
+		return ! is_null($value) ? $value : value($default);
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  \DateTime|int  $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		$minutes = $this->getMinutes($minutes);
+
+		if ( ! is_null($minutes))
+		{
+			$this->store->put($this->taggedItemKey($key), $value, $minutes);
+		}
+	}
+
+	/**
+	 * Store an item in the cache if the key does not exist.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  \DateTime|int  $minutes
+	 * @return bool
+	 */
+	public function add($key, $value, $minutes)
+	{
+		if (is_null($this->get($key)))
+		{
+			$this->put($key, $value, $minutes);
+
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function increment($key, $value = 1)
+	{
+		$this->store->increment($this->taggedItemKey($key), $value);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function decrement($key, $value = 1)
+	{
+		$this->store->decrement($this->taggedItemKey($key), $value);
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		$this->store->forever($this->taggedItemKey($key), $value);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		return $this->store->forget($this->taggedItemKey($key));
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		$this->tags->reset();
+	}
+
+	/**
+	 * Get an item from the cache, or store the default value.
+	 *
+	 * @param  string  $key
+	 * @param  \DateTime|int  $minutes
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function remember($key, $minutes, Closure $callback)
+	{
+		// If the item exists in the cache we will just return this immediately
+		// otherwise we will execute the given Closure and cache the result
+		// of that execution for the given number of minutes in storage.
+		if ( ! is_null($value = $this->get($key))) return $value;
+
+		$this->put($key, $value = $callback(), $minutes);
+
+		return $value;
+	}
+
+	/**
+	 * Get an item from the cache, or store the default value forever.
+	 *
+	 * @param  string    $key
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function sear($key, Closure $callback)
+	{
+		return $this->rememberForever($key, $callback);
+	}
+
+	/**
+	 * Get an item from the cache, or store the default value forever.
+	 *
+	 * @param  string    $key
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function rememberForever($key, Closure $callback)
+	{
+		// If the item exists in the cache we will just return this immediately
+		// otherwise we will execute the given Closure and cache the result
+		// of that execution for the given number of minutes. It's easy.
+		if ( ! is_null($value = $this->get($key))) return $value;
+
+		$this->forever($key, $value = $callback());
+
+		return $value;
+	}
+
+	/**
+	 * Get a fully qualified key for a tagged item.
+	 *
+	 * @param  string  $key
+	 * @return string
+	 */
+	public function taggedItemKey($key)
+	{
+		return sha1($this->tags->getNamespace()).':'.$key;
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return $this->store->getPrefix();
+	}
+
+	/**
+	 * Calculate the number of minutes with the given duration.
+	 *
+	 * @param  \DateTime|int  $duration
+	 * @return int|null
+	 */
+	protected function getMinutes($duration)
+	{
+		if ($duration instanceof DateTime)
+		{
+			$fromNow = Carbon::instance($duration)->diffInMinutes();
+
+			return $fromNow > 0 ? $fromNow : null;
+		}
+
+		return is_string($duration) ? (int) $duration : $duration;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/WinCacheStore.php

@@ -0,0 +1,121 @@
+<?php namespace Illuminate\Cache;
+
+use Illuminate\Contracts\Cache\Store;
+
+class WinCacheStore extends TaggableStore implements Store {
+
+	/**
+	 * A string that should be prepended to keys.
+	 *
+	 * @var string
+	 */
+	protected $prefix;
+
+	/**
+	 * Create a new WinCache store.
+	 *
+	 * @param  string  $prefix
+	 * @return void
+	 */
+	public function __construct($prefix = '')
+	{
+		$this->prefix = $prefix;
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		$value = wincache_ucache_get($this->prefix.$key);
+
+		if ($value !== false)
+		{
+			return $value;
+		}
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		wincache_ucache_set($this->prefix.$key, $value, $minutes * 60);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function increment($key, $value = 1)
+	{
+		return wincache_ucache_inc($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function decrement($key, $value = 1)
+	{
+		return wincache_ucache_dec($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		$this->put($key, $value, 0);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		return wincache_ucache_delete($this->prefix.$key);
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		wincache_ucache_clear();
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return $this->prefix;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/XCacheStore.php

@@ -0,0 +1,121 @@
+<?php namespace Illuminate\Cache;
+
+use Illuminate\Contracts\Cache\Store;
+
+class XCacheStore extends TaggableStore implements Store {
+
+	/**
+	 * A string that should be prepended to keys.
+	 *
+	 * @var string
+	 */
+	protected $prefix;
+
+	/**
+	 * Create a new WinCache store.
+	 *
+	 * @param  string  $prefix
+	 * @return void
+	 */
+	public function __construct($prefix = '')
+	{
+		$this->prefix = $prefix;
+	}
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key)
+	{
+		$value = xcache_get($this->prefix.$key);
+
+		if (isset($value))
+		{
+			return $value;
+		}
+	}
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes)
+	{
+		xcache_set($this->prefix.$key, $value, $minutes * 60);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function increment($key, $value = 1)
+	{
+		return xcache_inc($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int
+	 */
+	public function decrement($key, $value = 1)
+	{
+		return xcache_dec($this->prefix.$key, $value);
+	}
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value)
+	{
+		return $this->put($key, $value, 0);
+	}
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key)
+	{
+		return xcache_unset($this->prefix.$key);
+	}
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush()
+	{
+		xcache_clear_cache(XC_TYPE_VAR);
+	}
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix()
+	{
+		return $this->prefix;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Cache/composer.json

@@ -0,0 +1,38 @@
+{
+    "name": "illuminate/cache",
+    "description": "The Illuminate Cache package.",
+    "license": "MIT",
+    "homepage": "http://laravel.com",
+    "support": {
+        "issues": "https://github.com/laravel/framework/issues",
+        "source": "https://github.com/laravel/framework"
+    },
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylorotwell@gmail.com"
+        }
+    ],
+    "require": {
+        "php": ">=5.4.0",
+        "illuminate/contracts": "5.0.*",
+        "illuminate/support": "5.0.*",
+        "nesbot/carbon": "~1.0"
+    },
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Cache\\": ""
+        }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "5.0-dev"
+        }
+    },
+    "suggest": {
+        "illuminate/database": "Required to use the database cache driver (5.0.*).",
+        "illuminate/filesystem": "Required to use the file cache driver (5.0.*).",
+        "illuminate/redis": "Required to use the redis cache driver (5.0.*)."
+    },
+    "minimum-stability": "dev"
+}

vendor/laravel/framework/src/Illuminate/Config/Repository.php

@@ -0,0 +1,158 @@
+<?php namespace Illuminate\Config;
+
+use ArrayAccess;
+use Illuminate\Contracts\Config\Repository as ConfigContract;
+
+class Repository implements ArrayAccess, ConfigContract {
+
+	/**
+	 * All of the configuration items.
+	 *
+	 * @var array
+	 */
+	protected $items = [];
+
+	/**
+	 * Create a new configuration repository.
+	 *
+	 * @param  array  $items
+	 * @return void
+	 */
+	public function __construct(array $items = array())
+	{
+		$this->items = $items;
+	}
+
+	/**
+	 * Determine if the given configuration value exists.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function has($key)
+	{
+		return array_has($this->items, $key);
+	}
+
+	/**
+	 * Get the specified configuration value.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public function get($key, $default = null)
+	{
+		return array_get($this->items, $key, $default);
+	}
+
+	/**
+	 * Set a given configuration value.
+	 *
+	 * @param  array|string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function set($key, $value = null)
+	{
+		if (is_array($key))
+		{
+			foreach ($key as $innerKey => $innerValue)
+			{
+				array_set($this->items, $innerKey, $innerValue);
+			}
+		}
+		else
+		{
+			array_set($this->items, $key, $value);
+		}
+	}
+
+	/**
+	 * Prepend a value onto an array configuration value.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function prepend($key, $value)
+	{
+		$array = $this->get($key);
+
+		array_unshift($array, $value);
+
+		$this->set($key, $array);
+	}
+
+	/**
+	 * Push a value onto an array configuration value.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function push($key, $value)
+	{
+		$array = $this->get($key);
+
+		$array[] = $value;
+
+		$this->set($key, $array);
+	}
+
+	/**
+	 * Get all of the configuration items for the application.
+	 *
+	 * @return array
+	 */
+	public function all()
+	{
+		return $this->items;
+	}
+
+	/**
+	 * Determine if the given configuration option exists.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function offsetExists($key)
+	{
+		return $this->has($key);
+	}
+
+	/**
+	 * Get a configuration option.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function offsetGet($key)
+	{
+		return $this->get($key);
+	}
+
+	/**
+	 * Set a configuration option.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function offsetSet($key, $value)
+	{
+		$this->set($key, $value);
+	}
+
+	/**
+	 * Unset a configuration option.
+	 *
+	 * @param  string  $key
+	 * @return void
+	 */
+	public function offsetUnset($key)
+	{
+		$this->set($key, null);
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Config/composer.json

@@ -0,0 +1,32 @@
+{
+    "name": "illuminate/config",
+    "description": "The Illuminate Config package.",
+    "license": "MIT",
+    "homepage": "http://laravel.com",
+    "support": {
+        "issues": "https://github.com/laravel/framework/issues",
+        "source": "https://github.com/laravel/framework"
+    },
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylorotwell@gmail.com"
+        }
+    ],
+    "require": {
+        "php": ">=5.4.0",
+        "illuminate/contracts": "5.0.*",
+        "illuminate/support": "5.0.*"
+    },
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Config\\": ""
+        }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "5.0-dev"
+        }
+    },
+    "minimum-stability": "dev"
+}

vendor/laravel/framework/src/Illuminate/Console/AppNamespaceDetectorTrait.php

@@ -0,0 +1,29 @@
+<?php namespace Illuminate\Console;
+
+use RuntimeException;
+
+trait AppNamespaceDetectorTrait {
+
+	/**
+	 * Get the application namespace from the Composer file.
+	 *
+	 * @return string
+	 *
+	 * @throws \RuntimeException
+	 */
+	protected function getAppNamespace()
+	{
+		$composer = json_decode(file_get_contents(base_path().'/composer.json'), true);
+
+		foreach ((array) data_get($composer, 'autoload.psr-4') as $namespace => $path)
+		{
+			foreach ((array) $path as $pathChoice)
+			{
+				if (realpath(app_path()) == realpath(base_path().'/'.$pathChoice)) return $namespace;
+			}
+		}
+
+		throw new RuntimeException("Unable to detect application namespace.");
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/Application.php

@@ -0,0 +1,167 @@
+<?php namespace Illuminate\Console;
+
+use Illuminate\Contracts\Events\Dispatcher;
+use Illuminate\Contracts\Container\Container;
+use Symfony\Component\Console\Input\ArrayInput;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\BufferedOutput;
+use Symfony\Component\Console\Application as SymfonyApplication;
+use Symfony\Component\Console\Command\Command as SymfonyCommand;
+use Illuminate\Contracts\Console\Application as ApplicationContract;
+
+class Application extends SymfonyApplication implements ApplicationContract {
+
+	/**
+	 * The Laravel application instance.
+	 *
+	 * @var \Illuminate\Contracts\Container\Container
+	 */
+	protected $laravel;
+
+	/**
+	 * The output from the previous command.
+	 *
+	 * @var \Symfony\Component\Console\Output\BufferedOutput
+	 */
+	protected $lastOutput;
+
+	/**
+	 * Create a new Artisan console application.
+	 *
+	 * @param  \Illuminate\Contracts\Container\Container  $laravel
+	 * @param  \Illuminate\Contracts\Events\Dispatcher  $events
+	 * @param  string  $version
+	 * @return void
+	 */
+	public function __construct(Container $laravel, Dispatcher $events, $version)
+	{
+		parent::__construct('Laravel Framework', $version);
+
+		$this->laravel = $laravel;
+		$this->setAutoExit(false);
+		$this->setCatchExceptions(false);
+
+		$events->fire('artisan.start', [$this]);
+	}
+
+	/**
+	 * Run an Artisan console command by name.
+	 *
+	 * @param  string  $command
+	 * @param  array  $parameters
+	 * @return int
+	 */
+	public function call($command, array $parameters = array())
+	{
+		$parameters['command'] = $command;
+
+		$this->lastOutput = new BufferedOutput;
+
+		return $this->find($command)->run(new ArrayInput($parameters), $this->lastOutput);
+	}
+
+	/**
+	 * Get the output for the last run command.
+	 *
+	 * @return string
+	 */
+	public function output()
+	{
+		return $this->lastOutput ? $this->lastOutput->fetch() : '';
+	}
+
+	/**
+	 * Add a command to the console.
+	 *
+	 * @param  \Symfony\Component\Console\Command\Command  $command
+	 * @return \Symfony\Component\Console\Command\Command
+	 */
+	public function add(SymfonyCommand $command)
+	{
+		if ($command instanceof Command)
+		{
+			$command->setLaravel($this->laravel);
+		}
+
+		return $this->addToParent($command);
+	}
+
+	/**
+	 * Add the command to the parent instance.
+	 *
+	 * @param  \Symfony\Component\Console\Command\Command  $command
+	 * @return \Symfony\Component\Console\Command\Command
+	 */
+	protected function addToParent(SymfonyCommand $command)
+	{
+		return parent::add($command);
+	}
+
+	/**
+	 * Add a command, resolving through the application.
+	 *
+	 * @param  string  $command
+	 * @return \Symfony\Component\Console\Command\Command
+	 */
+	public function resolve($command)
+	{
+		return $this->add($this->laravel->make($command));
+	}
+
+	/**
+	 * Resolve an array of commands through the application.
+	 *
+	 * @param  array|mixed  $commands
+	 * @return $this
+	 */
+	public function resolveCommands($commands)
+	{
+		$commands = is_array($commands) ? $commands : func_get_args();
+
+		foreach ($commands as $command)
+		{
+			$this->resolve($command);
+		}
+
+		return $this;
+	}
+
+	/**
+	 * Get the default input definitions for the applications.
+	 *
+	 * This is used to add the --env option to every available command.
+	 *
+	 * @return \Symfony\Component\Console\Input\InputDefinition
+	 */
+	protected function getDefaultInputDefinition()
+	{
+		$definition = parent::getDefaultInputDefinition();
+
+		$definition->addOption($this->getEnvironmentOption());
+
+		return $definition;
+	}
+
+	/**
+	 * Get the global environment option for the definition.
+	 *
+	 * @return \Symfony\Component\Console\Input\InputOption
+	 */
+	protected function getEnvironmentOption()
+	{
+		$message = 'The environment the command should run under.';
+
+		return new InputOption('--env', null, InputOption::VALUE_OPTIONAL, $message);
+	}
+
+	/**
+	 * Get the Laravel application instance.
+	 *
+	 * @return \Illuminate\Contracts\Foundation\Application
+	 */
+	public function getLaravel()
+	{
+		return $this->laravel;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/Command.php

@@ -0,0 +1,387 @@
+<?php namespace Illuminate\Console;
+
+use Symfony\Component\Console\Helper\Table;
+use Symfony\Component\Console\Input\ArrayInput;
+use Symfony\Component\Console\Output\NullOutput;
+use Symfony\Component\Console\Question\Question;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Question\ChoiceQuestion;
+use Symfony\Component\Console\Question\ConfirmationQuestion;
+use Illuminate\Contracts\Foundation\Application as LaravelApplication;
+
+class Command extends \Symfony\Component\Console\Command\Command {
+
+	/**
+	 * The Laravel application instance.
+	 *
+	 * @var \Illuminate\Contracts\Foundation\Application
+	 */
+	protected $laravel;
+
+	/**
+	 * The input interface implementation.
+	 *
+	 * @var \Symfony\Component\Console\Input\InputInterface
+	 */
+	protected $input;
+
+	/**
+	 * The output interface implementation.
+	 *
+	 * @var \Symfony\Component\Console\Output\OutputInterface
+	 */
+	protected $output;
+
+	/**
+	 * The console command name.
+	 *
+	 * @var string
+	 */
+	protected $name;
+
+	/**
+	 * The console command description.
+	 *
+	 * @var string
+	 */
+	protected $description;
+
+	/**
+	 * Create a new console command instance.
+	 *
+	 * @return void
+	 */
+	public function __construct()
+	{
+		parent::__construct($this->name);
+
+		// We will go ahead and set the name, description, and parameters on console
+		// commands just to make things a little easier on the developer. This is
+		// so they don't have to all be manually specified in the constructors.
+		$this->setDescription($this->description);
+
+		$this->specifyParameters();
+	}
+
+	/**
+	 * Specify the arguments and options on the command.
+	 *
+	 * @return void
+	 */
+	protected function specifyParameters()
+	{
+		// We will loop through all of the arguments and options for the command and
+		// set them all on the base command instance. This specifies what can get
+		// passed into these commands as "parameters" to control the execution.
+		foreach ($this->getArguments() as $arguments)
+		{
+			call_user_func_array(array($this, 'addArgument'), $arguments);
+		}
+
+		foreach ($this->getOptions() as $options)
+		{
+			call_user_func_array(array($this, 'addOption'), $options);
+		}
+	}
+
+	/**
+	 * Run the console command.
+	 *
+	 * @param  \Symfony\Component\Console\Input\InputInterface  $input
+	 * @param  \Symfony\Component\Console\Output\OutputInterface  $output
+	 * @return int
+	 */
+	public function run(InputInterface $input, OutputInterface $output)
+	{
+		$this->input = $input;
+
+		$this->output = $output;
+
+		return parent::run($input, $output);
+	}
+
+	/**
+	 * Execute the console command.
+	 *
+	 * @param  \Symfony\Component\Console\Input\InputInterface  $input
+	 * @param  \Symfony\Component\Console\Output\OutputInterface  $output
+	 * @return mixed
+	 */
+	protected function execute(InputInterface $input, OutputInterface $output)
+	{
+		$method = method_exists($this, 'handle') ? 'handle' : 'fire';
+
+		return $this->laravel->call([$this, $method]);
+	}
+
+	/**
+	 * Call another console command.
+	 *
+	 * @param  string  $command
+	 * @param  array   $arguments
+	 * @return int
+	 */
+	public function call($command, array $arguments = array())
+	{
+		$instance = $this->getApplication()->find($command);
+
+		$arguments['command'] = $command;
+
+		return $instance->run(new ArrayInput($arguments), $this->output);
+	}
+
+	/**
+	 * Call another console command silently.
+	 *
+	 * @param  string  $command
+	 * @param  array   $arguments
+	 * @return int
+	 */
+	public function callSilent($command, array $arguments = array())
+	{
+		$instance = $this->getApplication()->find($command);
+
+		$arguments['command'] = $command;
+
+		return $instance->run(new ArrayInput($arguments), new NullOutput);
+	}
+
+	/**
+	 * Get the value of a command argument.
+	 *
+	 * @param  string  $key
+	 * @return string|array
+	 */
+	public function argument($key = null)
+	{
+		if (is_null($key)) return $this->input->getArguments();
+
+		return $this->input->getArgument($key);
+	}
+
+	/**
+	 * Get the value of a command option.
+	 *
+	 * @param  string  $key
+	 * @return string|array
+	 */
+	public function option($key = null)
+	{
+		if (is_null($key)) return $this->input->getOptions();
+
+		return $this->input->getOption($key);
+	}
+
+	/**
+	 * Confirm a question with the user.
+	 *
+	 * @param  string  $question
+	 * @param  bool    $default
+	 * @return bool
+	 */
+	public function confirm($question, $default = false)
+	{
+		$helper = $this->getHelperSet()->get('question');
+
+		$question = new ConfirmationQuestion("<question>{$question}</question> ", $default);
+
+		return $helper->ask($this->input, $this->output, $question);
+	}
+
+	/**
+	 * Prompt the user for input.
+	 *
+	 * @param  string  $question
+	 * @param  string  $default
+	 * @return string
+	 */
+	public function ask($question, $default = null)
+	{
+		$helper = $this->getHelperSet()->get('question');
+
+		$question = new Question("<question>$question</question> ", $default);
+
+		return $helper->ask($this->input, $this->output, $question);
+	}
+
+	/**
+	 * Prompt the user for input with auto completion.
+	 *
+	 * @param  string  $question
+	 * @param  array   $choices
+	 * @param  string  $default
+	 * @return string
+	 */
+	public function askWithCompletion($question, array $choices, $default = null)
+	{
+		$helper = $this->getHelperSet()->get('question');
+
+		$question = new Question("<question>$question</question> ", $default);
+
+		$question->setAutocompleterValues($choices);
+
+		return $helper->ask($this->input, $this->output, $question);
+	}
+
+	/**
+	 * Prompt the user for input but hide the answer from the console.
+	 *
+	 * @param  string  $question
+	 * @param  bool    $fallback
+	 * @return string
+	 */
+	public function secret($question, $fallback = true)
+	{
+		$helper = $this->getHelperSet()->get('question');
+
+		$question = new Question("<question>$question</question> ");
+
+		$question->setHidden(true)->setHiddenFallback($fallback);
+
+		return $helper->ask($this->input, $this->output, $question);
+	}
+
+	/**
+	 * Give the user a single choice from an array of answers.
+	 *
+	 * @param  string  $question
+	 * @param  array   $choices
+	 * @param  string  $default
+	 * @param  mixed   $attempts
+	 * @param  bool    $multiple
+	 * @return bool
+	 */
+	public function choice($question, array $choices, $default = null, $attempts = null, $multiple = null)
+	{
+		$helper = $this->getHelperSet()->get('question');
+
+		$question = new ChoiceQuestion("<question>$question</question> ", $choices, $default);
+
+		$question->setMaxAttempts($attempts)->setMultiselect($multiple);
+
+		return $helper->ask($this->input, $this->output, $question);
+	}
+
+	/**
+	 * Format input to textual table.
+	 *
+	 * @param  array   $headers
+	 * @param  array   $rows
+	 * @param  string  $style
+	 * @return void
+	 */
+	public function table(array $headers, array $rows, $style = 'default')
+	{
+		$table = new Table($this->output);
+
+		$table->setHeaders($headers)->setRows($rows)->setStyle($style)->render();
+	}
+
+	/**
+	 * Write a string as information output.
+	 *
+	 * @param  string  $string
+	 * @return void
+	 */
+	public function info($string)
+	{
+		$this->output->writeln("<info>$string</info>");
+	}
+
+	/**
+	 * Write a string as standard output.
+	 *
+	 * @param  string  $string
+	 * @return void
+	 */
+	public function line($string)
+	{
+		$this->output->writeln($string);
+	}
+
+	/**
+	 * Write a string as comment output.
+	 *
+	 * @param  string  $string
+	 * @return void
+	 */
+	public function comment($string)
+	{
+		$this->output->writeln("<comment>$string</comment>");
+	}
+
+	/**
+	 * Write a string as question output.
+	 *
+	 * @param  string  $string
+	 * @return void
+	 */
+	public function question($string)
+	{
+		$this->output->writeln("<question>$string</question>");
+	}
+
+	/**
+	 * Write a string as error output.
+	 *
+	 * @param  string  $string
+	 * @return void
+	 */
+	public function error($string)
+	{
+		$this->output->writeln("<error>$string</error>");
+	}
+
+	/**
+	 * Get the console command arguments.
+	 *
+	 * @return array
+	 */
+	protected function getArguments()
+	{
+		return array();
+	}
+
+	/**
+	 * Get the console command options.
+	 *
+	 * @return array
+	 */
+	protected function getOptions()
+	{
+		return array();
+	}
+
+	/**
+	 * Get the output implementation.
+	 *
+	 * @return \Symfony\Component\Console\Output\OutputInterface
+	 */
+	public function getOutput()
+	{
+		return $this->output;
+	}
+
+	/**
+	 * Get the Laravel application instance.
+	 *
+	 * @return \Illuminate\Contracts\Foundation\Application
+	 */
+	public function getLaravel()
+	{
+		return $this->laravel;
+	}
+
+	/**
+	 * Set the Laravel application instance.
+	 *
+	 * @param  \Illuminate\Contracts\Foundation\Application  $laravel
+	 * @return void
+	 */
+	public function setLaravel(LaravelApplication $laravel)
+	{
+		$this->laravel = $laravel;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/ConfirmableTrait.php

@@ -0,0 +1,50 @@
+<?php namespace Illuminate\Console;
+
+use Closure;
+
+trait ConfirmableTrait {
+
+	/**
+	 * Confirm before proceeding with the action.
+	 *
+	 * @param  string    $warning
+	 * @param  \Closure|null  $callback
+	 * @return bool
+	 */
+	public function confirmToProceed($warning = 'Application In Production!', Closure $callback = null)
+	{
+		$shouldConfirm = $callback ?: $this->getDefaultConfirmCallback();
+
+		if (call_user_func($shouldConfirm))
+		{
+			if ($this->option('force')) return true;
+
+			$this->comment(str_repeat('*', strlen($warning) + 12));
+			$this->comment('*     '.$warning.'     *');
+			$this->comment(str_repeat('*', strlen($warning) + 12));
+			$this->output->writeln('');
+
+			$confirmed = $this->confirm('Do you really wish to run this command? [y/N]');
+
+			if ( ! $confirmed)
+			{
+				$this->comment('Command Cancelled!');
+
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * Get the default confirmation callback.
+	 *
+	 * @return \Closure
+	 */
+	protected function getDefaultConfirmCallback()
+	{
+		return function() { return $this->getLaravel()->environment() == 'production'; };
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/GeneratorCommand.php

@@ -0,0 +1,208 @@
+<?php namespace Illuminate\Console;
+
+use Illuminate\Filesystem\Filesystem;
+use Symfony\Component\Console\Input\InputArgument;
+
+abstract class GeneratorCommand extends Command {
+
+	use AppNamespaceDetectorTrait;
+
+	/**
+	 * The filesystem instance.
+	 *
+	 * @var \Illuminate\Filesystem\Filesystem
+	 */
+	protected $files;
+
+	/**
+	 * The type of class being generated.
+	 *
+	 * @var string
+	 */
+	protected $type;
+
+	/**
+	 * Create a new controller creator command instance.
+	 *
+	 * @param  \Illuminate\Filesystem\Filesystem  $files
+	 * @return void
+	 */
+	public function __construct(Filesystem $files)
+	{
+		parent::__construct();
+
+		$this->files = $files;
+	}
+
+	/**
+	 * Get the stub file for the generator.
+	 *
+	 * @return string
+	 */
+	abstract protected function getStub();
+
+	/**
+	 * Execute the console command.
+	 *
+	 * @return void
+	 */
+	public function fire()
+	{
+		$name = $this->parseName($this->getNameInput());
+
+		if ($this->files->exists($path = $this->getPath($name)))
+		{
+			$this->error($this->type.' already exists!');
+
+			return false;
+		}
+
+		$this->makeDirectory($path);
+
+		$this->files->put($path, $this->buildClass($name));
+
+		$this->info($this->type.' created successfully.');
+	}
+
+	/**
+	 * Get the destination class path.
+	 *
+	 * @param  string  $name
+	 * @return string
+	 */
+	protected function getPath($name)
+	{
+		$name = str_replace($this->getAppNamespace(), '', $name);
+
+		return $this->laravel['path'].'/'.str_replace('\\', '/', $name).'.php';
+	}
+
+	/**
+	 * Parse the name and format according to the root namespace.
+	 *
+	 * @param  string  $name
+	 * @return string
+	 */
+	protected function parseName($name)
+	{
+		$rootNamespace = $this->getAppNamespace();
+
+		if (starts_with($name, $rootNamespace))
+		{
+			return $name;
+		}
+
+		if (str_contains($name, '/'))
+		{
+			$name = str_replace('/', '\\', $name);
+		}
+
+		return $this->parseName($this->getDefaultNamespace(trim($rootNamespace, '\\')).'\\'.$name);
+	}
+
+	/**
+	 * Get the default namespace for the class.
+	 *
+	 * @param  string  $rootNamespace
+	 * @return string
+	 */
+	protected function getDefaultNamespace($rootNamespace)
+	{
+		return $rootNamespace;
+	}
+
+	/**
+	 * Build the directory for the class if necessary.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	protected function makeDirectory($path)
+	{
+		if ( ! $this->files->isDirectory(dirname($path)))
+		{
+			$this->files->makeDirectory(dirname($path), 0777, true, true);
+		}
+	}
+
+	/**
+	 * Build the class with the given name.
+	 *
+	 * @param  string  $name
+	 * @return string
+	 */
+	protected function buildClass($name)
+	{
+		$stub = $this->files->get($this->getStub());
+
+		return $this->replaceNamespace($stub, $name)->replaceClass($stub, $name);
+	}
+
+	/**
+	 * Replace the namespace for the given stub.
+	 *
+	 * @param  string  $stub
+	 * @param  string  $name
+	 * @return $this
+	 */
+	protected function replaceNamespace(&$stub, $name)
+	{
+		$stub = str_replace(
+			'{{namespace}}', $this->getNamespace($name), $stub
+		);
+
+		$stub = str_replace(
+			'{{rootNamespace}}', $this->getAppNamespace(), $stub
+		);
+
+		return $this;
+	}
+
+	/**
+	 * Get the full namespace name for a given class.
+	 *
+	 * @param  string  $name
+	 * @return string
+	 */
+	protected function getNamespace($name)
+	{
+		return trim(implode('\\', array_slice(explode('\\', $name), 0, -1)), '\\');
+	}
+
+	/**
+	 * Replace the class name for the given stub.
+	 *
+	 * @param  string  $stub
+	 * @param  string  $name
+	 * @return string
+	 */
+	protected function replaceClass($stub, $name)
+	{
+		$class = str_replace($this->getNamespace($name).'\\', '', $name);
+
+		return str_replace('{{class}}', $class, $stub);
+	}
+
+	/**
+	 * Get the desired class name from the input.
+	 *
+	 * @return string
+	 */
+	protected function getNameInput()
+	{
+		return $this->argument('name');
+	}
+
+	/**
+	 * Get the console command arguments.
+	 *
+	 * @return array
+	 */
+	protected function getArguments()
+	{
+		return array(
+			array('name', InputArgument::REQUIRED, 'The name of the class'),
+		);
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/ScheduleServiceProvider.php

@@ -0,0 +1,36 @@
+<?php namespace Illuminate\Console;
+
+use Illuminate\Support\ServiceProvider;
+
+class ScheduleServiceProvider extends ServiceProvider {
+
+	/**
+	 * Indicates if loading of the provider is deferred.
+	 *
+	 * @var bool
+	 */
+	protected $defer = true;
+
+	/**
+	 * Register the service provider.
+	 *
+	 * @return void
+	 */
+	public function register()
+	{
+		$this->commands('Illuminate\Console\Scheduling\ScheduleRunCommand');
+	}
+
+	/**
+	 * Get the services provided by the provider.
+	 *
+	 * @return array
+	 */
+	public function provides()
+	{
+		return [
+			'Illuminate\Console\Scheduling\ScheduleRunCommand',
+		];
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/Scheduling/CallbackEvent.php

@@ -0,0 +1,126 @@
+<?php namespace Illuminate\Console\Scheduling;
+
+use LogicException;
+use InvalidArgumentException;
+use Illuminate\Contracts\Container\Container;
+
+class CallbackEvent extends Event {
+
+	/**
+	 * The callback to call.
+	 *
+	 * @var string
+	 */
+	protected $callback;
+
+	/**
+	 * The parameters to pass to the method.
+	 *
+	 * @var array
+	 */
+	protected $parameters;
+
+	/**
+	 * Create a new event instance.
+	 *
+	 * @param  string  $callback
+	 * @param  array  $parameters
+	 * @return void
+	 */
+	public function __construct($callback, array $parameters = array())
+	{
+		$this->callback = $callback;
+		$this->parameters = $parameters;
+
+		if ( ! is_string($this->callback) && ! is_callable($this->callback))
+		{
+			throw new InvalidArgumentException(
+				"Invalid scheduled callback event. Must be string or callable."
+			);
+		}
+	}
+
+	/**
+	 * Run the given event.
+	 *
+	 * @param  \Illuminate\Contracts\Container\Container  $container
+	 * @return mixed
+	 */
+	public function run(Container $container)
+	{
+		if ($this->description)
+		{
+			touch($this->mutexPath());
+		}
+
+		try {
+			$response = $container->call($this->callback, $this->parameters);
+		} catch (\Exception $e) {
+			$this->removeMutex();
+
+			throw $e;
+		}
+
+		$this->removeMutex();
+
+		parent::callAfterCallbacks($container);
+
+		return $response;
+	}
+
+	/**
+	 * Remove the mutex file from disk.
+	 *
+	 * @return void
+	 */
+	protected function removeMutex()
+	{
+		if ($this->description)
+		{
+			@unlink($this->mutexPath());
+		}
+	}
+
+	/**
+	 * Do not allow the event to overlap each other.
+	 *
+	 * @return $this
+	 */
+	public function withoutOverlapping()
+	{
+		if ( ! isset($this->description))
+		{
+			throw new LogicException(
+				"A scheduled event name is required to prevent overlapping. Use the 'name' method before 'withoutOverlapping'."
+			);
+		}
+
+		return $this->skip(function()
+		{
+			return file_exists($this->mutexPath());
+		});
+	}
+
+	/**
+	 * Get the mutex path for the scheduled command.
+	 *
+	 * @return string
+	 */
+	protected function mutexPath()
+	{
+		return storage_path().'/framework/schedule-'.md5($this->description);
+	}
+
+	/**
+	 * Get the summary of the event for display.
+	 *
+	 * @return string
+	 */
+	public function getSummaryForDisplay()
+	{
+		if (is_string($this->description)) return $this->description;
+
+		return is_string($this->callback) ? $this->callback : 'Closure';
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/Scheduling/Event.php

@@ -0,0 +1,756 @@
+<?php namespace Illuminate\Console\Scheduling;
+
+use Closure;
+use Carbon\Carbon;
+use LogicException;
+use Cron\CronExpression;
+use GuzzleHttp\Client as HttpClient;
+use Illuminate\Contracts\Mail\Mailer;
+use Symfony\Component\Process\Process;
+use Illuminate\Contracts\Container\Container;
+use Illuminate\Contracts\Foundation\Application;
+
+class Event {
+
+	/**
+	 * The command string.
+	 *
+	 * @var string
+	 */
+	public $command;
+
+	/**
+	 * The cron expression representing the event's frequency.
+	 *
+	 * @var string
+	 */
+	public $expression = '* * * * * *';
+
+	/**
+	 * The timezone the date should be evaluated on.
+	 *
+	 * @var \DateTimeZone|string
+	 */
+	public $timezone;
+
+	/**
+	 * The user the command should run as.
+	 *
+	 * @var string
+	 */
+	public $user;
+
+	/**
+	 * The list of environments the command should run under.
+	 *
+	 * @var array
+	 */
+	public $environments = [];
+
+	/**
+	 * Indicates if the command should run in maintenance mode.
+	 *
+	 * @var bool
+	 */
+	public $evenInMaintenanceMode = false;
+
+	/**
+	 * Indicates if the command should not overlap itself.
+	 *
+	 * @var bool
+	 */
+	public $withoutOverlapping = false;
+
+	/**
+	 * The filter callback.
+	 *
+	 * @var \Closure
+	 */
+	protected $filter;
+
+	/**
+	 * The reject callback.
+	 *
+	 * @var \Closure
+	 */
+	protected $reject;
+
+	/**
+	 * The location that output should be sent to.
+	 *
+	 * @var string
+	 */
+	public $output = '/dev/null';
+
+	/**
+	 * The array of callbacks to be run after the event is finished.
+	 *
+	 * @var array
+	 */
+	protected $afterCallbacks = [];
+
+	/**
+	 * The human readable description of the event.
+	 *
+	 * @var string
+	 */
+	public $description;
+
+	/**
+	 * Create a new event instance.
+	 *
+	 * @param  string  $command
+	 * @return void
+	 */
+	public function __construct($command)
+	{
+		$this->command = $command;
+	}
+
+	/**
+	 * Run the given event.
+	 *
+	 * @param  \Illuminate\Contracts\Container\Container  $container
+	 * @return void
+	 */
+	public function run(Container $container)
+	{
+		if (count($this->afterCallbacks) > 0)
+		{
+			$this->runCommandInForeground($container);
+		}
+		else
+		{
+			$this->runCommandInBackground();
+		}
+	}
+
+	/**
+	 * Run the command in the background using exec.
+	 *
+	 * @return void
+	 */
+	protected function runCommandInBackground()
+	{
+		chdir(base_path());
+
+		exec($this->buildCommand());
+	}
+
+	/**
+	 * Run the command in the foreground.
+	 *
+	 * @param  \Illuminate\Contracts\Container\Container  $container
+	 * @return void
+	 */
+	protected function runCommandInForeground(Container $container)
+	{
+		(new Process(
+			trim($this->buildCommand(), '& '), base_path(), null, null, null
+		))->run();
+
+		$this->callAfterCallbacks($container);
+	}
+
+	/**
+	 * Call all of the "after" callbacks for the event.
+	 *
+	 * @param  \Illuminate\Contracts\Container\Container  $container
+	 * @return void
+	 */
+	protected function callAfterCallbacks(Container $container)
+	{
+		foreach ($this->afterCallbacks as $callback)
+		{
+			$container->call($callback);
+		}
+	}
+
+	/**
+	 * Build the comand string.
+	 *
+	 * @return string
+	 */
+	public function buildCommand()
+	{
+		if ($this->withoutOverlapping)
+		{
+			$command = '(touch '.$this->mutexPath().'; '.$this->command.'; rm '.$this->mutexPath().') > '.$this->output.' 2>&1 &';
+		}
+		else
+		{
+			$command = $this->command.' > '.$this->output.' 2>&1 &';
+		}
+
+
+		return $this->user ? 'sudo -u '.$this->user.' '.$command : $command;
+	}
+
+	/**
+	 * Get the mutex path for the scheduled command.
+	 *
+	 * @return string
+	 */
+	protected function mutexPath()
+	{
+		return storage_path().'/framework/schedule-'.md5($this->expression.$this->command);
+	}
+
+	/**
+	 * Determine if the given event should run based on the Cron expression.
+	 *
+	 * @param  \Illuminate\Contracts\Foundation\Application  $app
+	 * @return bool
+	 */
+	public function isDue(Application $app)
+	{
+		if ( ! $this->runsInMaintenanceMode() && $app->isDownForMaintenance())
+		{
+			return false;
+		}
+
+		return $this->expressionPasses() &&
+			   $this->filtersPass($app) &&
+			   $this->runsInEnvironment($app->environment());
+	}
+
+	/**
+	 * Determine if the Cron expression passes.
+	 *
+	 * @return bool
+	 */
+	protected function expressionPasses()
+	{
+		$date = Carbon::now();
+
+		if ($this->timezone)
+		{
+			$date->setTimezone($this->timezone);
+		}
+
+		return CronExpression::factory($this->expression)->isDue($date->toDateTimeString());
+	}
+
+	/**
+	 * Determine if the filters pass for the event.
+	 *
+	 * @param  \Illuminate\Contracts\Foundation\Application  $app
+	 * @return bool
+	 */
+	protected function filtersPass(Application $app)
+	{
+		if (($this->filter && ! $app->call($this->filter)) ||
+			 $this->reject && $app->call($this->reject))
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Determine if the event runs in the given environment.
+	 *
+	 * @param  string  $environment
+	 * @return bool
+	 */
+	public function runsInEnvironment($environment)
+	{
+		return empty($this->environments) || in_array($environment, $this->environments);
+	}
+
+	/**
+	 * Determine if the event runs in maintenance mode.
+	 *
+	 * @return bool
+	 */
+	public function runsInMaintenanceMode()
+	{
+		return $this->evenInMaintenanceMode;
+	}
+
+	/**
+	 * The Cron expression representing the event's frequency.
+	 *
+	 * @param  string  $expression
+	 * @return $this
+	 */
+	public function cron($expression)
+	{
+		$this->expression = $expression;
+
+		return $this;
+	}
+
+	/**
+	 * Schedule the event to run hourly.
+	 *
+	 * @return $this
+	 */
+	public function hourly()
+	{
+		return $this->cron('0 * * * * *');
+	}
+
+	/**
+	 * Schedule the event to run daily.
+	 *
+	 * @return $this
+	 */
+	public function daily()
+	{
+		return $this->cron('0 0 * * * *');
+	}
+
+	/**
+	 * Schedule the command at a given time.
+	 *
+	 * @param  string  $time
+	 * @return $this
+	 */
+	public function at($time)
+	{
+		return $this->dailyAt($time);
+	}
+
+	/**
+	 * Schedule the event to run daily at a given time (10:00, 19:30, etc).
+	 *
+	 * @param  string  $time
+	 * @return $this
+	 */
+	public function dailyAt($time)
+	{
+		$segments = explode(':', $time);
+
+		return $this->spliceIntoPosition(2, (int) $segments[0])
+					->spliceIntoPosition(1, count($segments) == 2 ? (int) $segments[1] : '0');
+	}
+
+	/**
+	 * Schedule the event to run twice daily.
+	 *
+	 * @return $this
+	 */
+	public function twiceDaily()
+	{
+		return $this->cron('0 1,13 * * * *');
+	}
+
+	/**
+	 * Schedule the event to run only on weekdays.
+	 *
+	 * @return $this
+	 */
+	public function weekdays()
+	{
+		return $this->spliceIntoPosition(5, '1-5');
+	}
+
+	/**
+	 * Schedule the event to run only on Mondays.
+	 *
+	 * @return $this
+	 */
+	public function mondays()
+	{
+		return $this->days(1);
+	}
+
+	/**
+	 * Schedule the event to run only on Tuesdays.
+	 *
+	 * @return $this
+	 */
+	public function tuesdays()
+	{
+		return $this->days(2);
+	}
+
+	/**
+	 * Schedule the event to run only on Wednesdays.
+	 *
+	 * @return $this
+	 */
+	public function wednesdays()
+	{
+		return $this->days(3);
+	}
+
+	/**
+	 * Schedule the event to run only on Thursdays.
+	 *
+	 * @return $this
+	 */
+	public function thursdays()
+	{
+		return $this->days(4);
+	}
+
+	/**
+	 * Schedule the event to run only on Fridays.
+	 *
+	 * @return $this
+	 */
+	public function fridays()
+	{
+		return $this->days(5);
+	}
+
+	/**
+	 * Schedule the event to run only on Saturdays.
+	 *
+	 * @return $this
+	 */
+	public function saturdays()
+	{
+		return $this->days(6);
+	}
+
+	/**
+	 * Schedule the event to run only on Sundays.
+	 *
+	 * @return $this
+	 */
+	public function sundays()
+	{
+		return $this->days(0);
+	}
+
+	/**
+	 * Schedule the event to run weekly.
+	 *
+	 * @return $this
+	 */
+	public function weekly()
+	{
+		return $this->cron('0 0 * * 0 *');
+	}
+
+	/**
+	 * Schedule the event to run weekly on a given day and time.
+	 *
+	 * @param  int  $day
+	 * @param  string  $time
+	 * @return $this
+	 */
+	public function weeklyOn($day, $time = '0:0')
+	{
+		$this->dailyAt($time);
+
+		return $this->spliceIntoPosition(5, $day);
+	}
+
+	/**
+	 * Schedule the event to run monthly.
+	 *
+	 * @return $this
+	 */
+	public function monthly()
+	{
+		return $this->cron('0 0 1 * * *');
+	}
+
+	/**
+	 * Schedule the event to run yearly.
+	 *
+	 * @return $this
+	 */
+	public function yearly()
+	{
+		return $this->cron('0 0 1 1 * *');
+	}
+
+	/**
+	 * Schedule the event to run every five minutes.
+	 *
+	 * @return $this
+	 */
+	public function everyFiveMinutes()
+	{
+		return $this->cron('*/5 * * * * *');
+	}
+
+	/**
+	 * Schedule the event to run every ten minutes.
+	 *
+	 * @return $this
+	 */
+	public function everyTenMinutes()
+	{
+		return $this->cron('*/10 * * * * *');
+	}
+
+	/**
+	 * Schedule the event to run every thirty minutes.
+	 *
+	 * @return $this
+	 */
+	public function everyThirtyMinutes()
+	{
+		return $this->cron('0,30 * * * * *');
+	}
+
+	/**
+	 * Set the days of the week the command should run on.
+	 *
+	 * @param  array|dynamic  $days
+	 * @return $this
+	 */
+	public function days($days)
+	{
+		$days = is_array($days) ? $days : func_get_args();
+
+		return $this->spliceIntoPosition(5, implode(',', $days));
+	}
+
+	/**
+	 * Set the timezone the date should be evaluated on.
+	 *
+	 * @param  \DateTimeZone|string  $timezone
+	 * @return $this
+	 */
+	public function timezone($timezone)
+	{
+		$this->timezone = $timezone;
+
+		return $this;
+	}
+
+	/**
+	 * Set which user the command should run as.
+	 *
+	 * @param  string  $user
+	 * @return $this
+	 */
+	public function user($user)
+	{
+		$this->user = $user;
+
+		return $this;
+	}
+
+	/**
+	 * Limit the environments the command should run in.
+	 *
+	 * @param  array|dynamic  $environments
+	 * @return $this
+	 */
+	public function environments($environments)
+	{
+		$this->environments = is_array($environments) ? $environments : func_get_args();
+
+		return $this;
+	}
+
+	/**
+	 * State that the command should run even in maintenance mode.
+	 *
+	 * @return $this
+	 */
+	public function evenInMaintenanceMode()
+	{
+		$this->evenInMaintenanceMode = true;
+
+		return $this;
+	}
+
+	/**
+	 * Do not allow the event to overlap each other.
+	 *
+	 * @return $this
+	 */
+	public function withoutOverlapping()
+	{
+		$this->withoutOverlapping = true;
+
+		return $this->skip(function()
+		{
+			return file_exists($this->mutexPath());
+		});
+	}
+
+	/**
+	 * Register a callback to further filter the schedule.
+	 *
+	 * @param  \Closure  $callback
+	 * @return $this
+	 */
+	public function when(Closure $callback)
+	{
+		$this->filter = $callback;
+
+		return $this;
+	}
+
+	/**
+	 * Register a callback to further filter the schedule.
+	 *
+	 * @param  \Closure  $callback
+	 * @return $this
+	 */
+	public function skip(Closure $callback)
+	{
+		$this->reject = $callback;
+
+		return $this;
+	}
+
+	/**
+	 * Send the output of the command to a given location.
+	 *
+	 * @param  string  $location
+	 * @return $this
+	 */
+	public function sendOutputTo($location)
+	{
+		$this->output = $location;
+
+		return $this;
+	}
+
+	/**
+	 * E-mail the results of the scheduled operation.
+	 *
+	 * @param  array|dynamic  $addresses
+	 * @return $this
+	 *
+	 * @throws \LogicException
+	 */
+	public function emailOutputTo($addresses)
+	{
+		if (is_null($this->output) || $this->output == '/dev/null')
+		{
+			throw new LogicException("Must direct output to a file in order to e-mail results.");
+		}
+
+		$addresses = is_array($addresses) ? $addresses : func_get_args();
+
+		return $this->then(function(Mailer $mailer) use ($addresses)
+		{
+			$this->emailOutput($mailer, $addresses);
+		});
+	}
+
+	/**
+	 * E-mail the output of the event to the recipients.
+	 *
+	 * @param  \Illuminate\Contracts\Mail\Mailer  $mailer
+	 * @param  array  $addresses
+	 * @return void
+	 */
+	protected function emailOutput(Mailer $mailer, $addresses)
+	{
+		$mailer->raw(file_get_contents($this->output), function($m) use ($addresses)
+		{
+			$m->subject($this->getEmailSubject());
+
+			foreach ($addresses as $address)
+			{
+				$m->to($address);
+			}
+		});
+	}
+
+	/**
+	 * Get the e-mail subject line for output results.
+	 *
+	 * @return string
+	 */
+	protected function getEmailSubject()
+	{
+		if ($this->description)
+		{
+			return 'Scheduled Job Output ('.$this->description.')';
+		}
+
+		return 'Scheduled Job Output';
+	}
+
+	/**
+	 * Register a callback to ping a given URL after the job runs.
+	 *
+	 * @param  string  $url
+	 * @return $this
+	 */
+	public function thenPing($url)
+	{
+		return $this->then(function() use ($url) { (new HttpClient)->get($url); });
+	}
+
+	/**
+	 * Register a callback to be called after the operation.
+	 *
+	 * @param  \Closure  $callback
+	 * @return $this
+	 */
+	public function then(Closure $callback)
+	{
+		$this->afterCallbacks[] = $callback;
+
+		return $this;
+	}
+
+	/**
+	 * Set the human-friendly description of the event.
+	 *
+	 * @param  string  $description
+	 * @return $this
+	 */
+	public function name($description)
+	{
+		return $this->description($description);
+	}
+
+	/**
+	 * Set the human-friendly description of the event.
+	 *
+	 * @param  string  $description
+	 * @return $this
+	 */
+	public function description($description)
+	{
+		$this->description = $description;
+
+		return $this;
+	}
+
+	/**
+	 * Splice the given value into the given position of the expression.
+	 *
+	 * @param  int  $position
+	 * @param  string  $value
+	 * @return void
+	 */
+	protected function spliceIntoPosition($position, $value)
+	{
+		$segments = explode(' ', $this->expression);
+
+		$segments[$position - 1] = $value;
+
+		return $this->cron(implode(' ', $segments));
+	}
+
+	/**
+	 * Get the summary of the event for display.
+	 *
+	 * @return string
+	 */
+	public function getSummaryForDisplay()
+	{
+		if (is_string($this->description)) return $this->description;
+
+		return $this->buildCommand();
+	}
+
+	/**
+	 * Get the Cron expression for the event.
+	 *
+	 * @return string
+	 */
+	public function getExpression()
+	{
+		return $this->expression;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/Scheduling/Schedule.php

@@ -0,0 +1,76 @@
+<?php namespace Illuminate\Console\Scheduling;
+
+use Illuminate\Contracts\Foundation\Application;
+
+class Schedule {
+
+	/**
+	 * All of the events on the schedule.
+	 *
+	 * @var array
+	 */
+	protected $events = [];
+
+	/**
+	 * Add a new callback event to the schedule.
+	 *
+	 * @param  string  $callback
+	 * @param  array   $parameters
+	 * @return \Illuminate\Console\Scheduling\Event
+	 */
+	public function call($callback, array $parameters = array())
+	{
+		$this->events[] = $event = new CallbackEvent($callback, $parameters);
+
+		return $event;
+	}
+
+	/**
+	 * Add a new Artisan command event to the schedule.
+	 *
+	 * @param  string  $command
+	 * @return \Illuminate\Console\Scheduling\Event
+	 */
+	public function command($command)
+	{
+		return $this->exec(PHP_BINARY.' artisan '.$command);
+	}
+
+	/**
+	 * Add a new command event to the schedule.
+	 *
+	 * @param  string  $command
+	 * @return \Illuminate\Console\Scheduling\Event
+	 */
+	public function exec($command)
+	{
+		$this->events[] = $event = new Event($command);
+
+		return $event;
+	}
+
+	/**
+	 * Get all of the events on the schedule.
+	 *
+	 * @return array
+	 */
+	public function events()
+	{
+		return $this->events;
+	}
+
+	/**
+	 * Get all of the events on the schedule that are due.
+	 *
+	 * @param  \Illuminate\Contracts\Foundation\Application  $app
+	 * @return array
+	 */
+	public function dueEvents(Application $app)
+	{
+		return array_filter($this->events, function($event) use ($app)
+		{
+			return $event->isDue($app);
+		});
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/Scheduling/ScheduleRunCommand.php

@@ -0,0 +1,63 @@
+<?php namespace Illuminate\Console\Scheduling;
+
+use Illuminate\Console\Command;
+
+class ScheduleRunCommand extends Command {
+
+	/**
+	 * The console command name.
+	 *
+	 * @var string
+	 */
+	protected $name = 'schedule:run';
+
+	/**
+	 * The console command description.
+	 *
+	 * @var string
+	 */
+	protected $description = 'Run the scheduled commands';
+
+	/**
+	 * The schedule instance.
+	 *
+	 * @var \Illuminate\Console\Scheduling\Schedule
+	 */
+	protected $schedule;
+
+	/**
+	 * Create a new command instance.
+	 *
+	 * @param  \Illuminate\Console\Scheduling\Schedule  $schedule
+	 * @return void
+	 */
+	public function __construct(Schedule $schedule)
+	{
+		$this->schedule = $schedule;
+
+		parent::__construct();
+	}
+
+	/**
+	 * Execute the console command.
+	 *
+	 * @return void
+	 */
+	public function fire()
+	{
+		$events = $this->schedule->dueEvents($this->laravel);
+
+		foreach ($events as $event)
+		{
+			$this->line('<info>Running scheduled command:</info> '.$event->getSummaryForDisplay());
+
+			$event->run($this->laravel);
+		}
+
+		if (count($events) === 0)
+		{
+			$this->info('No scheduled commands are ready to run.');
+		}
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Console/composer.json

@@ -0,0 +1,39 @@
+{
+    "name": "illuminate/console",
+    "description": "The Illuminate Console package.",
+    "license": "MIT",
+    "homepage": "http://laravel.com",
+    "support": {
+        "issues": "https://github.com/laravel/framework/issues",
+        "source": "https://github.com/laravel/framework"
+    },
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylorotwell@gmail.com"
+        }
+    ],
+    "require": {
+        "php": ">=5.4.0",
+        "illuminate/contracts": "5.0.*",
+        "symfony/console": "2.6.*",
+        "nesbot/carbon": "~1.0"
+    },
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Console\\": ""
+        }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "5.0-dev"
+        }
+    },
+    "suggest": {
+        "guzzlehttp/guzzle": "Required to use the thenPing method on schedules (~5.0).",
+        "mtdowling/cron-expression": "Required to use scheduling component (~1.0).",
+        "symfony/process": "Required to use scheduling component (2.6.*).",
+        "nesbot/carbon": "Required to use scheduling component (~1.0)."
+    },
+    "minimum-stability": "dev"
+}

vendor/laravel/framework/src/Illuminate/Container/BindingResolutionException.php

@@ -0,0 +1,5 @@
+<?php namespace Illuminate\Container;
+
+use Exception;
+
+class BindingResolutionException extends Exception {}

vendor/laravel/framework/src/Illuminate/Container/ContextualBindingBuilder.php

@@ -0,0 +1,58 @@
+<?php namespace Illuminate\Container;
+
+use Illuminate\Contracts\Container\ContextualBindingBuilder as ContextualBindingBuilderContract;
+
+class ContextualBindingBuilder implements ContextualBindingBuilderContract {
+
+	/**
+	 * The underlying container instance.
+	 *
+	 * @var \Illuminate\Container\Container
+	 */
+	protected $container;
+
+	/**
+	 * The concrete instance.
+	 *
+	 * @var string
+	 */
+	protected $concrete;
+
+	/**
+	 * Create a new contextual binding builder.
+	 *
+	 * @param  \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;
+
+		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);
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Container/composer.json

@@ -0,0 +1,31 @@
+{
+    "name": "illuminate/container",
+    "description": "The Illuminate Container package.",
+    "license": "MIT",
+    "homepage": "http://laravel.com",
+    "support": {
+        "issues": "https://github.com/laravel/framework/issues",
+        "source": "https://github.com/laravel/framework"
+    },
+    "authors": [
+        {
+            "name": "Taylor Otwell",
+            "email": "taylorotwell@gmail.com"
+        }
+    ],
+    "require": {
+        "php": ">=5.4.0",
+        "illuminate/contracts": "5.0.*"
+    },
+    "autoload": {
+        "psr-4": {
+            "Illuminate\\Container\\": ""
+        }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "5.0-dev"
+        }
+    },
+    "minimum-stability": "dev"
+}

vendor/laravel/framework/src/Illuminate/Contracts/Auth/Authenticatable.php

@@ -0,0 +1,41 @@
+<?php namespace Illuminate\Contracts\Auth;
+
+interface Authenticatable {
+
+	/**
+	 * Get the unique identifier for the user.
+	 *
+	 * @return mixed
+	 */
+	public function getAuthIdentifier();
+
+	/**
+	 * Get the password for the user.
+	 *
+	 * @return string
+	 */
+	public function getAuthPassword();
+
+	/**
+	 * Get the token value for the "remember me" session.
+	 *
+	 * @return string
+	 */
+	public function getRememberToken();
+
+	/**
+	 * Set the token value for the "remember me" session.
+	 *
+	 * @param  string  $value
+	 * @return void
+	 */
+	public function setRememberToken($value);
+
+	/**
+	 * Get the column name for the "remember me" token.
+	 *
+	 * @return string
+	 */
+	public function getRememberTokenName();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Auth/CanResetPassword.php

@@ -0,0 +1,12 @@
+<?php namespace Illuminate\Contracts\Auth;
+
+interface CanResetPassword {
+
+	/**
+	 * Get the e-mail address where password reset links are sent.
+	 *
+	 * @return string
+	 */
+	public function getEmailForPasswordReset();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Auth/Guard.php

@@ -0,0 +1,100 @@
+<?php namespace Illuminate\Contracts\Auth;
+
+interface Guard {
+
+	/**
+	 * Determine if the current user is authenticated.
+	 *
+	 * @return bool
+	 */
+	public function check();
+
+	/**
+	 * Determine if the current user is a guest.
+	 *
+	 * @return bool
+	 */
+	public function guest();
+
+	/**
+	 * Get the currently authenticated user.
+	 *
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function user();
+
+	/**
+	 * Log a user into the application without sessions or cookies.
+	 *
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	public function once(array $credentials = array());
+
+	/**
+	 * Attempt to authenticate a user using the given credentials.
+	 *
+	 * @param  array  $credentials
+	 * @param  bool   $remember
+	 * @param  bool   $login
+	 * @return bool
+	 */
+	public function attempt(array $credentials = array(), $remember = false, $login = true);
+
+	/**
+	 * Attempt to authenticate using HTTP Basic Auth.
+	 *
+	 * @param  string  $field
+	 * @return \Symfony\Component\HttpFoundation\Response|null
+	 */
+	public function basic($field = 'email');
+
+	/**
+	 * Perform a stateless HTTP Basic login attempt.
+	 *
+	 * @param  string  $field
+	 * @return \Symfony\Component\HttpFoundation\Response|null
+	 */
+	public function onceBasic($field = 'email');
+
+	/**
+	 * Validate a user's credentials.
+	 *
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	public function validate(array $credentials = array());
+
+	/**
+	 * Log a user into the application.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @param  bool  $remember
+	 * @return void
+	 */
+	public function login(Authenticatable $user, $remember = false);
+
+	/**
+	 * Log the given user ID into the application.
+	 *
+	 * @param  mixed  $id
+	 * @param  bool   $remember
+	 * @return \Illuminate\Contracts\Auth\Authenticatable
+	 */
+	public function loginUsingId($id, $remember = false);
+
+	/**
+	 * Determine if the user was authenticated via "remember me" cookie.
+	 *
+	 * @return bool
+	 */
+	public function viaRemember();
+
+	/**
+	 * Log the user out of the application.
+	 *
+	 * @return void
+	 */
+	public function logout();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Auth/PasswordBroker.php

@@ -0,0 +1,76 @@
+<?php namespace Illuminate\Contracts\Auth;
+
+use Closure;
+
+interface PasswordBroker {
+
+	/**
+	 * Constant representing a successfully sent reminder.
+	 *
+	 * @var string
+	 */
+	const RESET_LINK_SENT = 'passwords.sent';
+
+	/**
+	 * Constant representing a successfully reset password.
+	 *
+	 * @var string
+	 */
+	const PASSWORD_RESET = 'passwords.reset';
+
+	/**
+	 * Constant representing the user not found response.
+	 *
+	 * @var string
+	 */
+	const INVALID_USER = 'passwords.user';
+
+	/**
+	 * Constant representing an invalid password.
+	 *
+	 * @var string
+	 */
+	const INVALID_PASSWORD = 'passwords.password';
+
+	/**
+	 * Constant representing an invalid token.
+	 *
+	 * @var string
+	 */
+	const INVALID_TOKEN = 'passwords.token';
+
+	/**
+	 * Send a password reset link to a user.
+	 *
+	 * @param  array  $credentials
+	 * @param  \Closure|null  $callback
+	 * @return string
+	 */
+	public function sendResetLink(array $credentials, Closure $callback = null);
+
+	/**
+	 * Reset the password for the given token.
+	 *
+	 * @param  array     $credentials
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function reset(array $credentials, Closure $callback);
+
+	/**
+	 * Set a custom password validator.
+	 *
+	 * @param  \Closure  $callback
+	 * @return void
+	 */
+	public function validator(Closure $callback);
+
+	/**
+	 * Determine if the passwords match for the request.
+	 *
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	public function validateNewPassword(array $credentials);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Auth/Registrar.php

@@ -0,0 +1,21 @@
+<?php namespace Illuminate\Contracts\Auth;
+
+interface Registrar {
+
+	/**
+	 * Get a validator for an incoming registration request.
+	 *
+	 * @param  array  $data
+	 * @return \Illuminate\Contracts\Validation\Validator
+	 */
+	public function validator(array $data);
+
+	/**
+	 * Create a new user instance after a valid registration.
+	 *
+	 * @param  array  $data
+	 * @return \Illuminate\Contracts\Auth\Authenticatable
+	 */
+	public function create(array $data);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Auth/UserProvider.php

@@ -0,0 +1,48 @@
+<?php namespace Illuminate\Contracts\Auth;
+
+interface UserProvider {
+
+	/**
+	 * Retrieve a user by their unique identifier.
+	 *
+	 * @param  mixed  $identifier
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function retrieveById($identifier);
+
+	/**
+	 * Retrieve a user by by their unique identifier and "remember me" token.
+	 *
+	 * @param  mixed   $identifier
+	 * @param  string  $token
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function retrieveByToken($identifier, $token);
+
+	/**
+	 * Update the "remember me" token for the given user in storage.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @param  string  $token
+	 * @return void
+	 */
+	public function updateRememberToken(Authenticatable $user, $token);
+
+	/**
+	 * Retrieve a user by the given credentials.
+	 *
+	 * @param  array  $credentials
+	 * @return \Illuminate\Contracts\Auth\Authenticatable|null
+	 */
+	public function retrieveByCredentials(array $credentials);
+
+	/**
+	 * Validate a user against the given credentials.
+	 *
+	 * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
+	 * @param  array  $credentials
+	 * @return bool
+	 */
+	public function validateCredentials(Authenticatable $user, array $credentials);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Bus/Dispatcher.php

@@ -0,0 +1,53 @@
+<?php namespace Illuminate\Contracts\Bus;
+
+use Closure;
+use ArrayAccess;
+
+interface Dispatcher {
+
+	/**
+	 * Marshal a command and dispatch it to its appropriate handler.
+	 *
+	 * @param  mixed  $command
+	 * @param  array  $array
+	 * @return mixed
+	 */
+	public function dispatchFromArray($command, array $array);
+
+	/**
+	 * Marshal a command and dispatch it to its appropriate handler.
+	 *
+	 * @param  mixed  $command
+	 * @param  \ArrayAccess  $source
+	 * @param  array  $extras
+	 * @return mixed
+	 */
+	public function dispatchFrom($command, ArrayAccess $source, array $extras = []);
+
+	/**
+	 * Dispatch a command to its appropriate handler.
+	 *
+	 * @param  mixed  $command
+	 * @param  \Closure|null  $afterResolving
+	 * @return mixed
+	 */
+	public function dispatch($command, Closure $afterResolving = null);
+
+	/**
+	 * Dispatch a command to its appropriate handler in the current process.
+	 *
+	 * @param  mixed  $command
+	 * @param  \Closure|null  $afterResolving
+	 * @return mixed
+	 */
+	public function dispatchNow($command, Closure $afterResolving = null);
+
+	/**
+	 * Set the pipes commands should be piped through before dispatching.
+	 *
+	 * @param  array  $pipes
+	 * @return $this
+	 */
+	public function pipeThrough(array $pipes);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Bus/HandlerResolver.php

@@ -0,0 +1,47 @@
+<?php namespace Illuminate\Contracts\Bus;
+
+use Closure;
+
+interface HandlerResolver {
+
+	/**
+	 * Get the handler instance for the given command.
+	 *
+	 * @param  mixed  $command
+	 * @return mixed
+	 */
+	public function resolveHandler($command);
+
+	/**
+	 * Get the handler class for the given command.
+	 *
+	 * @param  mixed  $command
+	 * @return string
+	 */
+	public function getHandlerClass($command);
+
+	/**
+	 * Get the handler method for the given command.
+	 *
+	 * @param  mixed  $command
+	 * @return string
+	 */
+	public function getHandlerMethod($command);
+
+	/**
+	 * Register command to handler mappings.
+	 *
+	 * @param  array  $commands
+	 * @return void
+	 */
+	public function maps(array $commands);
+
+	/**
+	 * Register a fallback mapper callback.
+	 *
+	 * @param  \Closure  $mapper
+	 * @return void
+	 */
+	public function mapUsing(Closure $mapper);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Bus/QueueingDispatcher.php

@@ -0,0 +1,13 @@
+<?php namespace Illuminate\Contracts\Bus;
+
+interface QueueingDispatcher extends Dispatcher {
+
+	/**
+	 * Dispatch a command to its appropriate handler behind a queue.
+	 *
+	 * @param  mixed  $command
+	 * @return mixed
+	 */
+	public function dispatchToQueue($command);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Bus/SelfHandling.php

@@ -0,0 +1,3 @@
+<?php namespace Illuminate\Contracts\Bus;
+
+interface SelfHandling {}

vendor/laravel/framework/src/Illuminate/Contracts/Cache/Factory.php

@@ -0,0 +1,13 @@
+<?php namespace Illuminate\Contracts\Cache;
+
+interface Factory {
+
+	/**
+	 * Get a cache store instance by name.
+	 *
+	 * @param  string|null  $name
+	 * @return mixed
+	 */
+	public function store($name = null);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Cache/Repository.php

@@ -0,0 +1,98 @@
+<?php namespace Illuminate\Contracts\Cache;
+
+use Closure;
+
+interface Repository {
+
+	/**
+	 * Determine if an item exists in the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function has($key);
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public function get($key, $default = null);
+
+	/**
+	 * Retrieve an item from the cache and delete it.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public function pull($key, $default = null);
+
+	/**
+	 * Store an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  \DateTime|int  $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes);
+
+	/**
+	 * Store an item in the cache if the key does not exist.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  \DateTime|int  $minutes
+	 * @return bool
+	 */
+	public function add($key, $value, $minutes);
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value);
+
+	/**
+	 * Get an item from the cache, or store the default value.
+	 *
+	 * @param  string  $key
+	 * @param  \DateTime|int  $minutes
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function remember($key, $minutes, Closure $callback);
+
+	/**
+	 * Get an item from the cache, or store the default value forever.
+	 *
+	 * @param  string   $key
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function sear($key, Closure $callback);
+
+	/**
+	 * Get an item from the cache, or store the default value forever.
+	 *
+	 * @param  string   $key
+	 * @param  \Closure  $callback
+	 * @return mixed
+	 */
+	public function rememberForever($key, Closure $callback);
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string $key
+	 * @return bool
+	 */
+	public function forget($key);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Cache/Store.php

@@ -0,0 +1,72 @@
+<?php namespace Illuminate\Contracts\Cache;
+
+interface Store {
+
+	/**
+	 * Retrieve an item from the cache by key.
+	 *
+	 * @param  string  $key
+	 * @return mixed
+	 */
+	public function get($key);
+
+	/**
+	 * Store an item in the cache for a given number of minutes.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @param  int     $minutes
+	 * @return void
+	 */
+	public function put($key, $value, $minutes);
+
+	/**
+	 * Increment the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function increment($key, $value = 1);
+
+	/**
+	 * Decrement the value of an item in the cache.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return int|bool
+	 */
+	public function decrement($key, $value = 1);
+
+	/**
+	 * Store an item in the cache indefinitely.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function forever($key, $value);
+
+	/**
+	 * Remove an item from the cache.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function forget($key);
+
+	/**
+	 * Remove all items from the cache.
+	 *
+	 * @return void
+	 */
+	public function flush();
+
+	/**
+	 * Get the cache key prefix.
+	 *
+	 * @return string
+	 */
+	public function getPrefix();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Config/Repository.php

@@ -0,0 +1,49 @@
+<?php namespace Illuminate\Contracts\Config;
+
+interface Repository {
+
+	/**
+	 * Determine if the given configuration value exists.
+	 *
+	 * @param  string  $key
+	 * @return bool
+	 */
+	public function has($key);
+
+	/**
+	 * Get the specified configuration value.
+	 *
+	 * @param  string  $key
+	 * @param  mixed   $default
+	 * @return mixed
+	 */
+	public function get($key, $default = null);
+
+	/**
+	 * Set a given configuration value.
+	 *
+	 * @param  array|string  $key
+	 * @param  mixed   $value
+	 * @return void
+	 */
+	public function set($key, $value = null);
+
+	/**
+	 * Prepend a value onto an array configuration value.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function prepend($key, $value);
+
+	/**
+	 * Push a value onto an array configuration value.
+	 *
+	 * @param  string  $key
+	 * @param  mixed  $value
+	 * @return void
+	 */
+	public function push($key, $value);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Console/Application.php

@@ -0,0 +1,21 @@
+<?php namespace Illuminate\Contracts\Console;
+
+interface Application {
+
+	/**
+	 * Call a console application command.
+	 *
+	 * @param  string  $command
+	 * @param  array  $parameters
+	 * @return int
+	 */
+	public function call($command, array $parameters = array());
+
+	/**
+	 * Get the output from the last command.
+	 *
+	 * @return string
+	 */
+	public function output();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Console/Kernel.php

@@ -0,0 +1,46 @@
+<?php namespace Illuminate\Contracts\Console;
+
+interface Kernel {
+
+	/**
+	 * Handle an incoming console command.
+	 *
+	 * @param  \Symfony\Component\Console\Input\InputInterface  $input
+	 * @param  \Symfony\Component\Console\Output\OutputInterface  $output
+	 * @return int
+	 */
+	public function handle($input, $output = null);
+
+	/**
+	 * Run an Artisan console command by name.
+	 *
+	 * @param  string  $command
+	 * @param  array  $parameters
+	 * @return int
+	 */
+	public function call($command, array $parameters = array());
+
+	/**
+	 * Queue an Artisan console command by name.
+	 *
+	 * @param  string  $command
+	 * @param  array  $parameters
+	 * @return int
+	 */
+	public function queue($command, array $parameters = array());
+
+	/**
+	 * Get all of the commands registered with the console.
+	 *
+	 * @return array
+	 */
+	public function all();
+
+	/**
+	 * Get the output for the last run command.
+	 *
+	 * @return string
+	 */
+	public function output();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Container/Container.php

@@ -0,0 +1,143 @@
+<?php namespace Illuminate\Contracts\Container;
+
+use Closure;
+
+interface Container {
+
+	/**
+	 * Determine if the given abstract type has been bound.
+	 *
+	 * @param  string  $abstract
+	 * @return bool
+	 */
+	public function bound($abstract);
+
+	/**
+	 * Alias a type to a different name.
+	 *
+	 * @param  string  $abstract
+	 * @param  string  $alias
+	 * @return void
+	 */
+	public function alias($abstract, $alias);
+
+	/**
+	 * Assign a set of tags to a given binding.
+	 *
+	 * @param  array|string  $abstracts
+	 * @param  array|mixed   ...$tags
+	 * @return void
+	 */
+	public function tag($abstracts, $tags);
+
+	/**
+	 * Resolve all of the bindings for a given tag.
+	 *
+	 * @param  array  $tag
+	 * @return array
+	 */
+	public function tagged($tag);
+
+	/**
+	 * 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);
+
+	/**
+	 * 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);
+
+	/**
+	 * Register a shared binding in the container.
+	 *
+	 * @param  string  $abstract
+	 * @param  \Closure|string|null  $concrete
+	 * @return void
+	 */
+	public function singleton($abstract, $concrete = null);
+
+	/**
+	 * "Extend" an abstract type in the container.
+	 *
+	 * @param  string    $abstract
+	 * @param  \Closure  $closure
+	 * @return void
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function extend($abstract, Closure $closure);
+
+	/**
+	 * Register an existing instance as shared in the container.
+	 *
+	 * @param  string  $abstract
+	 * @param  mixed   $instance
+	 * @return void
+	 */
+	public function instance($abstract, $instance);
+
+	/**
+	 * Define a contextual binding.
+	 *
+	 * @param  string  $concrete
+	 * @return \Illuminate\Contracts\Container\ContextualBindingBuilder
+	 */
+	public function when($concrete);
+
+	/**
+	 * Resolve the given type from the container.
+	 *
+	 * @param  string  $abstract
+	 * @param  array   $parameters
+	 * @return mixed
+	 */
+	public function make($abstract, $parameters = array());
+
+	/**
+	 * 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 = array(), $defaultMethod = null);
+
+	/**
+	 * Determine if the given abstract type has been resolved.
+	 *
+	 * @param  string $abstract
+	 * @return bool
+	 */
+	public function resolved($abstract);
+
+	/**
+	 * Register a new resolving callback.
+	 *
+	 * @param  string    $abstract
+	 * @param  \Closure  $callback
+	 * @return void
+	 */
+	public function resolving($abstract, Closure $callback = null);
+
+	/**
+	 * Register a new after resolving callback.
+	 *
+	 * @param  string    $abstract
+	 * @param  \Closure  $callback
+	 * @return void
+	 */
+	public function afterResolving($abstract, Closure $callback = null);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Container/ContextualBindingBuilder.php

@@ -0,0 +1,21 @@
+<?php namespace Illuminate\Contracts\Container;
+
+interface ContextualBindingBuilder {
+
+	/**
+	 * Define the abstract target that depends on the context.
+	 *
+	 * @param  string  $abstract
+	 * @return $this
+	 */
+	public function needs($abstract);
+
+	/**
+	 * Define the implementation for the contextual binding.
+	 *
+	 * @param  \Closure|string  $implementation
+	 * @return void
+	 */
+	public function give($implementation);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Cookie/Factory.php

@@ -0,0 +1,42 @@
+<?php namespace Illuminate\Contracts\Cookie;
+
+interface Factory {
+
+	/**
+	 * Create a new cookie instance.
+	 *
+	 * @param  string  $name
+	 * @param  string  $value
+	 * @param  int     $minutes
+	 * @param  string  $path
+	 * @param  string  $domain
+	 * @param  bool    $secure
+	 * @param  bool    $httpOnly
+	 * @return \Symfony\Component\HttpFoundation\Cookie
+	 */
+	public function make($name, $value, $minutes = 0, $path = null, $domain = null, $secure = false, $httpOnly = true);
+
+	/**
+	 * Create a cookie that lasts "forever" (five years).
+	 *
+	 * @param  string  $name
+	 * @param  string  $value
+	 * @param  string  $path
+	 * @param  string  $domain
+	 * @param  bool    $secure
+	 * @param  bool    $httpOnly
+	 * @return \Symfony\Component\HttpFoundation\Cookie
+	 */
+	public function forever($name, $value, $path = null, $domain = null, $secure = false, $httpOnly = true);
+
+	/**
+	 * Expire the given cookie.
+	 *
+	 * @param  string  $name
+	 * @param  string  $path
+	 * @param  string  $domain
+	 * @return \Symfony\Component\HttpFoundation\Cookie
+	 */
+	public function forget($name, $path = null, $domain = null);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Cookie/QueueingFactory.php

@@ -0,0 +1,27 @@
+<?php namespace Illuminate\Contracts\Cookie;
+
+interface QueueingFactory extends Factory {
+
+	/**
+	 * Queue a cookie to send with the next response.
+	 *
+	 * @param  mixed
+	 * @return void
+	 */
+	public function queue();
+
+	/**
+	 * Remove a cookie from the queue.
+	 *
+	 * @param  string  $name
+	 */
+	public function unqueue($name);
+
+	/**
+	 * Get the cookies which have been queued for the next request.
+	 *
+	 * @return array
+	 */
+	public function getQueuedCookies();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Database/ModelIdentifier.php

@@ -0,0 +1,32 @@
+<?php namespace Illuminate\Contracts\Database;
+
+class ModelIdentifier {
+
+	/**
+	 * The class name of the model.
+	 *
+	 * @var string
+	 */
+	public $class;
+
+	/**
+	 * The unique identifier of the model.
+	 *
+	 * @var mixed
+	 */
+	public $id;
+
+	/**
+	 * Create a new model identifier.
+	 *
+	 * @param  string  $class
+	 * @param  mixed  $id
+	 * @return void
+	 */
+	public function __construct($class, $id)
+	{
+		$this->id = $id;
+		$this->class = $class;
+	}
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Debug/ExceptionHandler.php

@@ -0,0 +1,33 @@
+<?php namespace Illuminate\Contracts\Debug;
+
+use Exception;
+
+interface ExceptionHandler {
+
+	/**
+	 * Report or log an exception.
+	 *
+	 * @param  \Exception  $e
+	 * @return void
+	 */
+	public function report(Exception $e);
+
+	/**
+	 * Render an exception into an HTTP response.
+	 *
+	 * @param  \Illuminate\Http\Request  $request
+	 * @param  \Exception  $e
+	 * @return \Symfony\Component\HttpFoundation\Response
+	 */
+	public function render($request, Exception $e);
+
+	/**
+	 * Render an exception to the console.
+	 *
+	 * @param  \Symfony\Component\Console\Output\OutputInterface  $output
+	 * @param  \Exception  $e
+	 * @return void
+	 */
+	public function renderForConsole($output, Exception $e);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Encryption/DecryptException.php

@@ -0,0 +1,5 @@
+<?php namespace Illuminate\Contracts\Encryption;
+
+use RuntimeException;
+
+class DecryptException extends RuntimeException {}

vendor/laravel/framework/src/Illuminate/Contracts/Encryption/Encrypter.php

@@ -0,0 +1,37 @@
+<?php namespace Illuminate\Contracts\Encryption;
+
+interface Encrypter {
+
+	/**
+	 * Encrypt the given value.
+	 *
+	 * @param  string  $value
+	 * @return string
+	 */
+	public function encrypt($value);
+
+	/**
+	 * Decrypt the given value.
+	 *
+	 * @param  string  $payload
+	 * @return string
+	 */
+	public function decrypt($payload);
+
+	/**
+	 * Set the encryption mode.
+	 *
+	 * @param  string  $mode
+	 * @return void
+	 */
+	public function setMode($mode);
+
+	/**
+	 * Set the encryption cipher.
+	 *
+	 * @param  string  $cipher
+	 * @return void
+	 */
+	public function setCipher($cipher);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Events/Dispatcher.php

@@ -0,0 +1,64 @@
+<?php namespace Illuminate\Contracts\Events;
+
+interface Dispatcher {
+
+	/**
+	 * Register an event listener with the dispatcher.
+	 *
+	 * @param  string|array  $events
+	 * @param  mixed   $listener
+	 * @param  int     $priority
+	 * @return void
+	 */
+	public function listen($events, $listener, $priority = 0);
+
+	/**
+	 * Determine if a given event has listeners.
+	 *
+	 * @param  string  $eventName
+	 * @return bool
+	 */
+	public function hasListeners($eventName);
+
+	/**
+	 * Fire an event until the first non-null response is returned.
+	 *
+	 * @param  string  $event
+	 * @param  array   $payload
+	 * @return mixed
+	 */
+	public function until($event, $payload = array());
+
+	/**
+	 * Fire an event and call the listeners.
+	 *
+	 * @param  string|object  $event
+	 * @param  mixed   $payload
+	 * @param  bool    $halt
+	 * @return array|null
+	 */
+	public function fire($event, $payload = array(), $halt = false);
+
+	/**
+	 * Get the event that is currently firing.
+	 *
+	 * @return string
+	 */
+	public function firing();
+
+	/**
+	 * Remove a set of listeners from the dispatcher.
+	 *
+	 * @param  string  $event
+	 * @return void
+	 */
+	public function forget($event);
+
+	/**
+	 * Forget all of the queued listeners.
+	 *
+	 * @return void
+	 */
+	public function forgetPushed();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Filesystem/Cloud.php

@@ -0,0 +1,3 @@
+<?php namespace Illuminate\Contracts\Filesystem;
+
+interface Cloud extends Filesystem {}

vendor/laravel/framework/src/Illuminate/Contracts/Filesystem/Factory.php

@@ -0,0 +1,13 @@
+<?php namespace Illuminate\Contracts\Filesystem;
+
+interface Factory {
+
+	/**
+	 * Get a filesystem implementation.
+	 *
+	 * @param  string  $name
+	 * @return \Illuminate\Contracts\Filesystem\Filesystem
+	 */
+	public function disk($name = null);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Filesystem/FileNotFoundException.php

@@ -0,0 +1,5 @@
+<?php namespace Illuminate\Contracts\Filesystem;
+
+use Exception;
+
+class FileNotFoundException extends Exception {}

vendor/laravel/framework/src/Illuminate/Contracts/Filesystem/Filesystem.php

@@ -0,0 +1,174 @@
+<?php namespace Illuminate\Contracts\Filesystem;
+
+interface Filesystem {
+
+	/**
+	 * The public visibility setting.
+	 *
+	 * @var string
+	 */
+	const VISIBILITY_PUBLIC = 'public';
+
+	/**
+	 * The private visibility setting.
+	 *
+	 * @var string
+	 */
+	const VISIBILITY_PRIVATE = 'private';
+
+	/**
+	 * Determine if a file exists.
+	 *
+	 * @param  string  $path
+	 * @return bool
+	 */
+	public function exists($path);
+
+	/**
+	 * Get the contents of a file.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 *
+	 * @throws \Illuminate\Contracts\Filesystem\FileNotFoundException
+	 */
+	public function get($path);
+
+	/**
+	 * Write the contents of a file.
+	 *
+	 * @param  string  $path
+	 * @param  string|resource  $contents
+	 * @param  string  $visibility
+	 * @return bool
+	 */
+	public function put($path, $contents, $visibility = null);
+
+	/**
+	 * Get the visibility for the given path.
+	 *
+	 * @param  string  $path
+	 * @return string
+	 */
+	public function getVisibility($path);
+
+	/**
+	 * Set the visibility for the given path.
+	 *
+	 * @param  string  $path
+	 * @param  string  $visibility
+	 * @return void
+	 */
+	public function setVisibility($path, $visibility);
+
+	/**
+	 * Prepend to a file.
+	 *
+	 * @param  string  $path
+	 * @param  string  $data
+	 * @return int
+	 */
+	public function prepend($path, $data);
+
+	/**
+	 * Append to a file.
+	 *
+	 * @param  string  $path
+	 * @param  string  $data
+	 * @return int
+	 */
+	public function append($path, $data);
+
+	/**
+	 * Delete the file at a given path.
+	 *
+	 * @param  string|array  $paths
+	 * @return bool
+	 */
+	public function delete($paths);
+
+	/**
+	 * Copy a file to a new location.
+	 *
+	 * @param  string  $from
+	 * @param  string  $to
+	 * @return bool
+	 */
+	public function copy($from, $to);
+
+	/**
+	 * Move a file to a new location.
+	 *
+	 * @param  string  $from
+	 * @param  string  $to
+	 * @return bool
+	 */
+	public function move($from, $to);
+
+	/**
+	 * Get the file size of a given file.
+	 *
+	 * @param  string  $path
+	 * @return int
+	 */
+	public function size($path);
+
+	/**
+	 * Get the file's last modification time.
+	 *
+	 * @param  string  $path
+	 * @return int
+	 */
+	public function lastModified($path);
+
+	/**
+	 * 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);
+
+	/**
+	 * Get all of the files from the given directory (recursive).
+	 *
+	 * @param  string|null  $directory
+	 * @return array
+	 */
+	public function allFiles($directory = null);
+
+	/**
+	 * 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);
+
+	/**
+	 * Get all (recursive) of the directories within a given directory.
+	 *
+	 * @param  string|null  $directory
+	 * @return array
+	 */
+	public function allDirectories($directory = null);
+
+	/**
+	 * Create a directory.
+	 *
+	 * @param  string  $path
+	 * @return bool
+	 */
+	public function makeDirectory($path);
+
+	/**
+	 * Recursively delete a directory.
+	 *
+	 * @param  string  $directory
+	 * @return bool
+	 */
+	public function deleteDirectory($directory);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Foundation/Application.php

@@ -0,0 +1,85 @@
+<?php namespace Illuminate\Contracts\Foundation;
+
+use Illuminate\Contracts\Container\Container;
+
+interface Application extends Container {
+
+	/**
+	 * Get the version number of the application.
+	 *
+	 * @return string
+	 */
+	public function version();
+
+	/**
+	 * Get the base path of the Laravel installation.
+	 *
+	 * @return string
+	 */
+	public function basePath();
+
+	/**
+	 * Get or check the current application environment.
+	 *
+	 * @param  mixed
+	 * @return string
+	 */
+	public function environment();
+
+	/**
+	 * Determine if the application is currently down for maintenance.
+	 *
+	 * @return bool
+	 */
+	public function isDownForMaintenance();
+
+	/**
+	 * Register all of the configured providers.
+	 *
+	 * @return void
+	 */
+	public function registerConfiguredProviders();
+
+	/**
+	 * Register a service provider with the application.
+	 *
+	 * @param  \Illuminate\Support\ServiceProvider|string  $provider
+	 * @param  array  $options
+	 * @param  bool   $force
+	 * @return \Illuminate\Support\ServiceProvider
+	 */
+	public function register($provider, $options = array(), $force = false);
+
+	/**
+	 * Register a deferred provider and service.
+	 *
+	 * @param  string  $provider
+	 * @param  string  $service
+	 * @return void
+	 */
+	public function registerDeferredProvider($provider, $service = null);
+
+	/**
+	 * Boot the application's service providers.
+	 *
+	 * @return void
+	 */
+	public function boot();
+
+	/**
+	 * Register a new boot listener.
+	 *
+	 * @param  mixed  $callback
+	 * @return void
+	 */
+	public function booting($callback);
+
+	/**
+	 * Register a new "booted" listener.
+	 *
+	 * @param  mixed  $callback
+	 * @return void
+	 */
+	public function booted($callback);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Hashing/Hasher.php

@@ -0,0 +1,33 @@
+<?php namespace Illuminate\Contracts\Hashing;
+
+interface Hasher {
+
+	/**
+	 * Hash the given value.
+	 *
+	 * @param  string  $value
+	 * @param  array   $options
+	 * @return string
+	 */
+	public function make($value, array $options = array());
+
+	/**
+	 * Check the given plain value against a hash.
+	 *
+	 * @param  string  $value
+	 * @param  string  $hashedValue
+	 * @param  array   $options
+	 * @return bool
+	 */
+	public function check($value, $hashedValue, array $options = array());
+
+	/**
+	 * Check if the given hash has been hashed using the given options.
+	 *
+	 * @param  string  $hashedValue
+	 * @param  array   $options
+	 * @return bool
+	 */
+	public function needsRehash($hashedValue, array $options = array());
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Http/Kernel.php

@@ -0,0 +1,36 @@
+<?php namespace Illuminate\Contracts\Http;
+
+interface Kernel {
+
+	/**
+	 * Bootstrap the application for HTTP requests.
+	 *
+	 * @return void
+	 */
+	public function bootstrap();
+
+	/**
+	 * Handle an incoming HTTP request.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @return \Symfony\Component\HttpFoundation\Response
+	 */
+	public function handle($request);
+
+	/**
+	 * Perform any final actions for the request lifecycle.
+	 *
+	 * @param  \Symfony\Component\HttpFoundation\Request  $request
+	 * @param  \Symfony\Component\HttpFoundation\Response  $response
+	 * @return void
+	 */
+	public function terminate($request, $response);
+
+	/**
+	 * Get the Laravel application instance.
+	 *
+	 * @return \Illuminate\Contracts\Foundation\Application
+	 */
+	public function getApplication();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Logging/Log.php

@@ -0,0 +1,97 @@
+<?php namespace Illuminate\Contracts\Logging;
+
+interface Log {
+
+	/**
+	 * Log an alert message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function alert($message, array $context = array());
+
+	/**
+	 * Log a critical message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function critical($message, array $context = array());
+
+	/**
+	 * Log an error message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function error($message, array $context = array());
+
+	/**
+	 * Log a warning message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function warning($message, array $context = array());
+
+	/**
+	 * Log a notice to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function notice($message, array $context = array());
+
+	/**
+	 * Log an informational message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function info($message, array $context = array());
+
+	/**
+	 * Log a debug message to the logs.
+	 *
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function debug($message, array $context = array());
+
+	/**
+	 * Log a message to the logs.
+	 *
+	 * @param  string  $level
+	 * @param  string  $message
+	 * @param  array  $context
+	 * @return void
+	 */
+	public function log($level, $message, array $context = array());
+
+	/**
+	 * 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');
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Mail/MailQueue.php

@@ -0,0 +1,28 @@
+<?php namespace Illuminate\Contracts\Mail;
+
+interface MailQueue {
+
+	/**
+	 * Queue a new e-mail message for sending.
+	 *
+	 * @param  string|array  $view
+	 * @param  array   $data
+	 * @param  \Closure|string  $callback
+	 * @param  string  $queue
+	 * @return mixed
+	 */
+	public function queue($view, array $data, $callback, $queue = null);
+
+	/**
+	 * Queue a new e-mail message for sending after (n) seconds.
+	 *
+	 * @param  int  $delay
+	 * @param  string|array  $view
+	 * @param  array  $data
+	 * @param  \Closure|string  $callback
+	 * @param  string  $queue
+	 * @return mixed
+	 */
+	public function later($delay, $view, array $data, $callback, $queue = null);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Mail/Mailer.php

@@ -0,0 +1,31 @@
+<?php namespace Illuminate\Contracts\Mail;
+
+interface Mailer {
+
+	/**
+	 * Send a new message when only a raw text part.
+	 *
+	 * @param  string  $text
+	 * @param  \Closure|string  $callback
+	 * @return int
+	 */
+	public function raw($text, $callback);
+
+	/**
+	 * Send a new message using a view.
+	 *
+	 * @param  string|array  $view
+	 * @param  array  $data
+	 * @param  \Closure|string  $callback
+	 * @return void
+	 */
+	public function send($view, array $data, $callback);
+
+	/**
+	 * Get the array of failed recipients.
+	 *
+	 * @return array
+	 */
+	public function failures();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Pagination/LengthAwarePaginator.php

@@ -0,0 +1,19 @@
+<?php namespace Illuminate\Contracts\Pagination;
+
+interface LengthAwarePaginator extends Paginator {
+
+	/**
+	 * Determine the total number of items in the data store.
+	 *
+	 * @return int
+	 */
+	public function total();
+
+	/**
+	 * Get the page number of the last available page.
+	 *
+	 * @return int
+	 */
+	public function lastPage();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Pagination/Paginator.php

@@ -0,0 +1,108 @@
+<?php namespace Illuminate\Contracts\Pagination;
+
+interface Paginator {
+
+	/**
+	 * Get the URL for a given page.
+	 *
+	 * @param  int  $page
+	 * @return string
+	 */
+	public function url($page);
+
+	/**
+	 * Add a set of query string values to the paginator.
+	 *
+	 * @param  array|string  $key
+	 * @param  string|null  $value
+	 * @return $this
+	 */
+	public function appends($key, $value = null);
+
+	/**
+	 * Get / set the URL fragment to be appended to URLs.
+	 *
+	 * @param  string|null  $fragment
+	 * @return $this|string
+	 */
+	public function fragment($fragment = null);
+
+	/**
+	 * The the URL for the next page, or null.
+	 *
+	 * @return string|null
+	 */
+	public function nextPageUrl();
+
+	/**
+	 * Get the URL for the previous page, or null.
+	 *
+	 * @return string|null
+	 */
+	public function previousPageUrl();
+
+	/**
+	 * Get all of the items being paginated.
+	 *
+	 * @return array
+	 */
+	public function items();
+
+	/**
+	 * Get the "index" of the first item being paginated.
+	 *
+	 * @return int
+	 */
+	public function firstItem();
+
+	/**
+	 * Get the "index" of the last item being paginated.
+	 *
+	 * @return int
+	 */
+	public function lastItem();
+
+	/**
+	 * Determine how many items are being shown per page.
+	 *
+	 * @return int
+	 */
+	public function perPage();
+
+	/**
+	 * Determine the current page being paginated.
+	 *
+	 * @return int
+	 */
+	public function currentPage();
+
+	/**
+	 * Determine if there are enough items to split into multiple pages.
+	 *
+	 * @return bool
+	 */
+	public function hasPages();
+
+	/**
+	 * Determine if there is more items in the data store.
+	 *
+	 * @return bool
+	 */
+	public function hasMorePages();
+
+	/**
+	 * Determine if the list of items is empty or not.
+	 *
+	 * @return bool
+	 */
+	public function isEmpty();
+
+	/**
+	 * Render the paginator using a given Presenter.
+	 *
+	 * @param  \Illuminate\Contracts\Pagination\Presenter|null  $presenter
+	 * @return string
+	 */
+	public function render(Presenter $presenter = null);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Pagination/Presenter.php

@@ -0,0 +1,19 @@
+<?php namespace Illuminate\Contracts\Pagination;
+
+interface Presenter {
+
+	/**
+	 * Render the given paginator.
+	 *
+	 * @return string
+	 */
+	public function render();
+
+	/**
+	 * Determine if the underlying paginator being presented has pages to show.
+	 *
+	 * @return bool
+	 */
+	public function hasPages();
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Pipeline/Hub.php

@@ -0,0 +1,14 @@
+<?php namespace Illuminate\Contracts\Pipeline;
+
+interface Hub {
+
+	/**
+	 * Send an object through one of the available pipelines.
+	 *
+	 * @param  mixed  $object
+	 * @param  string|null  $pipeline
+	 * @return mixed
+	 */
+	public function pipe($object, $pipeline = null);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Pipeline/Pipeline.php

@@ -0,0 +1,39 @@
+<?php namespace Illuminate\Contracts\Pipeline;
+
+use Closure;
+
+interface Pipeline {
+
+	/**
+	 * Set the traveler object being sent on the pipeline.
+	 *
+	 * @param  mixed  $traveler
+	 * @return $this
+	 */
+	public function send($traveler);
+
+	/**
+	 * Set the stops of the pipeline.
+	 *
+	 * @param  dynamic|array  $stops
+	 * @return $this
+	 */
+	public function through($stops);
+
+	/**
+	 * Set the method to call on the stops.
+	 *
+	 * @param  string  $method
+	 * @return $this
+	 */
+	public function via($method);
+
+	/**
+	 * Run the pipeline with a final destination callback.
+	 *
+	 * @param  \Closure  $destination
+	 * @return mixed
+	 */
+	public function then(Closure $destination);
+
+}

vendor/laravel/framework/src/Illuminate/Contracts/Queue/EntityNotFoundException.php

@@ -0,0 +1,21 @@
+<?php namespace Illuminate\Contracts\Queue;
+
+use InvalidArgumentException;
+
+class EntityNotFoundException extends InvalidArgumentException {
+
+	/**
+	 * Create a new exception instance.
+	 *
+	 * @param  string  $type
+	 * @param  mixed  $id
+	 * @return void
+	 */
+	public function __construct($type, $id)
+	{
+		$id = (string) $id;
+
+		parent::__construct("Queueable entity [{$type}] not found for ID [{$id}].");
+	}
+
+}