Set::normalize('foo,bar'); // returns array('foo' => null, 'bar' => null);
Set::normalize(array('foo', 'bar' => 'baz'); // returns array('foo' => null, 'bar' => 'baz');
| public static normalize ( string | array $list, boolean $assoc = true, string $sep = ',', boolean $trim = true ) : array | ||
| $list | string | array | List to normalize. |
| $assoc | boolean | If `true`, `$list` will be converted to an associative array. |
| $sep | string | If `$list` is a string, it will be split into an array with `$sep`. |
| $trim | boolean | If `true`, separated strings will be trimmed. |
| return | array | |
/**
* Initializes the record set and uses the database connection to get the column list contained
* in the query that created this object.
*
* @see lithium\data\collection\RecordSet::$_columns
* @return void
* @todo The part that uses _handle->schema() should be rewritten so that the column list
* is coming from the query object.
*/
protected function _init()
{
parent::_init();
if ($this->_result) {
$this->_columns = $this->_columnMap();
if ($this->_query) {
$columns = array_filter(array_keys($this->_columns));
$this->_dependencies = Set::expand(Set::normalize($columns));
$this->_keyIndex = $this->_keyIndex('');
}
}
}
/**
* Initializes the record set and uses the database connection to get the column list contained
* in the query that created this object.
*
* @see lithium\data\collection\RecordSet::$_columns
* @return void
* @todo The part that uses _handle->schema() should be rewritten so that the column list
* is coming from the query object.
*/
protected function _init()
{
parent::_init();
if (!$this->_result) {
return;
}
$this->_columns = $this->_columnMap();
if (!$this->_query) {
return;
}
$this->_keyIndex = $this->_keyIndex();
$this->_dependencies = Set::expand(Set::normalize(array_filter(array_keys($this->_columns))));
$this->_relationships = $this->_query->relationships();
}
/**
* Runs a test group or a specific test file based on the passed
* parameters.
*
* @param string $group If set, this test group is run. If not set, a group test may
* also be run by passing the 'group' option to the $options parameter.
* @param array $options Options array for the test run. Valid options are:
* - 'case': The fully namespaced test case to be run.
* - 'group': The fully namespaced test group to be run.
* - 'filters': An array of filters that the test output should be run through.
* @return array A compact array of the title, an array of the results, as well
* as an additional array of the results after the $options['filters']
* have been applied.
*/
public static function run($group = null, $options = array())
{
$defaults = array('title' => $group, 'filters' => array(), 'reporter' => 'text');
$options += $defaults;
$items = (array) $group;
$isCase = preg_match('/Test$/', $group);
if ($isCase) {
$items = array(new $group());
}
$options['filters'] = Set::normalize($options['filters']);
$group = static::_group($items);
$report = static::_report($group, $options);
$report->run();
return $report;
}
/**
* Runs a test group or a specific test file based on the passed
* parameters.
*
* @param string $group If set, this test group is run. If not set, a group test may
* also be run by passing the 'group' option to the $options parameter.
* @param array $options Options array for the test run. Valid options are:
* - 'case': The fully namespaced test case to be run.
* - 'group': The fully namespaced test group to be run.
* - 'filters': An array of filters that the test output should be run through.
* @return array A compact array of the title, an array of the results, as well
* as an additional array of the results after the $options['filters']
* have been applied.
* @filter
*/
public static function run($group = null, array $options = array())
{
$defaults = array('title' => $group, 'filters' => array(), 'reporter' => 'text');
$options += $defaults;
$isCase = is_string($group) && preg_match('/Test$/', $group);
$items = $isCase ? array(new $group()) : (array) $group;
$options['filters'] = Set::normalize($options['filters']);
$group = static::_group($items);
$report = static::_report($group, $options);
return static::_filter(__FUNCTION__, compact('report'), function ($self, $params, $chain) {
$environment = Environment::get();
Environment::set('test');
$params['report']->run();
Environment::set($environment);
return $params['report'];
});
}
protected static function _prepareMatchParams($parameters)
{
foreach (Set::normalize($parameters) as $token => $scope) {
if (strpos($token, 'T_') !== 0) {
unset($parameters[$token]);
foreach (array('before', 'after') as $key) {
if (!isset($scope[$key])) {
continue;
}
$items = array();
foreach ((array) $scope[$key] as $item) {
$items[] = strpos($item, 'T_') !== 0 ? static::token($item) : $item;
}
$scope[$key] = $items;
}
$parameters[static::token($token)] = $scope;
}
}
return $parameters;
}
/**
* Iterates through relationship types to construct relation map.
*
* @return void
* @todo See if this can be rewritten to be lazy.
*/
protected static function _relationsToLoad()
{
try {
if (!static::connection()) {
return;
}
} catch (ConfigExcepton $e) {
return;
}
$self = static::_object();
foreach ($self->_relationTypes as $type) {
$self->{$type} = Set::normalize($self->{$type});
foreach ($self->{$type} as $name => $config) {
$self->_relationsToLoad[$name] = $type;
}
}
}
public function testMixedKeyNormalization() {
$input = array('"string"' => array('before' => '=>'), 1 => array('before' => '=>'));
$result = Set::normalize($input);
$this->assertEqual($input, $result);
$input = 'Foo,Bar,Baz';
$result = Set::normalize($input);
$this->assertEqual(array('Foo' => null, 'Bar' => null, 'Baz' => null), $result);
$input = array('baz' => 'foo', 'bar');
$result = Set::normalize($input, false);
$this->assertEqual(array('baz' => 'foo', 'bar' => null), $result);
}
protected function _init()
{
parent::_init();
unset($this->_config['type']);
$keys = array_keys($this->_config);
foreach ($this->_initializers as $key) {
$val = $this->_config[$key];
if ($val !== null) {
$this->_config[$key] = is_array($val) ? array() : null;
$this->{$key}($val);
}
}
if ($list = $this->_config['whitelist']) {
$this->_config['whitelist'] = array_combine($list, $list);
}
if ($this->_entity && !$this->_config['model']) {
$this->model($this->_entity->model());
}
if ($this->_config['with']) {
if (!($model = $this->model())) {
throw new ConfigException("The `'with'` option needs a valid binded model.");
}
$this->_config['with'] = Set::normalize($this->_config['with']);
}
if ($model = $this->model()) {
$this->alias($this->_config['alias'] ?: $model::meta('name'));
}
$this->fields($this->_config['fields']);
unset($this->_config['entity'], $this->_config['init']);
}
/**
* Iterates through relationship types to construct relation map.
*
* @return void
* @todo See if this can be rewritten to be lazy.
*/
protected static function _relations()
{
$self = static::_object();
if (!$self->_meta['connection']) {
return;
}
foreach ($self->_relationTypes as $type => $keys) {
foreach (Set::normalize($self->{$type}) as $name => $config) {
static::bind($type, $name, (array) $config);
}
}
}
/**
* Iterates through relationship types to construct relation map.
*
* @todo See if this can be rewritten to be lazy.
* @return void
*/
protected static function _relationsToLoad()
{
try {
if (!($connection = static::connection())) {
return;
}
} catch (ConfigException $e) {
return;
}
if (!$connection::enabled('relationships')) {
return;
}
$self = static::_object();
foreach ($self->_relationTypes as $type) {
$self->{$type} = Set::normalize($self->{$type});
foreach ($self->{$type} as $name => $config) {
$self->_relationsToLoad[$name] = $type;
$fieldName = $self->_relationFieldName($type, $name);
$self->_relationFieldNames[$fieldName] = $name;
}
}
}
public function testMixedKeyNormalization()
{
$input = array('"string"' => array('before' => '=>'), 1 => array('before' => '=>'));
$result = Set::normalize($input);
$this->assertEqual($input, $result);
}
/**
* Initializes behaviors from the `$_actsAs` property of the model.
*
* @return void
*/
protected static function _initializeBehaviors()
{
$model = get_called_class();
if (!empty(static::$_initializedBehaviors[$model])) {
return;
}
static::$_initializedBehaviors[$model] = true;
$self = $model::_object();
if (!property_exists($self, '_actsAs')) {
return;
}
foreach (Set::normalize($self->_actsAs) as $name => $config) {
static::bindBehavior($name, $config ?: []);
}
}
/**
* Iterates through relationship types to construct relation map.
*
* @return void
* @todo See if this can be rewritten to be lazy.
*/
protected static function _relations()
{
$relations = array();
$self = static::_instance();
foreach ($self->_relationTypes as $type => $keys) {
foreach (Set::normalize($self->{$type}) as $name => $options) {
$key = Inflector::underscore($type == 'belongsTo' ? $name : $self->_meta['name']);
$defaults = array('type' => $type, 'class' => $name, 'fields' => true, 'key' => $key . '_id');
$relations[$name] = (array) $options + $defaults;
}
}
return $relations;
}
/**
* Creates the database object and set default values for it.
*
* Options defined:
* - 'database' _string_ Name of the database to use. Defaults to `null`.
* - 'host' _string_ Name/address of server to connect to. Defaults to 'localhost'.
* - 'login' _string_ Username to use when connecting to server. Defaults to 'root'.
* - 'password' _string_ Password to use when connecting to server. Defaults to `''`.
* - 'persistent' _boolean_ If true a persistent connection will be attempted, provided the
* adapter supports it. Defaults to `true`.
*
* @param $config array Array of configuration options.
* @return Database object.
*/
public function __construct(array $config = array())
{
$defaults = array('persistent' => true, 'host' => 'localhost', 'login' => 'root', 'password' => '', 'database' => null, 'encoding' => null, 'dsn' => null, 'options' => array());
$this->_strings += array('read' => 'SELECT {:fields} FROM {:source} {:alias} {:joins} {:conditions} {:group} ' . '{:having} {:order} {:limit};{:comment}');
$this->_strategies += array('joined' => function ($self, $model, $context) {
$with = $context->with();
$strategy = function ($me, $model, $tree, $path, $from, &$deps) use($self, $context, $with) {
foreach ($tree as $name => $childs) {
if (!($rel = $model::relations($name))) {
throw new QueryException("Model relationship `{$name}` not found.");
}
$constraints = array();
$alias = $name;
$relPath = $path ? $path . '.' . $name : $name;
if (isset($with[$relPath])) {
list($unallowed, $allowed) = Set::slice($with[$relPath], array('alias', 'constraints'));
if ($unallowed) {
$message = "Only `'alias'` and `'constraints'` are allowed in ";
$message .= "`'with'` using the `'joined'` strategy.";
throw new QueryException($message);
}
extract($with[$relPath]);
}
$to = $context->alias($alias, $relPath);
$deps[$to] = $deps[$from];
$deps[$to][] = $from;
if ($context->relationships($relPath) === null) {
$context->relationships($relPath, array('type' => $rel->type(), 'model' => $rel->to(), 'fieldName' => $rel->fieldName(), 'alias' => $to));
$self->join($context, $rel, $from, $to, $constraints);
}
if (!empty($childs)) {
$me($me, $rel->to(), $childs, $relPath, $to, $deps);
}
}
};
$tree = Set::expand(Set::normalize(array_keys($with)));
$alias = $context->alias();
$deps = array($alias => array());
$strategy($strategy, $model, $tree, '', $alias, $deps);
$models = $context->models();
foreach ($context->fields() as $field) {
list($alias, $field) = $self->invokeMethod('_splitFieldname', array($field));
$alias = $alias ?: $field;
if ($alias && isset($models[$alias])) {
foreach ($deps[$alias] as $depAlias) {
$depModel = $models[$depAlias];
$context->fields(array($depAlias => (array) $depModel::meta('key')));
}
}
}
}, 'nested' => function ($self, $model, $context) {
throw new QueryException("This strategy is not yet implemented.");
});
parent::__construct($config + $defaults);
}