altorouter.class.php

Go to the documentation of this file.

<?php
//namespace AltoRouter;
class AltoRouter
{
    protected $routes = array();
    protected $namedRoutes = array();
    protected $basePath = '';
    protected $ignoreCase = false;
    protected $matchTypes = array(
        'i'  => '[0-9]++',
        'a'  => '[0-9A-Za-z]++',
        'h'  => '[0-9A-Fa-f]++',
        '*'  => '.+?',
        '**' => '.++',
        ''   => '[^/\.]++'
    );
    protected $defaultParams = array();
    protected $transformers = array();
    public function __construct(
        $routes = array(),
        $basePath = '',
        $matchTypes = array(),
        $defaultParams = array(),
        $ignoreCase = false
    ) {
        $this->addRoutes($routes);
        $this->setBasePath($basePath);
        $this->addMatchTypes($matchTypes);
        $this->addDefaultParams($defaultParams);
        $this->setIgnoreCase($ignoreCase);
    }
    public function __call(
        $name,
        $arguments
    ) {
        $name = strtolower($name);
        $validTypes = array(
            'get' => 'GET',
            'put' => 'PUT',
            'head' => 'HEAD',
            'post' => 'POST',
            'patch' => 'PATCH',
            'delete' => 'DELETE',
            'options' => 'OPTIONS'
        );
        // If method type is invalid don't do anything.
        if (!isset($validTypes[$name])) {
            return;
        }
        // Prepend the type to our arguments to pass to the map.
        array_unshift(
            $arguments,
            $validTypes[$name]
        );
        // Pass to the map method.
        call_user_func_array(
            array($this, 'map'),
            $arguments
        );
        return $this;
    }
    public function getRoutes()
    {
        return $this->routes;
    }
    public function getNamedRoutes()
    {
        return $this->namedRoutes;
    }
    public function getBasePath()
    {
        return $this->basePath;
    }
    public function getDefaultParams()
    {
        return $this->getDefaultParams();
    }
    public function getIgnoreCase()
    {
        return $this->ignoreCase;
    }
    public function addRoutes($routes)
    {
        if (!is_array($routes)
            && !$routes instanceof \Traversable
        ) {
            $msg
                = 'Routes should be an array or an instance of Traversable';
            if (!defined('HHVM_VERSION')) {
                $msg = _('Routes should be an array or an instance of Traversable');
            }
            throw new \Exception($msg);
        }
        foreach ($routes as $route) {
            call_user_func_array(array($this, 'map'), $route);
        }
        return $this;
    }
    public function setBasePath($basePath)
    {
        $this->basePath = $basePath;
        return $this;
    }
    public function setIgnoreCase($ignoreCase)
    {
        $this->ignoreCase = (bool)$ignoreCase;
        return $this;
    }
    public function addMatchTypes($matchTypes)
    {
        $this->matchTypes = array_merge(
            $this->matchTypes,
            $matchTypes
        );
        return $this;
    }
    public function addDefaultParams($defaultParams)
    {
        $this->defaultParams = array_merge(
            $this->defaultParams,
            $defaultParams
        );
        return $this;
    }
    public function addTransformer($matchType, \AltoTransformer $transformer)
    {
        $this->transformers[$matchType] = $transformer;
        return $this;
    }
    public function map(
        $method,
        $route,
        $target,
        $name = null
    ) {
        foreach (explode('|', $method) as $method) {
            if (!isset($this->routes[$method])) {
                $this->routes[$method] = array();
            }
            $this->routes[$method][] = array($route, $target, $name);
            unset($method);
        }
        if ($name) {
            if (isset($this->namedRoutes[$name])) {
                $msg = sprintf(
                    "%s '%s'",
                    'Can not redeclare route',
                    $name
                );
                if (!defined('HHVM_VERSION')) {
                    $msg = sprintf(
                        "%s '%s'",
                        _('Can not redeclare route'),
                        $name
                    );
                }
                throw new \Exception($msg);
            }
            $this->namedRoutes[$name] = $route;
        }
        return $this;
    }
    public function generate(
        $routeName,
        array $params = array()
    ) {
        // Check if named route exists
        if (!isset($this->namedRoutes[$routeName])) {
            throw new \Exception(
                "Route '{$routeName}' does not exist."
            );
        }
        // Replace named parameters
        $route = $this->namedRoutes[$routeName];
        // prepend base path to route url again
        $url = $this->basePath . $route;
        // merge with default params.
        $params = array_merge(
            $this->defaultParams,
            $params
        );
        $pattern = '`(/|\.|)\[([^:\]]*+)(?::([^:\]]*+))?\](\?|)`';
        if (preg_match_all($pattern, $route, $matches, PREG_SET_ORDER)) {
            foreach ($matches as $index => $match) {
                list(
                    $block,
                    $pre,
                    $type,
                    $param,
                    $optional
                ) = $match;
                if ($pre) {
                    $block = substr($block, 1);
                }
                if (isset($this->transformers[$type])) {
                    $params[$param] = $this->transformers[$type]
                        ->toUrl($params[$param]);
                }
                if (isset($params[$param])) {
                    // Part is found, replace for param value.
                    $url = str_replace(
                        $block,
                        $params[$param],
                        $url
                    );
                } elseif ($optional && $index !== 0) {
                    $url = str_replace(
                        $pre . $block,
                        '',
                        $url
                    );
                } else {
                    $url = str_replace(
                        $block,
                        '',
                        $url
                    );
                }
            }
        }
        return $url;
    }
    public function match(
        $requestUrl = null,
        $requestMethod = null
    ) {
        $params = array();
        $match = false;
        // set Request Url if it isn't passed as parameter
        if (null === $requestUrl) {
            $requestUrl = $this->getRequestURI() ?: '/';
        }
        // strip base path from request url
        $requestUrl = substr(
            $requestUrl,
            strlen($this->basePath)
        );
        // Strip query string (?a=b) from Request Url
        if (false !== ($strpos = strpos($requestUrl, '?'))) {
            $requestUrl = substr($requestUrl, 0, $strpos);
        }
        // set Request Method if it isn't passed as a parameter
        if (null === $requestMethod) {
            $requestMethod = $this->getRequestMethod() ?: 'GET';
        }
        if (empty($this->routes[$requestMethod])) {
            return false;
        }
        foreach ($this->routes[$requestMethod] as $handler) {
            list(
                $route,
                $target,
                $name
            ) = $handler;
            unset($handler);
            if ('*' === $route) {
                // * wildcard (matches all)
                $match = true;
            } elseif (isset($route[0])
                && $route[0] === '@'
            ) {
                // @ regex delimiter
                $pattern = '`'
                    . substr($route, 1)
                    . '`u'
                    . ($this->ignoreCase ? 'i' : null);
                $match = (1 === preg_match($pattern, $requestUrl, $params));
            } elseif (false === ($position = strpos($route, '['))) {
                // No params in url, do string comparison
                $match = 0 === strcmp($requestUrl, $route);
            } else {
                // Compare longest non-param string with url
                if (0 !== strncmp($requestUrl, $route, $position)) {
                    continue;
                }
                $regex = $this->_compileRoute($route);
                $match = (1 === preg_match($regex['regex'], $requestUrl, $params));
            }
            if ($match) {
                if ($params) {
                    $routeisarr = is_array($route);
                    foreach ($params as $key => $value) {
                        if (is_numeric($key)) {
                            unset($params[$key]);
                            continue;
                        }
                        if (!$routeisarr) {
                            continue;
                        }
                        $type = $route['types'][$key];
                        if (isset($this->transformers[$type])) {
                            $params[$key]
                                = $this->transformers[$type]->fromUrl($value);
                        }
                        unset($values);
                    }
                    $params['method'] = $requestMethod;
                }
                $result = $this->getMatchedResult(
                    $target,
                    $params,
                    $name
                );
                if ($result) {
                    return $result;
                }
            }
        }
        return false;
    }
    private function _compileRoute($route)
    {
        $pattern = '`(/|\.|)\[([^:\]]*+)(?::([^:\]]*+))?\](\?|)`';
        $route = array(
            'regex' => sprintf(
                '`^%s$`u%s',
                $route,
                ($this->ignoreCase ? 'i' : '')
            ),
            'types' => array()
        );
        if (preg_match_all($pattern, $route['regex'], $matches, PREG_SET_ORDER)) {
            $matchTypes = $this->matchTypes;
            foreach ($matches as $match) {
                list(
                    $block,
                    $pre,
                    $type,
                    $param,
                    $optional,
                ) = $match;
                unset($match);
                $optional = ('' !== $optional ? '?' : null);
                $route['types'][$param] = $type;
                if (isset($matchTypes[$type])) {
                    $type = $matchTypes[$type];
                }
                if ('.' === $pre) {
                    $pre = '\.';
                }
                // Older versions of PCRE require the 'P' in (?P<named>)
                $pattern = '(?:'
                    . ('' !== $pre ? $pre.'+' : null)
                    . '('
                    . ('' !== $param ? "?P<$param>" : null)
                    . $type
                    . ')'
                    . $optional
                    . '(/+|))'
                    . $optional;
                $route['regex'] = str_replace($block, $pattern, $route['regex']);
            }
        }
        return $route;
    }
    protected function getRequestURI()
    {
        return filter_input(INPUT_SERVER, 'REQUEST_URI');
    }
    protected function getRequestMethod()
    {
        return filter_input(INPUT_SERVER, 'REQUEST_METHOD');
    }
    protected function getMatchedResult(
        $target,
        $params,
        $name
    ) {
        return array(
            'target' => $target,
            'params' => $params,
            'name' => $name
        );
    }
}