PHP CakeText::tokenize方法代码示例

 /**
  * Main execution function to indent a folder recursivly
  *
  * @return void
  */
 public function folder()
 {
     if (!empty($this->params['extensions'])) {
         $this->settings['files'] = CakeText::tokenize($this->params['extensions']);
     }
     if (!empty($this->params['again'])) {
         $this->settings['againWithHalf'] = true;
     }
     if (!empty($this->args)) {
         if (!empty($this->args[0]) && $this->args[0] !== 'app') {
             $folder = $this->args[0];
             if ($folder === '/') {
                 $folder = APP;
             }
             $folder = realpath($folder);
             if (!file_exists($folder)) {
                 return $this->error('folder not exists: ' . $folder . '');
             }
             $this->_paths[] = $folder;
         } elseif ($this->args[0] === 'app') {
             $this->_paths[] = APP;
         }
         if (!empty($this->params['files'])) {
             $this->settings['files'] = explode(',', $this->params['files']);
         }
         $this->out($folder);
         $this->out('searching...');
         $this->_searchFiles();
         $this->out('found: ' . count($this->_files));
         if (!empty($this->params['dry-run'])) {
             $this->out('TEST DONE');
         } else {
             $continue = $this->in('Modifying files! Continue?', ['y', 'n'], 'n');
             if (strtolower($continue) !== 'y' && strtolower($continue) !== 'yes') {
                 return $this->error('...aborted');
             }
             $this->_correctFiles();
             $this->out('DONE');
         }
     } else {
         $this->out('Usage: cake intend folder');
         $this->out('"folder" is then intended recursivly');
         $this->out('default file types are');
         $this->out('[' . implode(', ', $this->settings['files']) . ']');
         $this->out('');
         $this->out('Specify file types manually:');
         $this->out('-files php,js,css');
     }
 }

 /**
  * testTokenize method
  *
  * @return void
  */
 public function testTokenize()
 {
     $result = CakeText::tokenize('A,(short,boring test)');
     $expected = array('A', '(short,boring test)');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('A,(short,more interesting( test)');
     $expected = array('A', '(short,more interesting( test)');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('A,(short,very interesting( test))');
     $expected = array('A', '(short,very interesting( test))');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('"single tag"', ' ', '"', '"');
     $expected = array('"single tag"');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('tagA "single tag" tagB', ' ', '"', '"');
     $expected = array('tagA', '"single tag"', 'tagB');
     $this->assertEquals($expected, $result);
     // Ideographic width space.
     $result = CakeText::tokenize("tagA　\"single　tag\"　tagB", "　", '"', '"');
     $expected = array('tagA', '"single　tag"', 'tagB');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('');
     $expected = array();
     $this->assertEquals($expected, $result);
 }

 /**
  * beforeFind Callback
  *
  * @param Model $Model Model find is being run on.
  * @param array $query Array of Query parameters.
  * @return array Modified query
  */
 public function beforeFind(Model $Model, $query)
 {
     $this->runtime[$Model->alias]['virtualFields'] = $Model->virtualFields;
     $locale = $this->_getLocale($Model);
     if (empty($locale)) {
         return $query;
     }
     $db = $Model->getDataSource();
     $RuntimeModel = $this->translateModel($Model);
     if (!empty($RuntimeModel->tablePrefix)) {
         $tablePrefix = $RuntimeModel->tablePrefix;
     } else {
         $tablePrefix = $db->config['prefix'];
     }
     $joinTable = new StdClass();
     $joinTable->tablePrefix = $tablePrefix;
     $joinTable->table = $RuntimeModel->table;
     $joinTable->schemaName = $RuntimeModel->getDataSource()->getSchemaName();
     $this->_joinTable = $joinTable;
     $this->_runtimeModel = $RuntimeModel;
     $query['group'] = $Model->alias . '.id';
     //Modified for request only one per Id
     if (is_string($query['fields']) && $query['fields'] === "COUNT(*) AS {$db->name('count')}") {
         $query['fields'] = "COUNT(DISTINCT({$db->name($Model->escapeField())})) {$db->alias}count";
         $query['joins'][] = array('type' => 'INNER', 'alias' => $RuntimeModel->alias, 'table' => $joinTable, 'conditions' => array($Model->escapeField() => $db->identifier($RuntimeModel->escapeField('foreign_key')), $RuntimeModel->escapeField('model') => $Model->name, $RuntimeModel->escapeField('locale') => array($locale, Configure::read('webConfig.default_language'))));
         $conditionFields = $this->_checkConditions($Model, $query);
         foreach ($conditionFields as $field) {
             $query = $this->_addJoin($Model, $query, $field, $field, $locale);
         }
         unset($this->_joinTable, $this->_runtimeModel);
         return $query;
     } elseif (is_string($query['fields'])) {
         $query['fields'] = CakeText::tokenize($query['fields']);
     }
     $fields = array_merge($this->settings[$Model->alias], $this->runtime[$Model->alias]['fields']);
     $addFields = array();
     if (empty($query['fields'])) {
         $addFields = $fields;
     } elseif (is_array($query['fields'])) {
         $isAllFields = in_array($Model->alias . '.' . '*', $query['fields']) || in_array($Model->escapeField('*'), $query['fields']);
         foreach ($fields as $key => $value) {
             $field = is_numeric($key) ? $value : $key;
             if ($isAllFields || in_array($Model->alias . '.' . $field, $query['fields']) || in_array($field, $query['fields'])) {
                 $addFields[] = $field;
             }
         }
     }
     $this->runtime[$Model->alias]['virtualFields'] = $Model->virtualFields;
     if ($addFields) {
         foreach ($addFields as $_f => $field) {
             $aliasField = is_numeric($_f) ? $field : $_f;
             foreach (array($aliasField, $Model->alias . '.' . $aliasField) as $_field) {
                 $key = array_search($_field, (array) $query['fields']);
                 if ($key !== false) {
                     unset($query['fields'][$key]);
                 }
             }
             $query = $this->_addJoin($Model, $query, $field, $aliasField, $locale);
         }
     }
     $this->runtime[$Model->alias]['beforeFind'] = $addFields;
     unset($this->_joinTable, $this->_runtimeModel);
     return $query;
 }

 /**
  * Generates the fields list of an SQL query.
  *
  * @param Model $Model The model to get fields for.
  * @param string $alias Alias table name
  * @param mixed $fields The provided list of fields.
  * @param bool $quote If false, returns fields array unquoted
  * @return array
  */
 public function fields(Model $Model, $alias = null, $fields = array(), $quote = true)
 {
     if (empty($alias)) {
         $alias = $Model->alias;
     }
     $virtualFields = $Model->getVirtualField();
     $cacheKey = array($alias, get_class($Model), $Model->alias, $virtualFields, $fields, $quote, ConnectionManager::getSourceName($this), $Model->schemaName, $Model->table);
     $cacheKey = md5(serialize($cacheKey));
     if ($return = $this->cacheMethod(__FUNCTION__, $cacheKey)) {
         return $return;
     }
     $allFields = empty($fields);
     if ($allFields) {
         $fields = array_keys($Model->schema());
     } elseif (!is_array($fields)) {
         $fields = CakeText::tokenize($fields);
     }
     $fields = array_values(array_filter($fields));
     $allFields = $allFields || in_array('*', $fields) || in_array($Model->alias . '.*', $fields);
     $virtual = array();
     if (!empty($virtualFields)) {
         $virtualKeys = array_keys($virtualFields);
         foreach ($virtualKeys as $field) {
             $virtualKeys[] = $Model->alias . '.' . $field;
         }
         $virtual = $allFields ? $virtualKeys : array_intersect($virtualKeys, $fields);
         foreach ($virtual as $i => $field) {
             if (strpos($field, '.') !== false) {
                 $virtual[$i] = str_replace($Model->alias . '.', '', $field);
             }
             $fields = array_diff($fields, array($field));
         }
         $fields = array_values($fields);
     }
     if (!$quote) {
         if (!empty($virtual)) {
             $fields = array_merge($fields, $this->_constructVirtualFields($Model, $alias, $virtual));
         }
         return $fields;
     }
     $count = count($fields);
     if ($count >= 1 && !in_array($fields[0], array('*', 'COUNT(*)'))) {
         for ($i = 0; $i < $count; $i++) {
             if (is_string($fields[$i]) && in_array($fields[$i], $virtual)) {
                 unset($fields[$i]);
                 continue;
             }
             if (is_object($fields[$i]) && isset($fields[$i]->type) && $fields[$i]->type === 'expression') {
                 $fields[$i] = $fields[$i]->value;
             } elseif (preg_match('/^\\(.*\\)\\s' . $this->alias . '.*/i', $fields[$i])) {
                 continue;
             } elseif (!preg_match('/^.+\\(.*\\)/', $fields[$i])) {
                 $prepend = '';
                 if (strpos($fields[$i], 'DISTINCT') !== false) {
                     $prepend = 'DISTINCT ';
                     $fields[$i] = trim(str_replace('DISTINCT', '', $fields[$i]));
                 }
                 $dot = strpos($fields[$i], '.');
                 if ($dot === false) {
                     $prefix = !(strpos($fields[$i], ' ') !== false || strpos($fields[$i], '(') !== false);
                     $fields[$i] = $this->name(($prefix ? $alias . '.' : '') . $fields[$i]);
                 } else {
                     if (strpos($fields[$i], ',') === false) {
                         $build = explode('.', $fields[$i]);
                         if (!Hash::numeric($build)) {
                             $fields[$i] = $this->name(implode('.', $build));
                         }
                     }
                 }
                 $fields[$i] = $prepend . $fields[$i];
             } elseif (preg_match('/\\(([\\.\\w]+)\\)/', $fields[$i], $field)) {
                 if (isset($field[1])) {
                     if (strpos($field[1], '.') === false) {
                         $field[1] = $this->name($alias . '.' . $field[1]);
                     } else {
                         $field[0] = explode('.', $field[1]);
                         if (!Hash::numeric($field[0])) {
                             $field[0] = implode('.', array_map(array(&$this, 'name'), $field[0]));
                             $fields[$i] = preg_replace('/\\(' . $field[1] . '\\)/', '(' . $field[0] . ')', $fields[$i], 1);
                         }
                     }
                 }
             }
         }
     }
     if (!empty($virtual)) {
         $fields = array_merge($fields, $this->_constructVirtualFields($Model, $alias, $virtual));
     }
     return $this->cacheMethod(__FUNCTION__, $cacheKey, array_unique($fields));
 }

 /**
  * Handles the before/after filter logic for find('list') operations. Only called by Model::find().
  *
  * @param string $state Either "before" or "after"
  * @param array $query Query.
  * @param array $results Results.
  * @return array Key/value pairs of primary keys/display field values of all records found
  * @see Model::find()
  */
 protected function _findList($state, $query, $results = array())
 {
     if ($state === 'before') {
         if (empty($query['fields'])) {
             $query['fields'] = array("{$this->alias}.{$this->primaryKey}", "{$this->alias}.{$this->displayField}");
             $list = array("{n}.{$this->alias}.{$this->primaryKey}", "{n}.{$this->alias}.{$this->displayField}", null);
         } else {
             if (!is_array($query['fields'])) {
                 $query['fields'] = CakeText::tokenize($query['fields']);
             }
             if (count($query['fields']) === 1) {
                 if (strpos($query['fields'][0], '.') === false) {
                     $query['fields'][0] = $this->alias . '.' . $query['fields'][0];
                 }
                 $list = array("{n}.{$this->alias}.{$this->primaryKey}", '{n}.' . $query['fields'][0], null);
                 $query['fields'] = array("{$this->alias}.{$this->primaryKey}", $query['fields'][0]);
             } elseif (count($query['fields']) === 3) {
                 for ($i = 0; $i < 3; $i++) {
                     if (strpos($query['fields'][$i], '.') === false) {
                         $query['fields'][$i] = $this->alias . '.' . $query['fields'][$i];
                     }
                 }
                 $list = array('{n}.' . $query['fields'][0], '{n}.' . $query['fields'][1], '{n}.' . $query['fields'][2]);
             } else {
                 for ($i = 0; $i < 2; $i++) {
                     if (strpos($query['fields'][$i], '.') === false) {
                         $query['fields'][$i] = $this->alias . '.' . $query['fields'][$i];
                     }
                 }
                 $list = array('{n}.' . $query['fields'][0], '{n}.' . $query['fields'][1], null);
             }
         }
         if (!isset($query['recursive']) || $query['recursive'] === null) {
             $query['recursive'] = -1;
         }
         list($query['list']['keyPath'], $query['list']['valuePath'], $query['list']['groupPath']) = $list;
         return $query;
     }
     if (empty($results)) {
         return array();
     }
     return Hash::combine($results, $query['list']['keyPath'], $query['list']['valuePath'], $query['list']['groupPath']);
 }

 /**
  * Remove data matching $path from the $data array.
  * You can use `{n}` and `{s}` to remove multiple elements
  * from $data.
  *
  * @param array $data The data to operate on
  * @param string $path A path expression to use to remove.
  * @return array The modified array.
  * @link http://book.cakephp.org/2.0/en/core-utility-libraries/hash.html#Hash::remove
  */
 public static function remove(array $data, $path)
 {
     if (strpos($path, '[') === false) {
         $tokens = explode('.', $path);
     } else {
         $tokens = CakeText::tokenize($path, '.', '[', ']');
     }
     if (strpos($path, '{') === false && strpos($path, '[') === false) {
         return static::_simpleOp('remove', $data, $tokens);
     }
     $token = array_shift($tokens);
     $nextPath = implode('.', $tokens);
     list($token, $conditions) = static::_splitConditions($token);
     foreach ($data as $k => $v) {
         $match = static::_matchToken($k, $token);
         if ($match && is_array($v)) {
             if ($conditions && static::_matches($v, $conditions)) {
                 unset($data[$k]);
                 continue;
             }
             $data[$k] = static::remove($v, $nextPath);
             if (empty($data[$k])) {
                 unset($data[$k]);
             }
         } elseif ($match && empty($nextPath)) {
             unset($data[$k]);
         }
     }
     return $data;
 }

 /**
  * Gets a value from an array or object that is contained in a given path using an array path syntax, i.e.:
  * "{n}.Person.{[a-z]+}" - Where "{n}" represents a numeric key, "Person" represents a string literal,
  * and "{[a-z]+}" (i.e. any string literal enclosed in brackets besides {n} and {s}) is interpreted as
  * a regular expression.
  *
  * @param array $data Array from where to extract
  * @param string|array $path As an array, or as a dot-separated string.
  * @return mixed An array of matched items or the content of a single selected item or null in any of these cases: $path or $data are null, no items found.
  * @link http://book.cakephp.org/2.0/en/core-utility-libraries/set.html#Set::classicExtract
  */
 public static function classicExtract($data, $path = null)
 {
     if (empty($path)) {
         return $data;
     }
     if (is_object($data)) {
         if (!($data instanceof ArrayAccess || $data instanceof Traversable)) {
             $data = get_object_vars($data);
         }
     }
     if (empty($data)) {
         return null;
     }
     if (is_string($path) && strpos($path, '{') !== false) {
         $path = CakeText::tokenize($path, '.', '{', '}');
     } elseif (is_string($path)) {
         $path = explode('.', $path);
     }
     $tmp = array();
     if (empty($path)) {
         return null;
     }
     foreach ($path as $i => $key) {
         if (is_numeric($key) && (int) $key > 0 || $key === '0') {
             if (isset($data[$key])) {
                 $data = $data[$key];
             } else {
                 return null;
             }
         } elseif ($key === '{n}') {
             foreach ($data as $j => $val) {
                 if (is_int($j)) {
                     $tmpPath = array_slice($path, $i + 1);
                     if (empty($tmpPath)) {
                         $tmp[] = $val;
                     } else {
                         $tmp[] = Set::classicExtract($val, $tmpPath);
                     }
                 }
             }
             return $tmp;
         } elseif ($key === '{s}') {
             foreach ($data as $j => $val) {
                 if (is_string($j)) {
                     $tmpPath = array_slice($path, $i + 1);
                     if (empty($tmpPath)) {
                         $tmp[] = $val;
                     } else {
                         $tmp[] = Set::classicExtract($val, $tmpPath);
                     }
                 }
             }
             return $tmp;
         } elseif (strpos($key, '{') !== false && strpos($key, '}') !== false) {
             $pattern = substr($key, 1, -1);
             foreach ($data as $j => $val) {
                 if (preg_match('/^' . $pattern . '/s', $j) !== 0) {
                     $tmpPath = array_slice($path, $i + 1);
                     if (empty($tmpPath)) {
                         $tmp[$j] = $val;
                     } else {
                         $tmp[$j] = Set::classicExtract($val, $tmpPath);
                     }
                 }
             }
             return $tmp;
         } else {
             if (isset($data[$key])) {
                 $data = $data[$key];
             } else {
                 return null;
             }
         }
     }
     return $data;
 }

 /**
  * Gets the values from an array matching the $path expression.
  * The path expression is a dot separated expression, that can contain a set
  * of patterns and expressions:
  *
  * - `{n}` Matches any numeric key, or integer.
  * - `{s}` Matches any string key.
  * - `{*}` Matches any value.
  * - `Foo` Matches any key with the exact same value.
  *
  * There are a number of attribute operators:
  *
  *  - `=`, `!=` Equality.
  *  - `>`, `<`, `>=`, `<=` Value comparison.
  *  - `=/.../` Regular expression pattern match.
  *
  * Given a set of User array data, from a `$User->find('all')` call:
  *
  * - `1.User.name` Get the name of the user at index 1.
  * - `{n}.User.name` Get the name of every user in the set of users.
  * - `{n}.User[id]` Get the name of every user with an id key.
  * - `{n}.User[id>=2]` Get the name of every user with an id key greater than or equal to 2.
  * - `{n}.User[username=/^paul/]` Get User elements with username matching `^paul`.
  *
  * @param array  $data The data to extract from.
  * @param string $path The path to extract.
  *
  * @return array An array of the extracted values. Returns an empty array
  *   if there are no matches.
  * @link http://book.cakephp.org/2.0/en/core-utility-libraries/hash.html#Hash::extract
  */
 public static function extract(array $data, $path)
 {
     if (empty($path)) {
         return $data;
     }
     // Simple paths.
     if (!preg_match('/[{\\[]/', $path)) {
         return (array) static::get($data, $path);
     }
     if (strpos($path, '[') === FALSE) {
         $tokens = explode('.', $path);
     } else {
         $tokens = CakeText::tokenize($path, '.', '[', ']');
     }
     $_key = '__set_item__';
     $context = array($_key => array($data));
     foreach ($tokens as $token) {
         $next = array();
         list($token, $conditions) = static::_splitConditions($token);
         foreach ($context[$_key] as $item) {
             foreach ((array) $item as $k => $v) {
                 if (static::_matchToken($k, $token)) {
                     $next[] = $v;
                 }
             }
         }
         // Filter for attributes.
         if ($conditions) {
             $filter = array();
             foreach ($next as $item) {
                 if (is_array($item) && static::_matches($item, $conditions)) {
                     $filter[] = $item;
                 }
             }
             $next = $filter;
         }
         $context = array($_key => $next);
     }
     return $context[$_key];
 }

 public function _fromList(Model $Model, $val)
 {
     extract($this->settings[$Model->alias]);
     return CakeText::tokenize($val, $separator, $leftBound, $rightBound);
 }

 /**
  * Read database and Write schema object
  * accepts a connection as first arg or path to save as second arg
  *
  * @return void
  */
 public function generate()
 {
     $this->out(__d('cake_console', 'Generating Schema...'));
     $options = array();
     if ($this->params['force']) {
         $options['models'] = false;
     } elseif (!empty($this->params['models'])) {
         $options['models'] = CakeText::tokenize($this->params['models']);
     }
     $snapshot = false;
     if (isset($this->args[0]) && $this->args[0] === 'snapshot') {
         $snapshot = true;
     }
     if (!$snapshot && file_exists($this->Schema->path . DS . $this->params['file'])) {
         $snapshot = true;
         $prompt = __d('cake_console', "Schema file exists.\n [O]verwrite\n [S]napshot\n [Q]uit\nWould you like to do?");
         $result = strtolower($this->in($prompt, array('o', 's', 'q'), 's'));
         if ($result === 'q') {
             return $this->_stop();
         }
         if ($result === 'o') {
             $snapshot = false;
         }
     }
     $cacheDisable = Configure::read('Cache.disable');
     Configure::write('Cache.disable', true);
     $content = $this->Schema->read($options);
     $content['file'] = $this->params['file'];
     Configure::write('Cache.disable', $cacheDisable);
     if (!empty($this->params['exclude']) && !empty($content)) {
         $excluded = CakeText::tokenize($this->params['exclude']);
         foreach ($excluded as $table) {
             unset($content['tables'][$table]);
         }
     }
     if ($snapshot === true) {
         $fileName = basename($this->params['file'], '.php');
         $Folder = new Folder($this->Schema->path);
         $result = $Folder->read();
         $numToUse = false;
         if (isset($this->params['snapshot'])) {
             $numToUse = $this->params['snapshot'];
         }
         $count = 0;
         if (!empty($result[1])) {
             foreach ($result[1] as $file) {
                 if (preg_match('/' . preg_quote($fileName) . '(?:[_\\d]*)?\\.php$/', $file)) {
                     $count++;
                 }
             }
         }
         if ($numToUse !== false) {
             if ($numToUse > $count) {
                 $count = $numToUse;
             }
         }
         $content['file'] = $fileName . '_' . $count . '.php';
     }
     if ($this->Schema->write($content)) {
         $this->out(__d('cake_console', 'Schema file: %s generated', $content['file']));
         return $this->_stop();
     }
     $this->err(__d('cake_console', 'Schema file: %s generated'));
     return $this->_stop();
 }

 /**
  * Overwrite the schema.php file
  *
  * @return void
  */
 protected function _overwriteSchema()
 {
     $options = array();
     if ($this->params['force']) {
         $options['models'] = false;
     } elseif (!empty($this->params['models'])) {
         $options['models'] = CakeText::tokenize($this->params['models']);
     }
     $cacheDisable = Configure::read('Cache.disable');
     Configure::write('Cache.disable', true);
     $content = $this->Schema->read($options);
     $file = 'schema.php';
     Configure::write('Cache.disable', $cacheDisable);
     if (!empty($this->params['exclude']) && !empty($content)) {
         $excluded = CakeText::tokenize($this->params['exclude']);
         foreach ($excluded as $table) {
             unset($content['tables'][$table]);
         }
     }
     if ($this->Schema->write($content)) {
         $this->out(__d('cake_console', 'Schema file: %s generated', $file));
         return $this->_stop();
     }
     $this->err(__d('cake_console', 'Schema file: %s generated'));
     return $this->_stop();
 }

 /**
  * Generate ResultSet
  *
  * @param mixed $results The results to modify.
  * @return void
  */
 public function resultSet($results)
 {
     $this->results = $results;
     $this->map = array();
     $numFields = $results->columnCount();
     $index = 0;
     $j = 0;
     // PDO::getColumnMeta is experimental and does not work with sqlite3,
     // so try to figure it out based on the querystring
     $querystring = $results->queryString;
     if (stripos($querystring, 'SELECT') === 0 && stripos($querystring, 'FROM') > 0) {
         $selectpart = substr($querystring, 7);
         $selects = array();
         foreach (CakeText::tokenize($selectpart, ',', '(', ')') as $part) {
             $fromPos = stripos($part, ' FROM ');
             if ($fromPos !== false) {
                 $selects[] = trim(substr($part, 0, $fromPos));
                 break;
             }
             $selects[] = $part;
         }
     } elseif (strpos($querystring, 'PRAGMA table_info') === 0) {
         $selects = array('cid', 'name', 'type', 'notnull', 'dflt_value', 'pk');
     } elseif (strpos($querystring, 'PRAGMA index_list') === 0) {
         $selects = array('seq', 'name', 'unique');
     } elseif (strpos($querystring, 'PRAGMA index_info') === 0) {
         $selects = array('seqno', 'cid', 'name');
     }
     while ($j < $numFields) {
         if (!isset($selects[$j])) {
             $j++;
             continue;
         }
         if (preg_match('/\\bAS(?!.*\\bAS\\b)\\s+(.*)/i', $selects[$j], $matches)) {
             $columnName = trim($matches[1], '"');
         } else {
             $columnName = trim(str_replace('"', '', $selects[$j]));
         }
         if (strpos($selects[$j], 'DISTINCT') === 0) {
             $columnName = str_ireplace('DISTINCT', '', $columnName);
         }
         $metaType = false;
         try {
             $metaData = (array) $results->getColumnMeta($j);
             if (!empty($metaData['sqlite:decl_type'])) {
                 $metaType = trim($metaData['sqlite:decl_type']);
             }
         } catch (Exception $e) {
         }
         if (strpos($columnName, '.')) {
             $parts = explode('.', $columnName);
             $this->map[$index++] = array(trim($parts[0]), trim($parts[1]), $metaType);
         } else {
             $this->map[$index++] = array(0, $columnName, $metaType);
         }
         $j++;
     }
 }

 /**
  * testTokenize method
  *
  * @return void
  */
 public function testTokenize()
 {
     $result = CakeText::tokenize('A,(short,boring test)');
     $expected = array('A', '(short,boring test)');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('A,(short,more interesting( test)');
     $expected = array('A', '(short,more interesting( test)');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('A,(short,very interesting( test))');
     $expected = array('A', '(short,very interesting( test))');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('"single tag"', ' ', '"', '"');
     $expected = array('"single tag"');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('tagA "single tag" tagB', ' ', '"', '"');
     $expected = array('tagA', '"single tag"', 'tagB');
     $this->assertEquals($expected, $result);
     $result = CakeText::tokenize('');
     $expected = array();
     $this->assertEquals($expected, $result);
 }

 /**
  * CakeText::tokenizeをSiteSetting用に修正
  *
  * @param string $keyPath Hashクラスのpath
  * @return array
  */
 protected static function _tokenize($keyPath)
 {
     $pathes = CakeText::tokenize($keyPath, '.', '[', ']');
     $pathes = preg_replace('/[\\[\\]]/', '', $pathes);
     return $pathes;
 }

 /**
  * Takes list of items and transforms it into an array
  * + cleaning (trim, no empty parts, etc).
  * Similar to CakeText::tokenize, but with more logic.
  *
  * //TODO: 3.4. parameter as array, move to Lib
  *
  * @deprecated Will be removed in 1.0.
  * @param string $string containing the parts
  * @param string $separator (defaults to ',')
  * @param bool $camelize (true/false): problems with äöüß etc!
  * @return array Results as list
  */
 public function parseList($string, $separator = null, $camelize = false, $capitalize = true)
 {
     if ($separator === null) {
         $separator = ',';
     }
     // parses the list, but leaves tokens untouched inside () brackets
     $stringArray = CakeText::tokenize($string, $separator);
     $returnArray = [];
     if (empty($stringArray)) {
         return [];
     }
     foreach ($stringArray as $t) {
         $t = trim($t);
         if (!empty($t)) {
             if ($camelize === true) {
                 $t = mb_strtolower($t);
                 $t = Inflector::camelize(Inflector::underscore($t));
                 // problems with non-alpha chars!
             } elseif ($capitalize === true) {
                 $t = ucwords($t);
             }
             $returnArray[] = $t;
         }
     }
     return $returnArray;
 }