major session refactoring.

application/config/application.php

@@ -154,7 +154,7 @@ return array(
 		'Redis'      => 'Laravel\\Redis',
 		'Request'    => 'Laravel\\Request',
 		'Response'   => 'Laravel\\Response',
-		'Session'    => 'Laravel\\Session\\Manager',
+		'Session'    => 'Laravel\\Facades\\Session',
 		'Str'        => 'Laravel\\Str',
 		'Validator'  => 'Laravel\\Validation\\Validator',
 		'View'       => 'Laravel\\View',

laravel/autoloader.php

+<?php namespace Laravel;
+
+class Autoloader {
+
+	/**
+	 * The class alises defined for the application.
+	 *
+	 * @var array
+	 */
+	protected $aliases = array();
+
+	/**
+	 * The PSR-0 compliant libraries registered with the auto-loader.
+	 *
+	 * @var array
+	 */
+	protected $libraries = array();
+
+	/**
+	 * The paths to be searched by the auto-loader.
+	 *
+	 * @var array
+	 */
+	protected $paths = array(BASE_PATH, CLASS_PATH);
+
+	/**
+	 * Create a new auto-loader instance.
+	 *
+	 * @param  array  $aliases
+	 * @return void
+	 */
+	public function __construct($aliases = array())
+	{
+		$this->aliases = $aliases;
+	}
+
+	/**
+	 * Load the file corresponding to a given class.
+	 *
+	 * @param  string  $class
+	 * @return void
+	 */
+	public function load($class)
+	{
+		// Most of the core classes are aliases for convenient access in spite
+		// of the namespace. If an alias is defined for the class, we will load
+		// the alias and bail out of the auto-load method.
+		if (array_key_exists($class, $this->aliases))
+		{
+			return class_alias($this->aliases[$class], $class);
+		}
+
+		$file = str_replace('\\', '/', $class);
+
+		$namespace = substr($class, 0, strpos($class, '\\'));
+
+		// If the class namespace exists in the libraries array, it means that
+		// the library is PSR-0 compliant, and we will load it following those
+		// standards. This allows us to add many third-party libraries to an
+		// application and be able to auto-load them automatically.
+		if (array_key_exists($namespace, $this->libraries))
+		{
+			require CLASS_PATH.$this->psr($file);
+		}
+
+		foreach ($this->paths as $path)
+		{
+			if (file_exists($path = $path.strtolower($file).EXT))
+			{
+				require $path;
+
+				return;
+			}
+		}
+
+		// If the namespace exists in the classes directory, we will assume the
+		// library is PSR-0 compliant, and will add the namespace to the array
+		// of libraries and load the class accordingly.
+		if (is_dir(CLASS_PATH.$namespace))
+		{
+			$this->libraries[] = $namespace;
+
+			require CLASS_PATH.$this->psr($file);
+		}
+	}
+
+	/**
+	 * Format a path for PSR-0 compliant auto-loading.
+	 *
+	 * @param  string  $file
+	 * @return string
+	 */
+	protected function psr($file)
+	{
+		return str_replace('_', '/', $file);
+	}
+
+}
\ No newline at end of file

laravel/bootstrap/constants.php

@@ -4,11 +4,6 @@ define('BLADE_EXT', '.blade.php');
 define('CRLF', chr(13).chr(10));
 define('EXT', '.php');
 
-/**
- * Define a function that registers an array of constants if they haven't
- * haven't already been registered. This allows the constants to
- * be changed from their default values when unit testing.
- */
 function constants($constants)
 {
 	foreach ($constants as $key => $value)
@@ -17,11 +12,6 @@ function constants($constants)
 	}
 }
 
-/**
- * Register the core framework paths. All other paths are built on
- * top of these core paths. All of these paths are changable by
- * the developer in the front controller.
- */
 $constants = array(
 	'APP_PATH'     => realpath($application).'/',
 	'BASE_PATH'    => realpath("$laravel/..").'/',
@@ -34,19 +24,13 @@ constants($constants);
 
 unset($application, $public, $storage, $laravel);
 
-/**
- * Register all of the other framework paths. All of these paths
- * are built on top of the core paths above. We still allow the
- * developer to override these for easy unit testing.
- */
 $constants = array(
 	'CACHE_PATH'      => STORAGE_PATH.'cache/',
+	'CLASS_PATH'      => APP_PATH.'classes/',
 	'CONFIG_PATH'     => APP_PATH.'config/',
 	'CONTROLLER_PATH' => APP_PATH.'controllers/',
 	'DATABASE_PATH'   => STORAGE_PATH.'database/',
 	'LANG_PATH'       => APP_PATH.'language/',
-	'LIBRARY_PATH'    => APP_PATH.'libraries/',
-	'MODEL_PATH'      => APP_PATH.'models/',
 	'ROUTE_PATH'      => APP_PATH.'routes/',
 	'SESSION_PATH'    => STORAGE_PATH.'sessions/',
 	'SYS_CONFIG_PATH' => SYS_PATH.'config/',
@@ -57,11 +41,6 @@ $constants = array(
 
 constants($constants);
 
-/**
- * Set the Laravel environment configuration path constant.
- * The environment is controlled by setting an environment
- * variable on the server running Laravel.
- */
 $environment = (isset($_SERVER['LARAVEL_ENV'])) ? CONFIG_PATH.$_SERVER['LARAVEL_ENV'].'/' : '';
 
 constants(array('ENV_CONFIG_PATH' => $environment));

laravel/bootstrap/core.php

@@ -2,69 +2,20 @@
 
 require 'constants.php';
 
-/**
- * Load the classes that can't be resolved through the auto-loader.
- * These are typically classes that are used by the auto-loader or
- * configuration classes, and therefore cannot be auto-loaded.
- */
 require SYS_PATH.'arr'.EXT;
 require SYS_PATH.'config'.EXT;
+require SYS_PATH.'facades'.EXT;
+require SYS_PATH.'container'.EXT;
+require SYS_PATH.'autoloader'.EXT;
 
-/**
- * Load some core configuration files by default so we don't have to
- * let them fall through the Config parser. This will allow us to
- * load these files faster for each request.
- */
 Config::load('application');
 Config::load('container');
 Config::load('session');
 
-/**
- * Bootstrap the application inversion of control (IoC) container.
- * The container provides the convenient resolution of objects and
- * their dependencies, allowing for flexibility and testability
- * within the framework and application.
- */
-require SYS_PATH.'container'.EXT;
-
-$container = new Container(Config::$items['container']);
-
-IoC::$container = $container;
-
-unset($container);
-
-/**
- * Register the application auto-loader. The auto-loader closure
- * is responsible for the lazy-loading of all of the Laravel core
- * classes, as well as the developer created libraries and models.
- */
-$aliases = Config::$items['application']['aliases'];
-
-spl_autoload_register(function($class) use ($aliases)
-{
-	if (array_key_exists($class, $aliases))
-	{
-		return class_alias($aliases[$class], $class);
-	}
-
-	$file = strtolower(str_replace('\\', '/', $class));
-
-	foreach (array(BASE_PATH, MODEL_PATH, LIBRARY_PATH) as $path)
-	{
-		if (file_exists($path = $path.$file.EXT))
-		{
-			require_once $path;
-
-			return;
-		}
-	}
-});
+IoC::bootstrap();
 
-unset($aliases);
+spl_autoload_register(array(IoC::container()->core('autoloader'), 'load'));
 
-/**
- * Define a few convenient global functions.
- */
 function e($value)
 {
 	return HTML::entities($value);

laravel/config/container.php

@@ -2,25 +2,11 @@
 
 return array(
 
-	/*
-	|--------------------------------------------------------------------------
-	| Laravel Routing Components
-	|--------------------------------------------------------------------------
-	|
-	| The following components are used by the Laravel routing system.
-	|
-	| The router is used to map a given method and URI to a route intance.
-	|
-	| The route loader is responsible for loading the appropriates routes file
-	| for a given request URI, as well as loading all routes when the framework
-	| needs to find a named route wtihin the application.
-	|
-	| The route caller is responsible for receiving a route and taking the
-	| appropriate action to execute that route. Some routes delegate execution
-	| to a controller, so this class will also resolve controllers out of the
-	| container and call the appropriate methods on those controllers.
-	|
-	*/
+	'laravel.autoloader' => array('singleton' => true, 'resolver' => function($c)
+	{
+		return new Autoloader(Config::$items['application']['aliases']);		
+	}),
+
 
 	'laravel.routing.router' => array('singleton' => true, 'resolver' => function($c)
 	{
@@ -39,17 +25,6 @@ return array(
 		return new Routing\Caller($c, require APP_PATH.'filters'.EXT, CONTROLLER_PATH);
 	}),
 
-	/*
-	|--------------------------------------------------------------------------
-	| Laravel Database Connectors
-	|--------------------------------------------------------------------------
-	|
-	| The following components are used to establish PDO database connections
-	| to the various database systems supported by Laravel. By resolving these
-	| connectors out of the IoC container, new database systems may be added
-	| by simply registering a connector in the container.
-	|
-	*/
 
 	'laravel.database.connectors.sqlite' => array('resolver' => function($c)
 	{
@@ -66,16 +41,6 @@ return array(
 		return new Database\Connectors\Postgres;
 	}),
 
-	/*
-	|--------------------------------------------------------------------------
-	| Laravel Caching Components
-	|--------------------------------------------------------------------------
-	|
-	| The following components are used by the wonderfully simple Laravel cache
-	| system. Each driver is resolved through the container, so new drivers may
-	| be added by simply registering them in the container.
-	|
-	*/
 
 	'laravel.cache.apc' => array('resolver' => function($c)
 	{
@@ -118,29 +83,6 @@ return array(
 		return $memcache;
 	}),
 
-	/*
-	|--------------------------------------------------------------------------
-	| Laravel Session Components
-	|--------------------------------------------------------------------------
-	|
-	| The following components are used by the Laravel session system.
-	|
-	| The framework allows the session ID to be transported via a variety
-	| of different mechanisms by resolve the ID itself and the session
-	| transporter instance out of the container. This allows sessions
-	| to be used by clients who cannot receive cookies.
-	|
-	| The session manager is responsible for loading the session payload
-	| from the session driver, as well as examining the payload validitiy
-	| and things like the CSRF token.
-	|
-	*/
-
-	'laravel.session.transporter' => array('resolver' => function($c)
-	{
-		return new Session\Transporters\Cookie;
-	}),
-
 
 	'laravel.session.apc' => array('resolver' => function($c)
 	{

laravel/container.php

@@ -10,6 +10,16 @@ class IoC {
 	public static $container;
 
 	/**
+	 * Bootstrap the global IoC instance.
+	 *
+	 * @return void
+	 */
+	public static function bootstrap()
+	{
+		static::$container = new Container(Config::$items['container']);
+	}
+
+	/**
 	 * Get the active container instance.
 	 *
 	 * @return Container

laravel/facades.php

+<?php namespace Laravel\Facades;
+
+use Laravel\IoC;
+
+/**
+ * The Laravel framework makes thorough use of dependency injection assisted by an application
+ * inversion of control container. This allows for great flexibility, easy testing, and better
+ * architecture. However, most PHP framework users may be used to accessing classes through
+ * a variety of static methods. Laravel provides "facades" to simulate this behavior while
+ * still using heavy dependency injection.
+ *
+ * Each class that is commonly used by the developer has a corresponding facade defined in
+ * this file. All of the various facades inherit from the abstract Facade class, which only
+ * has a single __callStatic magic method. The facade simply resolves the requested class
+ * out of the IoC container and calls the appropriate method.
+ */
+abstract class Facade {
+
+	/**
+	 * Magic Method for passing methods to a class registered in the IoC container.
+	 * This provides a convenient method of accessing functions on classes that
+	 * could not otherwise be accessed staticly.
+	 *
+	 * Facades allow Laravel to still have a high level of dependency injection
+	 * and testability while still accomodating the common desire to conveniently
+	 * use classes via static methods.
+	 */
+	public static function __callStatic($method, $parameters)
+	{
+		$class = IoC::container()->resolve(static::$resolve);
+
+		$count = count($parameters);
+
+		if ($count > 5)
+		{
+			return call_user_func_array(array($class, $method), $parameters);
+		}
+		elseif ($count == 1)
+		{
+			return $class->$method($parameters[0]);
+		}
+		elseif ($count == 2)
+		{
+			return $class->$method($parameters[0], $parameters[1]);
+		}
+		elseif ($count == 3)
+		{
+			return $class->$method($parameters[0], $parameters[1], $parameters[2]);
+		}
+		elseif ($count == 4)
+		{
+			return $class->$method($parameters[0], $parameters[1], $parameters[2], $parameters[3]);
+		}
+		elseif ($count == 5)
+		{
+			return $class->$method($parameters[0], $parameters[1], $parameters[2], $parameters[3], $parameters[4]);
+		}
+	}
+
+}
+
+class Autoloader extends Facade { public static $resolve = 'laravel.autoloader'; }
+class Session    extends Facade { public static $resolve = 'laravel.session'; }
\ No newline at end of file

laravel/form.php

@@ -159,7 +159,7 @@ class Form {
 			throw new \Exception("A session driver must be specified before using CSRF tokens.");			
 		}
 
-		return Session\Manager::get('csrf_token');
+		return IoC::container()->core('session')->get('csrf_token');
 	}
 
 	/**

laravel/input.php

@@ -96,7 +96,9 @@ class Input {
 			throw new \Exception('A session driver must be specified in order to access old input.');
 		}
 
-		return Arr::get(Session\Manager::get(Input::old_input, array()), $key, $default);
+		$session = IoC::container()->core('session');
+
+		return Arr::get($session->get(Input::old_input, array()), $key, $default);
 	}
 
 	/**

laravel/laravel.php

@@ -26,11 +26,21 @@ date_default_timezone_set(Config::$items['application']['timezone']);
  */
 if (Config::$items['session']['driver'] !== '')
 {
+	require SYS_PATH.'cookie'.EXT;
+	require SYS_PATH.'session/payload'.EXT;
+
 	$driver = IoC::container()->core('session.'.Config::$items['session']['driver']);
 
-	$transporter = IoC::container()->core('session.transporter');
+	if ( ! is_null($id = Cookie::get(Session\Payload::cookie)))
+	{
+		$payload = new Session\Payload($driver->load($id));
+	}
+	else
+	{
+		$payload = new Session\Payload;
+	}
 
-	Session\Manager::start($driver, $transporter);
+	IoC::container()->instance('laravel.session', $payload);
 }
 
 /**
@@ -113,13 +123,13 @@ $response->content = $response->render();
 
 /**
  * Close the session and write the active payload to persistent
- * storage. The input for the current request is also flashed
- * to the session so it will be available for the next request
- * via the Input::old method.
+ * storage. The session cookie will also be written and if the
+ * driver is a sweeper, session garbage collection might be
+ * performed depending on the "sweepage" probability.
  */
 if (Config::$items['session']['driver'] !== '')
 {
-	Session\Manager::close();
+	IoC::container()->core('session')->save($driver);
 }
 
 /**

laravel/redirect.php

@@ -61,7 +61,7 @@ class Redirect extends Response {
 			throw new \Exception('A session driver must be set before setting flash data.');
 		}
 
-		Session\Manager::flash($key, $value);
+		IoC::container()->core('session')->flash($key, $value);
 
 		return $this;
 	}

laravel/session/transporters/cookie.php

-<?php namespace Laravel\Session\Transporters;
-
-class Cookie implements Transporter {
-
-	/**
-	 * The name of the cookie used to store the session ID.
-	 *
-	 * @var string
-	 */
-	const key = 'laravel_session';
-
-	/**
-	 * Get the session identifier for the request.
-	 *
-	 * @param  array   $config
-	 * @return string
-	 */
-	public function get($config)
-	{
-		return \Laravel\Cookie::get(Cookie::key);
-	}
-
-	/**
-	 * Store the session identifier for the request.
-	 *
-	 * @param  string  $id
-	 * @param  array   $config
-	 * @return void
-	 */
-	public function put($id, $config)
-	{
-		extract($config, EXTR_SKIP);
-
-		$minutes = ( ! $expire_on_close) ? $lifetime : 0;
-
-		\Laravel\Cookie::put(Cookie::key, $id, $minutes, $path, $domain, $secure);
-	}
-
-}
\ No newline at end of file

laravel/session/transporters/transporter.php

-<?php namespace Laravel\Session\Transporters;
-
-/**
- * Session transporters are responsible for getting the session identifier
- * to the client. This can be done via cookies or some other means.
- */
-interface Transporter {
-
-	/**
-	 * Get the session identifier for the request.
-	 *
-	 * @param  array   $config
-	 * @return string
-	 */
-	public function get($config);
-
-	/**
-	 * Store the session identifier for the request.
-	 *
-	 * @param  string  $id
-	 * @param  array   $config
-	 * @return void
-	 */
-	public function put($id, $config);
-
-}
\ No newline at end of file

storage/sessions/.gitignore

+*
\ No newline at end of file