Merge branch 'develop' of github.com:laravel/laravel into develop

application/config/error.php

@@ -66,21 +66,4 @@ return array(
 		Log::exception($exception);
 	},
 
-	/*
-	|--------------------------------------------------------------------------
-	| PHP INI Display Errors Setting
-	|--------------------------------------------------------------------------
-	|
-	| Here you may specify the display_errors setting of the PHP.ini file.
-	| Typically you may keep this "Off", as Laravel will cleanly handle
-	| the display of all errors.
-	|
-	| However, if you encounter an infamous white screen of death scenario,
-	| turning this "On" may help you solve the problem by getting the
-	| real error message being thrown by the application.
-	|
-	*/
-
-	'display' => 'Off',
-
 );
\ No newline at end of file

application/start.php

 <?php
 
+/*
+|--------------------------------------------------------------------------
+| PHP Display Errors Configuration
+|--------------------------------------------------------------------------
+|
+| Since Laravel intercepts and displays all errors with a detailed stack
+| trace, we can turn off the display_errors ini directive. However, you
+| may want to enable this option if you ever run into a dreaded white
+| screen of death, as it can provide some clues.
+|
+*/
+
+ini_set('display_errors', 'On');
+
+/*
+|--------------------------------------------------------------------------
+| Laravel Configuration Loader
+|--------------------------------------------------------------------------
+|
+| The Laravel configuration loader is responsible for returning an array
+| of configuration options for a given bundle and file. By default, we
+| use the files provided with Laravel; however, you are free to use
+| your own storage mechanism for configuration arrays.
+|
+*/
+
+Laravel\Event::listen(Laravel\Config::loader, function($bundle, $file)
+{
+	return Laravel\Config::file($bundle, $file);
+});
+
+/*
+|--------------------------------------------------------------------------
+| Register Class Aliases
+|--------------------------------------------------------------------------
+|
+| Aliases allow you to use classes without always specifying their fully
+| namespaced path. This is convenient for working with any library that
+| makes a heavy use of namespace for class organization. Here we will
+| simply register the configured class aliases.
+|
+*/
+
+$aliases = Laravel\Config::get('application.aliases');
+
+Laravel\Autoloader::$aliases = $aliases;
+
+/*
+|--------------------------------------------------------------------------
+| Laravel View Loader
+|--------------------------------------------------------------------------
+|
+| The Laravel view loader is responsible for returning the full file path
+| for the given bundle and view. Of course, a default implementation is
+| provided to load views according to typical Laravel conventions but
+| you may change this to customize how your views are organized.
+|
+*/
+
+Event::listen(View::loader, function($bundle, $view)
+{
+	return View::file($bundle, $view);
+});
+
+/*
+|--------------------------------------------------------------------------
+| Laravel Language Loader
+|--------------------------------------------------------------------------
+|
+| The Laravel language loader is responsible for returning the array of
+| language lines for a given bundle, language, and "file". A default
+| implementation has been provided which uses the default language
+| directories included with Laravel. However, you may tweak this
+| method to laad your language arrays however you wish.
+|
+*/
+
+Event::listen(Lang::loader, function($bundle, $language, $file)
+{
+	return Lang::file($bundle, $language, $file);
+});
+
+/*
+|--------------------------------------------------------------------------
+| Set The Default Timezone
+|--------------------------------------------------------------------------
+|
+| We need to set the default timezone for the application. This controls
+| the timezone that will be used by any of the date methods and classes
+| utilized by Laravel or your application. The timezone may be set in
+| your application configuration file.
+|
+*/
+
+date_default_timezone_set(Config::get('application.timezone'));
+
+/*
+|--------------------------------------------------------------------------
+| Start / Load The User Session
+|--------------------------------------------------------------------------
+|
+| Sessions allow the web, which is stateless, to simulate state. In other
+| words, sessions allow you to store information about the current user
+| and state of your application. Here we'll just fire up the session
+| if a session driver has been configured.
+|
+*/
+
+if ( ! Request::cli() and Config::get('session.driver') !== '')
+{
+	Session::load();
+}
+
 /*
 |--------------------------------------------------------------------------
 | Auto-Loader Mappings

changes.txt

@@ -10,3 +10,8 @@ Changes for 3.1:
 	- Pattern based filters.
 	- Better session ID assignment
 	- Added cviebrock's unsigned support.
+	- Added config, view, and lang loaders.
+	- Moved more stuff into application/start
+	- Removed error.display config options.
+	- Added foreign key support to schema builder.
+	- Postgres "unique" indexes are now added with ADD CONSTRAINT
\ No newline at end of file

laravel/cli/command.php

@@ -44,7 +44,7 @@ class Command {
 			throw new \Exception("Sorry, I can't find that task.");
 		}
 
-		if(is_callable(array($task, $method)))
+		if (is_callable(array($task, $method)))
 		{
 			$task->$method(array_slice($arguments, 1));
 		}
@@ -114,7 +114,7 @@ class Command {
 
 		// First we'll check to see if the task has been registered in the
 		// application IoC container. This allows all dependencies to be
-		// injected into tasks for more testability.
+		// injected into tasks for more flexible testability.
 		if (IoC::registered("task: {$identifier}"))
 		{
 			return IoC::resolve("task: {$identifier}");

laravel/config.php

@@ -20,6 +20,13 @@ class Config {
 	 */
 	public static $cache = array();
 
+	/**
+	 * The configuration loader event name.
+	 *
+	 * @var string
+	 */
+	const loader = 'laravel.config.loader';
+
 	/**
 	 * Determine if a configuration item or file exists.
 	 *
@@ -106,8 +113,7 @@ class Config {
 
 		// If the item is null, it means the developer wishes to set the entire
 		// configuration array to a given value, so we will pass the entire
-		// array for the bundle into the array_set method, otherwise we'll
-		// only pass the file array for the bundle.
+		// array for the bundle into the array_set method.
 		if (is_null($item))
 		{
 			array_set(static::$items[$bundle], $file, $value);
@@ -166,6 +172,31 @@ class Config {
 	{
 		if (isset(static::$items[$bundle][$file])) return true;
 
+		// We allow a "config.loader" event to be registered which is responsible for
+		// returning an array representing the configuration for the bundle and file
+		// requested. This allows many types of config "drivers".
+		$config = Event::first(static::loader, func_get_args());
+
+		// If configuration items were actually found for the bundle and file we
+		// will add them to the configuration array and return true, otherwise
+		// we will return false indicating the file was not found.
+		if (count($config) > 0)
+		{
+			static::$items[$bundle][$file] = $config;
+		}
+
+		return isset(static::$items[$bundle][$file]);
+	}
+
+	/**
+	 * Load the configuration items from a configuration file.
+	 *
+	 * @param  string  $bundle
+	 * @param  string  $file
+	 * @return array
+	 */
+	public static function file($bundle, $file)
+	{
 		$config = array();
 
 		// Configuration files cascade. Typically, the bundle configuration array is
@@ -179,12 +210,7 @@ class Config {
 			}
 		}
 
-		if (count($config) > 0)
-		{
-			static::$items[$bundle][$file] = $config;
-		}
-
-		return isset(static::$items[$bundle][$file]);
+		return $config;
 	}
 
 	/**

laravel/core.php

 <?php namespace Laravel;
 
-/**
- * Define all of the constants that we will need to use the framework.
- * These are things like file extensions, as well as all of the paths
- * used by the framework. All of the paths are built on top of the
- * basic application, laravel, and public paths.
- */
+/*
+|--------------------------------------------------------------------------
+| PHP Display Errors Configuration
+|--------------------------------------------------------------------------
+|
+| Register the constants used by the framework. These are things like file
+| extensions and other information that we want to be able to access with
+| just a simple constant.
+|
+*/
+
 define('EXT', '.php');
 define('CRLF', "\r\n");
 define('DEFAULT_BUNDLE', 'application');
 define('MB_STRING', (int) function_exists('mb_get_info'));
 
-/**
- * Require all of the classes that can't be loaded by the auto-loader.
- * These are typically classes that the auto-loader relies upon to
- * load classes, such as the array and configuration classes.
- */
+/*
+|--------------------------------------------------------------------------
+| Require Core Classes
+|--------------------------------------------------------------------------
+|
+| Here we will just load in the classes that are used for every request
+| or are used by the configuration class. It is quicker and simpler to
+| just manually load them in instead of using the auto-loader.
+|
+*/
+
+require path('sys').'ioc'.EXT;
 require path('sys').'event'.EXT;
 require path('sys').'bundle'.EXT;
 require path('sys').'config'.EXT;
 require path('sys').'helpers'.EXT;
 require path('sys').'autoloader'.EXT;
 
-/**
- * Register the Autoloader's "load" method on the auto-loader stack.
- * This method provides the lazy-loading of all class files, as well
- * as any PSR-0 compliant libraries used by the application.
- */
+/*
+|--------------------------------------------------------------------------
+| Register The Framework Auto-Loader
+|--------------------------------------------------------------------------
+|
+| Next we'll register the Autoloader class on the SPL auto-loader stack
+| so it can lazy-load our class files as we need them. This class and
+| method will be called each time a class is needed but has not been
+| defined yet and will load the appropriate file.
+|
+*/
+
 spl_autoload_register(array('Laravel\\Autoloader', 'load'));
 
-/**
- * Register the Laravel namespace so that the auto-loader loads it
- * according to the PSR-0 naming conventions. This should provide
- * fast resolution of all core classes.
- */
+/*
+|--------------------------------------------------------------------------
+| Register The Laravel Namespace
+|--------------------------------------------------------------------------
+|
+| Register the "Laravel" namespace and its directory mapping so the class
+| loader can quickly load all of the core classes using PSR-0 style load
+| conventions throughout the "laravel" directory since all core classes
+| are namespaced into the "Laravel" namespace.
+|
+*/
+
 Autoloader::namespaces(array('Laravel' => path('sys')));
 
-/**
- * Set the CLI options on the $_SERVER global array so we can easily
- * retrieve them from the various parts of the CLI code. We can use
- * the Request class to access them conveniently.
- */
+/*
+|--------------------------------------------------------------------------
+| Set The CLI Options Array
+|--------------------------------------------------------------------------
+|
+| If the current request is from the Artisan command-line interface, we
+| will parse the command line arguments and options and set them the
+| array of options in the $_SERVER global array for convenience.
+|
+*/
+
 if (defined('STDIN'))
 {
 	$console = CLI\Command::options($_SERVER['argv']);
@@ -52,39 +84,34 @@ if (defined('STDIN'))
 	$_SERVER['CLI'] = $options;
 }
 
-/**
- * The Laravel environment may be specified on the CLI using the env
- * option, allowing the developer to easily use local configuration
- * files from the CLI since the environment is usually controlled
- * by server environmenet variables.
- */
+/*
+|--------------------------------------------------------------------------
+| Set The CLI Laravel Environment
+|--------------------------------------------------------------------------
+|
+| Next we'll set the LARAVEL_ENV variable if the current request is from
+| the Artisan command-line interface. Since the environment is often
+| specified within an Apache .htaccess file, we need to set it here
+| when the request is not coming through Apache.
+|
+*/
+
 if (isset($_SERVER['CLI']['ENV']))
 {
 	$_SERVER['LARAVEL_ENV'] = $_SERVER['CLI']['ENV'];
 }
 
-/**
- * Register all of the core class aliases. These aliases provide a
- * convenient way of working with the Laravel core classes without
- * having to worry about the namespacing. The developer is also
- * free to remove aliases when they extend core classes.
- */
-Autoloader::$aliases = Config::get('application.aliases');
-
-/**
- * Register the default timezone for the application. This will
- * be the default timezone used by all date functions through
- * throughout the entire application.
- */
-$timezone = Config::get('application.timezone');
-
-date_default_timezone_set($timezone);
-
-/**
- * Finally we'll grab all of the bundles and register them
- * with the bundle class. All of the bundles are stored in
- * an array within the application directory.
- */
+/*
+|--------------------------------------------------------------------------
+| Register The Laravel Bundles
+|--------------------------------------------------------------------------
+|
+| Finally we will register all of the bundles that have been defined for
+| the application. None of them will be started, yet but will be setup
+| so that they may be started by the develop at any time.
+|
+*/
+
 $bundles = require path('app').'bundles'.EXT;
 
 foreach ($bundles as $bundle => $config)

laravel/database/schema/grammars/grammar.php

@@ -6,14 +6,60 @@ use Laravel\Database\Schema\Table;
 abstract class Grammar extends \Laravel\Database\Grammar {
 
 	/**
-	 * Get the appropriate data type definition for the column.
+	 * Generate the SQL statement for creating a foreign key.
+	 *
+	 * @param  Table    $table
+	 * @param  Command  $command
+	 * @return string
+	 */
+	public function foreign(Table $table, Fluent $command)
+	{
+		$name = $command->name;
+
+		// We need to wrap both of the table names in quoted identifiers to protect
+		// against any possible keyword collisions, both the table on which the
+		// command is being executed and the referenced table are wrapped.
+		$table = $this->wrap($table);
+
+		$on = $this->wrap($command->on);
+
+		// Next we need to columnize both the command table's columns as well as
+		// the columns referenced by the foreign key. We'll cast the referenced
+		// columns to an array since they aren't by the fluent command.
+		$foreign = $this->columnize($command->columns);
+
+		$referenced = $this->columnize((array) $command->references);
+
+		$sql = "ALTER TABLE $table ADD CONSTRAINT $name ";
+
+		return $sql .= "FOREIGN KEY ($foreign) REFERENCES $on ($referenced)";
+	}
+
+	/**
+	 * Drop a constraint from the table.
+	 *
+	 * @param  Table   $table
+	 * @param  Fluent  $fluent
+	 * @return string
+	 */
+	protected function drop_constraint(Table $table, Fluent $command)
+	{
+		return "ALTER TABLE ".$this->wrap($table)." DROP CONSTRAINT ".$command->name;
+	}
+
+	/**
+	 * Get the SQL syntax for indicating if a column is unsigned.
 	 *
+	 * @param  Table   $table
 	 * @param  Fluent  $column
 	 * @return string
 	 */
-	protected function type(Fluent $column)
+	protected function unsigned(Table $table, Fluent $column)
 	{
-		return $this->{'type_'.$column->type}($column);
+		if ($column->type == 'integer' && $column->unsigned)
+		{
+			return ' UNSIGNED';
+		}
 	}
 
 	/**
@@ -40,18 +86,14 @@ abstract class Grammar extends \Laravel\Database\Grammar {
 	}
 
 	/**
-	 * Get the SQL syntax for indicating if a column is unsigned.
+	 * Get the appropriate data type definition for the column.
 	 *
-	 * @param  Table   $table
 	 * @param  Fluent  $column
 	 * @return string
 	 */
-	protected function unsigned(Table $table, Fluent $column)
-	{
-		if ($column->type == 'integer' && $column->unsigned)
+	protected function type(Fluent $column)
 	{
-			return ' UNSIGNED';
-		}
+		return $this->{'type_'.$column->type}($column);
 	}
 
 }
\ No newline at end of file

laravel/database/schema/grammars/mysql.php

@@ -292,6 +292,18 @@ class MySQL extends Grammar {
 		return 'ALTER TABLE '.$this->wrap($table)." DROP INDEX {$command->name}";
 	}
 
+	/**
+	 * Drop a foreign key constraint from the table.
+	 *
+	 * @param  Table   $table
+	 * @param  Fluent  $fluent
+	 * @return string
+	 */
+	public function drop_foreign(Table $table, Fluent $command)
+	{
+		return "ALTER TABLE ".$this->wrap($table)." DROP FOREIGN KEY ".$command->name;
+	}
+
 	/**
 	 * Generate the data-type definition for a string.
 	 *

laravel/database/schema/grammars/postgres.php

@@ -146,7 +146,11 @@ class Postgres extends Grammar {
 	 */
 	public function unique(Table $table, Fluent $command)
 	{
-		return $this->key($table, $command, true);
+		$table = $this->wrap($table);
+
+		$columns = $this->columnize($command->columns);
+
+		return "ALTER TABLE $table ADD CONSTRAINT ".$command->name." UNIQUE ($columns)";
 	}
 
 	/**
@@ -250,7 +254,7 @@ class Postgres extends Grammar {
 	 */
 	public function drop_unique(Table $table, Fluent $command)
 	{
-		return $this->drop_key($table, $command);
+		return $this->drop_constraint($table, $command);
 	}
 
 	/**
@@ -289,6 +293,18 @@ class Postgres extends Grammar {
 		return 'DROP INDEX '.$command->name;
 	}
 
+	/**
+	 * Drop a foreign key constraint from the table.
+	 *
+	 * @param  Table   $table
+	 * @param  Fluent  $fluent
+	 * @return string
+	 */
+	public function drop_foreign(Table $table, Fluent $command)
+	{
+		return $this->drop_constraint($table, $command);		
+	}
+
 	/**
 	 * Generate the data-type definition for a string.
 	 *

laravel/database/schema/grammars/sqlserver.php

@@ -311,6 +311,18 @@ class SQLServer extends Grammar {
 		return "DROP INDEX {$command->name} ON ".$this->wrap($table);
 	}
 
+	/**
+	 * Drop a foreign key constraint from the table.
+	 *
+	 * @param  Table   $table
+	 * @param  Fluent  $fluent
+	 * @return string
+	 */
+	public function drop_foreign(Table $table, Fluent $command)
+	{
+		return $this->drop_constraint($table, $command);		
+	}
+
 	/**
 	 * Generate the data-type definition for a string.
 	 *

laravel/database/schema/table.php

@@ -108,6 +108,17 @@ class Table {
 		return $this->key(__FUNCTION__, $columns, $name);
 	}
 
+	/**
+	 * Add a foreign key constraint to the table.
+	 *
+	 * @param  string|array  $columns
+	 * @param  string        $name
+	 */
+	public function foreign($columns, $name = null)
+	{
+		return $this->key(__FUNCTION__, $columns, $name);
+	}
+
 	/**
 	 * Create a command for creating any index.
 	 *
@@ -196,6 +207,17 @@ class Table {
 		return $this->drop_key(__FUNCTION__, $name);
 	}
 
+	/**
+	 * Drop a foreign key constraint from the table.
+	 *
+	 * @param  string  $name
+	 * @return void
+	 */
+	public function drop_foreign($name)
+	{
+		return $this->drop_key(__FUNCTION__, $name);
+	}
+
 	/**
 	 * Create a command to drop any type of index.
 	 *
@@ -205,7 +227,7 @@ class Table {
 	 */
 	protected function drop_key($type, $name)
 	{
-		return $this->command($type, array('name' => $name));
+		return $this->command($type, compact('name'));
 	}
 
 	/**

laravel/error.php

@@ -12,7 +12,7 @@ class Error {
 	{
 		static::log($exception);
 
-		ob_end_clean();
+		ob_get_level() and ob_end_clean();
 
 		// If detailed errors are enabled, we'll just format the exception into
 		// a simple error message and display it on the screen. We don't use a

laravel/event.php

@@ -40,6 +40,31 @@ class Event {
 		static::$events[$event][] = $callback;
 	}
 
+	/**
+	 * Override all callbacks for a given event with a new callback.
+	 *
+	 * @param  string  $event
+	 * @param  mixed   $callback
+	 * @return void
+	 */
+	public static function override($event, $callback)
+	{
+		static::clear($event);
+
+		static::listen($event, $callback);
+	}
+
+	/**
+	 * Clear all event listeners for a given event.
+	 *
+	 * @param  string  $event
+	 * @return void
+	 */
+	public static function clear($event)
+	{
+		static::$events[$event] = array();
+	}
+
 	/**
 	 * Fire an event and return the first response.
 	 *

laravel/lang.php

@@ -32,6 +32,13 @@ class Lang {
 	 */
 	protected static $lines = array();
 
+	/**
+	 * The language loader event name.
+	 *
+	 * @var string
+	 */
+	const loader = 'laravel.language.loader';
+
 	/**
 	 * Create a new Lang instance.
 	 *
@@ -179,6 +186,26 @@ class Lang {
 			return true;
 		}
 
+		// We use a "loader" event to delegate the loading of the language
+		// array, which allows the develop to organize the language line
+		// arrays for their application however they wish.
+		$lines = Event::first(static::loader, func_get_args());
+
+		static::$lines[$bundle][$language][$file] = $lines;
+
+		return count($lines) > 0;
+	}
+
+	/**
+	 * Load a language array from a language file.
+	 *
+	 * @param  string  $bundle
+	 * @param  string  $language
+	 * @param  string  $file
+	 * @return array
+	 */
+	public static function file($bundle, $language, $file)
+	{
 		$lines = array();
 
 		// Language files can belongs to the application or to any bundle
@@ -191,12 +218,7 @@ class Lang {
 			$lines = require $path;
 		}
 
-		// All of the language lines are cached in an array so we can
-		// quickly look them up on subsequent reqwuests for the line.
-		// This keeps us from loading files each time.
-		static::$lines[$bundle][$language][$file] = $lines;
-
-		return count($lines) > 0;
+		return $lines;
 	}
 
 	/**

laravel/laravel.php

 <?php namespace Laravel;
 
-/**
- * Bootstrap the core framework components like the IoC container and
- * the configuration class, and the class auto-loader. Once this file
- * has run, the framework is essentially ready for use.
- */
+/*
+|--------------------------------------------------------------------------
+| Bootstrap The Framework Core
+|--------------------------------------------------------------------------
+|
+| By including this file, the core of the framework will be setup which
+| includes the class auto-loader, and the registration of any bundles.
+| Basically, once this file has been included, the entire framework
+| may be used by the developer.
+|
+*/
 require 'core.php';
 
-/**
- * Register the PHP exception handler. The framework throws exceptions
- * on every error that cannot be handled. All of those exceptions will
- * be sent through this closure for processing.
- */
+/*
+|--------------------------------------------------------------------------
+| Setup Error & Exception Handling
+|--------------------------------------------------------------------------
+|
+| Next we'll register custom handlers for all errors and exceptions so we
+| can display a clean error message for all errors, as well as do any
+| custom error logging that may be setup by the developer.
+|
+*/
+
 set_exception_handler(function($e)
 {
 	Error::exception($e);
 });
 
-/**
- * Register the PHP error handler. All PHP errors will fall into this
- * handler which will convert the error into an ErrorException object
- * and pass the exception into the exception handler.
- */
+
 set_error_handler(function($code, $error, $file, $line)
 {
 	Error::native($code, $error, $file, $line);
 });
 
-/**
- * Register the shutdown handler. This function will be called at the
- * end of the PHP script or on a fatal PHP error. If a PHP error has
- * occured, we will convert it to an ErrorException and pass it
- * to the common exception handler for the framework.
- */
+
 register_shutdown_function(function()
 {
 	Error::shutdown();
 });
 
-/**
- * Setting the PHP error reporting level to -1 essentially forces
- * PHP to report every error, and it is guranteed to show every
- * error on future versions of PHP.
- *
- * If error detail is turned off, we will turn off all PHP error
- * reporting and display since the framework will be displaying
- * a generic message and we do not want any sensitive details
- * about the exception leaking into the views.
- */
+/*
+|--------------------------------------------------------------------------
+| Report All Errors
+|--------------------------------------------------------------------------
+|
+| By setting error reporting to -1, we essentially force PHP to report
+| every error, and this is guranteed to show every error on future
+| releases of PHP. This allows everything to be fixed early!
+|
+*/
+
 error_reporting(-1);
 
-ini_set('display_errors', Config::get('error.display'));
+/*
+|--------------------------------------------------------------------------
+| Magic Quotes Strip Slashes
+|--------------------------------------------------------------------------
+|
+| Even though "Magic Quotes" are deprecated in PHP 5.3.x, they may still
+| be enabled on the server. To account for this, we will strip slashes
+| on all input arrays if magic quotes are enabled for the server.
+|
+*/
 
-/**
- * Even though "Magic Quotes" are deprecated in PHP 5.3, they may
- * still be enabled on the server. To account for this, we will
- * strip slashes on all input arrays if magic quotes are turned
- * on for the server environment.
- */
 if (magic_quotes())
 {
 	$magics = array(&$_GET, &$_POST, &$_COOKIE, &$_REQUEST);
@@ -68,24 +75,18 @@ if (magic_quotes())
 	}
 }
 
-/**
- * Load the session using the session manager. The payload will
- * be set on a static property of the Session class for easy
- * access throughout the framework and application.
- */
-if (Config::get('session.driver') !== '')
-{
-	Session::start(Config::get('session.driver'));
-
-	Session::load(Cookie::get(Config::get('session.cookie')));
-}
+/*
+|--------------------------------------------------------------------------
+| Sniff The Input For The Request
+|--------------------------------------------------------------------------
+|
+| Next we'll gather the input to the application based on the global input
+| variables for the current request. The input will be gathered based on
+| the current request method and will be set on the Input manager class
+| as a simple static $input property which can be easily accessed.
+|
+*/
 
-/**
- * Gather the input to the application based on the global input
- * variables for the current request. The input will be gathered
- * based on the current request method and will be set on the
- * Input manager class' static $input property.
- */
 $input = array();
 
 switch (Request::method())
@@ -111,90 +112,137 @@ switch (Request::method())
 		}
 }
 
-/**
- * The spoofed request method is removed from the input so it is not
- * unexpectedly included in Input::all() or Input::get(). Leaving it
- * in the input array could cause unexpected results if an Eloquent
- * model is filled with the input.
- */
+/*
+|--------------------------------------------------------------------------
+| Remove The Spoofer Input
+|--------------------------------------------------------------------------
+|
+| The spoofed request method is removed from the input so it is not in
+| the Input::all() or Input::get() results. Leaving it in the array
+| could cause unexpected results since the developer won't be
+| expecting it to be present.
+|
+*/
+
 unset($input[Request::spoofer]);
 
 Input::$input = $input;
 
-/**
- * Load the "application" bundle. Though the application folder is
- * not typically considered a bundle, it is started like one and
- * essentially serves as the "default" bundle.
- */
+/*
+|--------------------------------------------------------------------------
+| Start The Application Bundle
+|--------------------------------------------------------------------------
+|
+| The application "bundle" is the default bundle for the installation and
+| we'll fire it up first. In this bundle's bootstrap, more configuration
+| will take place and the developer can hook into some of the core
+| framework events such as the configuration loader.
+|
+*/
+
 Bundle::start(DEFAULT_BUNDLE);
 
-/**
- * Auto-start any bundles configured to start on every request.
- * This is especially useful for debug bundles or bundles that
- * are used throughout the application.
- */
+/*
+|--------------------------------------------------------------------------
+| Auto-Start Other Bundles
+|--------------------------------------------------------------------------
+|
+| Bundles that are used throughout the application may be auto-started
+| so they are immediately available on every request without needing
+| to explicitly start them within the application.
+|
+*/
+
 foreach (Bundle::$bundles as $bundle => $config)
 {
 	if ($config['auto']) Bundle::start($bundle);
 }
 
-/**
- * Register the "catch-all" route that handles 404 responses for
- * routes that can not be matched to any other route within the
- * application. We'll just raise the 404 event.
- */
+/*
+|--------------------------------------------------------------------------
+| Register The Catch-All Route
+|--------------------------------------------------------------------------
+|
+| This route will catch all requests that do not hit another route in
+| the application, and will raise the 404 error event so the error
+| can be handled by the developer in their 404 event listener.
+|
+*/
+
 Routing\Router::register('*', '(:all)', function()
 {
 	return Event::first('404');
 });
 
-/**
- * If the requset URI has too many segments, we will bomb out of
- * the request. This is too avoid potential DDoS attacks against
- * the framework by overloading the controller lookup method
- * with thousands of segments.
- */
-$uri = URI::current();
+/*
+|--------------------------------------------------------------------------
+| Route The Incoming Request
+|--------------------------------------------------------------------------
+|
+| Phew! We can finally route the request to the appropriate route and
+| execute the route to get the response. This will give an instance
+| of the Response object that we can send back to the browser
+|
+*/
 
-if (count(URI::$segments) > 15)
-{
-	throw new \Exception("Invalid request. Too many URI segments.");
-}
+$uri = URI::current();
 
-/**
- * Route the request to the proper route in the application. If a
- * route is found, the route will be called via the request class
- * static property. If no route is found, the 404 response will
- * be returned to the browser.
- */
 Request::$route = Routing\Router::route(Request::method(), $uri);
 
 $response = Request::$route->call();
 
-/**
- * Close the session and write the active payload to persistent
- * 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.
- */
+/*
+|--------------------------------------------------------------------------
+| Persist The Session To Storage
+|--------------------------------------------------------------------------
+|
+| If a session driver has been configured, we will save the session to
+| storage so it is avaiable for the next request. This will also set
+| the session cookie in the cookie jar to be sent to the user.
+|
+*/
+
 if (Config::get('session.driver') !== '')
 {
 	Session::save();
 }
 
-/**
- * Send all of the cookies to the browser. The cookies are
- * stored in a "jar" until the end of a request, primarily
- * to make testing the cookie functionality of the site
- * much easier since the jar can be inspected.
- */
+/*
+|--------------------------------------------------------------------------
+| Let's Eat Cookies
+|--------------------------------------------------------------------------
+|
+| All cookies set during the request are actually stored in a cookie jar
+| until the end of the request so they can be expected by unit tests or
+| the developer. Here, we'll push them out to the browser.
+|
+*/
+
 Cookie::send();	
 
-/**
- * Send the final response to the browser and fire the
- * final event indicating that the processing for the
- * current request is completed.
- */
+/*
+|--------------------------------------------------------------------------
+| Send The Response To The Browser
+|--------------------------------------------------------------------------
+|
+| We'll send the response back to the browser here. This method will also
+| send all of the response headers to the browser as well as the string
+| content of the Response. This should make the view available to the
+| browser and show something pretty to the user.
+|
+*/
+
 $response->send();
 
+/*
+|--------------------------------------------------------------------------
+| And We're Done!
+|--------------------------------------------------------------------------
+|
+| Raise the "done" event so extra output can be attached to the response
+| This allows the adding of debug toolbars, etc. to the view, or may be
+| used to do some kind of logging by the application.
+|
+*/
+
 Event::fire('laravel.done');
\ No newline at end of file

laravel/request.php

@@ -141,6 +141,27 @@ class Request {
 		return defined('STDIN');
 	}
 
+	/**
+	 * Get the Laravel environment for the current request.
+	 *
+	 * @return string|null
+	 */
+	public static function env()
+	{
+		if (isset($_SERVER['LARAVEL_ENV'])) return $_SERVER['LARAVEL_ENV'];
+	}
+
+	/**
+	 * Determine the current request environment.
+	 *
+	 * @param  string  $env
+	 * @return bool
+	 */
+	public static function is_env($env)
+	{
+		return static::env() === $env;
+	}
+
 	/**
 	 * Get the main route handling the request.
 	 *

laravel/session.php

@@ -17,7 +17,19 @@ class Session {
 	const csrf_token = 'csrf_token';
 
 	/**
-	 * Create the session payload instance and load the session for the request.
+	 * Create the session payload and the load the session.
+	 *
+	 * @return void
+	 */
+	public static function load()
+	{
+		static::start(Config::get('session.driver'));
+
+		static::$instance->load(Cookie::get(Config::get('session.cookie')));
+	}
+
+	/**
+	 * Create the session payload instance for the request.
 	 *
 	 * @param  string  $driver
 	 * @return void

laravel/view.php

@@ -51,6 +51,13 @@ class View implements ArrayAccess {
 	 */
 	public static $paths = array(DEFAULT_BUNDLE => array(''));
 
+	/**
+	 * The Laravel view loader event name.
+	 *
+	 * @var string
+	 */
+	const loader = 'laravel.view.loader';
+
 	/**
 	 * The Laravel view engine event name.
 	 *
@@ -106,28 +113,40 @@ class View implements ArrayAccess {
 	 */
 	protected function path($view)
 	{
-		$view = str_replace('.', '/', $view);
+		list($bundle, $view) = Bundle::parse($view);
 
-		$root = Bundle::path(Bundle::name($view)).'views/';
+		$view = str_replace('.', '/', $view);
 
-		// We need to make sure that the view exists. If it doesn't, we will
-		// throw an exception since there is not any point in going further.
-		// If it does, we can just return the full view path.
-		$paths = array_get(static::$paths, Bundle::name($view), array(''));
+		// We delegate the determination of view paths to the view loader
+		// event so that the developer is free to override and manage
+		// the loading views in any way they see fit.
+		$path = Event::first(static::loader, array($bundle, $view));
 
-		foreach ($paths as $path)
-		{
-			foreach (static::$extensions as $ext)
+		if ( ! is_null($path))
 		{
-				$file = $root.$path.Bundle::element($view).$ext;
-
-				if (file_exists($file)) return $file;
-			}
+			return $path;
 		}
 
 		throw new \Exception("View [$view] doesn't exist.");
 	}
 
+	/**
+	 * Get the path to a view using the default folder convention.
+	 *
+	 * @param  string  $bundle
+	 * @param  string  $view
+	 * @return string
+	 */
+	public static function file($bundle, $view)
+	{
+		$root = Bundle::path($bundle).'views/';
+
+		if (file_exists($path = $root.$view.EXT))
+		{
+			return $path;
+		}
+	}
+
 	/**
 	 * Create a new view instance.
 	 *