Hydrator Strategy to extract and hydrate Boolean values

.travis.yml

@@ -6,6 +6,7 @@ php:
   - 5.5
   - 5.6
   - hhvm
+  - hhvm-nightly
 
 install:
   - sudo apt-get install parallel
@@ -33,3 +34,4 @@ matrix:
   fast_finish: true
   allow_failures:
     - php: hhvm
+    - php: hhvm-nightly

README.md

@@ -1,4 +1,4 @@
-### Welcome to the *Zend Framework 2.3* Release!
+### Welcome to the *Zend Framework 2.4* Release!
 
 Master:
 [![Build Status](https://secure.travis-ci.org/zendframework/zf2.png?branch=master)](http://travis-ci.org/zendframework/zf2)
@@ -9,13 +9,20 @@ Develop:
 
 ## RELEASE INFORMATION
 
-*Zend Framework 2.3.2dev*
+*Zend Framework 2.4.0dev*
 
-This is the second maintenance release for the version 2.3 series.
+This is the fourth minor (feature) release for the version 2 series.
 
-DD MMM YYYY
+DD MMM YYY
 
-### UPDATES IN 2.3.2
+### UPDATES IN 2.4.0
+
+- [#6154](https://github.com/zendframework/zf2/pull/6154) updates
+  `Zend\InputFilter\BaseInputFilter::isValid()` to accept an optional `$context`
+  parameter; if used, this value will be passed to all composed inputs as
+  context, instead of the value provided to `setData()`. For classes overriding
+  the `isValid()` method of an InputFilter, you will need to add
+  `$context = null` as an argument.
 
 Please see [CHANGELOG.md](CHANGELOG.md).
 

library/Zend/Cache/Storage/Adapter/Redis.php

@@ -13,12 +13,14 @@
 use RedisException as RedisResourceException;
 use stdClass;
 use Traversable;
+use Zend\Cache\Storage\ClearByPrefixInterface;
 use Zend\Cache\Exception;
 use Zend\Cache\Storage\Capabilities;
 use Zend\Cache\Storage\FlushableInterface;
 use Zend\Cache\Storage\TotalSpaceCapableInterface;
 
 class Redis extends AbstractAdapter implements
+    ClearByPrefixInterface,
     FlushableInterface,
     TotalSpaceCapableInterface
 {
@@ -370,6 +372,32 @@ public function flush()
         }
     }
 
+    /* ClearByPrefixInterface */
+
+    /**
+     * Remove items matching given prefix
+     *
+     * @param string $prefix
+     * @return bool
+     */
+    public function clearByPrefix($prefix)
+    {
+        $redis = $this->getRedisResource();
+
+        $prefix = (string) $prefix;
+        if ($prefix === '') {
+            throw new Exception\InvalidArgumentException('No prefix given');
+        }
+
+        $options   = $this->getOptions();
+        $namespace = $options->getNamespace();
+        $prefix    = ($namespace === '') ? '' : $namespace . $options->getNamespaceSeparator() . $prefix;
+
+        $redis->delete($redis->keys($prefix.'*'));
+
+        return true;
+    }
+
     /* TotalSpaceCapableInterface */
 
     /**

library/Zend/Code/Generator/ClassGenerator.php

@@ -56,6 +56,11 @@ class ClassGenerator extends AbstractGenerator
      */
     protected $properties = array();
 
+    /**
+     * @var PropertyGenerator[] Array of constants
+     */
+    protected $constants = array();
+
     /**
      * @var MethodGenerator[] Array of methods
      */
@@ -74,7 +79,6 @@ class ClassGenerator extends AbstractGenerator
      */
     public static function fromReflection(ClassReflection $classReflection)
     {
-        // class generator
         $cg = new static($classReflection->getName());
 
         $cg->setSourceContent($cg->getSourceContent());
@@ -93,11 +97,12 @@ public static function fromReflection(ClassReflection $classReflection)
 
         /* @var \Zend\Code\Reflection\ClassReflection $parentClass */
         $parentClass = $classReflection->getParentClass();
+        $interfaces  = $classReflection->getInterfaces();
+
         if ($parentClass) {
             $cg->setExtendedClass($parentClass->getName());
-            $interfaces = array_diff($classReflection->getInterfaces(), $parentClass->getInterfaces());
-        } else {
-            $interfaces = $classReflection->getInterfaces();
+
+            $interfaces = array_diff($interfaces, $parentClass->getInterfaces());
         }
 
         $interfaceNames = array();
@@ -109,20 +114,36 @@ public static function fromReflection(ClassReflection $classReflection)
         $cg->setImplementedInterfaces($interfaceNames);
 
         $properties = array();
+
         foreach ($classReflection->getProperties() as $reflectionProperty) {
             if ($reflectionProperty->getDeclaringClass()->getName() == $classReflection->getName()) {
                 $properties[] = PropertyGenerator::fromReflection($reflectionProperty);
             }
         }
+
         $cg->addProperties($properties);
 
+        $constants = array();
+
+        foreach ($classReflection->getConstants() as $name => $value) {
+            $constants[] = array(
+                'name' => $name,
+                'value' => $value
+            );
+        }
+
+        $cg->addConstants($constants);
+
         $methods = array();
+
         foreach ($classReflection->getMethods() as $reflectionMethod) {
-            $className = ($cg->getNamespaceName())? $cg->getNamespaceName() . "\\" . $cg->getName() : $cg->getName();
+            $className = ($cg->getNamespaceName()) ? $cg->getNamespaceName() . "\\" . $cg->getName() : $cg->getName();
+
             if ($reflectionMethod->getDeclaringClass()->getName() == $className) {
                 $methods[] = MethodGenerator::fromReflection($reflectionMethod);
             }
         }
+
         $cg->addMethods($methods);
 
         return $cg;
@@ -414,6 +435,114 @@ public function getImplementedInterfaces()
         return $this->implementedInterfaces;
     }
 
+    /**
+     * @param  string $constantName
+     *
+     * @return PropertyGenerator|false
+     */
+    public function getConstant($constantName)
+    {
+        if (isset($this->constants[$constantName])) {
+            return $this->constants[$constantName];
+        }
+
+        return false;
+    }
+
+    /**
+     * @return PropertyGenerator[] indexed by constant name
+     */
+    public function getConstants()
+    {
+        return $this->constants;
+    }
+
+    /**
+     * @param  string $constantName
+     * @return bool
+     */
+    public function hasConstant($constantName)
+    {
+        return isset($this->constants[$constantName]);
+    }
+
+    /**
+     * Add constant from PropertyGenerator
+     *
+     * @param  PropertyGenerator           $constant
+     * @throws Exception\InvalidArgumentException
+     * @return ClassGenerator
+     */
+    public function addConstantFromGenerator(PropertyGenerator $constant)
+    {
+        $constantName = $constant->getName();
+
+        if (isset($this->constants[$constantName])) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                'A constant by name %s already exists in this class.',
+                $constantName
+            ));
+        }
+
+        if (! $constant->isConst()) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                'The value %s is not defined as a constant.',
+                $constantName
+            ));
+        }
+
+        $this->constants[$constantName] = $constant;
+
+        return $this;
+    }
+
+    /**
+     * Add Constant
+     *
+     * @param  string $name
+     * @param  string $value
+     * @throws Exception\InvalidArgumentException
+     * @return ClassGenerator
+     */
+    public function addConstant($name, $value)
+    {
+        if (!is_string($name)) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                '%s expects string for name',
+                __METHOD__
+            ));
+        }
+
+        if (empty($value) || !is_string($value)) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                '%s expects value for constant, value must be a string',
+                __METHOD__
+            ));
+        }
+
+        return $this->addConstantFromGenerator(new PropertyGenerator($name, $value, PropertyGenerator::FLAG_CONSTANT));
+    }
+
+    /**
+     * @param  PropertyGenerator[]|array[] $constants
+     *
+     * @return ClassGenerator
+     */
+    public function addConstants(array $constants)
+    {
+        foreach ($constants as $constant) {
+            if ($constant instanceof PropertyGenerator) {
+                $this->addPropertyFromGenerator($constant);
+            } else {
+                if (is_array($constant)) {
+                    call_user_func_array(array($this, 'addConstant'), $constant);
+                }
+            }
+        }
+
+        return $this;
+    }
+
     /**
      * @param  array $properties
      * @return ClassGenerator
@@ -453,6 +582,12 @@ public function addProperty($name, $defaultValue = null, $flags = PropertyGenera
             ));
         }
 
+        // backwards compatibility
+        // @todo remove this on next major version
+        if ($flags === PropertyGenerator::FLAG_CONSTANT) {
+            return $this->addConstant($name, $defaultValue);
+        }
+
         return $this->addPropertyFromGenerator(new PropertyGenerator($name, $defaultValue, $flags));
     }
 
@@ -474,6 +609,12 @@ public function addPropertyFromGenerator(PropertyGenerator $property)
             ));
         }
 
+        // backwards compatibility
+        // @todo remove this on next major version
+        if ($property->isConst()) {
+            return $this->addConstantFromGenerator($property);
+        }
+
         $this->properties[$propertyName] = $property;
         return $this;
     }
@@ -686,10 +827,12 @@ public function generate()
         }
 
         $uses = $this->getUses();
+
         if (!empty($uses)) {
             foreach ($uses as $use) {
                 $output .= 'use ' . $use . ';' . self::LINE_FEED;
             }
+
             $output .= self::LINE_FEED;
         }
 
@@ -709,24 +852,29 @@ public function generate()
         }
 
         $implemented = $this->getImplementedInterfaces();
+
         if (!empty($implemented)) {
             $output .= ' implements ' . implode(', ', $implemented);
         }
 
         $output .= self::LINE_FEED . '{' . self::LINE_FEED . self::LINE_FEED;
 
+        $constants = $this->getConstants();
+
+        foreach ($constants as $constant) {
+            $output .= $constant->generate() . self::LINE_FEED . self::LINE_FEED;
+        }
+
         $properties = $this->getProperties();
-        if (!empty($properties)) {
-            foreach ($properties as $property) {
-                $output .= $property->generate() . self::LINE_FEED . self::LINE_FEED;
-            }
+
+        foreach ($properties as $property) {
+            $output .= $property->generate() . self::LINE_FEED . self::LINE_FEED;
         }
 
         $methods = $this->getMethods();
-        if (!empty($methods)) {
-            foreach ($methods as $method) {
-                $output .= $method->generate() . self::LINE_FEED;
-            }
+
+        foreach ($methods as $method) {
+            $output .= $method->generate() . self::LINE_FEED;
         }
 
         $output .= self::LINE_FEED . '}' . self::LINE_FEED;

library/Zend/Code/Generator/MethodGenerator.php

@@ -167,25 +167,29 @@ public function setParameters(array $parameters)
     }
 
     /**
-     * @param  ParameterGenerator|string $parameter
+     * @param  ParameterGenerator|array|string $parameter
      * @throws Exception\InvalidArgumentException
      * @return MethodGenerator
      */
     public function setParameter($parameter)
     {
         if (is_string($parameter)) {
             $parameter = new ParameterGenerator($parameter);
-        } elseif (!$parameter instanceof ParameterGenerator) {
+        }
+
+        if (is_array($parameter)) {
+            $parameter = ParameterGenerator::fromArray($parameter);
+        }
+
+        if (!$parameter instanceof ParameterGenerator) {
             throw new Exception\InvalidArgumentException(sprintf(
                 '%s is expecting either a string, array or an instance of %s\ParameterGenerator',
                 __METHOD__,
                 __NAMESPACE__
             ));
         }
 
-        $parameterName = $parameter->getName();
-
-        $this->parameters[$parameterName] = $parameter;
+        $this->parameters[$parameter->getName()] = $parameter;
 
         return $this;
     }