Resolve conflicts

src/AbstractOptions.php

@@ -28,8 +28,6 @@ abstract class AbstractOptions implements ParameterObjectInterface
 
     /**
      * @param  array|Traversable|null $options
-     * @return AbstractOptions
-     * @throws Exception\InvalidArgumentException
      */
     public function __construct($options = null)
     {
@@ -41,7 +39,7 @@ public function __construct($options = null)
     /**
      * @param  array|Traversable $options
      * @throws Exception\InvalidArgumentException
-     * @return void
+     * @return AbstractOptions Provides fluent interface
      */
     public function setFromArray($options)
     {
@@ -55,6 +53,7 @@ public function setFromArray($options)
         foreach ($options as $key => $value) {
             $this->__set($key, $value);
         }
+        return $this;
     }
 
     /**
@@ -115,6 +114,7 @@ public function __get($key)
                 . 'which must be defined'
             );
         }
+
         return $this->{$getter}();
     }
 
@@ -131,14 +131,14 @@ public function __isset($key)
     /**
      * @see ParameterObject::__unset()
      * @param string $key
-     * @return void
      * @throws Exception\InvalidArgumentException
+     * @return void
      */
     public function __unset($key)
     {
         try {
             $this->__set($key, null);
-        } catch (\InvalidArgumentException $e) {
+        } catch (Exception\BadMethodCallException $e) {
             throw new Exception\InvalidArgumentException(
                 'The class property $' . $key . ' cannot be unset as'
                     . ' NULL is an invalid value for it',

src/Hydrator/AbstractHydrator.php

@@ -11,6 +11,7 @@
 namespace Zend\Stdlib\Hydrator;
 
 use ArrayObject;
+use Zend\Stdlib\Exception;
 use Zend\Stdlib\Hydrator\StrategyEnabledInterface;
 use Zend\Stdlib\Hydrator\Strategy\StrategyInterface;
 
@@ -44,7 +45,19 @@ public function __construct()
      */
     public function getStrategy($name)
     {
-        return $this->strategies[$name];
+        if (isset($this->strategies[$name])) {
+            return $this->strategies[$name];
+        }
+
+        if (!isset($this->strategies['*'])) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                '%s: no strategy by name of "%s", and no wildcard strategy present',
+                __METHOD__,
+                $name
+            ));
+        }
+
+        return $this->strategies['*'];
     }
 
     /**
@@ -55,7 +68,8 @@ public function getStrategy($name)
      */
     public function hasStrategy($name)
     {
-        return array_key_exists($name, $this->strategies);
+        return array_key_exists($name, $this->strategies)
+               || array_key_exists('*', $this->strategies);
     }
 
     /**

src/Hydrator/ClassMethods.php

@@ -17,22 +17,61 @@
  * @package    Zend_Stdlib
  * @subpackage Hydrator
  */
-class ClassMethods extends AbstractHydrator
+class ClassMethods extends AbstractHydrator implements HydratorOptionsInterface
 {
     /**
      * Flag defining whether array keys are underscore-separated (true) or camel case (false)
      * @var boolean
      */
-    protected $underscoreSeparatedKeys;
+    protected $underscoreSeparatedKeys = true;
 
     /**
      * Define if extract values will use camel case or name with underscore
-     * @param boolean $underscoreSeparatedKeys
+     * @param boolean|array $underscoreSeparatedKeys
      */
     public function __construct($underscoreSeparatedKeys = true)
     {
         parent::__construct();
+        $this->setUnderscoreSeparatedKeys($underscoreSeparatedKeys);
+    }
+
+    /**
+     * @param  array|\Traversable $options
+     * @return ClassMethods
+     * @throws Exception\InvalidArgumentException
+     */
+    public function setOptions($options)
+    {
+        if ($options instanceof Traversable) {
+            $options = ArrayUtils::iteratorToArray($options);
+        } elseif (!is_array($options)) {
+            throw new Exception\InvalidArgumentException(
+                'The options parameter must be an array or a Traversable'
+            );
+        }
+        if (isset($options['underscoreSeparatedKeys'])) {
+            $this->setUnderscoreSeparatedKeys($options['underscoreSeparatedKeys']);
+        }
+
+        return $this;
+    }
+
+    /**
+     * @param  boolean $underscoreSeparatedKeys
+     * @return ClassMethods
+     */
+    public function setUnderscoreSeparatedKeys($underscoreSeparatedKeys)
+    {
         $this->underscoreSeparatedKeys = $underscoreSeparatedKeys;
+        return $this;
+    }
+
+    /**
+     * @return boolean
+     */
+    public function getUnderscoreSeparatedKeys()
+    {
+        return $this->underscoreSeparatedKeys;
     }
 
     /**

src/Hydrator/HydratorOptionsInterface.php

@@ -0,0 +1,25 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ * @package   Zend_Stdlib
+ */
+
+namespace Zend\Stdlib\Hydrator;
+
+/**
+ * @category   Zend
+ * @package    Zend_Stdlib
+ * @subpackage Hydrator
+ */
+interface HydratorOptionsInterface
+{
+    /**
+     * @param  array|\Traversable $options
+     * @return HydratorOptionsInterface
+     */
+    public function setOptions($options);
+}

src/Hydrator/Strategy/SerializableStrategy.php

@@ -0,0 +1,128 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ * @package   Zend_Stdlib
+ */
+
+namespace Zend\Stdlib\Hydrator\Strategy;
+
+use Zend\Stdlib\Exception\InvalidArgumentException;
+use Zend\Serializer\Adapter\AdapterInterface as SerializerAdapter;
+use Zend\Serializer\Serializer as SerializerFactory;
+
+/**
+ * @category   Zend
+ * @package    Zend_Stdlib_Hydrator
+ * @subpackage Strategy
+ */
+class SerializableStrategy implements StrategyInterface
+{
+    /**
+     * @var string|SerializerAdapter
+     */
+    protected $serializer;
+
+    /**
+     * @var array
+     */
+    protected $serializerOptions = array();
+
+    /**
+     *
+     * @param mixed $serializer string or SerializerAdapter
+     */
+    public function __construct($serializer, $serializerOptions = null)
+    {
+        $this->setSerializer($serializer);
+        if($serializerOptions) {
+            $this->setSerializerOptions($serializerOptions);
+        }
+    }
+
+    /**
+     * Serialize the given value so that it can be extracted by the hydrator.
+     *
+     * @param mixed $value The original value.
+     * @return mixed Returns the value that should be extracted.
+     */
+    public function extract($value)
+    {
+        $serializer = $this->getSerializer();
+        return $serializer->serialize($value);
+    }
+
+    /**
+     * Unserialize the given value so that it can be hydrated by the hydrator.
+     *
+     * @param mixed $value The original value.
+     * @return mixed Returns the value that should be hydrated.
+     */
+    public function hydrate($value)
+    {
+        $serializer = $this->getSerializer();
+        return $serializer->unserialize($value);
+    }
+
+    /**
+     * Set serializer
+     *
+     * @param  string|SerializerAdapter $serializer
+     * @return Serializer
+     */
+    public function setSerializer($serializer)
+    {
+        if (!is_string($serializer) && !$serializer instanceof SerializerAdapter) {
+            throw new InvalidArgumentException(sprintf(
+                '%s expects either a string serializer name or Zend\Serializer\Adapter\AdapterInterface instance; '
+                . 'received "%s"',
+                __METHOD__,
+                (is_object($serializer) ? get_class($serializer) : gettype($serializer))
+            ));
+        }
+        $this->serializer = $serializer;
+        return $this;
+    }
+
+    /**
+     * Get serializer
+     *
+     * @return SerializerAdapter
+     */
+    public function getSerializer()
+    {
+        if (is_string($this->serializer)) {
+            $options = $this->getSerializerOptions();
+            $this->setSerializer(SerializerFactory::factory($this->serializer, $options));
+        } elseif (null === $this->serializer) {
+            $this->setSerializer(SerializerFactory::getDefaultAdapter());
+        }
+
+        return $this->serializer;
+    }
+
+    /**
+     * Set configuration options for instantiating a serializer adapter
+     *
+     * @param  mixed $serializerOptions
+     * @return SerializableStrategy
+     */
+    public function setSerializerOptions($serializerOptions)
+    {
+        $this->serializerOptions = $serializerOptions;
+        return $this;
+    }
+
+    /**
+     * Get configuration options for instantiating a serializer adapter
+     *
+     * @return mixed
+     */
+    public function getSerializerOptions()
+    {
+        return $this->serializerOptions;
+    }
+}

test/HydratorTest.php

@@ -16,6 +16,8 @@
 use ZendTest\Stdlib\TestAsset\ClassMethodsUnderscore;
 use ZendTest\Stdlib\TestAsset\ClassMethodsCamelCaseMissing;
 use ZendTest\Stdlib\TestAsset\Reflection as ReflectionAsset;
+use Zend\Stdlib\Hydrator\Strategy\DefaultStrategy;
+use Zend\Stdlib\Hydrator\Strategy\SerializableStrategy;
 
 /**
  * @category   Zend
@@ -163,6 +165,16 @@ public function testHydratorClassMethodsUnderscore()
         $this->assertEquals($test->hasBar(), false);
     }
 
+    public function testHydratorClassMethodsOptions()
+    {
+        $hydrator = new ClassMethods();
+        $this->assertTrue($hydrator->getUnderscoreSeparatedKeys());
+        $hydrator->setOptions(array('underscoreSeparatedKeys' => false));
+        $this->assertFalse($hydrator->getUnderscoreSeparatedKeys());
+        $hydrator->setUnderscoreSeparatedKeys(true);
+        $this->assertTrue($hydrator->getUnderscoreSeparatedKeys());
+    }
+
     public function testHydratorClassMethodsIgnoresInvalidValues()
     {
         $hydrator = new ClassMethods(true);
@@ -189,6 +201,39 @@ public function testHydratorClassMethodsDefaultBehaviorIsConvertUnderscoreToCame
         $this->assertEquals($test->getFooBarBaz(), 'bar');
     }
 
+    public function testRetrieveWildStrategyAndOther()
+    {
+        $hydrator = new ClassMethods();
+        $hydrator->addStrategy('default', new DefaultStrategy());
+        $hydrator->addStrategy('*', new SerializableStrategy('phpserialize'));
+        $default = $hydrator->getStrategy('default');
+        $this->assertEquals(get_class($default), 'Zend\Stdlib\Hydrator\Strategy\DefaultStrategy');
+        $serializable = $hydrator->getStrategy('*');
+        $this->assertEquals(get_class($serializable), 'Zend\Stdlib\Hydrator\Strategy\SerializableStrategy');
+    }
+
+    public function testUseWildStrategyByDefault()
+    {
+        $hydrator = new ClassMethods();
+        $datas = $hydrator->extract($this->classMethodsUnderscore);
+        $this->assertEquals($datas['foo_bar'], '1');
+        $hydrator->addStrategy('*', new SerializableStrategy('phpserialize'));
+        $datas = $hydrator->extract($this->classMethodsUnderscore);
+        $this->assertEquals($datas['foo_bar'], 's:1:"1";');
+    }
+
+    public function testUseWildStrategyAndOther()
+    {
+        $hydrator = new ClassMethods();
+        $datas = $hydrator->extract($this->classMethodsUnderscore);
+        $this->assertEquals($datas['foo_bar'], '1');
+        $hydrator->addStrategy('foo_bar', new DefaultStrategy());
+        $hydrator->addStrategy('*', new SerializableStrategy('phpserialize'));
+        $datas = $hydrator->extract($this->classMethodsUnderscore);
+        $this->assertEquals($datas['foo_bar'], '1');
+        $this->assertEquals($datas['foo_bar_baz'], 's:1:"2";');
+    }
+
     public function testHydratorClassMethodsCamelCaseWithSetterMissing()
     {
         $hydrator = new ClassMethods(false);