Skip to content

U
UserAdminV2
Commit 30c83f26 by Taylor Otwell
Options

overall code refactoring.

parent af24e8db
Showing with 720 additions and 560 deletions
application/filters.php
......@@ -35,7 +35,7 @@ return array(
'csrf' => function()
{
return (Input::get('csrf_token') !== Form::raw_token()) ? Response::view('error/500', 500) : null;
return (Input::get('csrf_token') !== Form::raw_token()) ? Response::make(View::make('error/500'), 500) : null;
},
);
\ No newline at end of file
public/.htaccess
<IfModule mod_rewrite.c>
RewriteEngine on
RewriteEngine on
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$1 [L]
RewriteRule ^(.*)$ index.php/$1 [L]
</IfModule>
\ No newline at end of file
public/index.php
......@@ -85,7 +85,7 @@ if (System\Config::get('session.driver') != '')
// --------------------------------------------------------------
// Execute the global "before" filter.
// --------------------------------------------------------------
$response = System\Filter::call('before');
$response = System\Filter::call('before', array(), true);
// --------------------------------------------------------------
// Only execute the route function if the "before" filter did
......@@ -107,12 +107,12 @@ if (is_null($response))
}
else
{
$response = System\Response::view('error/404', 404);
$response = System\Response::make(View::make('error/404'), 404);
}
}
else
{
$response = ( ! $response instanceof System\Response) ? new System\Response($response) : $response;
$response = System\Response::prepare($response);
}
// ----------------------------------------------------------
......
system/config.php
......@@ -17,8 +17,14 @@ class Config {
*/
public static function get($key)
{
// -----------------------------------------------------
// Parse the key to separate the file and key name.
// -----------------------------------------------------
list($file, $key) = static::parse($key);
// -----------------------------------------------------
// Load the appropriate configuration file.
// -----------------------------------------------------
static::load($file);
return (array_key_exists($key, static::$items[$file])) ? static::$items[$file][$key] : null;
......@@ -33,8 +39,14 @@ class Config {
*/
public static function set($key, $value)
{
// -----------------------------------------------------
// Parse the key to separate the file and key name.
// -----------------------------------------------------
list($file, $key) = static::parse($key);
// -----------------------------------------------------
// Load the appropriate configuration file.
// -----------------------------------------------------
static::load($file);
static::$items[$file][$key] = $value;
......@@ -55,6 +67,11 @@ class Config {
throw new \Exception("Invalid configuration key [$key].");
}
// -----------------------------------------------------
// The left side of the dot is the file name, while
// the right side of the dot is the item within that
// file being requested.
// -----------------------------------------------------
return array($segments[0], implode('.', array_slice($segments, 1)));
}
......@@ -66,6 +83,9 @@ class Config {
*/
public static function load($file)
{
// -----------------------------------------------------
// If we have already loaded the file, bail out.
// -----------------------------------------------------
if (array_key_exists($file, static::$items))
{
return;
......
system/crypt.php
......@@ -48,6 +48,9 @@ class Crypt {
mt_srand();
}
// -----------------------------------------------------
// Create the Mcrypt input vector and encrypt the value.
// -----------------------------------------------------
$iv = mcrypt_create_iv(static::iv_size(), $random);
$value = mcrypt_encrypt(static::$cipher, static::key(), $value, static::$mode, $iv);
......
system/db.php
......@@ -65,7 +65,7 @@ class DB {
// For UPDATE and DELETE statements, return the number
// or rows affected by the query.
//
// For INSERT statements, return a boolean.
// For everything else, return a boolean.
// ---------------------------------------------------
if (strpos(Str::upper($sql), 'SELECT') === 0)
{
......
system/db/eloquent/factory.php deleted 100644 → 0
<?php namespace System\DB\Eloquent;
class Factory {
/**
* Factory for creating new model instances.
*
* @param string $class
* @return object
*/
public static function make($class)
{
$model = new $class;
// -----------------------------------------------------
// Set the fluent query builder on the model.
// -----------------------------------------------------
$model->query = \System\DB\Query::table(Meta::table($class));
return $model;
}
}
\ No newline at end of file
system/db/eloquent/hydrate.php → system/db/eloquent/hydrator.php
<?php namespace System\DB\Eloquent;
class Hydrate {
class Hydrator {
/**
* Load the array of hydrated models.
......@@ -8,7 +8,7 @@ class Hydrate {
* @param object $eloquent
* @return array
*/
public static function from($eloquent)
public static function hydrate($eloquent)
{
// -----------------------------------------------------
// Load the base models.
......@@ -38,27 +38,30 @@ class Hydrate {
* Hydrate the base models for a query.
*
* @param string $class
* @param array $models
* @param array $results
* @return array
*/
private static function base($class, $models)
private static function base($class, $results)
{
$results = array();
$models = array();
foreach ($models as $model)
foreach ($results as $result)
{
$result = new $class;
$model = new $class;
$result->attributes = (array) $model;
$result->exists = true;
// -----------------------------------------------------
// Set the attributes and existence flag on the model.
// -----------------------------------------------------
$model->attributes = (array) $result;
$model->exists = true;
// -----------------------------------------------------
// The results are keyed by the ID on the record.
// -----------------------------------------------------
$results[$result->id] = $result;
$models[$model->id] = $model;
}
return $results;
return $models;
}
/**
......@@ -97,6 +100,9 @@ class Hydrate {
$result->ignore[$include] = (strpos($eloquent->relating, 'has_many') === 0) ? array() : null;
}
// -----------------------------------------------------
// Eagerly load the relationship.
// -----------------------------------------------------
if ($eloquent->relating == 'has_one' or $eloquent->relating == 'has_many')
{
static::eagerly_load_one_or_many($eloquent->relating_key, $eloquent->relating, $include, $model, $results);
......@@ -203,7 +209,9 @@ class Hydrate {
// We also add the foreign key to the select which will allow us
// to match the models back to their parents.
// -----------------------------------------------------
$inclusions = $model->query->where_in($relating_key, array_keys($results))->get(Meta::table(get_class($model)).'.*', $relating_table.'.'.$foreign_key);
$inclusions = $model->query
->where_in($relating_key, array_keys($results))
->get(\System\DB\Eloquent::table(get_class($model)).'.*', $relating_table.'.'.$foreign_key);
// -----------------------------------------------------
// Get the class name of the related model.
......@@ -217,6 +225,9 @@ class Hydrate {
{
$related = new $class;
// -----------------------------------------------------
// Set the attributes and existence flag on the model.
// -----------------------------------------------------
$related->exists = true;
$related->attributes = (array) $inclusion;
......
system/db/eloquent/meta.php deleted 100644 → 0
<?php namespace System\DB\Eloquent;
class Meta {
/**
* Get the table name for a model.
*
* @param string $class
* @return string
*/
public static function table($class)
{
// -----------------------------------------------------
// Check for a table name override.
// -----------------------------------------------------
if (property_exists($class, 'table'))
{
return $class::$table;
}
return \System\Str::lower(\System\Inflector::plural($class));
}
}
\ No newline at end of file
system/db/eloquent/relate.php deleted 100644 → 0
<?php namespace System\DB\Eloquent;
class Relate {
/**
* Retrieve the query for a 1:1 relationship.
*
* @param string $model
* @param string $foreign_key
* @param object $eloquent
* @return mixed
*/
public static function has_one($model, $foreign_key, $eloquent)
{
$eloquent->relating = __FUNCTION__;
return static::has_one_or_many($model, $foreign_key, $eloquent);
}
/**
* Retrieve the query for a 1:* relationship.
*
* @param string $model
* @param string $foreign_key
* @param object $eloquent
* @return mixed
*/
public static function has_many($model, $foreign_key, $eloquent)
{
$eloquent->relating = __FUNCTION__;
return static::has_one_or_many($model, $foreign_key, $eloquent);
}
/**
* Retrieve the query for a 1:1 or 1:* relationship.
*
* @param string $model
* @param string $foreign_key
* @param object $eloquent
* @return mixed
*/
private static function has_one_or_many($model, $foreign_key, $eloquent)
{
$eloquent->relating_key = (is_null($foreign_key)) ? \System\Str::lower(get_class($eloquent)).'_id' : $foreign_key;
return Factory::make($model)->where($eloquent->relating_key, '=', $eloquent->id);
}
/**
* Retrieve the query for a 1:1 belonging relationship.
*
* @param array $caller
* @param string $model
* @param object $eloquent
* @return mixed
*/
public static function belongs_to($caller, $model, $eloquent)
{
$eloquent->relating = __FUNCTION__;
$eloquent->relating_key = $caller['function'].'_id';
return Factory::make($model)->where('id', '=', $eloquent->attributes[$eloquent->relating_key]);
}
/**
* Retrieve the query for a *:* relationship.
*
* @param string $model
* @param string $table
* @param object $eloquent
* @return mixed
*/
public static function has_many_and_belongs_to($model, $table, $eloquent)
{
// -----------------------------------------------------
// Figure out the intermediate table name.
// -----------------------------------------------------
if (is_null($table))
{
$models = array(\System\Str::lower($model), \System\Str::lower(get_class($eloquent)));
sort($models);
$eloquent->relating_table = implode('_', $models);
}
else
{
$eloquent->relating_table = $table;
}
$eloquent->relating = __FUNCTION__;
$eloquent->relating_key = $eloquent->relating_table.'.'.\System\Str::lower(get_class($eloquent)).'_id';
return Factory::make($model)
->select(Meta::table($model).'.*')
->join($eloquent->relating_table, Meta::table($model).'.id', '=', $eloquent->relating_table.'.'.\System\Str::lower($model).'_id')
->where($eloquent->relating_key, '=', $eloquent->id);
}
}
\ No newline at end of file
system/db/eloquent/warehouse.php deleted 100644 → 0
<?php namespace System\DB\Eloquent;
class Warehouse {
/**
* Save an Eloquent model to the database.
*
* @param object $eloquent
* @return bool
*/
public static function put($eloquent)
{
$model = get_class($eloquent);
// -----------------------------------------------------
// Get a fresh query instance for the model.
// -----------------------------------------------------
$eloquent->query = \System\DB\Query::table(Meta::table($model));
// -----------------------------------------------------
// Set the creation and update timestamps.
// -----------------------------------------------------
if (property_exists($model, 'timestamps') and $model::$timestamps)
{
static::timestamp($eloquent);
}
if ($eloquent->exists)
{
return ($eloquent->query->where('id', '=', $eloquent->attributes['id'])->update($eloquent->dirty) == 1) ? true : false;
}
else
{
$eloquent->attributes['id'] = $eloquent->query->insert_get_id($eloquent->attributes);
}
$eloquent->exists = true;
return true;
}
/**
* Delete an Eloquent model from the database.
*
* @param object $eloquent
* @return bool
*/
public static function forget($eloquent)
{
return \System\DB::table(Meta::table(get_class($eloquent)))->where('id', '=', $eloquent->id)->delete() == 1;
}
/**
* Set the activity timestamps on a model.
*
* @param object $eloquent
* @return void
*/
private static function timestamp($eloquent)
{
$eloquent->updated_at = date('Y-m-d H:i:s');
if ( ! $eloquent->exists)
{
$eloquent->created_at = $eloquent->updated_at;
}
}
}
\ No newline at end of file
system/db/query/compiler.php
......@@ -10,18 +10,30 @@ class Compiler {
*/
public static function select($query)
{
// ----------------------------------------------------
// Add the SELECT, FROM, and WHERE clause to the query.
// ----------------------------------------------------
$sql = $query->select.' '.$query->from.' '.$query->where;
// ----------------------------------------------------
// Add the ORDER BY clause to the query.
// ----------------------------------------------------
if (count($query->orderings) > 0)
{
$sql .= ' ORDER BY '.implode(', ', $query->orderings);
}
// ----------------------------------------------------
// Add the LIMIT clause to the query.
// ----------------------------------------------------
if ( ! is_null($query->limit))
{
$sql .= ' LIMIT '.$query->limit;
}
// ----------------------------------------------------
// Add the OFFSET clause to the query.
// ----------------------------------------------------
if ( ! is_null($query->offset))
{
$sql .= ' OFFSET '.$query->offset;
......@@ -39,11 +51,14 @@ class Compiler {
*/
public static function insert($query, $values)
{
// -----------------------------------------------------
// Begin the INSERT statement.
// -----------------------------------------------------
$sql = 'INSERT INTO '.$query->table.' (';
// ---------------------------------------------------
// ----------------------------------------------------
// Wrap each column name in keyword identifiers.
// ---------------------------------------------------
// ----------------------------------------------------
$columns = array();
foreach (array_keys($values) as $column)
......@@ -51,6 +66,9 @@ class Compiler {
$columns[] = $query->wrap($column);
}
// -----------------------------------------------------
// Concatenante the columns and values to the statement.
// -----------------------------------------------------
return $sql .= implode(', ', $columns).') VALUES ('.$query->parameterize($values).')';
}
......@@ -63,10 +81,13 @@ class Compiler {
*/
public static function update($query, $values)
{
// ----------------------------------------------------
// Initialize the UPDATE statement.
// ----------------------------------------------------
$sql = 'UPDATE '.$query->table.' SET ';
// ---------------------------------------------------
// Add each column set the query.
// Add each column set the statement.
// ---------------------------------------------------
$columns = array();
......@@ -75,6 +96,9 @@ class Compiler {
$columns[] = $query->wrap($column).' = ?';
}
// ---------------------------------------------------
// Concatenate the SETs to the statement.
// ---------------------------------------------------
return $sql .= implode(', ', $columns).' '.$query->where;
}
......
system/download.php
......@@ -109,6 +109,9 @@ class Download {
*/
public static function file($path, $name = null)
{
// -----------------------------------------------------
// If no filename was given, use the path basename.
// -----------------------------------------------------
if (is_null($name))
{
$name = basename($path);
......
system/error.php
......@@ -72,13 +72,13 @@ class Error {
if (Config::get('error.detail'))
{
$view = View::make('error/exception')
->bind('severity', $severity)
->bind('message', $message)
->bind('file', $file)
->bind('line', $e->getLine())
->bind('trace', $e->getTraceAsString())
->bind('contexts', static::context($file, $e->getLine()));
$view = View::make('exception')
->bind('severity', $severity)
->bind('message', $message)
->bind('file', $file)
->bind('line', $e->getLine())
->bind('trace', $e->getTraceAsString())
->bind('contexts', static::context($file, $e->getLine()));
Response::make($view, 500)->send();
}
......
system/filter.php
......@@ -14,15 +14,22 @@ class Filter {
*
* @param string $filter
* @param array $parameters
* @param bool $override
* @return mixed
*/
public static function call($filters, $parameters = array())
public static function call($filters, $parameters = array(), $override = false)
{
// --------------------------------------------------------------
// Load the filters if necessary.
// --------------------------------------------------------------
if (is_null(static::$filters))
{
static::$filters = require APP_PATH.'filters'.EXT;
}
// --------------------------------------------------------------
// Filters can be comma-delimited, so spin through each one.
// --------------------------------------------------------------
foreach (explode(', ', $filters) as $filter)
{
if ( ! isset(static::$filters[$filter]))
......@@ -33,10 +40,13 @@ class Filter {
$response = call_user_func_array(static::$filters[$filter], $parameters);
// --------------------------------------------------------------
// If the filter returned a response, return it since route
// filters can override route methods.
// If overriding is set to true and the filter returned a
// response, return that response.
//
// Overriding allows for convenient halting of the request
// flow for things like authentication, CSRF protection, etc.
// --------------------------------------------------------------
if ( ! is_null($response))
if ( ! is_null($response) and $override)
{
return $response;
}
......
system/hash.php
......@@ -25,7 +25,14 @@ class Hash {
*/
public function __construct($value, $salt = null)
{
// -------------------------------------------------------
// If no salt is given, we'll create a random salt to
// use when hashing the password.
//
// Otherwise, we will use the given salt.
// -------------------------------------------------------
$this->salt = (is_null($salt)) ? Str::random(16) : $salt;
$this->value = sha1($value.$this->salt);
}
......
system/inflector.php
......@@ -121,6 +121,9 @@ class Inflector {
*/
public static function plural($value)
{
// -----------------------------------------------------
// If we have already pluralized this word, return it.
// -----------------------------------------------------
if (array_key_exists($value, static::$plural_cache))
{
return static::$plural_cache[$value];
......@@ -169,6 +172,9 @@ class Inflector {
*/
public static function singular($value)
{
// -----------------------------------------------------
// If we have already singularized this word, return it.
// -----------------------------------------------------
if (array_key_exists($value, static::$singular_cache))
{
return static::$singular_cache[$value];
......
system/input.php
......@@ -21,27 +21,34 @@ class Input {
}
/**
* Determine if the old input data contains an item.
* Get an item from the input data.
*
* @param string $key
* @return bool
* @param mixed $default
* @return string
*/
public static function has_old($key)
public static function get($key = null, $default = null)
{
return ( ! is_null(static::old($key)));
// -----------------------------------------------------
// Has the input data been hydrated for the request?
// -----------------------------------------------------
if (is_null(static::$input))
{
static::hydrate();
}
return static::from_array(static::$input, $key, $default);
}
/**
* Get an item from the input data.
* Determine if the old input data contains an item.
*
* @param string $key
* @param mixed $default
* @return string
* @return bool
*/
public static function get($key = null, $default = null)
public static function has_old($key)
{
static::hydrate();
return static::from_array(static::$input, $key, $default);
return ( ! is_null(static::old($key)));
}
/**
......@@ -86,39 +93,36 @@ class Input {
*/
public static function hydrate()
{
if (is_null(static::$input))
switch (Request::method())
{
switch (Request::method())
{
case 'GET':
static::$input =& $_GET;
break;
case 'GET':
static::$input =& $_GET;
break;
case 'POST':
static::$input =& $_POST;
break;
case 'POST':
static::$input =& $_POST;
break;
case 'PUT':
case 'DELETE':
// ----------------------------------------------------------------------
// Typically, browsers do not support PUT and DELETE methods on HTML
// forms. So, we simulate them using a hidden POST variable.
//
// If the request method is being "spoofed", we'll move the POST array
// into the PUT / DELETE array.
// ----------------------------------------------------------------------
if (isset($_POST['request_method']) and ($_POST['request_method'] == 'PUT' or $_POST['request_method'] == 'DELETE'))
{
static::$input =& $_POST;
}
// ----------------------------------------------------------------------
// If the request is a true PUT request, read the php://input file.
// ----------------------------------------------------------------------
else
{
parse_str(file_get_contents('php://input'), static::$input);
}
}
case 'PUT':
case 'DELETE':
// ----------------------------------------------------------------------
// Typically, browsers do not support PUT and DELETE methods on HTML
// forms. So, we simulate them using a hidden POST variable.
//
// If the request method is being "spoofed", we'll move the POST array
// into the PUT / DELETE array.
// ----------------------------------------------------------------------
if (isset($_POST['request_method']) and ($_POST['request_method'] == 'PUT' or $_POST['request_method'] == 'DELETE'))
{
static::$input =& $_POST;
}
// ----------------------------------------------------------------------
// If the request is a true PUT request, read the php://input file.
// ----------------------------------------------------------------------
else
{
parse_str(file_get_contents('php://input'), static::$input);
}
}
}
......
system/lang.php
......@@ -65,8 +65,14 @@ class Lang {
$language = Config::get('application.language');
}
// -----------------------------------------------------
// Parse the key to separate the file and key name.
// -----------------------------------------------------
list($file, $line) = $this->parse($this->key);
// -----------------------------------------------------
// Load the appropriate language file.
// -----------------------------------------------------
$this->load($file, $language);
// --------------------------------------------------------------
......@@ -107,6 +113,10 @@ class Lang {
throw new \Exception("Invalid language key [$key].");
}
// --------------------------------------------------------------
// The left side of the dot is the file name, while the right
// side of the dot is the item within that file being requested.
// --------------------------------------------------------------
return array($segments[0], implode('.', array_slice($segments, 1)));
}
......@@ -119,6 +129,9 @@ class Lang {
*/
private function load($file, $language)
{
// --------------------------------------------------------------
// If we have already loaded the language file, bail out.
// --------------------------------------------------------------
if (in_array($language.$file, static::$loaded))
{
return;
......
system/loader.php
......@@ -18,18 +18,30 @@ return function($class) {
return class_alias($aliases[$class], $class);
}
// ----------------------------------------------------------
// Is the class a Laravel framework class?
// ----------------------------------------------------------
if (file_exists($path = BASE_PATH.$file.EXT))
{
require $path;
}
// ----------------------------------------------------------
// Is the class in the application/models directory?
// ----------------------------------------------------------
elseif (file_exists($path = APP_PATH.'models/'.$file.EXT))
{
require $path;
}
// ----------------------------------------------------------
// Is the class in the application/packages directory?
// ----------------------------------------------------------
elseif (file_exists($path = APP_PATH.'packages/'.$file.EXT))
{
require $path;
}
// ----------------------------------------------------------
// Is the class anywhere in the application directory?
// ----------------------------------------------------------
elseif (file_exists($path = APP_PATH.$file.EXT))
{
require $path;
......
system/redirect.php
......@@ -3,6 +3,24 @@
class Redirect {
/**
* The redirect response.
*
* @var Response
*/
public $response;
/**
* Create a new redirect instance.
*
* @param Response $response
* @return void
*/
public function __construct($response)
{
$this->response = $response;
}
/**
* Create a redirect response.
*
* @param string $url
......@@ -16,8 +34,29 @@ class Redirect {
$url = URL::to($url, $https);
return ($method == 'refresh')
? Response::make('', $status)->header('Refresh', '0;url='.$url)
: Response::make('', $status)->header('Location', $url);
? new static(Response::make('', $status)->header('Refresh', '0;url='.$url))
: new static(Response::make('', $status)->header('Location', $url));
}
/**
* Add an item to the session flash data.
*
* @param string $key
* @param mixed $value
* @return Response
*/
public function with($key, $value)
{
// ----------------------------------------------------
// Since this method uses sessions, make sure a driver
// has been specified in the configuration file.
// ----------------------------------------------------
if (Config::get('session.driver') != '')
{
Session::flash($key, $value);
}
return $this;
}
/**
......
system/request.php
......@@ -16,44 +16,43 @@ class Request {
*/
public static function uri()
{
// -------------------------------------------------------
// If we have already determined the URI, return it.
// -------------------------------------------------------
if ( ! is_null(static::$uri))
{
return static::$uri;
}
// -------------------------------------------------------
// If the PATH_INFO is available, use it.
// -------------------------------------------------------
if (isset($_SERVER['PATH_INFO']))
{
return static::$uri = static::tidy($_SERVER['PATH_INFO']);
$uri = $_SERVER['PATH_INFO'];
}
if ( ! isset($_SERVER['REQUEST_URI']))
// -------------------------------------------------------
// No PATH_INFO? Let's try REQUEST_URI.
// -------------------------------------------------------
elseif (isset($_SERVER['REQUEST_URI']))
{
throw new \Exception('Unable to determine the request URI.');
$uri = str_replace('/index.php', '', $_SERVER['REQUEST_URI']);
}
$uri = parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH);
// --------------------------------------------------------------
// Slice the application URL off of the URI.
// --------------------------------------------------------------
if (strpos($uri, $base_url = parse_url(Config::get('application.url'), PHP_URL_PATH)) === 0)
// -------------------------------------------------------
// Neither PATH_INFO or REQUEST_URI are available.
// -------------------------------------------------------
else
{
$uri = substr($uri, strlen($base_url));
throw new \Exception('Unable to determine the request URI.');
}
return static::$uri = static::tidy($uri);
}
$uri = trim($uri, '/');
/**
* Tidy up a URI for use by Laravel. For empty URIs, a forward
* slash will be returned.
*
* @param string $uri
* @return string
*/
private static function tidy($uri)
{
return ($uri != '/') ? Str::lower(trim($uri, '/')) : '/';
// -------------------------------------------------------
// If the requests is to the root of the application, we
// always return a single forward slash.
// -------------------------------------------------------
return static::$uri = ($uri == '') ? '/' : Str::lower($uri);
}
/**
......@@ -64,8 +63,8 @@ class Request {
public static function method()
{
// --------------------------------------------------------------
// The method can be spoofed using a POST variable. This allows
// HTML forms to simulate PUT and DELETE methods.
// The method can be spoofed using a POST variable, allowing HTML
// forms to simulate PUT and DELETE requests.
// --------------------------------------------------------------
return (isset($_POST['request_method'])) ? $_POST['request_method'] : $_SERVER['REQUEST_METHOD'];
}
......
system/response.php
......@@ -102,15 +102,25 @@ class Response {
}
/**
* Factory for creating new view response instances.
* Take a value returned by a route and prepare a Response instance.
*
* @param string $view
* @param int $status
* @param mixed $response
* @return Response
*/
public static function view($view, $status = 200)
public static function prepare($response)
{
return static::make(View::make($view), $status);
// --------------------------------------------------------------
// If the response is a Redirect instance, grab the Response.
// --------------------------------------------------------------
if ($response instanceof Redirect)
{
$response = $response->response;
}
// --------------------------------------------------------------
// Make sure the response is an instance of the Response class.
// --------------------------------------------------------------
return ( ! $response instanceof Response) ? new static($response) : $response;
}
/**
......@@ -120,6 +130,9 @@ class Response {
*/
public function send()
{
// -------------------------------------------------
// If a Content-Type header has not been set, do it.
// -------------------------------------------------
if ( ! array_key_exists('Content-Type', $this->headers))
{
$this->header('Content-Type', 'text/html; charset=utf-8');
......@@ -130,14 +143,7 @@ class Response {
// -------------------------------------------------
if ( ! headers_sent())
{
$protocol = (isset($_SERVER['SERVER_PROTOCOL'])) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.1';
header($protocol.' '.$this->status.' '.$this->statuses[$this->status]);
foreach ($this->headers as $name => $value)
{
header($name.': '.$value, true);
}
$this->send_headers();
}
// -------------------------------------------------
......@@ -147,32 +153,41 @@ class Response {
}
/**
* Add a header to the response.
* Send the response headers to the browser.
*
* @param string $name
* @param string $value
* @return Response
* @return void
*/
public function header($name, $value)
public function send_headers()
{
$this->headers[$name] = $value;
return $this;
// -------------------------------------------------
// Get the proper protocol.
// -------------------------------------------------
$protocol = (isset($_SERVER['SERVER_PROTOCOL'])) ? $_SERVER['SERVER_PROTOCOL'] : 'HTTP/1.1';
// -------------------------------------------------
// Send the protocol and status header.
// -------------------------------------------------
header($protocol.' '.$this->status.' '.$this->statuses[$this->status]);
// -------------------------------------------------
// Send the rest of the response headers.
// -------------------------------------------------
foreach ($this->headers as $name => $value)
{
header($name.': '.$value, true);
}
}
/**
* Add an item to the session flash data.
* Add a header to the response.
*
* @param string $key
* @param mixed $value
* @param string $name
* @param string $value
* @return Response
*/
public function with($key, $value)
public function header($name, $value)
{
if (Config::get('session.driver') != '')
{
Session::flash($key, $value);
}
$this->headers[$name] = $value;
return $this;
}
......@@ -186,58 +201,4 @@ class Response {
return $this->status == 301 or $this->status == 302;
}
/**
* Magic Method for getting response View data.
*/
public function __get($key)
{
// ------------------------------------------------------
// Attempt to get the data from the View.
// ------------------------------------------------------
if ($this->content instanceof View)
{
return $this->content->$key;
}
}
/**
* Magic Method for setting response View data.
*/
public function __set($key, $value)
{
// ------------------------------------------------------
// Attempt to set the data on the View.
// ------------------------------------------------------
if ($this->content instanceof View)
{
$this->content->bind($key, $value);
}
}
/**
* Magic Method for handling dynamic method calls.
*/
public function __call($method, $parameters)
{
// ------------------------------------------------------
// Attempt to the pass the method to the View instance.
// ------------------------------------------------------
if ($this->content instanceof View and method_exists($this->content, $method))
{
call_user_func_array(array($this->content, $method), $parameters);
return $this;
}
throw new \Exception("Method [$method] does not exist on the Response class.");
}
/**
* Get the content of the response.
*/
public function __toString()
{
return (string) $this->content;
}
}
\ No newline at end of file
system/route.php
......@@ -55,7 +55,7 @@ class Route {
// --------------------------------------------------------------
// Call the "before" route filters.
// --------------------------------------------------------------
$response = isset($this->route['before']) ? Filter::call($this->route['before']) : null;
$response = isset($this->route['before']) ? Filter::call($this->route['before'], array(), true) : null;
// --------------------------------------------------------------
// Call the route callback.
......@@ -66,7 +66,7 @@ class Route {
}
}
$response = ( ! $response instanceof Response) ? new Response($response) : $response;
$response = Response::prepare($response);
// --------------------------------------------------------------
// Call the "after" route filters.
......
system/route/finder.php 0 → 100644
<?php namespace System\Route;
class Finder {
/**
* All of the loaded routes.
*
* @var array
*/
public static $routes;
/**
* The named routes that have been found so far.
*
* @var array
*/
public static $names = array();
/**
* Find a route by name.
*
* @param string $name
* @return array
*/
public static function find($name)
{
// --------------------------------------------------------------
// Load the routes if we haven't already.
// --------------------------------------------------------------
if (is_null(static::$routes))
{
static::$routes = (is_dir(APP_PATH.'routes')) ? static::load() : require APP_PATH.'routes'.EXT;
}
// --------------------------------------------------------------
// Have we already located this route by name?
// --------------------------------------------------------------
if (array_key_exists($name, static::$names))
{
return static::$names[$name];
}
// --------------------------------------------------------------
// Instantiate the SPL array iterators.
// --------------------------------------------------------------
$arrayIterator = new \RecursiveArrayIterator(static::$routes);
$recursiveIterator = new \RecursiveIteratorIterator($arrayIterator);
// --------------------------------------------------------------
// Iterate over the routes and find the named route.
// --------------------------------------------------------------
foreach ($recursiveIterator as $iterator)
{
$route = $recursiveIterator->getSubIterator();
if ($route['name'] == $name)
{
return static::$names[$name] = array($arrayIterator->key() => iterator_to_array($route));
}
}
}
/**
* Load all of the routes from the routes directory.
*
* @return array
*/
private static function load()
{
$routes = array();
// --------------------------------------------------------------
// Merge all of the various route files together.
// --------------------------------------------------------------
foreach (glob(APP_PATH.'routes/*') as $file)
{
if (filetype($file) == 'file')
{
$routes = array_merge(require $file, $routes);
}
}
return $routes;
}
}
\ No newline at end of file
system/route/loader.php 0 → 100644
<?php namespace System\Route;
class Loader {
/**
* Load the route file based on the first segment of the URI.
*
* @param string $uri
* @return void
*/
public static function load($uri)
{
// --------------------------------------------------------------
// If a single routes is being used, return it.
// --------------------------------------------------------------
if ( ! is_dir(APP_PATH.'routes'))
{
return require APP_PATH.'routes'.EXT;
}
// --------------------------------------------------------------
// If the request is to the root, load the "home" routes file.
// --------------------------------------------------------------
if ($uri == '/')
{
if ( ! file_exists(APP_PATH.'routes/home'.EXT))
{
throw new \Exception("A [home] route file is required when using a route directory.");
}
return require APP_PATH.'routes/home'.EXT;
}
// --------------------------------------------------------------
// Load the route file matching the first segment of the URI.
// --------------------------------------------------------------
else
{
$segments = explode('/', trim($uri, '/'));
if ( ! file_exists(APP_PATH.'routes/'.$segments[0].EXT))
{
throw new \Exception("No route file defined for routes beginning with [".$segments[0]."]");
}
return array_merge(require APP_PATH.'routes/'.$segments[0].EXT, require APP_PATH.'routes/home'.EXT);
}
}
}
\ No newline at end of file
system/route/parser.php 0 → 100644
<?php namespace System\Route;
class Parser {
/**
* Get the parameters that should be passed to the route callback.
*
* @param string $uri
* @param string $route
* @return array
*/
public static function parameters($uri, $route)
{
// --------------------------------------------------------------
// Split the request URI into segments.
// --------------------------------------------------------------
$uri_segments = explode('/', $uri);
// --------------------------------------------------------------
// Split the route URI into segments.
// --------------------------------------------------------------
$route_segments = explode('/', $route);
// --------------------------------------------------------------
// Initialize the array of parameters.
// --------------------------------------------------------------
$parameters = array();
// --------------------------------------------------------------
// Extract all of the parameters out of the URI.
//
// Any segment wrapped in parentheses is considered a parameter.
// --------------------------------------------------------------
for ($i = 0; $i < count($route_segments); $i++)
{
if (strpos($route_segments[$i], '(') === 0)
{
$parameters[] = $uri_segments[$i];
}
}
return $parameters;
}
}
\ No newline at end of file
system/router.php
......@@ -10,13 +10,6 @@ class Router {
public static $routes;
/**
* The named routes that have been found so far.
*
* @var array
*/
public static $names = array();
/**
* Search a set of routes for the route matching a method and URI.
*
* @param string $method
......@@ -35,7 +28,7 @@ class Router {
// --------------------------------------------------------------
if (is_null(static::$routes))
{
static::$routes = static::routes($uri);
static::$routes = Route\Loader::load($uri);
}
// --------------------------------------------------------------
......@@ -59,118 +52,18 @@ class Router {
{
foreach (explode(', ', $keys) as $route)
{
// --------------------------------------------------------------
// Convert the route wild-cards to regular expressions.
// --------------------------------------------------------------
$route = str_replace(':num', '[0-9]+', str_replace(':any', '.+', $route));
if (preg_match('#^'.$route.'$#', $method.' '.$uri))
{
return new Route($callback, static::parameters(explode('/', $uri), explode('/', $route)));
return new Route($callback, Route\Parser::parameters($uri, $route));
}
}
}
}
}
/**
* Find a route by name.
*
* @param string $name
* @return array
*/
public static function find($name)
{
// --------------------------------------------------------------
// Have we already located this route by name?
// --------------------------------------------------------------
if (array_key_exists($name, static::$names))
{
return static::$names[$name];
}
$arrayIterator = new \RecursiveArrayIterator(static::$routes);
$recursiveIterator = new \RecursiveIteratorIterator($arrayIterator);
// --------------------------------------------------------------
// Find the named route.
// --------------------------------------------------------------
foreach ($recursiveIterator as $iterator)
{
$route = $recursiveIterator->getSubIterator();
if ($route['name'] == $name)
{
return static::$names[$name] = array($arrayIterator->key() => iterator_to_array($route));
}
}
}
/**
* Get the parameters that should be passed to the route callback.
*
* @param array $uri_segments
* @param array $route_segments
* @return array
*/
private static function parameters($uri_segments, $route_segments)
{
$parameters = array();
for ($i = 0; $i < count($route_segments); $i++)
{
// --------------------------------------------------------------
// Any segment wrapped in parentheses is a parameter.
// --------------------------------------------------------------
if (strpos($route_segments[$i], '(') === 0)
{
$parameters[] = $uri_segments[$i];
}
}
return $parameters;
}
/**
* Load the routes based on the request URI.
*
* @param string $uri
* @return void
*/
private static function routes($uri)
{
// --------------------------------------------------------------
// If a route directory is being used, load the route file
// corresponding to the first segment of the URI.
// --------------------------------------------------------------
if (is_dir(APP_PATH.'routes'))
{
if ($uri == '/')
{
if ( ! file_exists(APP_PATH.'routes/home'.EXT))
{
throw new \Exception("A [home] route file is required when using a route directory.");
}
return require APP_PATH.'routes/home'.EXT;
}
else
{
$segments = explode('/', trim($uri, '/'));
if ( ! file_exists(APP_PATH.'routes/'.$segments[0].EXT))
{
throw new \Exception("No route file defined for routes beginning with [".$segments[0]."]");
}
return require APP_PATH.'routes/'.$segments[0].EXT;
}
}
// --------------------------------------------------------------
// If no route directory is being used, we can simply load the
// routes file from the application directory.
// --------------------------------------------------------------
else
{
return require APP_PATH.'routes'.EXT;
}
}
}
\ No newline at end of file
system/session.php
......@@ -23,6 +23,9 @@ class Session {
*/
public static function driver()
{
// -----------------------------------------------------
// Create the session driver if we haven't already.
// -----------------------------------------------------
if (is_null(static::$driver))
{
static::$driver = Session\Factory::make(Config::get('session.driver'));
......@@ -110,21 +113,6 @@ class Session {
}
/**
* Get an item from the session and delete it.
*
* @param string $key
* @return mixed
*/
public static function once($key, $default = null)
{
$value = static::get($key, $default);
static::forget($key);
return $value;
}
/**
* Write an item to the session.
*
* @param string $key
......@@ -187,9 +175,19 @@ class Session {
*/
public static function close()
{
// -----------------------------------------------------
// Flash the old input data to the session.
// -----------------------------------------------------
static::flash('laravel_old_input', Input::get());
// -----------------------------------------------------
// Age the flash data.
// -----------------------------------------------------
static::age_flash();
// -----------------------------------------------------
// Save the session data to storage.
// -----------------------------------------------------
static::driver()->save(static::$session);
// -----------------------------------------------------
......
system/url.php
......@@ -52,13 +52,13 @@ class URL {
*/
public static function to_route($name, $parameters = array(), $https = false)
{
if ( ! is_null($route = Router::find($name)))
if ( ! is_null($route = Route\Finder::find($name)))
{
$uris = explode(', ', key($route));
// ----------------------------------------------------
// Get the first URI assigned to the route.
// ----------------------------------------------------
$uris = explode(', ', key($route));
$uri = substr($uris[0], strpos($uris[0], '/'));
// ----------------------------------------------------
......@@ -76,6 +76,18 @@ class URL {
}
/**
* Generate a HTTPS URL from a route name.
*
* @param string $name
* @param array $parameters
* @return string
*/
public static function to_secure_route($name, $parameters = array())
{
return static::to_route($name, $parameters, true);
}
/**
* Generate a URL friendly "slug".
*
* @param string $title
......
system/view.php
......@@ -56,10 +56,16 @@ class View {
*/
private function load($view)
{
// -----------------------------------------------------
// Does the view exist in the application directory?
// -----------------------------------------------------
if (file_exists($path = APP_PATH.'views/'.$view.EXT))
{
return file_get_contents($path);
}
// -----------------------------------------------------
// Does the view exist in the system directory?
// -----------------------------------------------------
elseif (file_exists($path = SYS_PATH.'views/'.$view.EXT))
{
return file_get_contents($path);
......@@ -90,6 +96,9 @@ class View {
*/
public function get()
{
// -----------------------------------------------------
// Set the last rendered view name to the current view.
// -----------------------------------------------------
static::$last = $this->view;
// -----------------------------------------------------
......@@ -103,8 +112,14 @@ class View {
}
}
// -----------------------------------------------------
// Extract the view data into the local scope.
// -----------------------------------------------------
extract($this->data, EXTR_SKIP);
// -----------------------------------------------------
// Get the string content of the view.
// -----------------------------------------------------
ob_start();
echo eval('?>'.$this->load($this->view));
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment