Annajwaszahro
/
MIF_E31222691
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

moving some laravel classes around, switching alias to reflect changes. added some factories. removed system ioc container config file.

This commit is contained in:
Taylor Otwell 2011-11-11 21:27:30 -06:00
parent b625ebdcf3
commit b6ab0b08ce
23 changed files with 384 additions and 388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
application/config/application.php
View File

@ -112,24 +112,26 @@
*/
'aliases' => array(
'Arr' => 'Laravel\\Arr',
'Asset' => 'Laravel\\Asset',
'Auth' => 'Laravel\\Security\\Auth',
'Auth' => 'Laravel\\Auth',
'Benchmark' => 'Laravel\\Benchmark',
'Cache' => 'Laravel\\Cache\\Manager',
'Config' => 'Laravel\\Config',
'Controller' => 'Laravel\\Routing\\Controller',
'Cookie' => 'Laravel\\Cookie',
'Crypter' => 'Laravel\\Security\\Crypter',
'Crypter' => 'Laravel\\Crypter',
'DB' => 'Laravel\\Database\\Manager',
'Eloquent' => 'Laravel\\Database\\Eloquent\\Model',
'File' => 'Laravel\\File',
'Form' => 'Laravel\\Form',
'Hash' => 'Laravel\\Security\\Hash',
'Hash' => 'Laravel\\Hash',
'HTML' => 'Laravel\\HTML',
'Inflector' => 'Laravel\\Inflector',
'Input' => 'Laravel\\Input',
'IoC' => 'Laravel\\IoC',
'Lang' => 'Laravel\\Lang',
'Memcached' => 'Laravel\\Memcached',
'Paginator' => 'Laravel\\Paginator',
'URL' => 'Laravel\\URL',
'Redirect' => 'Laravel\\Redirect',
@ -139,7 +141,7 @@
'Section' => 'Laravel\\Section',
'Session' => 'Laravel\\Facades\\Session',
'Str' => 'Laravel\\Str',
'Validator' => 'Laravel\\Validation\\Validator',
'Validator' => 'Laravel\\Validator',
'View' => 'Laravel\\View',
),

36
laravel/arr.php
View File

@ -75,6 +75,42 @@ public static function set(&$array, $key, $value)
$array[array_shift($keys)] = $value;
}
/**
* Remove an array item from a given array.
*
* The same "dot" syntax used by the "get" method may be used here.
*
* <code>
* // Remove the $array['user']['name'] item from the array
* Arr::forget($array, 'user.name');
* </code>
*
* @param array $array
* @param string $key
* @param mixed $value
* @return void
*/
public static function forget(&$array, $key)
{
if (is_null($key)) return;
$keys = explode('.', $key);
while (count($keys) > 1)
{
$key = array_shift($keys);
if ( ! isset($array[$key]) or ! is_array($array[$key]))
{
return;
}
$array =& $array[$key];
}
unset($array[array_shift($keys)]);
}
/**
* Return the first element in an array which passes a given truth test.
*

8
laravel/security/auth.php → laravel/auth.php
View File

@ -1,10 +1,4 @@
<?php namespace Laravel\Security;
use Laravel\IoC;
use Laravel\Str;
use Laravel\Config;
use Laravel\Cookie;
use Laravel\Session;
<?php namespace Laravel;
class Auth {

8
laravel/bootstrap/core.php
View File

@ -49,7 +49,6 @@
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;
/**
@ -61,13 +60,6 @@
Config::load('session');
Config::load('error');
/**
* Bootstrap the application inversion of control container. The IoC
* container is responsible for resolving classes, and helps keep the
* framework flexible.
*/
IoC::bootstrap();
/**
* Register the Autoloader's "load" method on the auto-loader stack.
* This method provides the lazy-loading of all class files, as well

34
laravel/cache/drivers/factory.php vendored Normal file
View File

@ -0,0 +1,34 @@
<?php namespace Laravel\Cache\Drivers;
use Laravel\Config;
class Factory {
/**
* Create a new cache driver instance.
*
* @param string $driver
* @return Driver
*/
public static function make($driver)
{
switch ($driver)
{
case 'apc':
return new APC(Config::get('cache.key'));
case 'file':
return new File(CACHE_PATH);
case 'memcached':
return new Memcached(\Laravel\Memcached::instance(), Config::get('cache.key'));
case 'redis':
return new Redis(\Laravel\Redis::db());
default:
throw new \Exception("Cache driver {$driver} is not supported.");
}
}
}

8
laravel/cache/manager.php vendored
View File

@ -1,4 +1,8 @@
<?php namespace Laravel\Cache; use Laravel\IoC, Laravel\Config;
<?php namespace Laravel\Cache;
use Laravel\Redis;
use Laravel\Config;
use Laravel\Memcached;
class Manager {
@ -37,7 +41,7 @@ public static function driver($driver = null)
throw new \Exception("Cache driver [$driver] is not supported.");
}
return static::$drivers[$driver] = IoC::core("cache.{$driver}");
return static::$drivers[$driver] = Drivers\Factory::make($driver);
}
return static::$drivers[$driver];

116
laravel/config/container.php
View File

@ -1,116 +0,0 @@
<?php namespace Laravel;
return array(
'laravel.routing.router' => array('singleton' => true, 'resolver' => function($c)
{
return new Routing\Router($c->core('routing.loader'), CONTROLLER_PATH);
}),
'laravel.routing.loader' => array('singleton' => true, 'resolver' => function($c)
{
return new Routing\Loader(APP_PATH, ROUTE_PATH);
}),
'laravel.routing.caller' => array('resolver' => function($c)
{
return new Routing\Caller($c, require APP_PATH.'filters'.EXT, CONTROLLER_PATH);
}),
'laravel.database.connectors.sqlite' => array('resolver' => function($c)
{
return new Database\Connectors\SQLite(DATABASE_PATH);
}),
'laravel.database.connectors.mysql' => array('resolver' => function($c)
{
return new Database\Connectors\MySQL;
}),
'laravel.database.connectors.pgsql' => array('resolver' => function($c)
{
return new Database\Connectors\Postgres;
}),
'laravel.cache.apc' => array('resolver' => function($c)
{
return new Cache\Drivers\APC(Config::get('cache.key'));
}),
'laravel.cache.file' => array('resolver' => function($c)
{
return new Cache\Drivers\File(CACHE_PATH);
}),
'laravel.cache.redis' => array('resolver' => function()
{
return new Cache\Drivers\Redis(Redis::db());
}),
'laravel.cache.memcached' => array('resolver' => function($c)
{
return new Cache\Drivers\Memcached($c->core('cache.memcache.connection'), Config::get('cache.key'));
}),
'laravel.cache.memcache.connection' => array('singleton' => true, 'resolver' => function($c)
{
$memcache = new \Memcache;
foreach (Config::get('cache.memcached') as $server)
{
$memcache->addServer($server['host'], $server['port'], true, $server['weight']);
}
if ($memcache->getVersion() === false)
{
throw new \Exception('Could not establish memcached connection. Please verify your memcached configuration.');
}
return $memcache;
}),
'laravel.session.apc' => array('resolver' => function($c)
{
return new Session\Drivers\APC($c->core('cache.apc'));
}),
'laravel.session.cookie' => array('resolver' => function($c)
{
return new Session\Drivers\Cookie;
}),
'laravel.session.database' => array('resolver' => function($c)
{
return new Session\Drivers\Database(Database\Manager::connection());
}),
'laravel.session.file' => array('resolver' => function($c)
{
return new Session\Drivers\File(SESSION_PATH);
}),
'laravel.session.redis' => array('resolver' => function($c)
{
return new Session\Drivers\Redis($c->core('cache.redis'));
}),
'laravel.session.memcached' => array('resolver' => function($c)
{
return new Session\Drivers\Memcached($c->core('cache.memcached'));
}),
);

2
laravel/security/crypter.php → laravel/crypter.php
View File

@ -1,4 +1,4 @@
<?php namespace Laravel\Security; use Laravel\Config;
<?php namespace Laravel;
if (trim(Config::$items['application']['key']) === '')
{

29
laravel/database/connectors/factory.php Normal file
View File

@ -0,0 +1,29 @@
<?php namespace Laravel\Database\Connectors;
class Factory {
/**
* Create a new database connector instance.
*
* @param string $driver
* @return Connector
*/
public static function make($driver)
{
switch ($driver)
{
case 'sqlite':
return new SQLite(DATABASE_PATH);
case 'mysql':
return new MySQL;
case 'pgsql':
return new Postgres;
default:
throw new \Exception("Database driver [$driver] is not supported.");
}
}
}

4
laravel/database/manager.php
View File

@ -32,7 +32,7 @@ public static function connection($connection = null)
{
if (is_null($connection)) $connection = Config::get('database.default');
if ( ! array_key_exists($connection, static::$connections))
if ( ! isset(static::$connections[$connection]))
{
$config = Config::get("database.connections.{$connection}");
@ -65,7 +65,7 @@ protected static function connect($config)
return call_user_func($config['connector'], $config);
}
return IoC::core("database.connectors.{$config['driver']}")->connect($config);
return Connectors\Factory::make($config['driver'])->connect($config);
}
/**

2
laravel/security/hash.php → laravel/hash.php
View File

@ -1,4 +1,4 @@
<?php namespace Laravel\Security; use Laravel\Str;
<?php namespace Laravel;
class Hash {

17
laravel/input.php
View File

@ -76,6 +76,23 @@ public static function flash()
}
}
/**
* Flush the old input from the session.
*
* On a successful form submission, the application may redirect to another
* form. If this is the case, it may be necessary to flush the old input
* so that the new form does not have the previous form's data.
*
* @return void
*/
public static function flush()
{
if (Config::$items['session']['driver'] !== '')
{
IoC::core('session')->flash(Input::old_input, array());
}
}
/**
* Determine if the old input data contains an item.
*

237
laravel/container.php → laravel/ioc.php
View File

@ -3,32 +3,96 @@
class IoC {
/**
* The active container instance.
* The registered dependencies.
*
* @var Container
* @var array
*/
public static $container;
protected static $registry = array();
/**
* Bootstrap the global IoC instance.
* The resolved singleton instances.
*
* @var array
*/
protected static $singletons = array();
/**
* Bootstrap the application IoC container.
*
* @param array $registry
* @return void
*/
public static function bootstrap()
public static function bootstrap($registry = array())
{
Config::load('container');
static::$container = new Container(Config::$items['container']);
static::$registry = Config::$items['container'];
}
/**
* Get the active container instance.
* Register an object and its resolver.
*
* @return Container
* The IoC container instance is always passed to the resolver, allowing the
* nested resolution of other objects from the container.
*
* <code>
* // Register an object and its resolver
* IoC::register('mailer', function($c) {return new Mailer;});
* </code>
*
* @param string $name
* @param Closure $resolver
* @return void
*/
public static function container()
public static function register($name, $resolver, $singleton = false)
{
return static::$container;
static::$registry[$name] = array('resolver' => $resolver, 'singleton' => $singleton);
}
/**
* Determine if an object has been registered in the container.
*
* @param string $name
* @return bool
*/
public static function registered($name)
{
return array_key_exists($name, static::$registry);
}
/**
* Register an object as a singleton.
*
* Singletons will only be instantiated the first time they are resolved.
* On subsequent requests for the object, the original instance will be returned.
*
* @param string $name
* @param Closure $resolver
* @return void
*/
public static function singleton($name, $resolver)
{
static::register($name, $resolver, true);
}
/**
* Register an instance as a singleton.
*
* This method allows you to register an already existing object instance
* with the container to be managed as a singleton instance.
*
* <code>
* // Register an instance as a singleton in the container
* IoC::instance('mailer', new Mailer);
* </code>
*
* @param string $name
* @param mixed $instance
* @return void
*/
public static function instance($name, $instance)
{
static::$singletons[$name] = $instance;
}
/**
@ -51,141 +115,7 @@ public static function container()
*/
public static function core($name, $parameters = array())
{
return static::$container->core($name, $parameters);
}
/**
* Magic Method for calling methods on the active container instance.
*
* <code>
* // Call the "resolve" method on the active container
* $instance = IoC::resolve('laravel.routing.router');
*
* // Call the "instance" method on the active container
* IoC::instance('mailer', new Mailer);
* </code>
*/
public static function __callStatic($method, $parameters)
{
return call_user_func_array(array(static::$container, $method), $parameters);
}
}
class Container {
/**
* The resolved singleton instances.
*
* @var array
*/
public $singletons = array();
/**
* The registered dependencies.
*
* @var array
*/
protected $registry = array();
/**
* Create a new IoC container instance.
*
* @param array $registry
* @return void
*/
public function __construct($registry = array())
{
$this->registry = $registry;
}
/**
* Register an object and its resolver.
*
* The IoC container instance is always passed to the resolver, allowing the
* nested resolution of other objects from the container.
*
* <code>
* // Register an object and its resolver
* IoC::register('mailer', function($c) {return new Mailer;});
* </code>
*
* @param string $name
* @param Closure $resolver
* @return void
*/
public function register($name, $resolver, $singleton = false)
{
$this->registry[$name] = array('resolver' => $resolver, 'singleton' => $singleton);
}
/**
* Determine if an object has been registered in the container.
*
* @param string $name
* @return bool
*/
public function registered($name)
{
return array_key_exists($name, $this->registry);
}
/**
* Register an object as a singleton.
*
* Singletons will only be instantiated the first time they are resolved.
* On subsequent requests for the object, the original instance will be returned.
*
* @param string $name
* @param Closure $resolver
* @return void
*/
public function singleton($name, $resolver)
{
$this->register($name, $resolver, true);
}
/**
* Register an instance as a singleton.
*
* This method allows you to register an already existing object instance
* with the container to be managed as a singleton instance.
*
* <code>
* // Register an instance as a singleton in the container
* IoC::instance('mailer', new Mailer);
* </code>
*
* @param string $name
* @param mixed $instance
* @return void
*/
public function instance($name, $instance)
{
$this->singletons[$name] = $instance;
}
/**
* Resolve a core Laravel class from the container.
*
* <code>
* // Resolve the "laravel.router" class from the container
* $input = IoC::core('router');
*
* // Equivalent resolution using the "resolve" method
* $input = IoC::resolve('laravel.router');
*
* // Pass an array of parameters to the resolver
* $input = IoC::core('router', array('test'));
* </code>
*
* @param string $name
* @param array $parameters
* @return mixed
*/
public function core($name, $parameters = array())
{
return $this->resolve("laravel.{$name}", $parameters);
return static::resolve("laravel.{$name}", $parameters);
}
/**
@ -203,23 +133,28 @@ public function core($name, $parameters = array())
* @param array $parameters
* @return mixed
*/
public function resolve($name, $parameters = array())
public static function resolve($name, $parameters = array())
{
if (array_key_exists($name, $this->singletons)) return $this->singletons[$name];
if (array_key_exists($name, static::$singletons))
{
return static::$singletons[$name];
}
if ( ! $this->registered($name))
if ( ! static::registered($name))
{
throw new \Exception("Error resolving [$name]. No resolver has been registered in the container.");
}
$object = call_user_func($this->registry[$name]['resolver'], $this, $parameters);
$object = call_user_func(static::$registry[$name]['resolver'], $parameters);
if (isset($this->registry[$name]['singleton']) and $this->registry[$name]['singleton'])
if (isset(static::$registry[$name]['singleton']) and static::$registry[$name]['singleton'])
{
return $this->singletons[$name] = $object;
return static::$singletons[$name] = $object;
}
return $object;
}
}
IoC::bootstrap();

15
laravel/laravel.php
View File

@ -99,11 +99,16 @@
*/
if (Config::$items['session']['driver'] !== '')
{
$driver = IoC::core('session.'.Config::$items['session']['driver']);
require SYS_PATH.'ioc'.EXT;
require SYS_PATH.'session/payload'.EXT;
require SYS_PATH.'session/drivers/driver'.EXT;
require SYS_PATH.'session/drivers/factory'.EXT;
$id = Cookie::get(Config::$items['session']['cookie']);
IoC::instance('laravel.session', new Session\Manager($driver, $id));
$driver = Session\Drivers\Factory::make(Config::$items['session']['driver']);
IoC::instance('laravel.session', new Session\Payload($driver, $id));
}
/**
@ -168,7 +173,11 @@
list($uri, $method) = array(Request::uri(), Request::method());
Request::$route = IoC::core('routing.router')->route($method, $uri);
$loader = new Routing\Loader(APP_PATH, ROUTE_PATH);
$router = new Routing\Router($loader, CONTROLLER_PATH);
Request::$route = $router->route($method, $uri);
if ( ! is_null(Request::$route))
{

62
laravel/memcached.php Normal file
View File

@ -0,0 +1,62 @@
<?php namespace Laravel;
class Memcached {
/**
* The Memcached connection instance.
*
* @var Memcache
*/
protected static $instance;
/**
* Get the Memcached connection instance.
*
* This connection will be managed as a singleton instance so that only
* one connection to the Memcached severs will be established.
*
* @return Memcache
*/
public static function instance()
{
if (is_null(static::$instance))
{
static::$instance = static::connect(Config::get('cache.memcached'));
}
return static::$instance;
}
/**
* Create a new Memcached connection instance.
*
* The configuration array passed to this method should be an array of
* server hosts / ports, like those defined in the cache configuration
* file.
*
* <code>
* // Create a new localhost Memcached connection instance.
* $memcache = Memcached::connect(array('host' => '127.0.0.1', 'port' => 11211));
* </code>
*
* @param array $servers
* @return Memcache
*/
public static function connect($servers)
{
$memcache = new \Memcache;
foreach ($servers as $server)
{
$memcache->addServer($server['host'], $server['port'], true, $server['weight']);
}
if ($memcache->getVersion() === false)
{
throw new \Exception('Could not establish memcached connection. Please verify your configuration.');
}
return $memcache;
}
}

2
laravel/validation/messages.php → laravel/messages.php
View File

@ -1,4 +1,4 @@
<?php namespace Laravel\Validation;
<?php namespace Laravel;
class Messages {

2
laravel/section.php
View File

@ -38,7 +38,7 @@ class Section {
*/
public static function start($section, $content = '')
{
if ($content !== '')
if ($content == '')
{
ob_start();

2
laravel/session/drivers/cookie.php
View File

@ -1,6 +1,6 @@
<?php namespace Laravel\Session\Drivers;
use Laravel\Security\Crypter;
use Laravel\Crypter;
class Cookie implements Driver {

40
laravel/session/drivers/factory.php Normal file
View File

@ -0,0 +1,40 @@
<?php namespace Laravel\Session\Drivers;
use Laravel\Cache\Manager as Cache;
class Factory {
/**
* Create a new session driver instance.
*
* @param string $driver
* @return Driver
*/
public static function make($driver)
{
switch ($driver)
{
case 'apc':
return new APC(Cache::driver('apc'));
case 'cookie':
return new Cookie;
case 'database':
return new Database(\Laravel\Database\Manager::connection());
case 'file':
return new File(SESSION_PATH);
case 'memcached':
return new Memcached(Cache::driver('memcached'));
case 'redis':
return new Redis(Cache::driver('redis'));
default:
throw new \Exception("Session driver [$driver] is not supported.");
}
}
}

80
laravel/session/manager.php → laravel/session/payload.php
View File

@ -1,6 +1,7 @@
<?php namespace Laravel\Session;
use Closure;
use Laravel\Arr;
use Laravel\Str;
use Laravel\Config;
use Laravel\Cookie;
@ -12,7 +13,7 @@
throw new \Exception("An application key is required to use sessions.");
}
class Manager {
class Payload {
/**
* The session array that is stored by the driver.
@ -42,19 +43,26 @@ public function __construct(Driver $driver, $id)
$this->session = $driver->load($id);
}
// If the session doesn't exist or is invalid, we will create a new session
// array and mark the session as being non-existent. Some drivers, such as
// the database driver, need to know whether the session exists in storage
// so they can know whether to "insert" or "update" the session.
if (is_null($this->session) or $this->invalid())
{
$this->exists = false;
$this->session = array('id' => Str::random(40), 'data' => array());
$this->session = array('id' => Str::random(40), 'data' => array(
':new:' => array(),
':old:' => array(),
));
}
// A CSRF token is stored in every session. The token is used by the Form
// class and the "csrf" filter to protect the application from cross-site
// request forgery attacks. The token is simply a long, random string
// which should be posted with each request.
if ( ! $this->has('csrf_token'))
{
// A CSRF token is stored in every session. The token is used by the
// Form class and the "csrf" filter to protect the application from
// cross-site request forgery attacks. The token is simply a long,
// random string which should be posted with each request.
$this->put('csrf_token', Str::random(40));
}
}
@ -113,12 +121,17 @@ public function has($key)
*/
public function get($key, $default = null)
{
foreach (array($key, ':old:'.$key, ':new:'.$key) as $possibility)
if (isset($this->session['data'][$key]))
{
if (array_key_exists($possibility, $this->session['data']))
{
return $this->session['data'][$possibility];
}
return $this->session['data'][$key];
}
elseif (isset($this->session['data'][':new:'][$key]))
{
return $this->session['data'][':new:'][$key];
}
elseif (isset($this->session['data'][':old:'][$key]))
{
return $this->session['data'][':old:'][$key];
}
return ($default instanceof Closure) ? call_user_func($default) : $default;
@ -133,13 +146,14 @@ public function get($key, $default = null)
*/
public function put($key, $value)
{
$this->session['data'][$key] = $value;
Arr::set($this->session['data'], $key, $value);
}
/**
* Write an item to the session flash data.
*
* Flash data only exists for the next request to the application.
* Flash data only exists for the next request to the application, and is
* useful for storing temporary data such as error or status messages.
*
* @param string $key
* @param mixed $value
@ -147,27 +161,17 @@ public function put($key, $value)
*/
public function flash($key, $value)
{
$this->put(':new:'.$key, $value);
Arr::set($this->session['data'][':new:'], $key, $value);
}
/**
* Keep all of the session flash data from expiring at the end of the request.
* Keep the session flash data from expiring at the end of the request.
*
* @return void
*/
public function reflash()
{
$flash = array();
foreach ($this->session['data'] as $key => $value)
{
if (strpos($key, ':old:') === 0)
{
$flash[] = str_replace(':old:', '', $key);
}
}
$this->keep($flash);
$this->session['data'][':new:'] += $this->session['data'][':old:'];
}
/**
@ -188,11 +192,11 @@ public function keep($keys)
* Remove an item from the session data.
*
* @param string $key
* @return Driver
* @return void
*/
public function forget($key)
{
unset($this->session['data'][$key]);
Arr::forget($this->session['data'], $key);
}
/**
@ -250,7 +254,9 @@ public function save(Driver $driver)
// need to determine if garbage collection should be run for the request.
// Since garbage collection can be expensive, the probability of it
// occuring is controlled by the "sweepage" configuration option.
if ($driver instanceof Sweeper and (mt_rand(1, $config['sweepage'][1]) <= $config['sweepage'][0]))
$sweepage = $config['sweepage'];
if ($driver instanceof Sweeper and (mt_rand(1, $sweepage[1]) <= $sweepage[0]))
{
$driver->sweep(time() - ($config['lifetime'] * 60));
}
@ -267,21 +273,9 @@ public function save(Driver $driver)
*/
protected function age()
{
foreach ($this->session['data'] as $key => $value)
{
if (strpos($key, ':old:') === 0)
{
$this->forget($key);
}
}
$this->session['data'][':old:'] = $this->session['data'][':new:'];
// Now that all of the "old" keys have been removed from the session data,
// we can re-address all of the newly flashed keys to have old addresses.
// The array_combine method uses the first array for keys, and the second
// array for values to construct a single array from both.
$keys = str_replace(':new:', ':old:', array_keys($this->session['data']));
$this->session['data'] = array_combine($keys, array_values($this->session['data']));
$this->session['data'][':new:'] = array();
}
/**

7
laravel/validation/validator.php → laravel/validator.php
View File

@ -1,11 +1,6 @@
<?php namespace Laravel\Validation;
<?php namespace Laravel;
use Closure;
use Laravel\Arr;
use Laravel\Str;
use Laravel\File;
use Laravel\Lang;
use Laravel\Input;
use Laravel\Database\Manager as DB;
class Validator {

10
laravel/view.php
View File

@ -324,6 +324,16 @@ public function __unset($key)
unset($this->data[$key]);
}
/**
* Get the evaluated string content of the view.
*
* @return string
*/
public function __toString()
{
return $this->render();
}
/**
* Magic Method for handling the dynamic creation of named views.
*

41
laravel/views/error/exception.php
View File

@ -1,41 +0,0 @@
<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title><?php echo $severity; ?></title>
<style>
<?php echo file_get_contents(PUBLIC_PATH.'css/laravel.css'); ?>
</style>
<style>
pre {
word-wrap: break-word;
}
</style>
</head>
<body>
<div id="main">
<img src="http://laravel.com/img/splash/error.png" class="marker">
<h1><?php echo $severity; ?></h1>
<h3>Error Message:</h3>
<pre><?php echo $message; ?></pre>
<h3>Stack Trace:</h3>
<?php
$search = array(APP_PATH, SYS_PATH);
$replace = array('APP_PATH/', 'SYS_PATH/');
$trace = str_replace($search, $replace, $exception->getTraceAsString());
?>
<pre style="word-wrap: break-word;"><?php echo $trace; ?></pre>
</div>
</body>
</html>