PHP Inflector::classify方法代碼示例

 /**
  * undocumented function
  *
  * @return void
  */
 function main()
 {
     $choice = '';
     $Tasks = new Folder(dirname(__FILE__) . DS . 'tasks');
     list($folders, $files) = $Tasks->read();
     $i = 1;
     $choices = array();
     foreach ($files as $file) {
         if (preg_match('/upgrade_/', $file)) {
             $choices[$i] = basename($file, '.php');
             $this->out($i++ . '. ' . basename($file, '.php'));
         }
     }
     while ($choice == '') {
         $choice = $this->in("Enter a number from the list above, or 'q' to exit", null, 'q');
         if ($choice === 'q') {
             $this->out("Exit");
             $this->_stop();
         }
         if ($choice == '' || intval($choice) > count($choices)) {
             $this->err("The number you selected was not an option. Please try again.");
             $choice = '';
         }
     }
     if (intval($choice) > 0 && intval($choice) <= count($choices)) {
         $upgrade = Inflector::classify($choices[intval($choice)]);
     }
     $this->tasks = array($upgrade);
     $this->loadTasks();
     return $this->{$upgrade}->execute();
 }

 /**
  * Execution method always used for tasks
  *
  * @return void
  */
 public function execute()
 {
     if (!empty($this->args)) {
         $command = Inflector::classify(array_shift($this->args));
         if ($this->hasTask($command)) {
             return $this->{$command}->runCommand('execute', $this->args);
         }
     }
     $this->out(__d('webmaster', "Interactive Requirements Shell"));
     $this->hr();
     $this->out(__d('webmaster', "[A]vailability"));
     $this->out(__d('webmaster', "[I]mplementation"));
     $this->out(__d('webmaster', "[S]takeholder"));
     $this->out(__d('webmaster', "[Q]uit"));
     $option = $this->in(__d('webmaster', "What would you like to do?"), array_keys($this->__options));
     $method = $this->__options[strtoupper($option)];
     if ($this->hasMethod($method)) {
         $this->{$method}();
     } else {
         if ($this->hasTask($method)) {
             $this->{$method}->runCommand('execute', $this->args);
         }
     }
     $this->execute();
 }

 /**
  * Delegates the job of enforcing authorization to the active controller.
  *
  * When using this Authorize object, each Controller must define an
  * `::isAuthorized($user)` method. An Exception will be thrown if such
  * a method does not exist.
  *
  * The method takes as its only argument an array of User data as
  * normally provided by `Auth->user()` to use in determining access.
  *
  * The method must return a boolean true/false value where true
  * indicates the currently logged in User is allowed to access the
  * current CakeRequest, and false indicates the User's access is denied.
  *
  * As an example, if you wanted all logged-in-users to have access to
  * all parts of your app, you could add the following method to your
  * AppController:
  *
  * 		public function isAuthorized($user) {
  * 			return true;
  * 		}
  *
  * @param array $user An array containing a User record, typically provided by Auth->user().
  * @param CakeRequest $request The active HTTP request object.
  * @throws NotImplementedException If the controller does not define a valid ::isAuthorized() method.
  * @return bool	True if the current User has access to the requested section of the app, false otherwise.
  */
 public function authorize($user, CakeRequest $request)
 {
     if (!$this->controllerIsAuthorizedExists()) {
         throw new NotImplementedException(sprintf("%sController does not define the mandatory `::isAuthorized()` method used for authorization.", Inflector::classify($request->params['controller'])));
     }
     return $this->delegateToIsAuthorized($user);
 }

 public static function generate($args, $subfolder = 'default')
 {
     $subfolder = trim($subfolder, '/');
     if (!is_dir(PKGPATH . 'oil/views/' . $subfolder)) {
         throw new Exception('The subfolder for scaffolding templates doesn\'t exist or is spelled wrong: ' . $subfolder . ' ');
     }
     // Do this first as there is the largest chance of error here
     Generate::model($args, false);
     // Go through all arguments after the first and make them into field arrays
     $fields = array();
     foreach (array_slice($args, 1) as $arg) {
         // Parse the argument for each field in a pattern of name:type[constraint]
         preg_match('/([a-z0-9_]+):([a-z0-9_]+)(\\[([0-9]+)\\])?/i', $arg, $matches);
         $fields[] = array('name' => strtolower($matches[1]), 'type' => isset($matches[2]) ? $matches[2] : 'string', 'constraint' => isset($matches[4]) ? $matches[4] : null);
     }
     $data['singular'] = $singular = strtolower(array_shift($args));
     $data['model'] = $model_name = 'Model_' . \Inflector::classify($singular);
     $data['plural'] = $plural = \Inflector::pluralize($singular);
     $data['fields'] = $fields;
     $filepath = APPPATH . 'classes/controller/' . trim(str_replace(array('_', '-'), DS, $plural), DS) . '.php';
     $controller = \View::factory($subfolder . '/scaffold/controller', $data);
     $controller->actions = array(array('name' => 'index', 'params' => '', 'code' => \View::factory($subfolder . '/scaffold/actions/index', $data)), array('name' => 'view', 'params' => '$id = null', 'code' => \View::factory($subfolder . '/scaffold/actions/view', $data)), array('name' => 'create', 'params' => '$id = null', 'code' => \View::factory($subfolder . '/scaffold/actions/create', $data)), array('name' => 'edit', 'params' => '$id = null', 'code' => \View::factory($subfolder . '/scaffold/actions/edit', $data)), array('name' => 'delete', 'params' => '$id = null', 'code' => \View::factory($subfolder . '/scaffold/actions/delete', $data)));
     // Write controller
     Generate::create($filepath, $controller, 'controller');
     // Create each of the views
     foreach (array('index', 'view', 'create', 'edit', '_form') as $view) {
         Generate::create(APPPATH . 'views/' . $plural . '/' . $view . '.php', \View::factory($subfolder . '/scaffold/views/' . $view, $data), 'view');
     }
     // Add the default template if it doesnt exist
     if (!file_exists($app_template = APPPATH . 'views/template.php')) {
         Generate::create($app_template, file_get_contents(PKGPATH . 'oil/views/default/template.php'), 'view');
     }
     Generate::build();
 }

 public function __construct($from, $name, array $config)
 {
     $this->name = $name;
     $this->model_from = $from;
     $this->model_to = array_key_exists('model_to', $config) ? $config['model_to'] : \Inflector::get_namespace($from) . 'Model_' . \Inflector::classify($name);
     $this->key_from = array_key_exists('key_from', $config) ? (array) $config['key_from'] : $this->key_from;
     $this->key_to = array_key_exists('key_to', $config) ? (array) $config['key_to'] : $this->key_to;
     $this->conditions = array_key_exists('conditions', $config) ? (array) $config['conditions'] : array();
     if (!empty($config['table_through'])) {
         $this->table_through = $config['table_through'];
     } else {
         $table_name = array($this->model_from, $this->model_to);
         natcasesort($table_name);
         $table_name = array_merge($table_name);
         $this->table_through = \Inflector::tableize($table_name[0]) . '_' . \Inflector::tableize($table_name[1]);
     }
     $this->key_through_from = !empty($config['key_through_from']) ? (array) $config['key_through_from'] : (array) \Inflector::foreign_key($this->model_from);
     $this->key_through_to = !empty($config['key_through_to']) ? (array) $config['key_through_to'] : (array) \Inflector::foreign_key($this->model_to);
     $this->cascade_save = array_key_exists('cascade_save', $config) ? $config['cascade_save'] : $this->cascade_save;
     $this->cascade_delete = array_key_exists('cascade_delete', $config) ? $config['cascade_delete'] : $this->cascade_delete;
     if (!class_exists($this->model_to)) {
         throw new \FuelException('Related model not found by Many_Many relation "' . $this->name . '": ' . $this->model_to);
     }
     $this->model_to = get_real_class($this->model_to);
 }

 public static function getExternalConditions($select, $parentModel, $childName, $attributes)
 {
     $parentModelName = get_class($parentModel);
     $parentTableName = $parentModel->getTableName();
     // exhibitions
     $childName = array_key_exists('source', $attributes) ? $attributes['source'] : $childName;
     $childModelName = Inflector::classify($childName);
     $childTableName = Bbx_Model::load($childModelName)->getTableName();
     // images
     if (!array_key_exists($childTableName, $select->getPart('from'))) {
         $select->from($childTableName, array());
         // images
     }
     if (array_key_exists('as', $attributes)) {
         $refColumn = $attributes['as'] . '_id';
         $polyType = $attributes['as'] . '_type';
     } else {
         $refColumn = Inflector::singularize($parentTableName) . '_id';
     }
     try {
         $parentModel->getRowData();
         $select->where("`" . $childTableName . "`.`" . $refColumn . "` = " . $parentModel->id);
     } catch (Exception $e) {
         $select->where("`" . $childTableName . "`.`" . $refColumn . "` = `" . $parentTableName . "`.`id`");
     }
     if (isset($polyType)) {
         $select->where("`" . $childTableName . "`.`" . $polyType . "` = '" . Inflector::underscore($parentModelName) . "'");
     }
     return $select;
 }

 /**
  * @todo Implement testClassify().
  */
 public function testClassify()
 {
     $this->assertEquals(Inflector::classify('path.to.class_name'), 'Path\\To\\ClassName');
     $this->assertEquals(Inflector::classify('/path/to/class-name'), '\\Path\\To\\ClassName');
     $this->assertEquals(Inflector::classify('Path/To/ClassName'), 'Path\\To\\ClassName');
     $this->assertEquals(Inflector::classify('class_name'), 'ClassName');
 }

 function main()
 {
     if (empty($this->args)) {
         return $this->err('Usage: ./cake fixturize <table>');
     }
     if ($this->args[0] == '?') {
         return $this->out('Usage: ./cake fixturize <table> [-force] [-reindex]');
     }
     $options = array('force' => false, 'reindex' => false);
     foreach ($this->params as $key => $val) {
         foreach ($options as $name => $option) {
             if (isset($this->params[$name]) || isset($this->params['-' . $name]) || isset($this->params[$name[0]])) {
                 $options[$name] = true;
             }
         }
     }
     foreach ($this->args as $table) {
         $name = Inflector::classify($table);
         $Model = new AppModel(array('name' => $name, 'table' => $table));
         $file = sprintf('%stests/fixtures/%s_fixture.php', APP, Inflector::underscore($name));
         $File = new File($file);
         if ($File->exists() && !$options['force']) {
             $this->err(sprintf('File %s already exists, use --force option.', $file));
             continue;
         }
         $records = $Model->find('all');
         $out = array();
         $out[] = '<?php';
         $out[] = '';
         $out[] = sprintf('class %sFixture extends CakeTestFixture {', $name);
         $out[] = sprintf('	var $name = \'%s\';', $name);
         $out[] = '	var $records = array(';
         $File->write(join("\n", $out));
         foreach ($records as $record) {
             $out = array();
             $out[] = '		array(';
             if ($options['reindex']) {
                 foreach (array('old_id', 'vendor_id') as $field) {
                     if ($Model->hasField($field)) {
                         $record[$name][$field] = $record[$name]['id'];
                         break;
                     }
                 }
                 $record[$name]['id'] = String::uuid();
             }
             foreach ($record[$name] as $field => $val) {
                 $out[] = sprintf('			\'%s\' => \'%s\',', addcslashes($field, "'"), addcslashes($val, "'"));
             }
             $out[] = '		),';
             $File->write(join("\n", $out));
         }
         $out = array();
         $out[] = '	);';
         $out[] = '}';
         $out[] = '';
         $out[] = '?>';
         $File->write(join("\n", $out));
         $this->out(sprintf('-> Create %sFixture with %d records (%d bytes) in "%s"', $name, count($records), $File->size(), $file));
     }
 }

 /**
  * Helper for firing jobs
  *
  * @param array $data array of data to pass into a job
  * @return bool
  * @throws CakeException If if the job is invalid, could not be loaded or could not be enqueued
  */
 public function fireJob($data = array())
 {
     if (isset($data['job'])) {
         $new = $data;
         unset($data);
         $data[$this->alias] = $new;
     }
     if (empty($data[$this->alias]['job'])) {
         throw new CakeException(__('Invalid job.'));
     }
     foreach ($data[$this->alias] as $key => $val) {
         if ($key == 'job') {
             continue;
         }
         if (strpos($key, '_id') !== false) {
             $model = Inflector::classify(substr($key, 0, strpos($key, '_id')));
             $Model = ClassRegistry::init($model);
             $res = $Model->findById($val);
             $data[$this->alias][$key] = $res[$Model->alias];
         }
     }
     if (empty($data[$this->alias]['job'])) {
         throw new CakeException(__('Job could not be loaded.'));
     }
     $job = $data[$this->alias]['job'];
     unset($data[$this->alias]['job']);
     $data = array_values($data[$this->alias]);
     if ($this->enqueue($job, $data)) {
         return true;
     }
     throw new CakeException(__('Job could not be enqueued.'));
 }

 /**
  * Execution method always used for tasks
  *
  * @return void
  */
 function execute()
 {
     if (empty($this->params['skel'])) {
         $this->params['skel'] = '';
         if (is_dir(CAKE_CORE_INCLUDE_PATH . DS . 'cake' . DS . 'console' . DS . 'libs' . DS . 'templates' . DS . 'skel') === true) {
             $this->params['skel'] = CAKE_CORE_INCLUDE_PATH . DS . 'cake' . DS . 'console' . DS . 'libs' . DS . 'templates' . DS . 'skel';
         }
     }
     $plugin = null;
     if (isset($this->args[0])) {
         $plugin = Inflector::camelize($this->args[0]);
         $this->Dispatch->shiftArgs();
         $this->out(sprintf('Plugin: %s', $plugin));
         $pluginPath = Inflector::underscore($plugin) . DS;
         $this->out(sprintf('Plugin: %s', $this->path . $pluginPath));
     }
     if (isset($this->args[0]) && isset($plugin)) {
         $task = Inflector::classify($this->args[0]);
         $this->Dispatch->shiftArgs();
         if (in_array($task, $this->tasks)) {
             $this->{$task}->path = $this->path . $pluginPath . Inflector::underscore(Inflector::pluralize($task)) . DS;
             if (!is_dir($this->{$task}->path)) {
                 $this->err(sprintf(__("%s directory could not be found.\nBe sure you have created %s", true), $task, $this->{$task}->path));
             }
             $this->{$task}->loadTasks();
             $this->{$task}->execute();
         }
         exit;
     }
     $this->__interactive($plugin);
 }

 protected static function get_class_name($prefix = '')
 {
     if (!$prefix) {
         return __CLASS__;
     }
     return sprintf('%s_%s', __CLASS__, Inflector::classify($prefix));
 }

 /**
  * send
  *
  */
 public function send($model)
 {
     $models = Configure::read('Reminder.models');
     $modelName = Inflector::classify($model);
     $loader = ReminderConfigLoader::init($modelName);
     $layout = $loader->load('layout');
     try {
         $this->Reminder = ClassRegistry::init('Reminder.Reminder');
         $result = $this->Reminder->send($this->request->data, $modelName);
         if ($result === true) {
             $this->request->data = null;
             $this->Session->setFlash(__('Reminder mail has been sent'), Configure::read('Reminder.setFlashElement.success'), Configure::read('Reminder.setFlashParams.success'));
             $view = $loader->load('view.sent');
             if (empty($view)) {
                 $view = 'sent';
             }
             return $this->render($view, $layout);
         }
     } catch (ReminderException $e) {
         $this->Session->setFlash($e->getMessage(), Configure::read('Reminder.setFlashElement.error'), Configure::read('Reminder.setFlashParams.error'));
     }
     $emailField = $loader->load('email');
     $this->set(array('model' => $model, 'modelName' => $modelName, 'emailField' => $emailField));
     $view = $loader->load('view.send');
     if (empty($view)) {
         $view = 'send';
     }
     return $this->render($view, $layout);
 }

 private function initModel()
 {
     if (!$this->model) {
         $model = Inflector::classify($this->controller);
     }
     $this->{$model} = new $model();
 }

 function main()
 {
     if (empty($this->args)) {
         return $this->err('Usage: ./cake uuidize <table>');
     }
     if ($this->args[0] == '?') {
         return $this->out('Usage: ./cake uuidize <table> [-force] [-reindex]');
     }
     $options = array('force' => false, 'reindex' => false);
     foreach ($this->params as $key => $val) {
         foreach ($options as $name => $option) {
             if (isset($this->params[$name]) || isset($this->params['-' . $name]) || isset($this->params[$name[0]])) {
                 $options[$name] = true;
             }
         }
     }
     foreach ($this->args as $table) {
         $name = Inflector::classify($table);
         $Model = new AppModel(array('name' => $name, 'table' => $table));
         $records = $Model->find('all');
         foreach ($records as $record) {
             $Model->updateAll(array('id' => '"' . String::uuid() . '"'), array('id' => $record[$name]['id']));
         }
     }
 }

 /**
  * setup
  *
  * @param Model $Model
  * @param array $config
  * @return void
  */
 public function setup(Model $Model, $config = array())
 {
     $recipe = Configure::read('Oven.recipe');
     if (!empty($recipe)) {
         foreach ($recipe as $key => $type) {
             $modelName = Inflector::classify($key);
             if (!isset($this->settings['uploadFields'][$modelName])) {
                 $this->settings['uploadFields'][$modelName] = array();
             }
             if (!empty($type['schema'])) {
                 foreach ($type['schema'] as $field => $val) {
                     if (empty($val['type'])) {
                         continue;
                     }
                     if ($val['type'] == 'file') {
                         $this->settings['uploadFields'][$modelName][] = $field;
                     }
                 }
             }
         }
     }
     if (empty($config['uploadLocation'])) {
         $config['uploadLocation'] = Configure::read('Oven.config.upload_location');
         if (empty($config['uploadLocation'])) {
             $config['uploadLocation'] = WWW_ROOT . 'files' . DS . 'uploads' . DS;
         }
     }
     if (!file_exists($config['uploadLocation'])) {
         new Folder($config['uploadLocation'], true);
     }
     $this->settings = Set::merge($this->settings, $config);
 }