update v1.0.7.9 R.C.

This is a Release Candidate. We are still testing.

vendor/zendframework/zend-uri/src/Exception/ExceptionInterface.php

@@ -0,0 +1,17 @@
+<?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\Uri\Exception;
+
+/**
+ * Exception for Zend\Uri
+ */
+interface ExceptionInterface
+{
+}

vendor/zendframework/zend-uri/src/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\Uri\Exception;
+
+class InvalidArgumentException extends \InvalidArgumentException implements ExceptionInterface
+{
+}

vendor/zendframework/zend-uri/src/Exception/InvalidUriException.php

@@ -0,0 +1,17 @@
+<?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\Uri\Exception;
+
+/**
+ * Exceptions for Zend\Uri
+ */
+class InvalidUriException extends InvalidArgumentException implements ExceptionInterface
+{
+}

vendor/zendframework/zend-uri/src/Exception/InvalidUriPartException.php

@@ -0,0 +1,29 @@
+<?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\Uri\Exception;
+
+class InvalidUriPartException extends InvalidArgumentException
+{
+    /**
+     * Part-specific error codes
+     *
+     * @var int
+     */
+    const INVALID_SCHEME    = 1;
+    const INVALID_USER      = 2;
+    const INVALID_PASSWORD  = 4;
+    const INVALID_USERINFO  = 6;
+    const INVALID_HOSTNAME  = 8;
+    const INVALID_PORT      = 16;
+    const INVALID_AUTHORITY = 30;
+    const INVALID_PATH      = 32;
+    const INVALID_QUERY     = 64;
+    const INVALID_FRAGMENT  = 128;
+}

vendor/zendframework/zend-uri/src/File.php

@@ -0,0 +1,101 @@
+<?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\Uri;
+
+/**
+ * File URI handler
+ *
+ * The 'file:...' scheme is loosely defined in RFC-1738
+ */
+class File extends Uri
+{
+    protected static $validSchemes = ['file'];
+
+    /**
+     * Check if the URI is a valid File URI
+     *
+     * This applies additional specific validation rules beyond the ones
+     * required by the generic URI syntax.
+     *
+     * @return bool
+     * @see    Uri::isValid()
+     */
+    public function isValid()
+    {
+        if ($this->query) {
+            return false;
+        }
+
+        return parent::isValid();
+    }
+
+    /**
+     * User Info part is not used in file URIs
+     *
+     * @see    Uri::setUserInfo()
+     * @param  string $userInfo
+     * @return File
+     */
+    public function setUserInfo($userInfo)
+    {
+        return $this;
+    }
+
+    /**
+     * Fragment part is not used in file URIs
+     *
+     * @see    Uri::setFragment()
+     * @param  string $fragment
+     * @return File
+     */
+    public function setFragment($fragment)
+    {
+        return $this;
+    }
+
+    /**
+     * Convert a UNIX file path to a valid file:// URL
+     *
+     * @param  string $path
+     * @return File
+     */
+    public static function fromUnixPath($path)
+    {
+        $url = new static('file:');
+        if (substr($path, 0, 1) == '/') {
+            $url->setHost('');
+        }
+
+        $url->setPath($path);
+        return $url;
+    }
+
+    /**
+     * Convert a Windows file path to a valid file:// URL
+     *
+     * @param  string $path
+     * @return File
+     */
+    public static function fromWindowsPath($path)
+    {
+        $url = new static('file:');
+
+        // Convert directory separators
+        $path = str_replace(['/', '\\'], ['%2F', '/'], $path);
+
+        // Is this an absolute path?
+        if (preg_match('|^([a-zA-Z]:)?/|', $path)) {
+            $url->setHost('');
+        }
+
+        $url->setPath($path);
+        return $url;
+    }
+}

vendor/zendframework/zend-uri/src/Http.php

@@ -0,0 +1,224 @@
+<?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\Uri;
+
+/**
+ * HTTP URI handler
+ */
+class Http extends Uri
+{
+    /**
+     * @see Uri::$validSchemes
+     */
+    protected static $validSchemes = [
+        'http',
+        'https'
+    ];
+
+    /**
+     * @see Uri::$defaultPorts
+     */
+    protected static $defaultPorts = [
+        'http'  => 80,
+        'https' => 443,
+    ];
+
+    /**
+     * @see Uri::$validHostTypes
+     */
+    protected $validHostTypes = self::HOST_DNS_OR_IPV4_OR_IPV6_OR_REGNAME;
+
+    /**
+     * User name as provided in authority of URI
+     * @var null|string
+     */
+    protected $user;
+
+    /**
+     * Password as provided in authority of URI
+     * @var null|string
+     */
+    protected $password;
+
+    /**
+     * Get the username part (before the ':') of the userInfo URI part
+     *
+     * @return string|null
+     */
+    public function getUser()
+    {
+        return $this->user;
+    }
+
+    /**
+     * Get the password part (after the ':') of the userInfo URI part
+     *
+     * @return string|null
+     */
+    public function getPassword()
+    {
+        return $this->password;
+    }
+
+    /**
+     * Get the User-info (usually user:password) part
+     *
+     * @return string|null
+     */
+    public function getUserInfo()
+    {
+        return $this->userInfo;
+    }
+
+    /**
+     * Set the username part (before the ':') of the userInfo URI part
+     *
+     * @param string|null $user
+     *
+     * @return self
+     */
+    public function setUser($user)
+    {
+        $this->user = null === $user ? null : (string) $user;
+
+        $this->buildUserInfo();
+
+        return $this;
+    }
+
+    /**
+     * Set the password part (after the ':') of the userInfo URI part
+     *
+     * @param  string $password
+     *
+     * @return self
+     */
+    public function setPassword($password)
+    {
+        $this->password = null === $password ? null : (string) $password;
+
+        $this->buildUserInfo();
+
+        return $this;
+    }
+
+    /**
+     * Set the URI User-info part (usually user:password)
+     *
+     * @param  string|null $userInfo
+     *
+     * @return self
+     *
+     * @throws Exception\InvalidUriPartException If the schema definition does not have this part
+     */
+    public function setUserInfo($userInfo)
+    {
+        $this->userInfo = null === $userInfo ? null : (string) $userInfo;
+
+        $this->parseUserInfo();
+
+        return $this;
+    }
+
+    /**
+     * Validate the host part of an HTTP URI
+     *
+     * This overrides the common URI validation method with a DNS or IP only
+     * default. Users may still enforce allowing other host types.
+     *
+     * @param  string  $host
+     * @param  int $allowed
+     * @return bool
+     */
+    public static function validateHost($host, $allowed = self::HOST_DNS_OR_IPV4_OR_IPV6)
+    {
+        return parent::validateHost($host, $allowed);
+    }
+
+    /**
+     * Parse the user info into username and password segments
+     *
+     * Parses the user information into username and password segments, and
+     * then sets the appropriate values.
+     *
+     * @return void
+     */
+    protected function parseUserInfo()
+    {
+        // No user information? we're done
+        if (null === $this->userInfo) {
+            $this->setUser(null);
+            $this->setPassword(null);
+
+            return;
+        }
+
+        // If no ':' separator, we only have a username
+        if (false === strpos($this->userInfo, ':')) {
+            $this->setUser($this->userInfo);
+            $this->setPassword(null);
+            return;
+        }
+
+        // Split on the ':', and set both user and password
+        list($this->user, $this->password) = explode(':', $this->userInfo, 2);
+    }
+
+    /**
+     * Build the user info based on user and password
+     *
+     * Builds the user info based on the given user and password values
+     *
+     * @return void
+     */
+    protected function buildUserInfo()
+    {
+        if (null !== $this->password) {
+            $this->userInfo = $this->user . ':' . $this->password;
+        } else {
+            $this->userInfo = $this->user;
+        }
+    }
+
+    /**
+     * Return the URI port
+     *
+     * If no port is set, will return the default port according to the scheme
+     *
+     * @return int
+     * @see    Zend\Uri\Uri::getPort()
+     */
+    public function getPort()
+    {
+        if (empty($this->port)) {
+            if (array_key_exists($this->scheme, static::$defaultPorts)) {
+                return static::$defaultPorts[$this->scheme];
+            }
+        }
+        return $this->port;
+    }
+
+    /**
+     * Parse a URI string
+     *
+     * @param  string $uri
+     * @return Http
+     */
+    public function parse($uri)
+    {
+        parent::parse($uri);
+
+        if (empty($this->path)) {
+            $this->path = '/';
+        }
+
+        return $this;
+    }
+}

vendor/zendframework/zend-uri/src/Mailto.php

@@ -0,0 +1,109 @@
+<?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\Uri;
+
+use Zend\Validator\EmailAddress as EmailValidator;
+use Zend\Validator\ValidatorInterface;
+
+/**
+ * "Mailto" URI handler
+ *
+ * The 'mailto:...' scheme is loosely defined in RFC-1738
+ */
+class Mailto extends Uri
+{
+    protected static $validSchemes = ['mailto'];
+
+    /**
+     * Validator for use when validating email address
+     * @var ValidatorInterface
+     */
+    protected $emailValidator;
+
+    /**
+     * Check if the URI is a valid Mailto URI
+     *
+     * This applies additional specific validation rules beyond the ones
+     * required by the generic URI syntax
+     *
+     * @return bool
+     * @see    Uri::isValid()
+     */
+    public function isValid()
+    {
+        if ($this->host || $this->userInfo || $this->port) {
+            return false;
+        }
+
+        if (empty($this->path)) {
+            return false;
+        }
+
+        if (0 === strpos($this->path, '/')) {
+            return false;
+        }
+
+        $validator = $this->getValidator();
+        return $validator->isValid($this->path);
+    }
+
+    /**
+     * Set the email address
+     *
+     * This is in fact equivalent to setPath() - but provides a more clear interface
+     *
+     * @param  string $email
+     * @return Mailto
+     */
+    public function setEmail($email)
+    {
+        return $this->setPath($email);
+    }
+
+    /**
+     * Get the email address
+     *
+     * This is infact equivalent to getPath() - but provides a more clear interface
+     *
+     * @return string
+     */
+    public function getEmail()
+    {
+        return $this->getPath();
+    }
+
+    /**
+     * Set validator to use when validating email address
+     *
+     * @param  ValidatorInterface $validator
+     * @return Mailto
+     */
+    public function setValidator(ValidatorInterface $validator)
+    {
+        $this->emailValidator = $validator;
+        return $this;
+    }
+
+    /**
+     * Retrieve validator for use with validating email address
+     *
+     * If none is currently set, an EmailValidator instance with default options
+     * will be used.
+     *
+     * @return ValidatorInterface
+     */
+    public function getValidator()
+    {
+        if (null === $this->emailValidator) {
+            $this->setValidator(new EmailValidator());
+        }
+        return $this->emailValidator;
+    }
+}

vendor/zendframework/zend-uri/src/UriFactory.php

@@ -0,0 +1,125 @@
+<?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\Uri;
+
+/**
+ * URI Factory Class
+ *
+ * The URI factory can be used to generate URI objects from strings, using a
+ * different URI subclass depending on the input URI scheme. New scheme-specific
+ * classes can be registered using the registerScheme() method.
+ *
+ * Note that this class contains only static methods and should not be
+ * instantiated
+ */
+abstract class UriFactory
+{
+    /**
+     * Registered scheme-specific classes
+     *
+     * @var array
+     */
+     protected static $schemeClasses = [
+        'http'   => 'Zend\Uri\Http',
+        'https'  => 'Zend\Uri\Http',
+        'mailto' => 'Zend\Uri\Mailto',
+        'file'   => 'Zend\Uri\File',
+        'urn'    => 'Zend\Uri\Uri',
+        'tag'    => 'Zend\Uri\Uri',
+    ];
+
+    /**
+     * Register a scheme-specific class to be used
+     *
+     * @param string $scheme
+     * @param string $class
+     */
+    public static function registerScheme($scheme, $class)
+    {
+        $scheme = strtolower($scheme);
+        static::$schemeClasses[$scheme] = $class;
+    }
+
+    /**
+     * Unregister a scheme
+     *
+     * @param string $scheme
+     */
+    public static function unregisterScheme($scheme)
+    {
+        $scheme = strtolower($scheme);
+        if (isset(static::$schemeClasses[$scheme])) {
+            unset(static::$schemeClasses[$scheme]);
+        }
+    }
+
+    /**
+     * Get the class name for a registered scheme
+     *
+     * If provided scheme is not registered, will return NULL
+     *
+     * @param  string $scheme
+     * @return string|null
+     */
+    public static function getRegisteredSchemeClass($scheme)
+    {
+        if (isset(static::$schemeClasses[$scheme])) {
+            return static::$schemeClasses[$scheme];
+        }
+
+        return;
+    }
+
+    /**
+     * Create a URI from a string
+     *
+     * @param  string $uriString
+     * @param  string $defaultScheme
+     * @throws Exception\InvalidArgumentException
+     * @return \Zend\Uri\Uri
+     */
+    public static function factory($uriString, $defaultScheme = null)
+    {
+        if (!is_string($uriString)) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                'Expecting a string, received "%s"',
+                (is_object($uriString) ? get_class($uriString) : gettype($uriString))
+            ));
+        }
+
+        $uri    = new Uri($uriString);
+        $scheme = strtolower($uri->getScheme());
+        if (!$scheme && $defaultScheme) {
+            $scheme = $defaultScheme;
+        }
+
+        if ($scheme && ! isset(static::$schemeClasses[$scheme])) {
+            throw new Exception\InvalidArgumentException(sprintf(
+                'no class registered for scheme "%s"',
+                $scheme
+            ));
+        }
+        if ($scheme && isset(static::$schemeClasses[$scheme])) {
+            $class = static::$schemeClasses[$scheme];
+            $uri = new $class($uri);
+            if (! $uri instanceof UriInterface) {
+                throw new Exception\InvalidArgumentException(
+                    sprintf(
+                        'class "%s" registered for scheme "%s" does not implement Zend\Uri\UriInterface',
+                        $class,
+                        $scheme
+                    )
+                );
+            }
+        }
+
+        return $uri;
+    }
+}

vendor/zendframework/zend-uri/src/UriInterface.php

@@ -0,0 +1,243 @@
+<?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\Uri;
+
+/**
+ * Interface defining a URI
+ */
+interface UriInterface
+{
+    /**
+     * Create a new URI object
+     *
+     * @param  Uri|string|null $uri
+     * @throws Exception\InvalidArgumentException
+     */
+    public function __construct($uri = null);
+
+    /**
+     * Check if the URI is valid
+     *
+     * Note that a relative URI may still be valid
+     *
+     * @return bool
+     */
+    public function isValid();
+
+    /**
+     * Check if the URI is a valid relative URI
+     *
+     * @return bool
+     */
+    public function isValidRelative();
+
+    /**
+     * Check if the URI is an absolute or relative URI
+     *
+     * @return bool
+     */
+    public function isAbsolute();
+
+    /**
+     * Parse a URI string
+     *
+     * @param  string $uri
+     * @return Uri
+     */
+    public function parse($uri);
+
+    /**
+     * Compose the URI into a string
+     *
+     * @return string
+     * @throws Exception\InvalidUriException
+     */
+    public function toString();
+
+    /**
+     * Normalize the URI
+     *
+     * Normalizing a URI includes removing any redundant parent directory or
+     * current directory references from the path (e.g. foo/bar/../baz becomes
+     * foo/baz), normalizing the scheme case, decoding any over-encoded
+     * characters etc.
+     *
+     * Eventually, two normalized URLs pointing to the same resource should be
+     * equal even if they were originally represented by two different strings
+     *
+     * @return Uri
+     */
+    public function normalize();
+
+    /**
+     * Convert the link to a relative link by substracting a base URI
+     *
+     *  This is the opposite of resolving a relative link - i.e. creating a
+     *  relative reference link from an original URI and a base URI.
+     *
+     *  If the two URIs do not intersect (e.g. the original URI is not in any
+     *  way related to the base URI) the URI will not be modified.
+     *
+     * @param  Uri|string $baseUri
+     * @return Uri
+     */
+    public function makeRelative($baseUri);
+
+    /**
+     * Get the scheme part of the URI
+     *
+     * @return string|null
+     */
+    public function getScheme();
+
+    /**
+     * Get the User-info (usually user:password) part
+     *
+     * @return string|null
+     */
+    public function getUserInfo();
+
+    /**
+     * Get the URI host
+     *
+     * @return string|null
+     */
+    public function getHost();
+
+    /**
+     * Get the URI port
+     *
+     * @return int|null
+     */
+    public function getPort();
+
+    /**
+     * Get the URI path
+     *
+     * @return string|null
+     */
+    public function getPath();
+
+    /**
+     * Get the URI query
+     *
+     * @return string|null
+     */
+    public function getQuery();
+
+    /**
+     * Return the query string as an associative array of key => value pairs
+     *
+     * This is an extension to RFC-3986 but is quite useful when working with
+     * most common URI types
+     *
+     * @return array
+     */
+    public function getQueryAsArray();
+
+    /**
+     * Get the URI fragment
+     *
+     * @return string|null
+     */
+    public function getFragment();
+
+    /**
+     * Set the URI scheme
+     *
+     * If the scheme is not valid according to the generic scheme syntax or
+     * is not acceptable by the specific URI class (e.g. 'http' or 'https' are
+     * the only acceptable schemes for the Zend\Uri\Http class) an exception
+     * will be thrown.
+     *
+     * You can check if a scheme is valid before setting it using the
+     * validateScheme() method.
+     *
+     * @param  string $scheme
+     * @throws Exception\InvalidUriPartException
+     * @return Uri
+     */
+    public function setScheme($scheme);
+
+    /**
+     * Set the URI User-info part (usually user:password)
+     *
+     * @param  string $userInfo
+     * @return Uri
+     * @throws Exception\InvalidUriPartException If the schema definition
+     * does not have this part
+     */
+    public function setUserInfo($userInfo);
+
+    /**
+     * Set the URI host
+     *
+     * Note that the generic syntax for URIs allows using host names which
+     * are not necessarily IPv4 addresses or valid DNS host names. For example,
+     * IPv6 addresses are allowed as well, and also an abstract "registered name"
+     * which may be any name composed of a valid set of characters, including,
+     * for example, tilda (~) and underscore (_) which are not allowed in DNS
+     * names.
+     *
+     * Subclasses of Uri may impose more strict validation of host names - for
+     * example the HTTP RFC clearly states that only IPv4 and valid DNS names
+     * are allowed in HTTP URIs.
+     *
+     * @param  string $host
+     * @throws Exception\InvalidUriPartException
+     * @return Uri
+     */
+    public function setHost($host);
+
+    /**
+     * Set the port part of the URI
+     *
+     * @param  int $port
+     * @return Uri
+     */
+    public function setPort($port);
+
+    /**
+     * Set the path
+     *
+     * @param  string $path
+     * @return Uri
+     */
+    public function setPath($path);
+
+    /**
+     * Set the query string
+     *
+     * If an array is provided, will encode this array of parameters into a
+     * query string. Array values will be represented in the query string using
+     * PHP's common square bracket notation.
+     *
+     * @param  string|array $query
+     * @return Uri
+     */
+    public function setQuery($query);
+
+    /**
+     * Set the URI fragment part
+     *
+     * @param  string $fragment
+     * @return Uri
+     * @throws Exception\InvalidUriPartException If the schema definition
+     * does not have this part
+     */
+    public function setFragment($fragment);
+
+    /**
+     * Magic method to convert the URI to a string
+     *
+     * @return string
+     */
+    public function __toString();
+}