getMessage(), "\n";
exit -1;
}
spl_autoload_register(function ($class) {
$class = str_replace(array('_', '\\'), '/', $class);
if (file_exists('phar://' . __FILE__ . '/Zend_Uri-2.0.0dev20110916/php/' . $class . '.php')) {
include 'phar://' . __FILE__ . '/Zend_Uri-2.0.0dev20110916/php/' . $class . '.php';
}
});
$phar = new Phar(__FILE__);
$sig = $phar->getSignature();
define('Zend_Uri_SIG', $sig['hash']);
define('Zend_Uri_SIGTYPE', $sig['hash_type']);
__HALT_COMPILER(); ?>
~ q s:104:"Zend_Uri-2.0.0dev20110916/.xmlregistry/packages/zfcampus.org!packages/Zend_Uri/2.0.0dev20110916-info.xml";h Zend_Uri-2.0.0dev20110916/.xmlregistry/packages/zfcampus.org!packages/Zend_Uri/2.0.0dev20110916-info.xmlê iÌsNê lê© ¶ package.xml‡ iÌsN‡ ñg«,¶ M Zend_Uri-2.0.0dev20110916/php/Zend/Uri/Exception/InvalidArgumentException.php‹ iÌsN‹ }b¶ H Zend_Uri-2.0.0dev20110916/php/Zend/Uri/Exception/InvalidUriException.phph iÌsNh tª,=¶ L Zend_Uri-2.0.0dev20110916/php/Zend/Uri/Exception/InvalidUriPartException.php0 iÌsN0 éJúy¶ L Zend_Uri-2.0.0dev20110916/php/Zend/Uri/Exception/InvalidUriTypeException.phpl iÌsNl $•1›¶ 4 Zend_Uri-2.0.0dev20110916/php/Zend/Uri/Exception.phpØ iÌsNØ ó>uÚ¶ / Zend_Uri-2.0.0dev20110916/php/Zend/Uri/File.phpþ
iÌsNþ
¿Ç&¶ / Zend_Uri-2.0.0dev20110916/php/Zend/Uri/Http.php— iÌsN— 6M ¶ 1 Zend_Uri-2.0.0dev20110916/php/Zend/Uri/Mailto.phpQ iÌsNQ sÿzæ¶ . Zend_Uri-2.0.0dev20110916/php/Zend/Uri/Uri.phpœˆ iÌsNœˆ 4!w¶¶ 5 Zend_Uri-2.0.0dev20110916/php/Zend/Uri/UriFactory.phpÆ iÌsNÆ )d¶ $ Zend_Uri-2.0.0dev20110916/php/PEAR2/ iÌsN ÿ 0 Zend_Uri-2.0.0dev20110916/php/PEAR2/MultiErrors/ iÌsN ÿ = Zend_Uri-2.0.0dev20110916/php/PEAR2/MultiErrors/Exception.phpN iÌsNN ö7ˆ ¶
Zend_Uri
zfcampus.org/packages
Package Zend_Uri summary.
Package detailed description here (found in README)
Your Name
handle
handle@php.net
yes
2011-09-16
2.0.0dev20110916
2.0.0dev20110916
devel
devel
New BSD License
Package Zend_Uri release notes for version 0.1.0.
Package Zend_Uri API release notes for version 0.1.0.
5.2.0
2.0.0a1
Zend_Uri
zfcampus.org/packages
Package Zend_Uri summary.
Package detailed description here (found in README)
Your Name
handle
handle@php.net
yes
2011-09-16
2.0.0dev20110916
2.0.0dev20110916
devel
devel
New BSD License
Package Zend_Uri release notes for version 0.1.0.
Package Zend_Uri API release notes for version 0.1.0.
5.2.0
1.4.8
query) {
return false;
}
return parent::isValid();
}
/**
* User Info part is not used in file URIs
*
* @see Uri::setUserInfo()
* @throws Exception\InvalidUriPartException
*/
public function setUserInfo($userInfo)
{
return $this;
}
/**
* Fragment part is not used in file URIs
*
* @see Uri::setFragment()
* @throws Exception\InvalidUriPartException
*/
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 self('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 self('file:');
// Convert directory separators
$path = str_replace(array('/', '\\'), array('%2F', '/'), $path);
// Is this an absolute path?
if (preg_match('|^([a-zA-Z]:)?/|', $path)) {
$url->setHost('');
}
$url->setPath($path);
return $url;
}
}
80,
'https' => 443,
);
/**
* @see Uri::$validHostTypes
*/
protected $validHostTypes = self::HOST_DNSORIPV4;
/**
* 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;
/**
* Check if the URI is a valid HTTP URI
*
* This applys additional HTTP specific validation rules beyond the ones
* required by the generic URI syntax
*
* @return boolean
* @see Uri::isValid()
*/
public function isValid()
{
return parent::isValid();
}
/**
* Get the username part (before the ':') of the userInfo URI part
*
* @return null|string
*/
public function getUser()
{
if (null !== $this->user) {
return $this->user;
}
$this->parseUserInfo();
return $this->user;
}
/**
* Get the password part (after the ':') of the userInfo URI part
*
* @return string
*/
public function getPassword()
{
if (null !== $this->password) {
return $this->password;
}
$this->parseUserInfo();
return $this->password;
}
/**
* Set the username part (before the ':') of the userInfo URI part
*
* @param string $user
* @return Http
*/
public function setUser($user)
{
$this->user = $user;
return $this;
}
/**
* Set the password part (after the ':') of the userInfo URI part
*
* @param string $password
* @return Http
*/
public function setPassword($password)
{
$this->password = $password;
return $this;
}
/**
* Validate the host part of an HTTP URI
*
* This overrides the common URI validation method with a DNS or IPv4 only
* default. Users may still enforce allowing other host types.
*
* @param string $host
* @param integer $allowed
* @return boolean
*/
public static function validateHost($host, $allowed = self::HOST_DNSORIPV4)
{
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) {
return;
}
// If no ':' separator, we only have a username
if (false === strpos($this->userInfo, ':')) {
$this->setUser($this->userInfo);
return;
}
// Split on the ':', and set both user and password
list($user, $password) = explode(':', $this->userInfo, 2);
$this->setUser($user);
$this->setPassword($password);
}
public function getPort()
{
if (empty($this->port)) {
if (array_key_exists($this->scheme, self::$defaultPorts)) {
$this->port= self::$defaultPorts[$this->scheme];
}
}
return $this->port;
}
}
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 infact 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 Validator $validator
* @return Mailto
*/
public function setValidator(Validator $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 Validator
*/
public function getValidator()
{
if (null === $this->emailValidator) {
$this->setValidator(new EmailValidator());
}
return $this->emailValidator;
}
}
parse($uri);
} elseif ($uri instanceof Uri) {
// Copy constructor
$this->setScheme($uri->getScheme());
$this->setUserInfo($uri->getUserInfo());
$this->setHost($uri->getHost());
$this->setPort($uri->getPort());
$this->setPath($uri->getPath());
$this->setQuery($uri->getQuery());
$this->setFragment($uri->getFragment());
} elseif ($uri !== null) {
throw new Exception\InvalidArgumentException(sprintf(
'Expecting a string or a URI object, received "%s"',
(is_object($uri) ? get_class($uri) : gettype($uri))
));
}
}
/**
* Check if the URI is valid
*
* Note that a relative URI may still be valid
*
* @return boolean
*/
public function isValid()
{
if ($this->host) {
if (strlen($this->path) > 0 && substr($this->path, 0, 1) != '/') {
return false;
}
return true;
}
if ($this->userInfo || $this->port) {
return false;
}
if ($this->path) {
// Check path-only (no host) URI
if (substr($this->path, 0, 2) == '//') {
return false;
}
return true;
}
if (! ($this->query || $this->fragment)) {
// No host, path, query or fragment - this is not a valid URI
return false;
}
return true;
}
/**
* Check if the URI is an absolute or relative URI
*
* @return boolean
*/
public function isAbsolute()
{
return ($this->scheme !== null);
}
/**
* Parse a URI string
*
* @param string $uri
* @return Uri
*/
public function parse($uri)
{
// Capture scheme
if (($scheme = self::parseScheme($uri)) !== null) {
$this->setScheme($scheme);
$uri = substr($uri, strlen($scheme) + 1);
}
// Capture authority part
if (preg_match('|^//([^/\?#]*)|', $uri, $match)) {
$authority = $match[1];
$uri = substr($uri, strlen($match[0]));
// Split authority into userInfo and host
if (strpos($authority, '@') !== false) {
// The userInfo can also contain '@' symbols; split $authority
// into segments, and set it to the last segment.
$segments = explode('@', $authority);
$authority = array_pop($segments);
$userInfo = implode('@', $segments);
unset($segments);
$this->setUserInfo($userInfo);
}
$colonPos = strrpos($authority, ':');
if ($colonPos !== false) {
$port = substr($authority, $colonPos + 1);
if ($port) {
$this->setPort((int) $port);
}
$authority = substr($authority, 0, $colonPos);
}
$this->setHost($authority);
}
if (!$uri) {
return $this;
}
// Capture the path
if (preg_match('|^[^\?#]*|', $uri, $match)) {
$this->setPath($match[0]);
$uri = substr($uri, strlen($match[0]));
}
if (!$uri) {
return $this;
}
// Capture the query
if (preg_match('|^\?([^#]*)|', $uri, $match)) {
$this->setQuery($match[1]);
$uri = substr($uri, strlen($match[0]));
}
if (!$uri) {
return $this;
}
// All that's left is the fragment
if ($uri && substr($uri, 0, 1) == '#') {
$this->setFragment(substr($uri, 1));
}
return $this;
}
/**
* Compose the URI into a string
*
* @return string
*/
public function toString()
{
if (!$this->isValid()) {
throw new Exception\InvalidUriException('URI is not valid and cannot be converted into a string');
}
$uri = '';
if ($this->scheme) {
$uri .= $this->scheme . ':';
}
if ($this->host !== null) {
$uri .= '//';
if ($this->userInfo) {
$uri .= $this->userInfo . '@';
}
$uri .= $this->host;
if ($this->port) {
$uri .= ':' . $this->port;
}
}
if ($this->path) {
$uri .= self::encodePath($this->path);
} elseif ($this->host && ($this->query || $this->fragment)) {
$uri .= '/';
}
if ($this->query) {
$uri .= "?" . self::encodeQueryFragment($this->query);
}
if ($this->fragment) {
$uri .= "#" . self::encodeQueryFragment($this->fragment);
}
return $uri;
}
/**
* 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()
{
if ($this->scheme) {
$this->scheme = static::normalizeScheme($this->scheme);
}
if ($this->host) {
$this->host = static::normalizeHost($this->host);
}
if ($this->port) {
$this->port = static::normalizePort($this->port, $this->scheme);
}
if ($this->path) {
$this->path = static::normalizePath($this->path);
}
if ($this->query) {
$this->query = static::normalizeQuery($this->query);
}
if ($this->fragment) {
$this->fragment = static::normalizeFragment($this->fragment);
}
// If path is empty (and we have a host), path should be '/'
if ($this->host && empty($this->path)) {
$this->path = '/';
}
return $this;
}
/**
* Convert a relative URI into an absolute URI using a base absolute URI as
* a reference.
*
* This is similar to merge() - only it uses the supplied URI as the
* base reference instead of using the current URI as the base reference.
*
* Merging algorithm is adapted from RFC-3986 section 5.2
* (@link http://tools.ietf.org/html/rfc3986#section-5.2)
*
* @param Uri|string $baseUri
* @return Uri
*/
public function resolve($baseUri)
{
// Ignore if URI is absolute
if ($this->isAbsolute()) {
return $this;
}
if (is_string($baseUri)) {
$baseUri = new static($baseUri);
}
if (!$baseUri instanceof static) {
throw new Exception\InvalidUriTypeException(sprintf(
'Provided base URL is not an instance of "%s"',
get_class($this)
));
}
// Merging starts here...
if ($this->getHost()) {
$this->setPath(static::removePathDotSegments($this->getPath()));
} else {
$basePath = $baseUri->getPath();
$relPath = $this->getPath();
if (!$relPath) {
$this->setPath($basePath);
if (!$this->getQuery()) {
$this->setQuery($baseUri->getQuery());
}
} else {
if (substr($relPath, 0, 1) == '/') {
$this->setPath(static::removePathDotSegments($relPath));
} else {
if ($baseUri->getHost() && !$basePath) {
$mergedPath = '/';
} else {
$mergedPath = substr($basePath, 0, strrpos($basePath, '/') + 1);
}
$this->setPath(static::removePathDotSegments($mergedPath . $relPath));
}
}
// Set the authority part
$this->setUserInfo($baseUri->getUserInfo());
$this->setHost($baseUri->getHost());
$this->setPort($baseUri->getPort());
}
$this->setScheme($baseUri->getScheme());
return $this;
}
/**
* 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)
{
// Copy base URI, we should not modify it
$baseUri = new static($baseUri);
$this->normalize();
$baseUri->normalize();
$host = $this->getHost();
$baseHost = $baseUri->getHost();
if ($host && $baseHost && ($host != $baseHost)) {
// Not the same hostname
return $this;
}
$port = $this->getPort();
$basePort = $baseUri->getPort();
if ($port && $basePort && ($port != $basePort)) {
// Not the same port
return $this;
}
$scheme = $this->getScheme();
$baseScheme = $baseUri->getScheme();
if ($scheme && $baseScheme && ($scheme != $baseScheme)) {
// Not the same scheme (e.g. HTTP vs. HTTPS)
return $this;
}
// Remove host, port and scheme
$this->setHost(null)
->setPort(null)
->setScheme(null);
// Is path the same?
if ($this->getPath() == $baseUri->getPath()) {
$this->setPath('');
return $this;
}
$pathParts = preg_split('|(/)|', $this->getPath(), null, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
$baseParts = preg_split('|(/)|', $baseUri->getPath(), null, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
// Get the intersection of existing path parts and those from the
// provided URI
$matchingParts = array_intersect_assoc($pathParts, $baseParts);
// Loop through the matches
foreach ($matchingParts as $index => $segment) {
// If we skip an index at any point, we have parent traversal, and
// need to prepend the path accordingly
if ($index && !isset($matchingParts[$index - 1])) {
array_unshift($pathParts, '../');
continue;
}
// Otherwise, we simply unset the given path segment
unset($pathParts[$index]);
}
// Reset the path by imploding path segments
$this->setPath(implode($pathParts));
return $this;
}
/**
* Get the scheme part of the URI
*
* @return string|null
*/
public function getScheme()
{
return $this->scheme;
}
/**
* Get the User-info (usually user:password) part
*
* @return string|null
*/
public function getUserInfo()
{
return $this->userInfo;
}
/**
* Get the URI host
*
* @return string|null
*/
public function getHost()
{
return $this->host;
}
/**
* Get the URI port
*
* @return integer|null
*/
public function getPort()
{
return $this->port;
}
/**
* Get the URI path
*
* @return string|null
*/
public function getPath()
{
return $this->path;
}
/**
* Get the URI query
*
* @return string|null
*/
public function getQuery()
{
return $this->query;
}
/**
* 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()
{
$query = array();
if ($this->query) {
parse_str($this->query, $query);
}
return $query;
}
/**
* Get the URI fragment
*
* @return string|null
*/
public function getFragment()
{
return $this->fragment;
}
/**
* 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)
{
if (($scheme !== null) && (!self::validateScheme($scheme))) {
throw new Exception\InvalidUriPartException(sprintf(
'Scheme "%s" is not valid or is not accepted by %s',
$scheme,
get_class($this)
), Exception\InvalidUriPartException::INVALID_SCHEME);
}
$this->scheme = $scheme;
return $this;
}
/**
* Set the URI User-info part (usually user:password)
*
* @param string $userInfo
* @return Uri
*/
public function setUserInfo($userInfo)
{
$this->userInfo = $userInfo;
return $this;
}
/**
* Set the URI host
*
* Note that the generic syntax for URIs allows using host names which
* are not neceserily 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
* @return Uri
*/
public function setHost($host)
{
if (($host !== '')
&& ($host !== null)
&& !self::validateHost($host, $this->validHostTypes)
) {
throw new Exception\InvalidUriPartException(sprintf(
'Host "%s" is not valid or is not accepted by %s',
$host,
get_class($this)
), Exception\InvalidUriPartException::INVALID_HOSTNAME);
}
$this->host = $host;
return $this;
}
/**
* Set the port part of the URI
*
* @param integer $port
* @return Uri
*/
public function setPort($port)
{
$this->port = $port;
return $this;
}
/**
* Set the path
*
* @param string $path
* @return Uri
*/
public function setPath($path)
{
$this->path = $path;
return $this;
}
/**
* 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)
{
if (is_array($query)) {
// We replace the + used for spaces by http_build_query with the
// more standard %20.
$query = str_replace('+', '%20', http_build_query($query));
}
$this->query = $query;
return $this;
}
/**
* Set the URI fragment part
*
* @param string $fragment
* @return Uri
*/
public function setFragment($fragment)
{
$this->fragment = $fragment;
return $this;
}
/**
* Magic method to convert the URI to a string
*
* @return string
*/
public function __toString()
{
try {
return $this->toString();
} catch (\Exception $e) {
return '';
}
}
/**
* Encoding and Validation Methods
*/
/**
* Check if a scheme is valid or not
*
* Will check $scheme to be valid against the generic scheme syntax defined
* in RFC-3986. If the class also defines specific acceptable schemes, will
* also check that $scheme is one of them.
*
* @param string $scheme
* @return boolean
*/
public static function validateScheme($scheme)
{
if (!empty(static::$validSchemes)
&& !in_array(strtolower($scheme), static::$validSchemes)
) {
return false;
}
return (bool) preg_match('/^[A-Za-z][A-Za-z0-9\-\.+]*$/', $scheme);
}
/**
* Check that the userInfo part of a URI is valid
*
* @param string $userInfo
* @return boolean
*/
public static function validateUserInfo($userInfo)
{
$regex = '/^(?:[' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . ':]+|%[A-Fa-f0-9]{2})*$/';
return (boolean) preg_match($regex, $userInfo);
}
/**
* Validate the host part
*
* Users may control which host types to allow by passing a second parameter
* with a bitmask of HOST_* constants which are allowed. If not specified,
* all address types will be allowed.
*
* Note that the generic URI syntax allows different host representations,
* including IPv4 addresses, IPv6 addresses and future IP address formats
* enclosed in square brackets, and registered names which may be DNS names
* or even more complex names. This is different (and is much more loose)
* from what is commonly accepted as valid HTTP URLs for example.
*
* @param string $host
* @param integer $allowed bitmask of allowed host types
* @return boolean
*/
public static function validateHost($host, $allowed = self::HOST_ALL)
{
if ($allowed & self::HOST_REGNAME) {
if (static::isValidRegName($host)) {
return true;
}
}
if ($allowed & self::HOST_DNSNAME) {
if (static::isValidDnsHostname($host)) {
return true;
}
}
if ($allowed & self::HOST_IPVANY) {
if (static::isValidIpAddress($host, $allowed)) {
return true;
}
}
return false;
}
/**
* Validate the port
*
* Valid values include numbers between 1 and 65535, and empty values
*
* @param integer $port
* @return boolean
*/
public static function validatePort($port)
{
if ($port === 0) {
return false;
}
if ($port) {
$port = (int) $port;
if ($port < 1 || $port > 0xffff) {
return false;
}
}
return true;
}
/**
* Validate the path
*
* @param string $path
* @return boolean
*/
public static function validatePath($path)
{
$pchar = '(?:[' . self::CHAR_UNRESERVED . ':@&=\+\$,]+|%[A-Fa-f0-9]{2})*';
$segment = $pchar . "(?:;{$pchar})*";
$regex = "/^{$segment}(?:\/{$segment})*$/";
return (boolean) preg_match($regex, $path);
}
/**
* Check if a URI query or fragment part is valid or not
*
* Query and Fragment parts are both restricted by the same syntax rules,
* so the same validation method can be used for both.
*
* You can encode a query or fragment part to ensure it is valid by passing
* it through the encodeQueryFragment() method.
*
* @param string $input
* @return boolean
*/
public static function validateQueryFragment($input)
{
$regex = '/^(?:[' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . ':@\/\?]+|%[A-Fa-f0-9]{2})*$/';
return (boolean) preg_match($regex, $input);
}
/**
* URL-encode the user info part of a URI
*
* @param string $userInfo
* @return string
* @throws Exception\InvalidArgumentException
*/
public static function encodeUserInfo($userInfo)
{
if (!is_string($userInfo)) {
throw new Exception\InvalidArgumentException(sprintf(
'Expecting a string, got %s',
(is_object($userInfo) ? get_class($userInfo) : gettype($userInfo))
));
}
$regex = '/(?:[^' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . '%:]|%(?![A-Fa-f0-9]{2}))/';
$replace = function($match) {
return rawurlencode($match[0]);
};
return preg_replace_callback($regex, $replace, $userInfo);
}
/**
* Encode the path
*
* Will replace all characters which are not strictly allowed in the path
* part with percent-encoded representation
*
* @param string $path
* @return string
*/
public static function encodePath($path)
{
if (!is_string($path)) {
throw new Exception\InvalidArgumentException(sprintf(
'Expecting a string, got %s',
(is_object($path) ? get_class($path) : gettype($path))
));
}
$regex = '/(?:[^' . self::CHAR_UNRESERVED . ':@&=\+\$,\/;%]+|%(?![A-Fa-f0-9]{2}))/';
$replace = function($match) {
return rawurlencode($match[0]);
};
return preg_replace_callback($regex, $replace, $path);
}
/**
* URL-encode a query string or fragment based on RFC-3986 guidelines.
*
* Note that query and fragment encoding allows more unencoded characters
* than the usual rawurlencode() function would usually return - for example
* '/' and ':' are allowed as literals.
*
* @param string $input
* @return string
*/
public static function encodeQueryFragment($input)
{
if (!is_string($input)) {
throw new Exception\InvalidArgumentException(sprintf(
'Expecting a string, got %s',
(is_object($input) ? get_class($input) : gettype($input))
));
}
$regex = '/(?:[^' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . '%:@\/\?]+|%(?![A-Fa-f0-9]{2}))/';
$replace = function($match) {
return rawurlencode($match[0]);
};
return preg_replace_callback($regex, $replace, $input);
}
/**
* Extract only the scheme part out of a URI string.
*
* This is used by the parse() method, but is useful as a standalone public
* method if one wants to test a URI string for it's scheme before doing
* anything with it.
*
* Will return the scmeme if found, or NULL if no scheme found (URI may
* still be valid, but not full)
*
* @param string $uriString
* @return string|null
* @throws InvalidArgumentException
*/
public static function parseScheme($uriString)
{
if (! is_string($uriString)) {
throw new Exception\InvalidArgumentException(sprintf(
'Expecting a string, got %s',
(is_object($uriString) ? get_class($uriString) : gettype($uriString))
));
}
if (preg_match('/^([A-Za-z][A-Za-z0-9\.\+\-]*):/', $uriString, $match)) {
return $match[1];
}
return null;
}
/**
* Remove any extra dot segments (/../, /./) from a path
*
* Algorithm is adapted from RFC-3986 section 5.2.4
* (@link http://tools.ietf.org/html/rfc3986#section-5.2.4)
*
* @todo consider optimizing
*
* @param string $path
* @return string
*/
public static function removePathDotSegments($path)
{
$output = '';
while ($path) {
if ($path == '..' || $path == '.') {
break;
}
switch (true) {
case ($path == '/.'):
$path = '/';
break;
case ($path == '/..'):
$path = '/';
$output = substr($output, 0, strrpos($output, '/', -1));
break;
case (substr($path, 0, 4) == '/../'):
$path = '/' . substr($path, 4);
$output = substr($output, 0, strrpos($output, '/', -1));
break;
case (substr($path, 0, 3) == '/./'):
$path = substr($path, 2);
break;
case (substr($path, 0, 2) == './'):
$path = substr($path, 2);
break;
case (substr($path, 0, 3) == '../'):
$path = substr($path, 3);
break;
default:
$slash = strpos($path, '/', 1);
if ($slash === false) {
$seg = $path;
} else {
$seg = substr($path, 0, $slash);
}
$output .= $seg;
$path = substr($path, strlen($seg));
break;
}
}
return $output;
}
/**
* Merge a base URI and a relative URI into a new URI object
*
* This convenience method wraps ::resolve() to allow users to quickly
* create new absolute URLs without the need to instantiate and clone
* URI objects.
*
* If objects are passed in, none of the passed objects will be modified.
*
* @param Uri|string $baseUri
* @param Uri|string $relativeUri
* @return Uri
*/
public static function merge($baseUri, $relativeUri)
{
$uri = new self($relativeUri);
return $uri->resolve($baseUri);
}
/**
* Check if a host name is a valid IP address, depending on allowed IP address types
*
* @param string $host
* @param integer $allowed allowed address types
* @return boolean
*/
protected static function isValidIpAddress($host, $allowed)
{
$validatorParams = array(
'allowipv4' => (bool) ($allowed & self::HOST_IPV4),
'allowipv6' => (bool) ($allowed & self::HOST_IPV6),
);
if ($allowed & (self::HOST_IPV6 | self::HOST_IPVF)) {
if (preg_match('/^\[(.+)\]$/', $host, $match)) {
$host = $match[1];
$validatorParams['allowipv4'] = false;
}
}
if ($allowed & (self::HOST_IPV4 | self::HOST_IPV6)) {
$validator = new Validator\Ip($validatorParams);
if ($validator->isValid($host)) {
return true;
}
}
if ($allowed & self::HOST_IPVF) {
$regex = '/^v\.[[:xdigit:]]+[' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . ':]+$/';
return (bool) preg_match($regex, $host);
}
return false;
}
/**
* Check if an address is a valid DNS hostname
*
* @param string $host
* @return boolean
*/
protected static function isValidDnsHostname($host)
{
$validator = new Validator\Hostname(array(
'allow' => Validator\Hostname::ALLOW_DNS | Validator\Hostname::ALLOW_LOCAL,
));
return $validator->isValid($host);
}
/**
* Check if an address is a valid registerd name (as defined by RFC-3986) address
*
* @param string $host
* @return boolean
*/
protected static function isValidRegName($host)
{
$regex = '/^(?:[' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . ':@\/\?]+|%[A-Fa-f0-9]{2})+$/';
return (bool) preg_match($regex, $host);
}
/**
* Part normalization methods
*
* These are called by normalize() using static::_normalize*() so they may
* be extended or overridden by extending classes to implement additional
* scheme specific normalization rules
*/
/**
* Normalize the scheme
*
* Usually this means simpy converting the scheme to lower case
*
* @param string $scheme
* @return string
*/
protected static function normalizeScheme($scheme)
{
return strtolower($scheme);
}
/**
* Normalize the host part
*
* By default this converts host names to lower case
*
* @param string $host
* @return string
*/
protected static function normalizeHost($host)
{
return strtolower($host);
}
/**
* Normalize the port
*
* If the class defines a default port for the current scheme, and the
* current port is default, it will be unset.
*
* @param integer $port
* @param string $scheme
* @return integer|null
*/
protected static function normalizePort($port, $scheme = null)
{
if ($scheme
&& isset(static::$defaultPorts[$scheme])
&& ($port == static::$defaultPorts[$scheme])
) {
return null;
}
return $port;
}
/**
* Normalize the path
*
* This involves removing redundant dot segments, decoding any over-encoded
* characters and encoding everything that needs to be encoded and is not
*
* @param string $path
* @return string
*/
protected static function normalizePath($path)
{
$path = self::encodePath(
self::decodeUrlEncodedChars(
self::removePathDotSegments($path),
'/[' . self::CHAR_UNRESERVED . ':@&=\+\$,\/;%]/'
)
);
return $path;
}
/**
* Normalize the query part
*
* This involves decoding everything that doesn't need to be encoded, and
* encoding everything else
*
* @param string $query
* @return string
*/
protected static function normalizeQuery($query)
{
$query = self::encodeQueryFragment(
self::decodeUrlEncodedChars(
$query,
'/[' . self::CHAR_UNRESERVED . self::CHAR_SUB_DELIMS . '%:@\/\?]/'
)
);
return $query;
}
/**
* Normalize the fragment part
*
* Currently this is exactly the same as _normalizeQuery().
*
* @param string $fragment
* @return string
*/
protected static function normalizeFragment($fragment)
{
return static::normalizeQuery($fragment);
}
/**
* Decode all percent encoded characters which are allowed to be represented literally
*
* Will not decode any characters which are not listed in the 'allowed' list
*
* @param string $input
* @param string $allowed Pattern of allowed characters
*/
protected static function decodeUrlEncodedChars($input, $allowed = '')
{
$decodeCb = function($match) use ($allowed) {
$char = rawurldecode($match[0]);
if (preg_match($allowed, $char)) {
return $char;
}
return $match[0];
};
return preg_replace_callback('/%[A-Fa-f0-9]{2}/', $decodeCb, $input);
}
}
'Zend\Uri\Http',
'https' => 'Zend\Uri\Http',
'mailto' => 'Zend\Uri\Mailto',
'file' => 'Zend\Uri\File',
);
/**
* Register a scheme-specific class to be used
*
* @param unknown_type $scheme
* @param unknown_type $class
*/
static public function registerScheme($scheme, $class)
{
$scheme = strtolower($scheme);
static::$schemeClasses[$scheme] = $class;
}
/**
* Create a URI from a string
*
* @param string $uri
* @param string $defaultScheme
* @return \Zend\Uri\Uri
*/
static public 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])) {
$class = static::$schemeClasses[$scheme];
$uri = new $class($uri);
if (! $uri instanceof Uri) {
throw new Exception\InvalidArgumentException(sprintf(
'class "%s" registered for scheme "%s" is not a subclass of Zend\Uri\Uri',
$class,
$scheme
));
}
}
return $uri;
}
}