/** * 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) { } /**