Update to drupal 8.0.0-rc1. For more information, see https://www.drupal.org/node/2582663

vendor/zendframework/zend-hydrator/src/Strategy/BooleanStrategy.php

@@ -0,0 +1,104 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy;
+
+use Zend\Hydrator\Exception\InvalidArgumentException;
+
+/**
+ * This Strategy extracts and hydrates int and string values to Boolean values
+ */
+class BooleanStrategy implements StrategyInterface
+{
+    /**
+     * @var int|string
+     */
+    private $trueValue;
+
+    /**
+     * @var int|string
+     */
+    private $falseValue;
+
+    /**
+     * @param int|string $trueValue
+     * @param int|string $falseValue
+     * @throws InvalidArgumentException
+     */
+    public function __construct($trueValue, $falseValue)
+    {
+        if (!is_int($trueValue) && !is_string($trueValue)) {
+            throw new InvalidArgumentException(sprintf(
+                'Unable to instantiate BooleanStrategy. Expected int or string as $trueValue. %s was given',
+                is_object($trueValue) ? get_class($trueValue) : gettype($trueValue)
+            ));
+        }
+
+        if (!is_int($falseValue) && !is_string($falseValue)) {
+            throw new InvalidArgumentException(sprintf(
+                'Unable to instantiate BooleanStrategy. Expected int or string as $falseValue. %s was given',
+                is_object($falseValue) ? get_class($falseValue) : gettype($falseValue)
+            ));
+        }
+
+        $this->trueValue  = $trueValue;
+        $this->falseValue = $falseValue;
+    }
+
+    /**
+     * Converts the given value so that it can be extracted by the hydrator.
+     *
+     * @param  bool $value The original value.
+     * @throws InvalidArgumentException
+     * @return int|string Returns the value that should be extracted.
+     */
+    public function extract($value)
+    {
+        if (!is_bool($value)) {
+            throw new InvalidArgumentException(sprintf(
+                'Unable to extract. Expected bool. %s was given.',
+                is_object($value) ? get_class($value) : gettype($value)
+            ));
+        }
+
+        return $value === true ? $this->trueValue : $this->falseValue;
+    }
+
+    /**
+     * Converts the given value so that it can be hydrated by the hydrator.
+     *
+     * @param  int|string $value The original value.
+     * @throws InvalidArgumentException
+     * @return bool Returns the value that should be hydrated.
+     */
+    public function hydrate($value)
+    {
+        if (!is_string($value) && !is_int($value)) {
+            throw new InvalidArgumentException(sprintf(
+                'Unable to hydrate. Expected string or int. %s was given.',
+                is_object($value) ? get_class($value) : gettype($value)
+            ));
+        }
+
+        if ($value === $this->trueValue) {
+            return true;
+        }
+
+        if ($value === $this->falseValue) {
+            return false;
+        }
+
+        throw new InvalidArgumentException(sprintf(
+            'Unexpected value %s can\'t be hydrated. Expect %s or %s as Value.',
+            $value,
+            $this->trueValue,
+            $this->falseValue
+        ));
+    }
+}

vendor/zendframework/zend-hydrator/src/Strategy/ClosureStrategy.php

@@ -0,0 +1,113 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy;
+
+class ClosureStrategy implements StrategyInterface
+{
+    /**
+     * Function, used in extract method, default:
+     *
+     * <code>
+     * function ($value) {
+     *     return $value;
+     * };
+     * </code>
+     *
+     * @var callable
+     */
+    protected $extractFunc = null;
+
+    /**
+     * Function, used in hydrate method, default:
+     *
+     * <code>
+     * function ($value) {
+     *     return $value;
+     * };
+     * </code>
+     *
+     * @var callable
+     */
+    protected $hydrateFunc = null;
+
+    /**
+     * You can describe how your values will extract and hydrate, like this:
+     *
+     * <code>
+     * $hydrator->addStrategy('category', new ClosureStrategy(
+     *     function (Category $value) {
+     *         return (int) $value->id;
+     *     },
+     *     function ($value) {
+     *         return new Category((int) $value);
+     *     }
+     * ));
+     * </code>
+     *
+     * @param callable $extractFunc - anonymous function, that extract values
+     *     from object
+     * @param callable $hydrateFunc - anonymous function, that hydrate values
+     *     into object
+     */
+    public function __construct($extractFunc = null, $hydrateFunc = null)
+    {
+        if (isset($extractFunc)) {
+            if (!is_callable($extractFunc)) {
+                throw new \Exception('$extractFunc must be callable');
+            }
+
+            $this->extractFunc = $extractFunc;
+        } else {
+            $this->extractFunc = function ($value) {
+                return $value;
+            };
+        }
+
+        if (isset($hydrateFunc)) {
+            if (!is_callable($hydrateFunc)) {
+                throw new \Exception('$hydrateFunc must be callable');
+            }
+
+            $this->hydrateFunc = $hydrateFunc;
+        } else {
+            $this->hydrateFunc = function ($value) {
+                return $value;
+            };
+        }
+    }
+
+    /**
+     * Converts the given value so that it can be extracted by the hydrator.
+     *
+     * @param  mixed $value  The original value.
+     * @param  array $object The object is optionally provided as context.
+     * @return mixed Returns the value that should be extracted.
+     */
+    public function extract($value, $object = null)
+    {
+        $func = $this->extractFunc;
+
+        return $func($value, $object);
+    }
+
+    /**
+     * Converts the given value so that it can be hydrated by the hydrator.
+     *
+     * @param  mixed $value The original value.
+     * @param  array $data  The whole data is optionally provided as context.
+     * @return mixed Returns the value that should be hydrated.
+     */
+    public function hydrate($value, $data = null)
+    {
+        $func = $this->hydrateFunc;
+
+        return $func($value, $data);
+    }
+}

vendor/zendframework/zend-hydrator/src/Strategy/DateTimeFormatterStrategy.php

@@ -0,0 +1,80 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy;
+
+use DateTime;
+use DateTimeZone;
+
+class DateTimeFormatterStrategy implements StrategyInterface
+{
+    /**
+     * @var string
+     */
+    private $format;
+
+    /**
+     * @var DateTimeZone|null
+     */
+    private $timezone;
+
+    /**
+     * Constructor
+     *
+     * @param string            $format
+     * @param DateTimeZone|null $timezone
+     */
+    public function __construct($format = DateTime::RFC3339, DateTimeZone $timezone = null)
+    {
+        $this->format   = (string) $format;
+        $this->timezone = $timezone;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Converts to date time string
+     *
+     * @param mixed|DateTime $value
+     *
+     * @return mixed|string
+     */
+    public function extract($value)
+    {
+        if ($value instanceof DateTime) {
+            return $value->format($this->format);
+        }
+
+        return $value;
+    }
+
+    /**
+     * Converts date time string to DateTime instance for injecting to object
+     *
+     * {@inheritDoc}
+     *
+     * @param mixed|string $value
+     *
+     * @return mixed|DateTime
+     */
+    public function hydrate($value)
+    {
+        if ($value === '' || $value === null) {
+            return;
+        }
+
+        if ($this->timezone) {
+            $hydrated = DateTime::createFromFormat($this->format, $value, $this->timezone);
+        } else {
+            $hydrated = DateTime::createFromFormat($this->format, $value);
+        }
+
+        return $hydrated ?: $value;
+    }
+}

vendor/zendframework/zend-hydrator/src/Strategy/DefaultStrategy.php

@@ -0,0 +1,35 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy;
+
+class DefaultStrategy implements StrategyInterface
+{
+    /**
+     * Converts 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)
+    {
+        return $value;
+    }
+
+    /**
+     * Converts 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)
+    {
+        return $value;
+    }
+}

vendor/zendframework/zend-hydrator/src/Strategy/Exception/ExceptionInterface.php

@@ -0,0 +1,14 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy\Exception;
+
+interface ExceptionInterface
+{
+}

vendor/zendframework/zend-hydrator/src/Strategy/Exception/InvalidArgumentException.php

@@ -0,0 +1,14 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy\Exception;
+
+class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
+{
+}

vendor/zendframework/zend-hydrator/src/Strategy/ExplodeStrategy.php

@@ -0,0 +1,113 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy;
+
+class ExplodeStrategy implements StrategyInterface
+{
+    /**
+     * @var string
+     */
+    private $valueDelimiter;
+
+    /**
+     * @var int|null
+     */
+    private $explodeLimit;
+
+    /**
+     * Constructor
+     *
+     * @param string   $delimiter    String that the values will be split upon
+     * @param int|null $explodeLimit Explode limit
+     */
+    public function __construct($delimiter = ',', $explodeLimit = null)
+    {
+        $this->setValueDelimiter($delimiter);
+
+        $this->explodeLimit = ($explodeLimit === null) ? null : (int) $explodeLimit;
+    }
+
+    /**
+     * Sets the delimiter string that the values will be split upon
+     *
+     * @param  string $delimiter
+     * @return self
+     */
+    private function setValueDelimiter($delimiter)
+    {
+        if (!is_string($delimiter)) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                '%s expects Delimiter to be string, %s provided instead',
+                __METHOD__,
+                is_object($delimiter) ? get_class($delimiter) : gettype($delimiter)
+            ));
+        }
+
+        if (empty($delimiter)) {
+            throw new Exception\InvalidArgumentException('Delimiter cannot be empty.');
+        }
+
+        $this->valueDelimiter = $delimiter;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Split a string by delimiter
+     *
+     * @param string|null $value
+     *
+     * @return string[]
+     *
+     * @throws Exception\InvalidArgumentException
+     */
+    public function hydrate($value)
+    {
+        if (null === $value) {
+            return [];
+        }
+
+        if (!(is_string($value) || is_numeric($value))) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                '%s expects argument 1 to be string, %s provided instead',
+                __METHOD__,
+                is_object($value) ? get_class($value) : gettype($value)
+            ));
+        }
+
+        if ($this->explodeLimit !== null) {
+            return explode($this->valueDelimiter, $value, $this->explodeLimit);
+        }
+
+        return explode($this->valueDelimiter, $value);
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * Join array elements with delimiter
+     *
+     * @param string[] $value The original value.
+     *
+     * @return string|null
+     */
+    public function extract($value)
+    {
+        if (!is_array($value)) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                '%s expects argument 1 to be array, %s provided instead',
+                __METHOD__,
+                is_object($value) ? get_class($value) : gettype($value)
+            ));
+        }
+
+        return empty($value) ? null : implode($this->valueDelimiter, $value);
+    }
+}

vendor/zendframework/zend-hydrator/src/Strategy/SerializableStrategy.php

@@ -0,0 +1,123 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy;
+
+use Zend\Hydrator\Exception\InvalidArgumentException;
+use Zend\Serializer\Adapter\AdapterInterface as SerializerAdapter;
+use Zend\Serializer\Serializer as SerializerFactory;
+
+class SerializableStrategy implements StrategyInterface
+{
+    /**
+     * @var string|SerializerAdapter
+     */
+    protected $serializer;
+
+    /**
+     * @var array
+     */
+    protected $serializerOptions = [];
+
+    /**
+     *
+     * @param mixed $serializer string or SerializerAdapter
+     * @param mixed $serializerOptions
+     */
+    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 SerializableStrategy
+     */
+    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;
+    }
+}

vendor/zendframework/zend-hydrator/src/Strategy/StrategyChain.php

@@ -0,0 +1,73 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy;
+
+use Traversable;
+use Zend\Stdlib\ArrayUtils;
+
+class StrategyChain implements StrategyInterface
+{
+    /**
+     * Strategy chain for extraction
+     *
+     * @var StrategyInterface[]
+     */
+    private $extractionStrategies;
+
+    /**
+     * Strategy chain for hydration
+     *
+     * @var StrategyInterface[]
+     */
+    private $hydrationStrategies;
+
+    /**
+     * Constructor
+     *
+     * @param array|Traversable $extractionStrategies
+     */
+    public function __construct($extractionStrategies)
+    {
+        $extractionStrategies = ArrayUtils::iteratorToArray($extractionStrategies);
+        $this->extractionStrategies = array_map(
+            function (StrategyInterface $strategy) {
+                // this callback is here only to ensure type-safety
+                return $strategy;
+            },
+            $extractionStrategies
+        );
+
+        $this->hydrationStrategies = array_reverse($extractionStrategies);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function extract($value)
+    {
+        foreach ($this->extractionStrategies as $strategy) {
+            $value = $strategy->extract($value);
+        }
+
+        return $value;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hydrate($value)
+    {
+        foreach ($this->hydrationStrategies as $strategy) {
+            $value = $strategy->hydrate($value);
+        }
+
+        return $value;
+    }
+}

vendor/zendframework/zend-hydrator/src/Strategy/StrategyInterface.php

@@ -0,0 +1,34 @@
+<?php
+/**
+ * Zend Framework (http://framework.zend.com/)
+ *
+ * @link      http://github.com/zendframework/zf2 for the canonical source repository
+ * @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
+ * @license   http://framework.zend.com/license/new-bsd New BSD License
+ */
+
+namespace Zend\Hydrator\Strategy;
+
+/**
+ * @todo v3.0, add optional object/data to extract/hydrate.
+ */
+interface StrategyInterface
+{
+    /**
+     * Converts the given value so that it can be extracted by the hydrator.
+     *
+     * @param mixed   $value The original value.
+     * @param object $object (optional) The original object for context.
+     * @return mixed Returns the value that should be extracted.
+     */
+    public function extract($value);
+
+    /**
+     * Converts the given value so that it can be hydrated by the hydrator.
+     *
+     * @param mixed $value The original value.
+     * @param array  $data (optional) The original data for context.
+     * @return mixed Returns the value that should be hydrated.
+     */
+    public function hydrate($value);
+}