Zaphpa\Template

Complexity

Total Complexity

34

Size/Duplication

Total Lines	136
Duplicated Lines	13.24 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	4
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	6	2
A	getTemplate()	0	3	1
A	getExpression()	0	9	2
B	pattern()	0	20	7
A	addQueryParam()	9	9	2
A	addGlobalQueryParam()	9	9	2
C	match()	0	35	8
C	enforceParamMatching()	0	24	9
A	regex()	0	3	1

<?php

namespace Zaphpa;

/**
 * Generic URI matcher and parser implementation.
 */
class Template {

    private static $globalQueryParams = array();
    private $patterns = array();

    private $template  = null;
    private $params    = array();
    private $callbacks = array();

    public function __construct($path) {
        if ($path{0} != '/') {
            $path = "/$path";
        }
        $this->template = rtrim($path, '\/');
    }

    public function getTemplate() {
        return $this->template;
    }

    public function getExpression() {
        $expression = $this->template;
        if (preg_match_all('~(?P<match>\{(?P<name>.+?)\})~', $expression, $matches)) {
            $expressions = array_map(array($this, 'pattern'), $matches['name']);
            $expression  = str_replace($matches['match'], $expressions, $expression);
        }

        return sprintf('~^%s$~', $expression);
    }

    public function pattern($token, $pattern = null) {
        if ($pattern) {
            if (!isset($this->patterns[$token])) {
                $this->patterns[$token] = $pattern;
            }
        } else {

            if (isset($this->patterns[$token])) {
                $pattern = $this->patterns[$token];
            } else {
                $pattern = Constants::PATTERN_ANY;
            }

            if ((is_string($pattern) && is_callable($pattern)) || is_array($pattern)) {
                $this->callbacks[$token] = $pattern;
                $this->patterns[$token] = $pattern = Constants::PATTERN_ANY;
            }
            return sprintf($pattern, $token);
        }
    }

    public function addQueryParam($name, $pattern = '', $defaultValue = null) {
        if (!$pattern) {
            $pattern = Constants::PATTERN_ANY;
        }
        $this->params[$name] = (object) array(
            'pattern' => sprintf($pattern, $name),
            'value'   => $defaultValue
        );
    }

    public static function addGlobalQueryParam($name, $pattern = '', $defaultValue = null) {
        if (!$pattern) {
            $pattern = Constants::PATTERN_ANY;
        }
        self::$globalQueryParams[$name] = (object) array(
            'pattern' => sprintf($pattern, $name),
            'value'   => $defaultValue
        );
    }

    public function match($uri) {

        $uri = rtrim($uri, '\/');
        $match_found = preg_match($this->getExpression(), $uri, $matches);
        if (! $match_found) return;

        foreach($matches as $k => $v) {
            if (is_numeric($k)) {
                unset($matches[$k]);
            } else {
                if (isset($this->callbacks[$k])) {
                    $callback = Callback_Util::getCallback($this->callbacks[$k]);
                    $value    = call_user_func($callback, $v);
                    if ($value) {
                        $matches[$k] = $value;
                    } else {
                        throw new InvalidURIParameterException('Invalid parameters detected');
                    }
                }

                if (strpos($v, '/') !== false) {
                    $matches[$k] = explode('/', trim($v, '\/'));
                }
            }
        }

        $params = array_merge(self::$globalQueryParams, $this->params);

        if (!empty($params)) {
            $this->enforceParamMatching($params);
        }

        return $matches;

    }

    protected function enforceParamMatching($params) {

        foreach($params as $name => $param) {

            if (!isset($_GET[$name]) && $param->value) {
                $_GET[$name] = $param->value;
                $matched = true;
            } else if ($param->pattern && isset($_GET[$name])) {
                $result = preg_match(sprintf('~^%s$~', $param->pattern), $_GET[$name]);
                if (!$result && $param->value) {
                    $_GET[$name] = $param->value;
                    $result = true;
                }
                $matched = $result;
            } else {
                $matched = false;
            }

            if ($matched == false) {
                throw new Exception('Request does not match');
            }

        }
    }

    public static function regex($pattern) {
        return "(?P<%s>$pattern)";
    }
}