PHP Inflector::singularize方法代码示例

 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);
 }

 /**
  * Data source READ operation.
  *
  * @param string $query
  * @param array $options
  * @return mixed
  */
 public function read($query, array $options = array())
 {
     $params = $query->export($this);
     list($path, $data) = $this->_request($params);
     $source = $params['source'];
     $name = Inflector::singularize($source);
     $data = str_replace("\n", '', $this->_render("{$name}.list"));
     $result = $this->connection->post('xml-in', $data, array('type' => 'xml'));
     $result = $data = json_decode(json_encode(simplexml_load_string($result)), true);
     return $this->item($query->model(), array($result[$source]), array('class' => 'set'));
 }

 public function run($name = null, $null = null)
 {
     $library = Libraries::get($this->library);
     if (empty($library['prefix'])) {
         return false;
     }
     $model = Inflector::classify($name);
     $use = "\\{$library['prefix']}models\\{$model}";
     $params = array('namespace' => "{$library['prefix']}controllers", 'use' => $use, 'class' => "{$name}Controller", 'model' => $model, 'singular' => Inflector::singularize(Inflector::underscore($name)), 'plural' => Inflector::pluralize(Inflector::underscore($name)));
     if ($this->_save($this->template, $params)) {
         $this->out("{$params['class']} created in {$params['namespace']}.");
         return true;
     }
     return false;
 }

 protected function _init()
 {
     parent::_init();
     $config = $this->_config;
     $singularName = $config['name'];
     if ($config['type'] == 'hasMany') {
         $singularName = Inflector::singularize($config['name']);
     }
     if (!$config['to']) {
         $assoc = preg_replace("/\\w+\$/", "", $config['from']) . $singularName;
         $config['to'] = class_exists($assoc) ? $assoc : Libraries::locate('models', $assoc);
     }
     if (!$config['fieldName']) {
         $config['fieldName'] = lcfirst($config['name']);
     }
     $config['keys'] = $this->_keys($config['keys'], $config);
     $this->_config = $config;
 }

 public function relationship($class, $type, $name, array $config = array())
 {
     $field = Inflector::underscore(Inflector::singularize($name));
     $key = "{$field}_id";
     $primary = $class::meta('key');
     if (is_array($primary)) {
         $key = array_combine($primary, $primary);
     } elseif ($type === 'hasMany' || $type === 'hasOne') {
         if ($type === 'hasMany') {
             $field = Inflector::pluralize($field);
         }
         $secondary = Inflector::underscore(Inflector::singularize($class::meta('name')));
         $key = array($primary => "{$secondary}_id");
     }
     $from = $class;
     $fieldName = $field;
     $config += compact('type', 'name', 'key', 'from', 'fieldName');
     return $this->_instance('relationship', $config);
 }

 /**
  * Get the singular variable to use for data in controller methods.
  *
  * @param string $request
  * @return string
  */
 protected function _singular($request)
 {
     return Inflector::singularize(Inflector::camelize($request->action, false));
 }

 /**
  * Returns the field name of a relation name (underscore).
  *
  * @param string The type of the relation.
  * @param string The name of the relation.
  * @return string
  */
 public function relationFieldName($type, $name)
 {
     $fieldName = Inflector::underscore($name);
     if (preg_match('/Many$/', $type)) {
         $fieldName = Inflector::pluralize($fieldName);
     } else {
         $fieldName = Inflector::singularize($fieldName);
     }
     return $fieldName;
 }

 /**
  * Defines or modifies the default settings of a relationship between two models.
  *
  * @param string $class
  * @param string $type
  * @param string $name
  * @param array $config
  * @return array Returns an array containing the configuration for a model relationship.
  */
 public function relationship($class, $type, $name, array $config = array())
 {
     $singularName = $type == 'hasMany' ? Inflector::singularize($name) : $name;
     $keys = $type == 'belongsTo' ? $class::meta('name') : $singularName;
     $keys = Inflector::underscore($keys) . '_id';
     $from = $class;
     return $this->_instance('relationship', $config + compact('type', 'name', 'keys', 'from'));
 }

 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());
 }

 /**
  * Checks if the data container values are inside indexed arrays from binding.
  * Get the values from the binding coresponding to the model if such exists.
  *
  * @see lithium\security\auth\adapter\Form::check
  * @param array $data The array of raw form data.
  * @return array Original or sub array of the form data.
  */
 protected function _data($data)
 {
     $model = $this->_model;
     $index = strtolower(Inflector::singularize($model::meta('name')));
     return isset($data[$index]) && is_array($data[$index]) ? $data[$index] : $data;
 }

 /**
  * Creates a relationship binding between this model and another. Overwritten to allow model to model relations seperate of data source relations.
  *
  * @see lithium\data\model\Relationship
  * @param string $type The type of relationship to create. Must be one of `'hasOne'`,
  *               `'hasMany'` or `'belongsTo'`.
  * @param string $name The name of the relationship. If this is also the name of the model,
  *               the model must be in the same namespace as this model. Otherwise, the
  *               fully-namespaced path to the model class must be specified in `$config`.
  * @param array $config Any other configuration that should be specified in the relationship.
  *              See the `Relationship` class for more information.
  * @return object Returns an instance of the `Relationship` class that defines the connection.
  */
 public static function bind($type, $name, array $config = array())
 {
     $defaults = array('default' => false);
     // li3_embedded catch to make embedding easier
     if (isset($config['embedded']) && !isset($config['default'])) {
         if (!empty($config['embedded'])) {
             $config['default'] = true;
         } else {
             $config['default'] = false;
         }
     }
     $config += $defaults;
     $self = static::_object();
     if (!isset($config['to']) && isset($config['class'])) {
         $config['to'] = $config['class'];
     }
     if (!isset($config['to'])) {
         $config['to'] = $name;
     }
     $config['to'] = Libraries::locate('models', $config['to']);
     $targetModel = $config['to'];
     //TODO, add general exception option & add mongo exception for non embedded
     if (!empty($targetModel) && $config['default'] === false) {
         // continue on if default lithium relationship will not work
         if (isset($config['fieldName'])) {
             $fieldName = $config['fieldName'];
         } else {
             $fieldName = $name;
             if ($type == 'hasMany') {
                 $fieldName = Inflector::pluralize($name);
             } else {
                 $fieldName = Inflector::singularize($name);
             }
             $fieldName = Inflector::underscore($fieldName);
         }
         $key = "{$fieldName}_id";
         $from = get_called_class();
         $config += compact('type', 'name', 'key', 'from', 'fieldName');
         $connection = static::connection();
         $relationship = $connection->invokeMethod('_instance', array('relationship', $config));
         if (!empty($relationship)) {
             $self->_alternateRelations[$name] = $relationship;
             return null;
         }
     }
     return parent::bind($type, $name, $config);
 }

 public function testAddingSingularizationRules()
 {
     $before = Inflector::rules('singular');
     $result = Inflector::singularize('errata');
     $this->assertNull(Inflector::rules('singular', array('/rata/' => '\\1ratus')));
     $this->assertEqual(Inflector::singularize('errata'), $result);
     Inflector::reset();
     $this->assertNotEqual(Inflector::singularize('errata'), $result);
     $after = Inflector::rules('singular');
     $expected = array('rules', 'irregular', 'uninflected', 'regexUninflected', 'regexIrregular');
     $this->assertEqual(array_keys($before), $expected);
     $this->assertEqual(array_keys($after), $expected);
     $result = array_diff($after['rules'], $before['rules']);
     $this->assertEqual($result, array('/rata/' => '\\1ratus'));
     foreach (array('irregular', 'uninflected', 'regexUninflected', 'regexIrregular') as $key) {
         $this->assertIdentical($before[$key], $after[$key]);
     }
     $this->assertNull(Inflector::rules('singular', array('rules' => array('/rata/' => '\\1ratus'))));
     $this->assertIdentical(Inflector::rules('singular'), $after);
 }

 /**
  * If no resource parameter definition exists for a method, generate a default mapping.
  *
  * @param string $method The class method name to be called, i.e. `'index'`, `'add'`, etc.
  * @return array Returns an array where the key is the singular or plural name of the `Resource`
  *         class, i.e. `'post'` or `'posts'`, and the value is a sub-array with an
  *         optionally-non-namespaced model name or fully-qualified class name as the first
  *         value, and a `'call'` key, indicating the name of the class method to call.
  */
 protected function _default($method)
 {
     $name = lcfirst(static::_name());
     $isPlural = $method == 'index';
     $call = array(true => 'first', $isPlural => 'all', $method == 'add' => 'create');
     $key = $isPlural ? Inflector::pluralize($name) : Inflector::singularize($name);
     return array($key => array(static::binding(), 'call' => $call[true], 'required' => !$isPlural));
 }

 /**
  * 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;
 }

 /**
  * Generic delete() action.
  * The trick here is that $this->calling_class and $this->calling_method will hold a string
  * reference for which extended class called this delete() method. We need that in order to
  * get the proper records and access.
 */
 public function delete() {
     // get the "_type" ... page_type, user_type, or block_type
     $model = Inflector::classify(Inflector::singularize($this->request->params['controller']));
     $modelClass = 'minerva\models\\'.$model;
     
     $conditions = array();
     if(isset($this->request->params['id'])) {
         $conditions = array('id' => $this->request->params['id']);
     }
     if(isset($this->request->params['url'])) {
         $conditions = array('url' => $this->request->params['url']);
     }
     
     if(empty($conditions)) {
         $this->redirect(array('controller' => $this->request->params['controller'], 'action' => 'index'));
     }
     
     $document = $this->getDocument(array(
         'action' => __METHOD__,
         'request' => $this->request,
         'find_type' => 'first',
         'conditions' => $conditions
     ));
     
     if($document->delete()) {
         FlashMessage::set('The content has been deleted.', array('options' => array('type' => 'success', 'pnotify_title' => 'Success', 'pnotify_opacity' => .8)));
         $this->redirect(array('controller' => $this->request->params['controller'], 'action' => 'index'));
     } else {
         FlashMessage::set('The content could not be deleted, please try again.', array('options' => array('type' => 'error', 'pnotify_title' => 'Error', 'pnotify_opacity' => .8)));
         $this->redirect(array('controller' => $this->request->params['controller'], 'action' => 'index'));
     }
 }