Takes a under_scored word and turns it into a CamelCased or camelBack word
public function describe($entity, array $meta = array())
{
$var = "_" . Inflector::camelize($entity, false);
if ($this->{$var}) {
return $this->{$var};
}
return array();
}
/**
* undocumented function
*
* @return void
*/
protected function _init()
{
$class = Inflector::camelize($this->_config['reporter']);
if (!($reporter = Libraries::locate('test.reporter', $class))) {
throw new Exception("{$class} is not a valid reporter");
}
$this->reporter = new $reporter();
$this->group = $this->_config['group'];
$this->filters = $this->_config['filters'];
$this->title = $this->_config['title'] ?: $this->_config['title'];
}
/**
* Auto run the help command.
*
* @param string $command Name of the command to return help about.
* @return boolean
*/
public function run($command = null)
{
$message = 'Lithium console started in the ' . Environment::get() . ' environment.';
$message .= ' Use the --env=environment key to alter this.';
$this->out($message);
if (!$command) {
$this->_renderCommands();
return true;
}
if (!preg_match('/\\\\/', $command)) {
$command = Inflector::camelize($command);
}
if (!($class = Libraries::locate('command', $command))) {
$this->error("Command `{$command}` not found");
return false;
}
if (strpos($command, '\\') !== false) {
$command = join('', array_slice(explode("\\", $command), -1));
}
$command = strtolower(Inflector::slug($command));
$run = null;
$methods = $this->_methods($class);
$properties = $this->_properties($class);
$info = Inspector::info($class);
$this->out('USAGE', 'heading');
if (isset($methods['run'])) {
$run = $methods['run'];
unset($methods['run']);
$this->_renderUsage($command, $run, $properties);
}
foreach ($methods as $method) {
$this->_renderUsage($command, $method);
}
if (!empty($info['description'])) {
$this->nl();
$this->_renderDescription($info);
$this->nl();
}
if ($properties || $methods) {
$this->out('OPTIONS', 'heading');
}
if ($run) {
$this->_render($run['args']);
}
if ($methods) {
$this->_render($methods);
}
if ($properties) {
$this->_render($properties);
}
return true;
}
public function apply($testable, array $config = array())
{
$tokens = $testable->tokens();
$filtered = $testable->findAll(array(T_VARIABLE));
foreach ($filtered as $id) {
$token = $tokens[$id];
$isntSuperGlobal = !isset($this->_superglobals[$token['content']]);
if ($isntSuperGlobal) {
$name = preg_replace('/(\\$_?|_+$)/', '', $token['content']);
if ($name !== Inflector::camelize($name, false)) {
$this->addViolation(array('message' => "Variable {$name} is not camelBack style", 'line' => $token['line']));
}
}
}
}
/**
* Will iterate the tokens looking for a T_CLASS which should be
* in CamelCase and match the file name
*
* @param Testable $testable The testable object
* @return void
*/
public function apply($testable, array $config = array())
{
$tokens = $testable->tokens();
$pathinfo = pathinfo($testable->config('path'));
if ($pathinfo['extension'] !== 'php') {
return;
}
$filtered = $testable->findAll(array(T_CLASS));
foreach ($filtered as $key) {
$token = $tokens[$key];
$className = $tokens[$key + 2]['content'];
if ($className !== Inflector::camelize($className)) {
$this->addViolation(array('message' => 'Class name is not in CamelCase style', 'line' => $token['line']));
} elseif ($className !== $pathinfo['filename']) {
$this->addViolation(array('message' => 'Class name and file name should match', 'line' => $token['line']));
}
}
}
/**
* Will iterate the tokens looking for functions validating they have the
* correct camelBack naming style.
*
* @param Testable $testable The testable object
* @return void
*/
public function apply($testable, array $config = array())
{
$tokens = $testable->tokens();
$filtered = $testable->findAll(array(T_FUNCTION));
foreach ($filtered as $key) {
$token = $tokens[$key];
$label = Parser::label($key, $tokens);
$modifiers = Parser::modifiers($key, $tokens);
$isClosure = Parser::closure($key, $tokens);
if (in_array($label, $this->_magicMethods)) {
continue;
}
if ($testable->findNext(array(T_PROTECTED), $modifiers) !== false) {
$label = preg_replace('/^_/', '', $label);
}
if (!$isClosure && $label !== Inflector::camelize($label, false)) {
$this->addViolation(array('message' => 'Function "' . $label . '" is not in camelBack style', 'line' => $tokens[$tokens[$key]['parent']]['line']));
}
}
}
/**
* Get an instance of a sub-command
*
* @param string $name the name of the sub-command to instantiate
* @param array $config
* @return object;
*/
protected function _instance($name, array $config = array())
{
if ($class = Libraries::locate('command.create', Inflector::camelize($name))) {
$this->request->params['template'] = $this->template;
return new $class(array('request' => $this->request, 'classes' => $this->_classes));
}
return parent::_instance($name, $config);
}
/**
* Returns the field name of a relation name (camelBack).
*
* @param string The type of the relation.
* @param string The name of the relation.
* @return string
*/
public function relationFieldName($type, $name)
{
$fieldName = Inflector::camelize($name, false);
if (preg_match('/Many$/', $type)) {
$fieldName = Inflector::pluralize($fieldName);
} else {
$fieldName = Inflector::singularize($fieldName);
}
return $fieldName;
}
<?php /** * li3_flash_message plugin for Lithium: the most rad php framework. * * @copyright Copyright 2010, Michael Hüneburg * @license http://opensource.org/licenses/bsd-license.php The BSD License */ $class = (!empty($class)) ? $class : null; $class = \lithium\util\Inflector::camelize($class); ?> <div class="message<?= $class; ?>"> <?= $message; ?> </div>
/**
* requestAction() is a shortcut method to pulling back return data from any controller's method.
* Normally, you'd have to manually instantiate the class, call the method, and pass arguments...
* Which really isn't a big deal, but this is a convience to that. It also let's you pass a conveient library option.
*
* @param $options array[required] This is your basic controller/action url in array format, you can also pass 'library'
* @return Mixed data from the controller's method to use in your view template
*/
public function requestAction($options=array()) {
$defaults = array('library' => null, 'args' => null);
$options += $defaults;
if((!isset($options['controller'])) || (!isset($options['action']))) {
return false;
}
$controller_name = Inflector::camelize($options['controller']);
if(empty($options['library'])) {
$class = '\minerva\controllers\\'.$controller_name.'Controller';
} else {
$class = '\minerva\libraries\\'.$options['library'].'\controllers\\'.$controller_name.'Controller';
}
$controller = new $class();
return $controller->{$options['action']}($options['args']);
}
/**
* Determines Command to use for current request. If
*
* @param string $request
* @param string $params
* @param string $options
* @return class \lithium\console\COmmand
*/
protected static function _callable($request, $params, $options)
{
$params = compact('request', 'params', 'options');
return static::_filter(__FUNCTION__, $params, function ($self, $params, $chain) {
extract($params, EXTR_OVERWRITE);
$name = $class = $params['command'];
if (!$name) {
$request->params['args'][0] = $name;
$name = $class = '\\lithium\\console\\command\\Help';
}
if ($class[0] !== '\\') {
$name = Inflector::camelize($class);
$class = Libraries::locate('command', $name);
}
if (class_exists($class)) {
return new $class(compact('request'));
}
throw new UnexpectedValueException("Command `{$name}` not found");
});
}
public function testConfigManipulation()
{
$config = MockDispatcher::config();
$expected = array('rules' => array());
$this->assertEqual($expected, $config);
MockDispatcher::config(array('rules' => array('admin' => array('action' => 'admin_{:action}'))));
Router::connect('/', array('controller' => 'test', 'action' => 'test', 'admin' => true));
MockDispatcher::run(new Request(array('url' => '/')));
$result = end(MockDispatcher::$dispatched);
$expected = array('action' => 'admin_test', 'controller' => 'Test', 'admin' => true);
$this->assertEqual($expected, $result->params);
MockDispatcher::config(array('rules' => array('action' => array('action' => function ($params) {
return Inflector::camelize(strtolower($params['action']), false);
}))));
MockDispatcher::$dispatched = array();
Router::reset();
Router::connect('/', array('controller' => 'test', 'action' => 'TeST-camelize'));
MockDispatcher::run(new Request(array('url' => '/')));
$result = end(MockDispatcher::$dispatched);
$expected = array('action' => 'testCamelize', 'controller' => 'Test');
$this->assertEqual($expected, $result->params);
MockDispatcher::config(array('rules' => function ($params) {
if (isset($params['admin'])) {
return array('special' => array('action' => 'special_{:action}'));
}
return array();
}));
MockDispatcher::$dispatched = array();
Router::reset();
Router::connect('/', array('controller' => 'test', 'action' => 'test', 'admin' => true));
Router::connect('/special', array('controller' => 'test', 'action' => 'test', 'admin' => true, 'special' => true));
MockDispatcher::run(new Request(array('url' => '/')));
$result = end(MockDispatcher::$dispatched);
$expected = array('action' => 'test', 'controller' => 'Test', 'admin' => true);
$this->assertEqual($expected, $result->params);
MockDispatcher::run(new Request(array('url' => '/special')));
$result = end(MockDispatcher::$dispatched);
$expected = array('action' => 'special_test', 'controller' => 'Test', 'admin' => true, 'special' => true);
$this->assertEqual($expected, $result->params);
}
/**
* Get the class name for the migration.
*
* @param string $request
* @return string
*/
protected function _class($request)
{
return Inflector::camelize($request->action);
}
/**
* Get record data as an array
*
* @param bool $allProperties If true, get also properties without getter methods
* @return array Data
*/
protected function _getData($allProperties = false)
{
$data = array();
foreach ($this->_getEntityFields() as $field) {
$method = 'get' . Inflector::camelize($field);
if (method_exists($this, $method) && is_callable(array($this, $method))) {
$data[$field] = $this->{$method}();
} elseif ($allProperties && property_exists($this, $field)) {
$data[$field] = $this->{$field};
}
}
if (isset($name)) {
return array_key_exists($name, $data) ? $data[$name] : null;
}
return $data;
}
/**
* Attempts to apply a set of formatting rules from `$_rules` to a `$params` array, where each
* formatting rule is applied if the key of the rule in `$_rules` is present and not empty in
* `$params`. Also performs sanity checking against `$params` to ensure that no value
* matching a rule is present unless the rule check passes.
*
* @param array $params An array of route parameters to which rules will be applied.
* @return array Returns the `$params` array with formatting rules applied to array values.
*/
public static function applyRules(&$params)
{
$values = array();
$rules = static::$_rules;
if (!$params) {
return false;
}
if (isset($params['controller']) && is_string($params['controller'])) {
$controller = $params['controller'];
if (strpos($controller, '.') !== false) {
list($library, $controller) = explode('.', $controller);
$controller = $library . '.' . Inflector::camelize($controller);
$params += compact('library');
} elseif (strpos($controller, '\\') === false) {
$controller = Inflector::camelize($controller);
if (isset($params['library'])) {
$controller = "{$params['library']}.{$controller}";
}
}
$values = compact('controller');
}
$values += $params;
if (is_callable($rules)) {
$rules = $rules($params);
}
foreach ($rules as $rule => $value) {
if (!isset($values[$rule])) {
continue;
}
foreach ($value as $k => $v) {
if (is_callable($v)) {
$values[$k] = $v($values);
continue;
}
$match = preg_replace('/\\{:\\w+\\}/', '@', $v);
$match = preg_replace('/@/', '.+', preg_quote($match, '/'));
if (preg_match('/' . $match . '/i', $values[$k])) {
continue;
}
$values[$k] = String::insert($v, $values);
}
}
return $values;
}
protected static function _parseController(array $params)
{
if (!isset($params['controller'])) {
return $params;
}
if (strpos($params['controller'], '.')) {
$separated = explode('.', $params['controller'], 2);
list($params['library'], $params['controller']) = $separated;
}
if (strpos($params['controller'], '\\') === false) {
$params['controller'] = Inflector::camelize($params['controller']);
}
return $params;
}
public function __construct(array $config = array())
{
$self =& $this;
$defaults = array('base' => array(), 'text' => array(), 'textarea' => array(), 'select' => array('multiple' => false), 'attributes' => array('id' => function ($method, $name, $options) use(&$self) {
if (in_array($method, array('create', 'end', 'label', 'error'))) {
return;
}
if (!$name || $method == 'hidden' && $name == '_method') {
return;
}
$id = Inflector::camelize(Inflector::slug($name));
$model = ($binding = $self->binding()) ? $binding->model() : null;
return $model ? basename(str_replace('\\', '/', $model)) . $id : $id;
}, 'name' => function ($method, $name, $options) {
if (!strpos($name, '.')) {
return $name;
}
$name = explode('.', $name);
$first = array_shift($name);
return $first . '[' . join('][', $name) . ']';
}));
parent::__construct(Set::merge($defaults, $config));
}
/**
* Accepts parameters generated by the `Router` class in `Dispatcher::run()`, and produces a
* callable controller object. By default, this method uses the `'controller'` path lookup
* configuration in `Libraries::locate()` to return a callable object.
*
* @param object $request The instance of the `Request` class either passed into or generated by
* `Dispatcher::run()`.
* @param array $params The parameter array generated by routing the request.
* @param array $options Not currently implemented.
* @return object Returns a callable object which the request will be routed to.
*/
protected static function _callable($request, $params, $options)
{
$params = compact('request', 'params', 'options');
return static::_filter(__FUNCTION__, $params, function ($self, $params, $chain) {
extract($params, EXTR_OVERWRITE);
$library = '';
if (strpos($params['controller'], '.')) {
list($library, $params['controller']) = explode('.', $params['controller']);
$library .= '.';
}
$controller = $library . Inflector::camelize($params['controller']);
$class = Libraries::locate('controllers', $controller);
if (class_exists($class)) {
return new $class(compact('request'));
}
throw new Exception("Controller {$controller} not found");
});
}
/**
* Tests the storage mechanism for `$_underscored`, `$_camelized`,
* `$_humanized` and `$_pluralized`.
*
* @return void
*/
public function testStorageMechanism()
{
Inflector::reset();
$expected = array('TestField' => 'test_field');
$this->assertFalse($this->getProtectedValue('$_underscored'));
$this->assertEqual(Inflector::underscore('TestField'), 'test_field');
$this->assertEqual($expected, $this->getProtectedValue('$_underscored'));
$this->assertEqual(Inflector::underscore('TestField'), 'test_field');
$expected = array('test_field' => 'TestField');
$this->assertFalse($this->getProtectedValue('$_camelized'));
$this->assertEqual(Inflector::camelize('test_field', true), 'TestField');
$this->assertEqual($expected, $this->getProtectedValue('$_camelized'));
$this->assertEqual(Inflector::camelize('test_field', true), 'TestField');
$expected = array('test_field:_' => 'Test Field');
$this->assertFalse($this->getProtectedValue('$_humanized'));
$this->assertEqual(Inflector::humanize('test_field'), 'Test Field');
$this->assertEqual($expected, $this->getProtectedValue('$_humanized'));
$this->assertEqual(Inflector::humanize('test_field'), 'Test Field');
$expected = array('field' => 'fields');
$this->assertFalse($this->getProtectedValue('$_pluralized'));
$this->assertEqual(Inflector::pluralize('field'), 'fields');
$this->assertEqual($expected, $this->getProtectedValue('$_pluralized'));
$this->assertEqual(Inflector::pluralize('field'), 'fields');
}
public function testRunWithGenericActionRule()
{
MockDispatcher::config(array('rules' => array('action' => array('action' => function ($params) {
return Inflector::camelize(strtolower($params['action']), false);
}))));
Router::connect('/', array('controller' => 'test', 'action' => 'TeST-camelize'));
MockDispatcher::run(new Request(array('url' => '/')));
$result = end(MockDispatcher::$dispatched);
$expected = array('action' => 'testCamelize', 'controller' => 'Test');
$this->assertEqual($expected, $result->params);
}
/**
* testVariableNaming method
*
* @return void
*/
public function testVariableNaming()
{
$this->assertEqual(Inflector::camelize('test_field', false), 'testField');
$this->assertEqual(Inflector::camelize('test_fieLd', false), 'testFieLd');
$this->assertEqual(Inflector::camelize('test field', false), 'testField');
$this->assertEqual(Inflector::camelize('Test_field', false), 'testField');
}
public function describe($entity, $schema = array(), array $meta = array())
{
$source = '_' . Inflector::camelize($entity, false);
$fields = isset($this->{$source}) ? $this->{$source} : array();
return $this->_instance('schema', compact('fields'));
}
public function __construct(array $config = array())
{
$self =& $this;
$defaults = array('base' => array(), 'text' => array(), 'textarea' => array(), 'select' => array('multiple' => false), 'attributes' => array('id' => function ($method, $name, $options) use(&$self) {
if (in_array($method, array('create', 'end', 'label', 'error'))) {
return;
}
if (!$name || $method === 'hidden' && $name === '_method') {
return;
}
$info = $self->binding($name);
$model = $info->class;
$id = Inflector::camelize(Inflector::slug($info->name));
return $model ? basename(str_replace('\\', '/', $model)) . $id : $id;
}, 'name' => function ($method, $name, $options) {
if (!strpos($name, '.')) {
return $name;
}
$name = explode('.', $name);
$first = array_shift($name);
return $first . '[' . join('][', $name) . ']';
}), 'binding' => function ($object, $name = null) {
$result = compact('name') + array('data' => null, 'errors' => null, 'class' => null);
if (is_object($object)) {
$result = compact('name') + array('data' => $object->data($name), 'errors' => $object->errors($name), 'class' => $object->model());
}
return (object) $result;
});
parent::__construct(Set::merge($defaults, $config));
}
/**
* Create a `Swift_Message` from `li3_mailer\net\mail\Message`.
*
* @see li3_mailer\net\mail\transport\adapter\Swift::$_messageProperties
* @see li3_mailer\net\mail\transport\adapter\Swift::$_attachmentProperties
* @see li3_mailer\net\mail\Message
* @see Swift_Message
* @param object $message The `Message` object to translate.
* @return object The translated `Swift_Message` object.
*/
protected function _message($message)
{
$swiftMessage = Swift_Message::newInstance();
foreach ($this->_messageProperties as $prop => $translated) {
if (is_int($prop)) {
$prop = $translated;
}
if (!is_null($message->{$prop})) {
$value = $message->{$prop};
if ($translated === 'address') {
$translated = $prop;
if (is_array($value)) {
$newvalue = array();
foreach ($value as $name => $address) {
if (is_int($name)) {
$newvalue[] = $address;
} else {
$newvalue[$address] = $name;
}
}
$value = $newvalue;
}
}
$method = "set" . Inflector::camelize($translated);
$swiftMessage->{$method}($value);
}
}
$first = true;
foreach ($message->types() as $type => $contentType) {
if ($first) {
$first = false;
$swiftMessage->setBody($message->body($type), $contentType);
} else {
$swiftMessage->addPart($message->body($type), $contentType);
}
}
$headers = $swiftMessage->getHeaders();
foreach ($message->headers as $header => $value) {
$headers->addTextHeader($header, $value);
}
foreach ($message->attachments() as $attachment) {
if (isset($attachment['path'])) {
$path = $attachment['path'];
$swiftAttachment = Swift_Attachment::fromPath($path);
} else {
$data = $attachment['data'];
$swiftAttachment = Swift_Attachment::newInstance($data);
}
foreach ($this->_attachmentProperties as $prop => $translated) {
if (is_int($prop)) {
$prop = $translated;
}
if (isset($attachment[$prop])) {
$method = "set" . Inflector::camelize($translated);
$swiftAttachment->{$method}($attachment[$prop]);
}
}
$swiftMessage->attach($swiftAttachment);
}
return $swiftMessage;
}
/**
* Get the parent for the mock.
*
* @param string $request
* @return string
*/
protected function _parent($request)
{
$namespace = parent::_namespace($request);
$class = Inflector::camelize($request->action);
return "\\{$namespace}\\{$class}";
}
/**
* 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));
}
/**
* Attempts to apply a set of formatting rules from `$_rules` to a `$params` array, where each
* formatting rule is applied if the key of the rule in `$_rules` is present and not empty in
* `$params`. Also performs sanity checking against `$params` to ensure that no value
* matching a rule is present unless the rule check passes.
*
* @param array $params An array of route parameters to which rules will be applied.
* @return array Returns the `$params` array with formatting rules applied to array values.
*/
public static function applyRules($params)
{
$result = array();
if (!$params) {
return false;
}
if (isset($params['controller']) && is_string($params['controller'])) {
$controller = $params['controller'];
if (strpos($controller, '.') !== false) {
list($library, $controller) = explode('.', $controller);
$controller = $library . '.' . Inflector::camelize($controller);
} elseif (strpos($controller, '\\') === false) {
$controller = Inflector::camelize($controller);
}
$params['controller'] = $controller;
}
foreach (static::$_rules as $rule => $value) {
foreach ($value as $k => $v) {
if (!empty($params[$rule])) {
$result[$k] = String::insert($v, $params);
}
$match = preg_replace('/\\{:\\w+\\}/', '@', $v);
$match = preg_replace('/@/', '.+', preg_quote($match, '/'));
if (preg_match('/' . $match . '/i', $params[$k])) {
return false;
}
}
}
return $result + array_diff_key($params, $result);
}
/**
* Document relationships.
*
* @param string $class
* @param string $type Relationship type, e.g. `belongsTo`.
* @param string $name
* @param array $config
* @return array
*/
public function relationship($class, $type, $name, array $config = array())
{
$key = Inflector::camelize($type == 'belongsTo' ? $class::meta('name') : $name, false);
$config += compact('name', 'type', 'key');
$config['from'] = $class;
$relationship = $this->_classes['relationship'];
$defaultLinks = array('hasOne' => $relationship::LINK_EMBEDDED, 'hasMany' => $relationship::LINK_EMBEDDED, 'belongsTo' => $relationship::LINK_CONTAINED);
$config += array('link' => $defaultLinks[$type]);
return new $relationship($config);
}
/**
* testVariableNaming method
*
* @return void
*/
public function testCamelize()
{
$this->assertEqual(Inflector::camelize('test-field'), 'TestField');
$this->assertEqual(Inflector::camelize('test_field'), 'TestField');
$this->assertEqual(Inflector::camelize('test_fieLd', false), 'testFieLd');
$this->assertEqual(Inflector::camelize('test field', false), 'testField');
$this->assertEqual(Inflector::camelize('Test_field', false), 'testField');
}