Skip to content

U
UserAdminV2
Commit f0f3dffc by Taylor Otwell
Options

added module support!

parent 927c522e
Showing with 366 additions and 204 deletions
application/config/.gitignore deleted 100644 → 0
local/*
\ No newline at end of file
application/config/application.php
......@@ -65,6 +65,42 @@ return array(
/*
|--------------------------------------------------------------------------
| Auto-Loaded Packages
|--------------------------------------------------------------------------
|
| The packages that should be auto-loaded each time Laravel handles
| a request. These should generally be packages that you use on almost
| every request to your application.
|
| Each package specified here will be bootstrapped and can be conveniently
| used by your application's routes, models, and libraries.
|
| Note: The package names in this array should correspond to a package
| directory in application/packages.
|
*/
'packages' => array(),
/*
|--------------------------------------------------------------------------
| Active Modules
|--------------------------------------------------------------------------
|
| Modules are a convenient way to organize your application into logical
| components. Each module may have its own libraries, models, routes,
| views, language files, and configuration.
|
| Here you may specify which modules are "active" for your application.
| This simply gives Laravel an easy way to know which directories to
| check when auto-loading your classes, routes, and views.
|
*/
'modules' => array(),
/*
|--------------------------------------------------------------------------
| Application Key
|--------------------------------------------------------------------------
|
......
application/config/error.php
......@@ -50,7 +50,7 @@ return array(
|
*/
'logger' => function($severity, $message)
'logger' => function($severity, $message, $trace)
{
File::append(STORAGE_PATH.'log.txt', date('Y-m-d H:i:s').' '.$severity.' - '.$message.PHP_EOL);
},
......
application/config/local/application.php 0 → 100644
<?php
return array(
'url' => 'http://localhost/laravel/public'
);
\ No newline at end of file
application/config/package.php deleted 100644 → 0
<?php
return array(
/*
|--------------------------------------------------------------------------
| Auto-Loaded Packages
|--------------------------------------------------------------------------
|
| The packages that should be auto-loaded each time Laravel handles
| a request. These should generally be packages that you use on almost
| every request to your application.
|
| Each package specified here will be bootstrapped and can be conveniently
| used by your application's routes, models, and libraries.
|
| Note: The package names in this array should correspond to a package
| directory in application/packages.
|
*/
'autoload' => array(),
);
\ No newline at end of file
application/config/view.php deleted 100644 → 0
<?php
return array(
/*
|--------------------------------------------------------------------------
| Named Views
|--------------------------------------------------------------------------
|
| All of the named views for your application. Once you have defined the
| named view, you can create a View instance for that view using the
| View::of dynamic method.
|
| For example, if you define a "layout" named view, you could create an
| instance of that View by calling: View::of_layout().
|
| For more info, check out: http://laravel.com/docs/start/views#named
|
*/
'names' => array(
'home' => 'home/index',
),
);
\ No newline at end of file
application/filters.php
......@@ -46,13 +46,13 @@ return array(
'before' => function()
{
// Do stuff before every request is executed.
// Do stuff before every request to your application.
},
'after' => function($response)
{
// Do stuff after every request is executed.
// Do stuff after every request to your application.
},
......
application/models/entities/user.php 0 → 100644
<?php
namespace Entities;
class User extends \Eloquent {
public function friends()
{
return $this->has_many('Entities\\Friend');
}
public function roles()
{
return $this->has_and_belongs_to_many('Role');
}
}
class Friend extends \Eloquent {}
\ No newline at end of file
application/models/role.php 0 → 100644
<?php
class Role extends \Eloquent {}
\ No newline at end of file
application/routes.php
......@@ -41,7 +41,7 @@ return array(
'GET /' => function()
{
return View::make('home/index');
return View::make('home.index');
},
);
\ No newline at end of file
application/storage/db/.gitignore deleted 100644 → 0
*.sqlite
\ No newline at end of file
application/composers.php → application/views/composers.php
......@@ -12,8 +12,7 @@ return array(
| footer partial each time the view is created.
|
| The composer will receive an instance of the view being created, and is
| free to modify the view however you wish. Be sure to always return the
| view instance at the end of your composer.
| free to modify the view however you wish.
|
| For more information, check out: http://laravel.com/docs/start/views#composers
|
......@@ -21,7 +20,7 @@ return array(
'home/index' => function($view)
{
return $view;
// Do anything you want to the view.
},
);
\ No newline at end of file
application/views/home/index.php
......@@ -84,7 +84,7 @@
</div>
<div class="wrapper footer">
<?php echo System\Benchmark::check('laravel').'ms | '.System\Benchmark::memory(); ?>
<?php echo System\Benchmark::check('laravel').'ms | '.System\Benchmark::memory().'mb'; ?>
</div>
</body>
</html>
\ No newline at end of file
public/.htaccess deleted 100644 → 0
<IfModule mod_rewrite.c>
RewriteEngine on
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php/$1 [L]
</IfModule>
\ No newline at end of file
public/index.php
......@@ -3,7 +3,7 @@
* Laravel - A clean and classy framework for PHP web development.
*
* @package Laravel
* @version 1.4.1
* @version 1.5.0
* @author Taylor Otwell
* @link http://laravel.com
*/
......@@ -24,30 +24,43 @@ define('APP_PATH', realpath('../application').'/');
define('SYS_PATH', realpath($system = '../system').'/');
// --------------------------------------------------------------
// The path to the directory containing the system directory.
// The path to the public directory.
// --------------------------------------------------------------
define('BASE_PATH', realpath(str_replace('system', '', $system)).'/');
define('PUBLIC_PATH', realpath(__DIR__).'/');
// --------------------------------------------------------------
// The path to the public directory.
// The path to the packages directory.
// --------------------------------------------------------------
define('PUBLIC_PATH', realpath(__DIR__).'/');
define('PACKAGE_PATH', realpath('../packages').'/');
// --------------------------------------------------------------
// The path to the modules directory.
// --------------------------------------------------------------
define('MODULE_PATH', realpath('../modules').'/');
// --------------------------------------------------------------
// The path to the storage directory.
// --------------------------------------------------------------
define('STORAGE_PATH', realpath('../storage').'/');
// --------------------------------------------------------------
// The path to the directory containing the system directory.
// --------------------------------------------------------------
define('BASE_PATH', realpath(str_replace('system', '', $system)).'/');
// --------------------------------------------------------------
// Define various other framework paths.
// --------------------------------------------------------------
$constants = array(
'CACHE_PATH' => APP_PATH.'storage/cache/',
'CACHE_PATH' => STORAGE_PATH.'cache/',
'CONFIG_PATH' => APP_PATH.'config/',
'DATABASE_PATH' => APP_PATH.'storage/db/',
'DATABASE_PATH' => STORAGE_PATH.'db/',
'LANG_PATH' => APP_PATH.'lang/',
'LIBRARY_PATH' => APP_PATH.'libraries/',
'MODEL_PATH' => APP_PATH.'models/',
'PACKAGE_PATH' => APP_PATH.'packages/',
'ROUTE_PATH' => APP_PATH.'routes/',
'SCRIPT_PATH' => PUBLIC_PATH.'js/',
'SESSION_PATH' => APP_PATH.'storage/sessions/',
'STORAGE_PATH' => APP_PATH.'storage/',
'SESSION_PATH' => STORAGE_PATH.'sessions/',
'STYLE_PATH' => PUBLIC_PATH.'css/',
'VIEW_PATH' => APP_PATH.'views/',
);
......@@ -70,7 +83,6 @@ define('EXT', '.php');
require SYS_PATH.'loader'.EXT;
require SYS_PATH.'config'.EXT;
require SYS_PATH.'arr'.EXT;
// --------------------------------------------------------------
// Register the auto-loader.
// --------------------------------------------------------------
......@@ -145,7 +157,7 @@ require SYS_PATH.'routing/filter'.EXT;
// --------------------------------------------------------------
require SYS_PATH.'package'.EXT;
System\Package::load(System\Config::get('package.autoload'));
System\Package::load(System\Config::get('application.packages'));
// --------------------------------------------------------------
// Register the route filters.
......@@ -157,12 +169,28 @@ System\Routing\Filter::register(require APP_PATH.'filters'.EXT);
// --------------------------------------------------------------
$response = System\Routing\Filter::call('before', array(), true);
// ----------------------------------------------------------
// --------------------------------------------------------------
// Execute the route function.
// ----------------------------------------------------------
// --------------------------------------------------------------
if (is_null($response))
{
$route = System\Routing\Router::make(System\Request::method(), System\Request::uri(), new System\Routing\Loader(APP_PATH))->route();
$segments = explode('/', $uri = Request::uri());
if (in_array($segments[0], System\Config::get('application.modules')))
{
$route_path = MODULE_PATH.$segments[0].'/';
if (file_exists($filters = $route_path.'filters'.EXT))
{
System\Routing\Filter::register(require $filters);
}
}
else
{
$route_path = APP_PATH;
}
$route = System\Routing\Router::make(System\Request::method(), $uri, new System\Routing\Loader($route_path))->route();
$response = (is_null($route)) ? System\Response::error('404') : $route->call();
}
......@@ -171,14 +199,14 @@ else
$response = System\Response::prepare($response);
}
// ----------------------------------------------------------
// --------------------------------------------------------------
// Execute the global "after" filter.
// ----------------------------------------------------------
// --------------------------------------------------------------
System\Routing\Filter::call('after', array($response));
// ----------------------------------------------------------
// --------------------------------------------------------------
// Stringify the response.
// ----------------------------------------------------------
// --------------------------------------------------------------
$response->content = (string) $response->content;
// --------------------------------------------------------------
......
readme.md
......@@ -6,32 +6,22 @@ Laravel is a clean and classy framework for PHP web development. Freeing you fro
Stay true to the web with RESTful routing:
```php
<?php
'GET /' => function()
{
return View::make('home/index');
}
```
'GET /' => function()
{
return View::make('home/index');
}
Redirect to a named route and flash something to the session:
```php
<?php return Redirect::to_profile()->with('message', 'Welcome Back!');
```
return Redirect::to_profile()->with('message', 'Welcome Back!');
Retrieve a blog post and eagerly load the comments using Eloquent ORM:
```php
<?php $posts = Post::with('comments')->find(1);
```
$posts = Post::with('comments')->find(1);
Get input from the previous request to re-populate a form:
```php
<?php echo Input::old('email');
```
echo Input::old('email');
### Ready To Learn More?
......
system/config.php
......@@ -36,21 +36,19 @@ class Config {
*/
public static function get($key, $default = null)
{
if (strpos($key, '.') === false)
{
static::load($key);
list($module, $file, $key) = static::parse($key);
return Arr::get(static::$items, $key, $default);
if ( ! static::load($module, $file))
{
return is_callable($default) ? call_user_func($default) : $default;
}
list($file, $key) = static::parse($key);
if ( ! static::load($file))
if (is_null($key))
{
return is_callable($default) ? call_user_func($default) : $default;
return static::$items[$module][$file];
}
return Arr::get(static::$items[$file], $key, $default);
return Arr::get(static::$items[$module][$file], $key, $default);
}
/**
......@@ -62,11 +60,14 @@ class Config {
*/
public static function set($key, $value)
{
list($file, $key) = static::parse($key);
list($module, $file, $key) = static::parse($key);
static::load($file);
if (is_null($key) or ! static::load($module, $file))
{
throw new \Exception("Unable to find configuration file item [$key].");
}
static::$items[$file][$key] = $value;
static::$items[$module][$file][$key] = $value;
}
/**
......@@ -80,14 +81,24 @@ class Config {
*/
private static function parse($key)
{
$segments = explode('.', $key);
// Check for a module qualifier. If a module name is present, we need to extract it from
// the configuration key, otherwise, we will use "application" as the module.
$module = (strpos($key, '::') !== false) ? substr($key, 0, strpos($key, ':')) : 'application';
if (count($segments) < 2)
// If the configuration item is stored in a module, we need to strip the module qualifier
// off of the configuration key before continuing.
if ($module != 'application')
{
throw new \Exception("Invalid configuration key [$key].");
$key = substr($key, strpos($key, ':') + 2);
}
return array($segments[0], implode('.', array_slice($segments, 1)));
$segments = explode('.', $key);
// If there is more than one segment, we need to splice together and portion of the
// configuration key that comes after the first segment, which is the file name.
$key = (count($segments) > 1) ? implode('.', array_slice($segments, 1)) : null;
return array($module, $segments[0], $key);
}
/**
......@@ -97,25 +108,32 @@ class Config {
* Any environment specific configuration files will be merged with the root file.
*
* @param string $file
* @param string $module
* @return bool
*/
public static function load($file)
public static function load($module, $file)
{
if (array_key_exists($file, static::$items)) return true;
// If the configuration items for this module and file have already been
// loaded, we can bail out of this method.
if (isset(static::$items[$module]) and array_key_exists($file, static::$items[$module])) return true;
$path = ($module === 'application') ? CONFIG_PATH : MODULE_PATH.$module.'/config/';
$config = (file_exists($path = CONFIG_PATH.$file.EXT)) ? require $path : array();
// Load the base configuration items for the module and file.
$config = (file_exists($base = $path.$file.EXT)) ? require $base : array();
if (isset($_SERVER['LARAVEL_ENV']) and file_exists($path = CONFIG_PATH.$_SERVER['LARAVEL_ENV'].'/'.$file.EXT))
// Merge any enviornment specific configuration items for the module and file.
if (isset($_SERVER['LARAVEL_ENV']) and file_exists($path = $path.$_SERVER['LARAVEL_ENV'].'/'.$file.EXT))
{
$config = array_merge($config, require $path);
}
if (count($config) > 0)
{
static::$items[$file] = $config;
static::$items[$module][$file] = $config;
}
return isset(static::$items[$file]);
return isset(static::$items[$module][$file]);
}
}
\ No newline at end of file
system/db/eloquent/model.php
......@@ -151,7 +151,22 @@ abstract class Model {
return $class::$table;
}
return strtolower(Inflector::plural($class));
return strtolower(Inflector::plural(static::model($class)));
}
/**
* Get an Eloquent model name without any namespaces.
*
* @param string|Model $model
* @return string
*/
public static function model($model)
{
$class = (is_object($model)) ? get_class($model) : $model;
$segments = array_reverse(explode('\\', $class));
return $segments[0];
}
/**
......@@ -254,7 +269,7 @@ abstract class Model {
*/
private function has_one_or_many($model, $foreign_key)
{
$this->relating_key = (is_null($foreign_key)) ? strtolower(get_class($this)).'_id' : $foreign_key;
$this->relating_key = (is_null($foreign_key)) ? strtolower(static::model($this)).'_id' : $foreign_key;
return static::query($model)->where($this->relating_key, '=', $this->id);
}
......@@ -308,11 +323,11 @@ abstract class Model {
// Allowing the overriding of the foreign and associated keys provides the flexibility for
// self-referential many-to-many relationships, such as a "buddy list".
$this->relating_key = (is_null($foreign_key)) ? strtolower(get_class($this)).'_id' : $foreign_key;
$this->relating_key = (is_null($foreign_key)) ? strtolower(static::model($this)).'_id' : $foreign_key;
// The associated key is the foreign key name of the related model. So, if the related model
// is "Role", the associated key on the intermediate table would be "role_id".
$associated_key = (is_null($associated_key)) ? strtolower($model).'_id' : $associated_key;
$associated_key = (is_null($associated_key)) ? strtolower(static::model($model)).'_id' : $associated_key;
return static::query($model)
->select(array(static::table($model).'.*'))
......@@ -325,13 +340,13 @@ abstract class Model {
*
* By default, the intermediate table name is the plural names of the models
* arranged alphabetically and concatenated with an underscore.
*
*
* @param string $model
* @return string
*/
private function intermediate_table($model)
{
$models = array(Inflector::plural($model), Inflector::plural(get_class($this)));
$models = array(Inflector::plural(static::model($model)), Inflector::plural(static::model($this)));
sort($models);
......
system/lang.php
......@@ -68,16 +68,16 @@ class Lang {
$language = Config::get('application.language');
}
list($file, $line) = $this->parse($this->key);
list($module, $file, $line) = $this->parse($this->key, $language);
$this->load($file, $language);
$this->load($module, $file, $language);
if ( ! isset(static::$lines[$language.$file][$line]))
if ( ! isset(static::$lines[$module][$language.$file][$line]))
{
return is_callable($default) ? call_user_func($default) : $default;
}
$line = static::$lines[$language.$file][$line];
$line = static::$lines[$module][$language.$file][$line];
foreach ($this->replacements as $key => $value)
{
......@@ -94,34 +94,51 @@ class Lang {
* while the right side of the dot is the item within that file.
*
* @param string $key
* @param string $language
* @return array
*/
private function parse($key)
private function parse($key, $language)
{
// Check for a module qualifier. If a module name is present, we need to extract it from
// the language line, otherwise, we will use "application" as the module.
$module = (strpos($key, '::') !== false) ? substr($key, 0, strpos($key, ':')) : 'application';
// If the language line is stored in a module, we need to strip the module qualifier
// off of the language key before continuing.
if ($module != 'application')
{
$key = substr($key, strpos($key, ':') + 2);
}
$segments = explode('.', $key);
if (count($segments) < 2)
if (count($segments) > 1)
{
throw new \Exception("Invalid language key [$key].");
return array($module, $segments[0], $segments[1]);
}
return array($segments[0], implode('.', array_slice($segments, 1)));
throw new \Exception("Invalid language line [$key]. A specific line must be specified.");
}
/**
* Load a language file.
*
* @param string $module
* @param string $file
* @param string $language
* @return void
*/
private function load($file, $language)
private function load($module, $file, $language)
{
if (array_key_exists($language.$file, static::$lines)) return;
// If the language lines for the given module, file, and language have already been
// loaded, we can bail out of this method.
if (isset(static::$lines[$module][$language.$file])) return;
$path = ($module === 'application') ? LANG_PATH : MODULE_PATH.$module.'/lang/';
if (file_exists($path = LANG_PATH.$language.'/'.$file.EXT))
if (file_exists($path = $path.$language.'/'.$file.EXT))
{
static::$lines[$language.$file] = require $path;
static::$lines[$module][$language.$file] = require $path;
}
}
......
system/loader.php
......@@ -17,22 +17,28 @@ class Loader {
private static $aliases = array();
/**
* All of the active modules.
*
* @var array
*/
private static $modules = array();
/**
* Bootstrap the auto-loader.
*
* @return void
*/
public static function bootstrap()
{
static::$aliases = require CONFIG_PATH.'aliases'.EXT;
static::$aliases = Config::get('aliases');
static::$modules = Config::get('application.modules');
}
/**
* Load a class file for a given class name.
*
* This function is registered on the SPL auto-loader stack by the front controller during each request.
*
* All Laravel class names follow a namespace to directory convention. So, if a class exists in
* application/libraries/user, it shouold be placed in the "User" namespace.
* All Laravel class names follow a namespace to directory convention.
*
* @param string $class
* @return void
......@@ -46,13 +52,60 @@ class Loader {
return class_alias(static::$aliases[$class], $class);
}
if ( ! static::load_from_registered($file))
{
static::load_from_module($file);
}
}
/**
* Load a class that is stored in the registered directories.
*
* @param string $file
* @return bool
*/
private static function load_from_registered($file)
{
foreach (static::$paths as $directory)
{
if (file_exists($path = $directory.$file.EXT))
{
require $path;
return;
return true;
}
}
}
/**
* Load a class that is stored in a module.
*
* @param string $file
* @return void
*/
private static function load_from_module($file)
{
// Since all module models and libraries must be namespaced to the
// module name, we'll extract the module name from the file.
$module = substr($file, 0, strpos($file, '/'));
if (in_array($module, static::$modules))
{
$module = MODULE_PATH.$module.'/';
// Slice the module name off of the filename. Even though module libraries
// and models are namespaced under the module, there will obviously not be
// a folder matching that namespace in the libraries or models directories
// of the module. Slicing it off will allow us to make a clean search for
// the relevant class file.
$file = substr($file, strpos($file, '/') + 1);
foreach (array($module.'models', $module.'libraries') as $directory)
{
if (file_exists($path = $directory.'/'.$file.EXT))
{
return require $path;
}
}
}
}
......
system/request.php
......@@ -46,7 +46,7 @@ class Request {
}
// Remove the application index page from the URI.
if (strpos($uri, $index = '/'.Config::get('application.index')) === 0)
if (strpos($uri, $index = '/index.php') === 0)
{
$uri = substr($uri, strlen($index));
}
......
system/routing/loader.php
<?php namespace System\Routing;
use System\Config;
class Loader {
/**
......@@ -35,19 +37,17 @@ class Loader {
*/
public function load($uri)
{
return array_merge($this->load_nested_routes($uri), require $this->path.'routes'.EXT);
return array_merge($this->load_nested_routes(explode('/', $uri)), require $this->path.'routes'.EXT);
}
/**
* Load the appropriate routes from the routes directory.
*
* @param string $uri
* @param array $segments
* @return array
*/
private function load_nested_routes($uri)
private function load_nested_routes($segments)
{
$segments = explode('/', $uri);
// Work backwards through the URI segments until we find the deepest possible
// matching route directory. Once we find it, we will return those routes.
foreach (array_reverse($segments, true) as $key => $value)
......@@ -75,19 +75,35 @@ class Loader {
{
if ( ! is_null(static::$routes) and ! $reload) return static::$routes;
$routes = require $path.'routes'.EXT;
// Merge all of the module paths in with the specified path so that all
// active module routes will also be loaded. So, by default, this method
// will search the application path and all active module paths for routes.
$paths = array_merge(array($path), array_map(function($module) { return MODULE_PATH.$module.'/'; }, Config::get('application.modules')));
// Since route files can be nested deep within the route directory, we need to
// recursively spin through the directory to find every file.
$directoryIterator = new \RecursiveDirectoryIterator($path.'routes');
$routes = array();
$recursiveIterator = new \RecursiveIteratorIterator($directoryIterator, \RecursiveIteratorIterator::SELF_FIRST);
foreach ($recursiveIterator as $file)
foreach ($paths as $path)
{
if (filetype($file) === 'file' and strpos($file, EXT) !== false)
if (file_exists($path.'routes'.EXT))
{
$routes = array_merge($routes, require $path.'routes'.EXT);
}
if (is_dir($path.'routes'))
{
$routes = array_merge(require $file, $routes);
// Since route files can be nested deep within the route directory, we need to
// recursively spin through the directory to find every file.
$directoryIterator = new \RecursiveDirectoryIterator($path.'routes');
$recursiveIterator = new \RecursiveIteratorIterator($directoryIterator, \RecursiveIteratorIterator::SELF_FIRST);
foreach ($recursiveIterator as $file)
{
if (filetype($file) === 'file' and strpos($file, EXT) !== false)
{
$routes = array_merge($routes, require $file);
}
}
}
}
......
system/routing/router.php
......@@ -40,12 +40,12 @@ class Router {
*
* @param string $method
* @param string $uri
* @param array $routes
* @param Loader $loader
* @return Router
*/
public static function make($method, $uri, $routes = null)
public static function make($method, $uri, $loader)
{
return new static($method, $uri, $routes);
return new static($method, $uri, $loader);
}
/**
......
system/view.php
......@@ -17,6 +17,13 @@ class View {
public $data = array();
/**
* The module that contains the view.
*
* @var string
*/
public $module;
/**
* The path to the view.
*
* @var string
......@@ -24,13 +31,20 @@ class View {
public $path;
/**
* The view composers.
* The defined view composers.
*
* @var array
*/
private static $composers;
/**
* The defined view names.
*
* @var array
*/
private static $names;
/**
* Create a new view instance.
*
* @param string $view
......@@ -39,15 +53,16 @@ class View {
*/
public function __construct($view, $data = array())
{
$this->view = $view;
$this->data = $data;
if ( ! file_exists($path = VIEW_PATH.$view.EXT))
list($this->module, $this->path, $this->view) = static::parse($view);
if ( ! file_exists($this->path.$this->view.EXT))
{
throw new \Exception("View [$view] does not exist.");
}
$this->path = $path;
$this->compose();
}
/**
......@@ -59,33 +74,49 @@ class View {
*/
public static function make($view, $data = array())
{
if (is_null(static::$composers))
return new static($view, $data);
}
/**
* Parse a view identifier and get the module, path, and view name.
*
* @param string $view
* @return array
*/
private static function parse($view)
{
// Check for a module qualifier. If a module name is present, we need to extract it from
// the view name, otherwise, we will use "application" as the module.
$module = (strpos($view, '::') !== false) ? substr($view, 0, strpos($view, ':')) : 'application';
$path = ($module == 'application') ? VIEW_PATH : MODULE_PATH.$module.'/views/';
// If the view is stored in a module, we need to strip the module qualifier off
// of the view name before continuing.
if ($module != 'application')
{
static::$composers = require APP_PATH.'composers'.EXT;
$view = substr($view, strpos($view, ':') + 2);
}
$instance = new static($view, $data);
return (isset(static::$composers[$view])) ? call_user_func(static::$composers[$view], $instance) : $instance;
return array($module, $path, str_replace('.', '/', $view));
}
/**
* Create a new named view instance.
* Call the composer for the view instance.
*
* @param string $view
* @param array $data
* @return View
* @return void
*/
public static function of($view, $data = array())
private function compose()
{
$views = Config::get('view.names');
if ( ! array_key_exists($view, $views))
if (is_null(static::$composers[$this->module]))
{
throw new \Exception("Named view [$view] is not defined.");
static::$composers[$this->module] = (file_exists($path = $this->path.'composers'.EXT)) ? require $path : array();
}
return static::make($views[$view], $data);
if (isset(static::$composers[$this->module][$this->view]))
{
call_user_func(static::$composers[$this->module][$this->view], $this);
}
}
/**
......@@ -107,7 +138,7 @@ class View {
ob_start();
try { include $this->path; } catch (\Exception $e) { Error::handle($e); }
try { include $this->path.$this->view.EXT; } catch (\Exception $e) { Error::handle($e); }
return ob_get_clean();
}
......@@ -139,17 +170,6 @@ class View {
}
/**
* Magic Method for creating named view instances.
*/
public static function __callStatic($method, $parameters)
{
if (strpos($method, 'of_') === 0)
{
return static::of(substr($method, 3), Arr::get($parameters, 0, array()));
}
}
/**
* Magic Method for getting items from the view data.
*/
public function __get($key)
......
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