PHP Hash::normalize方法代码示例

 /**
  * {@inheritDoc}
  */
 public function initialize(array $config)
 {
     if (isset($config['events'])) {
         $this->config('events', $config['events'], false);
     }
     $config = $this->config();
     foreach ($config['events'] as $name => $options) {
         $this->config('events.' . $name, Hash::normalize($options));
         foreach (array_keys($this->config('events.' . $name)) as $field) {
             if (!in_array($field, $config['propertiesMap']) && !isset($config['propertiesMap'][$field])) {
                 $config['propertiesMap'][] = $field;
             }
         }
     }
     foreach ($config['propertiesMap'] as $property => $map) {
         if (is_numeric($property)) {
             unset($config['propertiesMap'][$property]);
             $property = $map;
             $map = $config['primaryKey'];
             $config['propertiesMap'] += [$property => $map];
         }
         if (strpos($map, '.') === false) {
             $config['propertiesMap'][$property] = implode('.', [$config['optionKey'], $map]);
         }
     }
     $this->config('propertiesMap', $config['propertiesMap'], false);
 }

 /**
  * Constructor.
  *
  * @param array $config Settings for the filter.
  */
 public function __construct($config = [])
 {
     if (isset($config['languages'])) {
         $config['languages'] = Hash::normalize($config['languages']);
     }
     $this->config($config);
 }

 /**
  * Initialize hook
  *
  * @param array $config The config for this behavior.
  * @return void
  */
 public function initialize(array $config)
 {
     $this->config(Hash::normalize($config));
     Type::map('upload.file', 'Josegonzalez\\Upload\\Database\\Type\\FileType');
     $schema = $this->_table->schema();
     foreach (array_keys($this->config()) as $field) {
         $schema->columnType($field, 'upload.file');
     }
     $this->_table->schema($schema);
 }

 /**
  * Constructor for a Route
  *
  * @param string $template Template string with parameter placeholders
  * @param array $defaults Array of defaults for the route.
  * @param string $options Array of parameters and additional options for the Route
  * @return void
  */
 public function __construct($template, $defaults = [], array $options = [])
 {
     if (strpos($template, ':lang') === false) {
         $template = '/:lang' . $template;
     }
     if ($template === '/:lang/') {
         $template = '/:lang';
     }
     $options['inflect'] = 'dasherize';
     $options['persist'][] = 'lang';
     if (!array_key_exists('lang', $options)) {
         if (self::$_langRegEx === null && ($langs = Configure::read('I18n.languages'))) {
             self::$_langRegEx = implode('|', array_keys(Hash::normalize($langs)));
         }
         $options['lang'] = self::$_langRegEx;
     }
     parent::__construct($template, $defaults, $options);
 }

 /**
  * Map entities to schema files
  * @param  array  $entities An array of entity names that need to be mapped to a schema class
  *   If the schema class does not exist, the default EntitySchema will be used.
  *
  * @return array A list of Entity class names as its key and a closure returning the schema class
  * @throws MissingViewVarException when the _entities view variable is empty
  * @throws MissingEntityException when defined entity class was not found in entities array
  */
 protected function _entitiesToSchema(array $entities)
 {
     if (empty($entities)) {
         throw new MissingViewVarException(['_entities']);
     }
     $schemas = [];
     $entities = Hash::normalize($entities);
     foreach ($entities as $entityName => $options) {
         $entityclass = App::className($entityName, 'Model\\Entity');
         if (!$entityclass) {
             throw new MissingEntityException([$entityName]);
         }
         $schemaClass = App::className($entityName, 'View\\Schema', 'Schema');
         if (!$schemaClass) {
             $schemaClass = App::className('JsonApi.Entity', 'View\\Schema', 'Schema');
         }
         $schema = function ($factory, $container) use($schemaClass, $entityName) {
             return new $schemaClass($factory, $container, $this, $entityName);
         };
         $schemas[$entityclass] = $schema;
     }
     return $schemas;
 }

 /**
  * Generate a set of inputs for `$fields` wrapped in a fieldset element.
  *
  * You can customize individual inputs through `$fields`.
  * ```
  * $this->Form->inputs([
  *   'name' => ['label' => 'custom label'],
  *   'email'
  * ]);
  * ```
  *
  * @param array $fields An array of the fields to generate. This array allows you to set custom
  *   types, labels, or other options.
  * @param array $options Options array. Valid keys are:
  * - `fieldset` Set to false to disable the fieldset. You can also pass an array of params to be
  *    applied as HTML attributes to the fieldset tag. If you pass an empty array, the fieldset will
  *    be enabled
  * - `legend` Set to false to disable the legend for the generated input set. Or supply a string
  *    to customize the legend text.
  * @return string Completed form inputs.
  * @link http://book.cakephp.org/3.0/en/views/helpers/form.html#generating-entire-forms
  */
 public function inputs(array $fields, array $options = [])
 {
     $fields = Hash::normalize($fields);
     $out = '';
     foreach ($fields as $name => $opts) {
         if ($opts === false) {
             continue;
         }
         $out .= $this->input($name, (array) $opts);
     }
     return $this->fieldset($out, $options);
 }

 /**
  * test normalizing arrays
  *
  * @return void
  */
 public function testNormalize()
 {
     $result = Hash::normalize(['one', 'two', 'three']);
     $expected = ['one' => null, 'two' => null, 'three' => null];
     $this->assertEquals($expected, $result);
     $result = Hash::normalize(['one', 'two', 'three'], false);
     $expected = ['one', 'two', 'three'];
     $this->assertEquals($expected, $result);
     $result = Hash::normalize(['one' => 1, 'two' => 2, 'three' => 3, 'four'], false);
     $expected = ['one' => 1, 'two' => 2, 'three' => 3, 'four' => null];
     $this->assertEquals($expected, $result);
     $result = Hash::normalize(['one' => 1, 'two' => 2, 'three' => 3, 'four']);
     $expected = ['one' => 1, 'two' => 2, 'three' => 3, 'four' => null];
     $this->assertEquals($expected, $result);
     $result = Hash::normalize(['one' => ['a', 'b', 'c' => 'cee'], 'two' => 2, 'three']);
     $expected = ['one' => ['a', 'b', 'c' => 'cee'], 'two' => 2, 'three' => null];
     $this->assertEquals($expected, $result);
 }

 /**
  * Loads the configured authentication objects.
  *
  * @return mixed either null on empty authenticate value, or an array of loaded objects.
  * @throws \Cake\Core\Exception\Exception
  */
 public function constructAuthenticate()
 {
     if (empty($this->_config['authenticate'])) {
         return;
     }
     $this->_authenticateObjects = [];
     $authenticate = Hash::normalize((array) $this->_config['authenticate']);
     $global = [];
     if (isset($authenticate[AuthComponent::ALL])) {
         $global = $authenticate[AuthComponent::ALL];
         unset($authenticate[AuthComponent::ALL]);
     }
     foreach ($authenticate as $alias => $config) {
         if (!empty($config['className'])) {
             $class = $config['className'];
             unset($config['className']);
         } else {
             $class = $alias;
         }
         $className = App::className($class, 'Auth', 'Authenticate');
         if (!class_exists($className)) {
             throw new Exception(sprintf('Authentication adapter "%s" was not found.', $class));
         }
         if (!method_exists($className, 'authenticate')) {
             throw new Exception('Authentication objects must implement an authenticate() method.');
         }
         $config = array_merge($global, (array) $config);
         $this->_authenticateObjects[$alias] = new $className($this->_registry, $config);
         $this->eventManager()->on($this->_authenticateObjects[$alias]);
     }
     return $this->_authenticateObjects;
 }

 /**
  * Returns fields to be displayed on scaffolded template
  *
  * @param array $assocations Associations list.
  * @return array
  */
 protected function _scaffoldFields(array $associations = [])
 {
     $action = $this->_action();
     $configuredFields = $action->config('scaffold.fields');
     if (!empty($configuredFields)) {
         $scaffoldFields = Hash::normalize($configuredFields);
     } else {
         $cols = $this->_table()->schema()->columns();
         $scaffoldFields = Hash::normalize($cols);
         $scope = $action->config('scope');
         if ($scope === 'entity' && !empty($associations['manyToMany'])) {
             foreach ($associations['manyToMany'] as $alias => $options) {
                 $scaffoldFields[sprintf('%s._ids', $options['entities'])] = ['multiple' => true];
             }
         }
     }
     // Check for blacklisted fields
     $blacklist = $action->config('scaffold.fields_blacklist');
     if (!empty($blacklist)) {
         $scaffoldFields = array_diff_key($scaffoldFields, array_combine($blacklist, $blacklist));
     }
     // Make sure all array values are an array
     foreach ($scaffoldFields as $field => $options) {
         if (!is_array($options)) {
             $scaffoldFields[$field] = (array) $options;
         }
         $scaffoldFields[$field] += ['formatter' => null];
     }
     return $scaffoldFields;
 }

 /**
  * Ensure data key is present in Controller:$viewVars
  *
  * @param \Crud\Event\Subject $subject Subject
  * @return void
  */
 protected function _ensureData(Subject $subject)
 {
     $controller = $this->_controller();
     $action = $this->_action();
     if (method_exists($action, 'viewVar')) {
         $viewVar = $action->viewVar();
     } else {
         $viewVar = 'data';
     }
     if (isset($controller->viewVars[$viewVar])) {
         return;
     }
     $key = $subject->success ? 'success' : 'error';
     $config = $action->config('api.' . $key);
     $data = [];
     if (isset($config['data']['subject'])) {
         $config['data']['subject'] = Hash::normalize((array) $config['data']['subject']);
         $subjectArray = (array) $subject;
         foreach ($config['data']['subject'] as $keyPath => $valuePath) {
             if ($valuePath === null) {
                 $valuePath = $keyPath;
             }
             $keyPath = $this->_expandPath($subject, $keyPath);
             $valuePath = $this->_expandPath($subject, $valuePath);
             $data = Hash::insert($data, $keyPath, Hash::get($subjectArray, $valuePath));
         }
     }
     if (isset($config['data']['entity'])) {
         $config['data']['entity'] = Hash::normalize((array) $config['data']['entity']);
         foreach ($config['data']['entity'] as $keyPath => $valuePath) {
             if ($valuePath === null) {
                 $valuePath = $keyPath;
             }
             if (method_exists($subject->entity, $valuePath)) {
                 $data = Hash::insert($data, $keyPath, call_user_func([$subject->entity, $valuePath]));
             } elseif (isset($subject->entity->{$valuePath})) {
                 $data = Hash::insert($data, $keyPath, $subject->entity->{$valuePath});
             }
         }
     }
     if (isset($config['data']['raw'])) {
         foreach ($config['data']['raw'] as $path => $value) {
             $path = $this->_expandPath($subject, $path);
             $data = Hash::insert($data, $path, $value);
         }
     }
     if (method_exists($action, 'viewVar')) {
         $viewVar = $action->viewVar();
     } else {
         $viewVar = 'data';
     }
     $controller->set($viewVar, $data);
 }

 /**
  * Merge each of the keys in a property together.
  *
  * @param array $current The current merged value.
  * @param array $parent The parent class' value.
  * @param bool $isAssoc Whether or not the merging should be done in associative mode.
  * @return mixed The updated value.
  */
 protected function _mergePropertyData($current, $parent, $isAssoc)
 {
     if (!$isAssoc) {
         return array_merge($parent, $current);
     }
     $parent = Hash::normalize($parent);
     foreach ($parent as $key => $value) {
         if (!isset($current[$key])) {
             $current[$key] = $value;
         }
     }
     return $current;
 }

 /**
  * Edit method
  *
  * @param string|null $id User id.
  * @return void|\Cake\Network\Respose
  * @throws \Cake\Network\Exception\NotFoundException Exception if the user couldn't be found.
  */
 public function edit($id = null)
 {
     $user = $this->Users->get($id, ['contain' => []]);
     $user->accessible('role_id', true);
     // the role_id field should be accessible
     $user->accessible('active', true);
     // the active field should be accessible
     $roles = $this->Users->Roles->find('list');
     if ($this->request->is(['patch', 'post', 'put'])) {
         $user = $this->Users->patchEntity($user, $this->request->data);
         if ($this->Users->save($user)) {
             $this->Flash->success(__('The user has been saved.'));
             return $this->redirect(['action' => 'index']);
         } else {
             $this->Flash->error(__('The user could not be saved. Please, try again.'));
         }
     }
     $customFields = Hash::normalize(Configure::read('CM.UserFields'));
     $this->set(compact('user', 'roles', 'customFields'));
     $this->render(Configure::read('CM.AdminUserViews.edit'));
 }

 /**
  * test normalizing arrays
  *
  * @return void
  */
 public function testNormalize()
 {
     $result = Hash::normalize(array('one', 'two', 'three'));
     $expected = array('one' => null, 'two' => null, 'three' => null);
     $this->assertEquals($expected, $result);
     $result = Hash::normalize(array('one', 'two', 'three'), false);
     $expected = array('one', 'two', 'three');
     $this->assertEquals($expected, $result);
     $result = Hash::normalize(array('one' => 1, 'two' => 2, 'three' => 3, 'four'), false);
     $expected = array('one' => 1, 'two' => 2, 'three' => 3, 'four' => null);
     $this->assertEquals($expected, $result);
     $result = Hash::normalize(array('one' => 1, 'two' => 2, 'three' => 3, 'four'));
     $expected = array('one' => 1, 'two' => 2, 'three' => 3, 'four' => null);
     $this->assertEquals($expected, $result);
     $result = Hash::normalize(array('one' => array('a', 'b', 'c' => 'cee'), 'two' => 2, 'three'));
     $expected = array('one' => array('a', 'b', 'c' => 'cee'), 'two' => 2, 'three' => null);
     $this->assertEquals($expected, $result);
 }

 /**
  * Generate a set of inputs for `$fields`. If $fields is empty the fields of current model
  * will be used.
  *
  * You can customize individual inputs through `$fields`.
  * {{{
  * $this->Form->inputs([
  *   'name' => ['label' => 'custom label']
  * ]);
  * }}}
  *
  * You can exclude fields by specifying them as false:
  *
  * {{{
  * $this->Form->inputs(['title' => false]);
  * }}}
  *
  * In the above example, no field would be generated for the title field.
  *
  * @param array $fields An array of customizations for the fields that will be
  *   generated. This array allows you to set custom types, labels, or other options.
  * @param array $options Options array. Valid keys are:
  * - `fieldset` Set to false to disable the fieldset.
  * - `legend` Set to false to disable the legend for the generated input set. Or supply a string
  *    to customize the legend text.
  * @return string Completed form inputs.
  * @link http://book.cakephp.org/2.0/en/core-libraries/helpers/form.html#FormHelper::inputs
  */
 public function inputs(array $fields = [], array $options = [])
 {
     $fieldset = $legend = true;
     $context = $this->_getContext();
     $modelFields = $context->fieldNames();
     $fields = array_merge(Hash::normalize($modelFields), Hash::normalize($fields));
     if (isset($options['legend'])) {
         $legend = $options['legend'];
     }
     if (isset($options['fieldset'])) {
         $fieldset = $options['fieldset'];
     }
     if ($legend === true) {
         $actionName = __d('cake', 'New %s');
         $isCreate = $context->isCreate();
         if (!$isCreate) {
             $actionName = __d('cake', 'Edit %s');
         }
         $modelName = Inflector::humanize(Inflector::singularize($this->request->params['controller']));
         $legend = sprintf($actionName, $modelName);
     }
     $out = null;
     foreach ($fields as $name => $options) {
         if ($options === false) {
             continue;
         }
         if (is_numeric($name) && !is_array($options)) {
             $name = $options;
             $options = [];
         }
         $entity = explode('.', $name);
         $out .= $this->input($name, (array) $options);
     }
     if ($fieldset) {
         if ($legend) {
             $out = $this->formatTemplate('legend', ['text' => $legend]) . $out;
         }
         $out = $this->formatTemplate('fieldset', ['content' => $out]);
     }
     return $out;
 }

 /**
  * Filter needed keys from cache
  *
  * @param array $keys The keys you want the values of
  * @return array The key value pairs
  */
 protected function _keysFromCache(array $keys)
 {
     return array_intersect_key($this->_cache(), Hash::normalize($keys));
 }