/**
* Get DB table name for the migration
* Table name is pluralized (tableized) class name by default
*
* @param $request
* @return string
*/
protected function _source($request)
{
if ($request->source) {
return $request->source;
}
return Inflector::tableize($request->action);
}
public function testIndexScaffold()
{
$this->_controller->index();
$scaffold = $this->_controller->access('scaffold');
$expected = array('base' => '/radium/configurations', 'controller' => 'Configurations', 'library' => 'radium', 'class' => 'MockConfigurations', 'model' => 'radium\\tests\\mocks\\data\\MockConfigurations', 'slug' => Inflector::underscore('MockConfigurations'), 'singular' => Inflector::singularize('MockConfigurations'), 'plural' => Inflector::pluralize('MockConfigurations'), 'table' => Inflector::tableize('MockConfigurations'), 'human' => Inflector::humanize('MockConfigurations'));
$this->assertEqual($expected, $scaffold);
}
public function path($entity)
{
$resource = Inflector::tableize(basename(str_replace('\\', '/', $entity->model())));
if ($entity->exists()) {
return '/' . $resource . '/' . $entity->_id;
} else {
return '/' . $resource;
}
}
public static function __init($options = array())
{
$self = static::_instance();
if (!isset($self->_meta['source'])) {
$model = get_class($self);
$tmp = explode('\\', $model);
$modelName = end($tmp);
$self->_meta['source'] = \lithium\util\Inflector::tableize($modelName);
}
parent::__init($options);
}
/**
* Return meta information, for compatibility with LI3.
*
* @param string $key - name of property to return, e.g.
* 'name' or 'source'
* @param string $val - ignored
*/
public static function meta($key = null, $val = null)
{
$class = get_called_class();
$parts = explode("\\", $class);
$name = $parts[count($parts) - 1];
if ($key == 'name') {
return strtolower($name);
} else {
if ($key == 'source') {
return static::$sourceName ? static::$sourceName : strtolower(Inflector::tableize($name));
}
}
}
/**
* Init default connection options and connects default finders.
*
* This method will set the `Model::$_schema`, `Model::$_meta`, `Model::$_finders` class
* attributes, as well as obtain a handle to the configured persistent storage connection
*
* @param string $class The fully-namespaced class name to initialize.
* @return object Returns the initialized model instance.
*/
protected static function _initialize($class)
{
$self = static::$_instances[$class];
if (isset(static::$_initialized[$class]) && static::$_initialized[$class]) {
return $self;
}
static::$_initialized[$class] = true;
$query = array();
$finders = array();
$meta = array();
$schema = array();
$source = array();
$classes = $self->_classes;
$initializers = array();
foreach (static::_parents() as $parent) {
$parentConfig = get_class_vars($parent);
foreach ($self->_autoConfig as $key) {
if (isset($parentConfig["_{$key}"])) {
$val = $parentConfig["_{$key}"];
${$key} = is_array($val) ? ${$key} + $val : $val;
}
}
if ($parent == __CLASS__) {
break;
}
}
$tmp = $self->_meta + $meta;
$source = array('meta' => array(), 'finders' => array(), 'schema' => array());
if ($tmp['connection']) {
$conn = $classes['connections']::get($tmp['connection']);
$source = ($conn ? $conn->configureClass($class) : array()) + $source;
}
$self->_classes = $classes;
$local = compact('class') + $self->_meta;
$self->_meta = $local + $source['meta'] + $meta;
$self->_initializers += array('name' => function ($self) {
return basename(str_replace('\\', '/', $self));
}, 'source' => function ($self) {
return Inflector::tableize($self::meta('name'));
}, 'title' => function ($self) {
$titleKeys = array('title', 'name');
$titleKeys = array_merge($titleKeys, (array) $self::meta('key'));
return $self::hasField($titleKeys);
});
if (is_object($self->_schema)) {
$self->_schema->append($source['schema']);
} elseif (is_array($self->_schema)) {
$self->_schema = $self->_schema + $source['schema'];
} else {
$self->_schema = $source['schema'];
}
$self->_finders += $source['finders'] + $self->_findFilters();
static::_relationsToLoad();
return $self;
}
/**
* Set/get method for `Model` metadata.
*
* @see lithium\data\Model::$_meta
* @param string $key Model metadata key.
* @param string $value Model metadata value.
* @return mixed Metadata value for a given key.
*/
public static function meta($key = null, $value = null)
{
$self = static::_object();
if ($value) {
$self->_meta[$key] = $value;
}
if (is_array($key)) {
$self->_meta = $key + $self->_meta;
}
if (!$self->_meta['initialized']) {
$self->_meta['initialized'] = true;
if ($self->_meta['source'] === null) {
$self->_meta['source'] = Inflector::tableize($self->_meta['name']);
}
$titleKeys = array('title', 'name', $self->_meta['key']);
$self->_meta['title'] = $self->_meta['title'] ?: static::hasField($titleKeys);
}
if (is_array($key) || empty($key) || !empty($value)) {
return $self->_meta;
}
return isset($self->_meta[$key]) ? $self->_meta[$key] : null;
}
/**
* creates all necessary array keys for rendering a menu/list item
*
* @param array $navitem all available data for a single navigation item
* @return array navitem filled with all needed keys
*/
private function _item($navitem)
{
$context = $this->_context;
$navitem['url'] = empty($navitem['url']) && !empty($navitem['name']) ? '/' . Inflector::tableize($navitem['name']) : $navitem['url'];
$navitem['name'] = empty($navitem['name']) && !empty($navitem['url']) ? Inflector::humanize(basename($navitem['url'])) : $navitem['name'];
$navitem['active'] = (bool) stristr($navitem['url'], $context->scaffold->slug);
$navitem['link'] = $context->url($navitem['url']);
$navitem['badge'] = empty($navitem['badge']) ? null : $this->_badge($navitem['badge']);
return $navitem;
}
/**
* Init default connection options and connects default finders.
*
* This method will set the `Model::$_schema`, `Model::$_meta`, `Model::$_finders` class
* attributes, as well as obtain a handle to the configured persistent storage connection
*
* @param string $class The fully-namespaced class name to initialize.
* @return object Returns the initialized model instance.
*/
protected static function _initialize($class)
{
$self = static::$_instances[$class];
if (isset(static::$_initialized[$class]) && static::$_initialized[$class]) {
return $self;
}
static::$_initialized[$class] = true;
$self->_inherit();
$source = array('classes' => array(), 'meta' => array(), 'finders' => array(), 'schema' => array());
$meta = $self->_meta;
if ($meta['connection']) {
$classes = $self->_classes;
$conn = $classes['connections']::get($meta['connection']);
$source = ($conn ? $conn->configureClass($class) : array()) + $source;
}
$self->_classes += $source['classes'];
$self->_meta = compact('class') + $self->_meta + $source['meta'];
$self->_initializers += array('name' => function ($self) {
return basename(str_replace('\\', '/', $self));
}, 'source' => function ($self) {
return Inflector::tableize($self::meta('name'));
}, 'title' => function ($self) {
$titleKeys = array('title', 'name');
$titleKeys = array_merge($titleKeys, (array) $self::meta('key'));
return $self::hasField($titleKeys);
});
if (is_object($self->_schema)) {
$self->_schema->append($source['schema']);
} else {
$self->_schema += $source['schema'];
}
$self->_finders += $source['finders'] + static::_finders();
$self->_classes += array('query' => 'lithium\\data\\model\\Query', 'validator' => 'lithium\\util\\Validator', 'entity' => 'lithium\\data\\Entity');
static::_relationsToLoad();
return $self;
}
public function testLazyMetadataInit()
{
MockPost::config(array('schema' => new Schema(array('fields' => array('id' => array('type' => 'integer'), 'name' => array('type' => 'string'), 'label' => array('type' => 'string'))))));
$this->assertIdentical('mock_posts', MockPost::meta('source'));
$this->assertIdentical('name', MockPost::meta('title'));
$this->assertEmpty(MockPost::meta('unexisting'));
$config = array('schema' => new Schema(array('fields' => array('id' => array('type' => 'integer'), 'name' => array('type' => 'string'), 'label' => array('type' => 'string')))), 'initializers' => array('source' => function ($self) {
return Inflector::tableize($self::meta('name'));
}, 'name' => function ($self) {
return Inflector::singularize('CoolPosts');
}, 'title' => function ($self) {
static $i = 1;
return 'label' . $i++;
}));
MockPost::reset();
MockPost::config($config);
$this->assertIdentical('cool_posts', MockPost::meta('source'));
$this->assertIdentical('label1', MockPost::meta('title'));
$this->assertNotIdentical('label2', MockPost::meta('title'));
$this->assertIdentical('label1', MockPost::meta('title'));
$meta = MockPost::meta();
$this->assertIdentical('label1', $meta['title']);
$this->assertIdentical('CoolPost', MockPost::meta('name'));
MockPost::reset();
unset($config['initializers']['title']);
$config['initializers']['source'] = function ($self) {
return Inflector::underscore($self::meta('name'));
};
MockPost::config($config);
$this->assertIdentical('cool_post', MockPost::meta('source'));
$this->assertIdentical('name', MockPost::meta('title'));
$this->assertIdentical('CoolPost', MockPost::meta('name'));
MockPost::reset();
MockPost::config($config);
$expected = array('class' => 'lithium\\tests\\mocks\\data\\MockPost', 'connection' => false, 'key' => 'id', 'name' => 'CoolPost', 'title' => 'name', 'source' => 'cool_post');
$this->assertEqual($expected, MockPost::meta());
}
/**
* testTableNaming method
*
* @return void
*/
public function testTabelize()
{
$this->assertEqual(Inflector::tableize('ArtistsGenre'), 'artists_genres');
$this->assertEqual(Inflector::tableize('FileSystem'), 'file_systems');
$this->assertEqual(Inflector::tableize('News'), 'news');
}
/**
* Generates different variations of the configured $this->model property name
*
* If no model is configured (i.e. `null`) - it automatically detects the corresponding
* model for this Controller via Inflection and `Libraries::locate()`.
*
* @see lithium\core\Libraries::locate()
* @param string $field defines, what variation of the default you want to have
* available are 'class', 'model', 'singular', 'plural' and 'table' and 'human'.
* if omitted, returns array containing all of them.
* @return array|string
**/
protected function _scaffold($field = null)
{
if (is_null($this->model)) {
$this->model = (string) Libraries::locate('models', $this->request->controller);
}
if (is_null($this->scaffold)) {
$class = basename(str_replace('\\', '/', $this->model));
$base = !empty($this->library) ? array('controller' => $this->controller, 'library' => $this->library) : array('controller' => $this->controller);
$this->scaffold = array('base' => Router::match($base, $this->request), 'controller' => strtolower($this->controller), 'library' => $this->library, 'class' => $class, 'model' => $this->model, 'slug' => Inflector::underscore($class), 'singular' => Inflector::singularize($class), 'plural' => Inflector::pluralize($class), 'table' => Inflector::tableize($class), 'human' => Inflector::humanize($class));
}
if (!is_null($field)) {
return isset($this->scaffold[$field]) ? $this->scaffold[$field] : false;
}
Environment::set(true, array('scaffold' => $this->scaffold));
return $this->scaffold;
}
* <current controller>/<current layout>_component
* component
* <current layout>_component
*
* <current controller> is tabelized name of current controller, for example:
* `ManageUsersController` is `manage_users`
* `UsersController` is `users`
*
* <current layout> is name of currently active layout, `'partial'` or `'backend'`
*
* To learn about template overloading read:
* @see li3_backend\extensions\controller\ComponentController::_viewAs()
*/
use lithium\util\Inflector;
$layout = $this->_config['layout'];
$controller = Inflector::tableize($this->_request->params['controller']);
/**
* Render controller's general component menu if exists
*/
try {
echo $this->_render('element', "{$controller}/component");
} catch (Exception $e) {
}
/**
* Render controller's component menu for current layout if exists
*/
try {
echo $this->_render('element', "{$controller}/{$layout}_component");
} catch (Exception $e) {
}
/**
