PHP Hash::filter方法代码示例

 /**
  * Callback for Routing.beforeDispatch event.
  *
  * @param \Cake\Event\Event $event The event instance.
  *
  * @return \Cake\Network\Response Response instance.
  */
 public function beforeDispatch(Event $event)
 {
     $request = $event->data['request'];
     $response = $event->data['response'];
     $path = urldecode($request->url);
     if (Configure::read('Glide.secureUrls')) {
         SignatureFactory::create(Security::salt())->validateRequest('/' . $path, $request->query);
     }
     $server = ServerFactory::create(Configure::read('Glide.serverConfig'));
     $cache = Configure::read('Glide.cache');
     if ($cache) {
         $timestamp = $server->getSource()->getTimestamp($server->getSourcePath($path));
         $response->modified($timestamp);
         if (!$response->checkNotModified($request)) {
             $response = $server->getImageResponse($path, $request->query);
         }
         $response->cache($timestamp, $cache);
     } else {
         $response = $server->getImageResponse($path, $request->query);
     }
     $headers = Hash::filter((array) Configure::read('Glide.headers'));
     foreach ($headers as $key => $value) {
         $response->header($key, $value);
     }
     return $response;
 }

 /**
  * Filters the params from POST data and merges in the whitelisted query string ones.
  *
  * @return array
  */
 protected function _filterParams()
 {
     $params = Hash::filter($this->request->data);
     if (!$this->config('queryStringWhitelist')) {
         return $params;
     }
     foreach ($this->config('queryStringWhitelist') as $field) {
         if (!isset($params[$field]) && $this->request->query($field) !== null) {
             $params[$field] = $this->request->query($field);
         }
     }
     return $params;
 }

 /**
  * Extracts nested validation errors
  *
  * @param EntityInterface $entity Entity to extract
  *
  * @return array
  */
 protected function _getErrors(EntityInterface $entity)
 {
     $errors = $entity->errors();
     foreach ($entity->visibleProperties() as $property) {
         $v = $entity[$property];
         if ($v instanceof EntityInterface) {
             $errors[$property] = $this->_getErrors($v);
         } elseif (is_array($v)) {
             foreach ($v as $key => $varValue) {
                 if ($varValue instanceof EntityInterface) {
                     $errors[$property][$key] = $this->_getErrors($varValue);
                 }
             }
         }
     }
     return Hash::filter($errors);
 }

 /**
  * Determine which fields of a form should be used for hash.
  * Populates $this->fields
  *
  * @param bool $lock Whether this field should be part of the validation
  *   or excluded as part of the unlockedFields.
  * @param string|array $field Reference to field to be secured. Can be dot
  *   separated string to indicate nesting or array of fieldname parts.
  * @param mixed $value Field value, if value should not be tampered with.
  * @return void
  */
 protected function _secure($lock, $field, $value = null)
 {
     if (empty($field) && $field !== '0') {
         return;
     }
     if (is_string($field)) {
         $field = Hash::filter(explode('.', $field));
     }
     foreach ($this->_unlockedFields as $unlockField) {
         $unlockParts = explode('.', $unlockField);
         if (array_values(array_intersect($field, $unlockParts)) === $unlockParts) {
             return;
         }
     }
     $field = implode('.', $field);
     $field = preg_replace('/(\\.\\d+)+$/', '', $field);
     if ($lock) {
         if (!in_array($field, $this->fields)) {
             if ($value !== null) {
                 return $this->fields[$field] = $value;
             } elseif (isset($this->fields[$field]) && $value === null) {
                 unset($this->fields[$field]);
             }
             $this->fields[] = $field;
         }
     } else {
         $this->unlockField($field);
     }
 }

 /**
  * testFilter method
  *
  * @return void
  */
 public function testFilter()
 {
     $result = Hash::filter(['0', false, true, 0, ['one thing', 'I can tell you', 'is you got to be', false]]);
     $expected = ['0', 2 => true, 3 => 0, 4 => ['one thing', 'I can tell you', 'is you got to be']];
     $this->assertSame($expected, $result);
     $result = Hash::filter([1, [false]]);
     $expected = [1];
     $this->assertEquals($expected, $result);
     $result = Hash::filter([1, [false, false]]);
     $expected = [1];
     $this->assertEquals($expected, $result);
     $result = Hash::filter([1, ['empty', false]]);
     $expected = [1, ['empty']];
     $this->assertEquals($expected, $result);
     $result = Hash::filter([1, ['2', false, [3, null]]]);
     $expected = [1, ['2', 2 => [3]]];
     $this->assertEquals($expected, $result);
     $this->assertSame([], Hash::filter([]));
 }

 /**
  * Extracts all parameters for wich a filter with a matching field
  * name exists.
  *
  * @param array $params The parameters array to extract from.
  * @param \Search\Model\Filter\Base[] $filters The filters to match against.
  * @return array The extracted parameters.
  */
 protected function _extractParams($params, $filters)
 {
     return array_intersect_key(Hash::filter($params), $filters);
 }

 /**
  * Get the namespace for a given class.
  *
  * @param string $className The class you want a namespace for.
  * @param string $pluginPath The plugin path.
  * @param string $prefixPath The prefix path.
  * @return string
  */
 protected function _getNamespace($className, $pluginPath = null, $prefixPath = null)
 {
     $namespace = preg_replace('/(.*)Controller\\//', '', $className);
     $namespace = preg_replace('/\\//', '\\', $namespace);
     $namespace = preg_replace('/\\.php/', '', $namespace);
     $prefixPath = preg_replace('/\\//', '\\', Inflector::camelize($prefixPath));
     if (!$pluginPath) {
         $rootNamespace = Configure::read('App.namespace');
     } else {
         $rootNamespace = preg_replace('/\\//', '\\', $pluginPath);
     }
     $namespace = [$rootNamespace, 'Controller', $prefixPath, $namespace];
     return implode('\\', Hash::filter($namespace));
 }

 /**
  * testFilter method
  *
  * @return void
  */
 public function testFilter()
 {
     $result = Hash::filter(array('0', false, true, 0, array('one thing', 'I can tell you', 'is you got to be', false)));
     $expected = array('0', 2 => true, 3 => 0, 4 => array('one thing', 'I can tell you', 'is you got to be'));
     $this->assertSame($expected, $result);
     $result = Hash::filter(array(1, array(false)));
     $expected = array(1);
     $this->assertEquals($expected, $result);
     $result = Hash::filter(array(1, array(false, false)));
     $expected = array(1);
     $this->assertEquals($expected, $result);
     $result = Hash::filter(array(1, array('empty', false)));
     $expected = array(1, array('empty'));
     $this->assertEquals($expected, $result);
     $result = Hash::filter(array(1, array('2', false, array(3, null))));
     $expected = array(1, array('2', 2 => array(3)));
     $this->assertEquals($expected, $result);
     $this->assertSame(array(), Hash::filter(array()));
 }

 protected function cleanup($rows)
 {
     $rows = Hash::filter($rows);
     foreach ($rows as $key => $row) {
         unset($rows[$key]['id'], $rows[$key]['value']);
     }
     return $rows;
 }