Weblabor

$router = Router::getInstance();

//Feltételek hozzáadása

//Ez a következő url-re lesz érvényes (saját mintaillesztés) /topic/2012-10-10-topic_title
$router->addRule('/topic/<:topicurl|[0-9]{4}\-[0-9]{2}\-[0-9]{2}\-[a-zA-Z0-9\_\-\+\%]{0,500}>', array('controller' => 'forum', 'action' => 'showTopic')); 
//Eredmény: array('topicurl' => '2012-10-10-topic_title')


//Statikus route + opcionális amelyben csak [a-zA-Z0-9\_\-\+\%]
$router->addRule('/topic/add(/<:optional>)', array('controller' => 'forum', 'action' => 'newTopic', 'template' => 'topic.form')); 
//Eredmény, amennyiben az url csak /topic/add üres tömb, ha van opcionális paraméter akkor array('optional' = 'ertek')

//Statikus
$router->addRule('/login', array('controller' => 'users', 'action' => 'showLogIn', 'template' => 'loginbox'));

//Teljes mintaillesztés 
//<:arraykey> - [a-zA-Z0-9\_\-\+\%]
//<#arraykey> - [0-9]
//<#arraykey> - (.*)
$router->addRule('/<:mit>/<:hogy>/<#id>(/<*barmi>)', array('controller' => 'forum', 'action' => 'index', 'template' => 'add')); 
//Eredmény array('mit' => 'ertek', 'hogy'=> 'ertek', 'id' => 'szam', 'barmi' => 'ertek')

//Minden egyéb esetben pl. /news/hircime/addcomment/15
//controller: news
//action: hircime
//params: array([0] => 'addcomment', [1] => '15')

//Router elindítása
$router->init();


//Meghívandó Osztály/Controller
$router->getController();

//Metódus
$router->getAction();

//Template
$router->getTemplate();

//Paraméterek
$router->getParams();

//Adott paraméter
$router->getParam(1);

<?php
class Router {

	static protected $instance;
	static protected $controller;
	static protected $action;
	static protected $template;
	static protected $params;
	static protected $rules;
	static protected $routeParamRegex="\<[\:|\*|\#]([^\>]+)\>";
	static protected $routeOptionalParamRegex="\(([^\<]*)\<[\:|\*|\#]([^\>]+)\>([^\)]*)\)";
	static protected $paramRegex="([a-zA-Z0-9\_\-\+\%]+)";
	static protected $paramRegexNumeric="([0-9]+)";
	static protected $paramRegexWildcard="(.*)";
	static protected $Regexp;
	static protected $namedParams=array();
	static protected $optionalParams=array();
	static protected $defaultParams=array();
	static protected $isStaticRoute=false;
 
	public static function getInstance(){
		if(isset(self::$instance) and (self::$instance instanceof self)){
			return self::$instance;
		}else{
			self::$instance=new self();
			return self::$instance;
		}
	}

	protected function __construct(){
		self::$rules=array();
	}
 
	private static function arrayClean($array){
		foreach($array as $key=> $value){
		  if(strlen($value)==0) unset($array[$key]);
		}  
	  }
    public function defaults(array $params=array()){
        if(count($params) > 0){
            self::$defaultParams=$params;
            return self;
        }
        return self::$defaultParams;
    }
	protected function optionalParamDefaults(){
        $defaultParams=self::defaults();
        $optionalParamDefaults=array();
        if(self::$optionalParams && count(self::$optionalParams) > 0){
            foreach(self::$optionalParams as $paramName=> $opts){
                if(isset($defaultParams[$paramName])){
                    $optionalParamDefaults[$paramName]=$defaultParams[$paramName];
                }else{
                    $optionalParamDefaults[$paramName]=null;
                }
            }
        }
        return $optionalParamDefaults;
	}
	private static function ruleMatch($rule, $data){    
		$data=trim($data, '/');
		if(preg_match(self::$Regexp, $data, $matches)){
			$opParams=self::optionalParamDefaults();
			if(!self::$isStaticRoute && count($matches)>1){
				
				array_shift($matches);
		
				$namedParamsIndexed=array_keys(self::$namedParams);
				$namedParams=array_merge(self::$namedParams, self::optionalParamDefaults());
				$namedParamsNotOptional=array_diff_key($namedParams, self::optionalParamDefaults());
				$namedParamsMatched=$namedParamsNotOptional;
			
				$c=count($namedParamsNotOptional);
				while(count($matches) > $c){
					$namedParamsMatched[$namedParamsIndexed[$c]]=$namedParams[$namedParamsIndexed[$c]];
					$c++;
				}
				
				$params=array_combine(array_keys($namedParamsMatched), $matches);
				
				if(count($namedParamsMatched) !=count($matches)){
					return false;
				}else{
					return $params;
					unset($params);
				}
			}else{
				return true;
			}
		}else{
			return false;
		}
	}
 
	private static function defaultRoutes($url){
		$items=explode('/',$url);
 
		foreach($items as $key=> $value){
			if(strlen($value)==0) unset($items[$key]);
		}
		if(count($items)){
			self::$controller=array_shift($items);
			self::$action=array_shift($items);
			self::$params=$items;
		}
	}
	protected function initRouteRegexp($rule){

		$rule=trim($rule, '/');
		$routeRegex=$rule;
		$regexOptionalMatches=array();
		preg_match_all("@" .self::$routeOptionalParamRegex. "@", $rule, $regexOptionalMatches, PREG_SET_ORDER);
		if(isset($regexOptionalMatches[0]) && count($regexOptionalMatches) > 0){
			// print_r($regexOptionalMatches);
			foreach($regexOptionalMatches as $paramMatch){
				
				$routeOptionalParams[$paramMatch[2]]=array(
					'routeSegment'=> $paramMatch[0],
					'prefix'=> $paramMatch[1],
					'suffix'=> $paramMatch[3],
				);
				
				$routeParamToken=substr($paramMatch[0], strlen('(' . $paramMatch[1])); 
				$routeParamToken=substr($routeParamToken, 0, -strlen($paramMatch[3] . ')'));
				$routeRegex=str_replace($paramMatch[0], "(?:" . preg_quote($paramMatch[1]) . $routeParamToken . preg_quote($paramMatch[3]) . ")?", $routeRegex);
				
			}
		}
		$regexMatches=array();
		preg_match_all("@" . self::$routeParamRegex . "@", $rule, $regexMatches, PREG_PATTERN_ORDER);
            if(isset($regexMatches[1]) && count($regexMatches[1]) > 0){
                $routeParamsMatched=array();
                foreach($regexMatches[1] as $paramIndex=> $paramName){
					
                    if(strpos($paramName, '|') !==false){
						
                        $paramParts=explode('|', $paramName);
                        $routeParamsMatched[]=$paramParts[0];
						
                        $routeRegex=str_replace("<:" . $paramName . ">", "(" . $paramParts[1] . ")", $routeRegex);
						
                    }else{
					
                        $routeParamsMatched[]=$paramName;
                        $routeRegex=str_replace("<:" . $paramName . ">", self::$paramRegex, $routeRegex);
                        $routeRegex=str_replace("<#" . $paramName . ">", self::$paramRegexNumeric, $routeRegex);
                        $routeRegex=str_replace("<*" . $paramName . ">", self::$paramRegexWildcard, $routeRegex);
						
                    }
                }
                $routeParams=array_combine($routeParamsMatched, $regexMatches[0]);
            }else{
				self::$isStaticRoute=true;
			}
        
		$routeRegex=str_replace('/', '\/', $routeRegex);
		
		self::$Regexp="/^" . $routeRegex . "$/";
		self::$namedParams=$routeParams;
		self::$optionalParams=$routeOptionalParams;
	}
	
	public static function init(){
		$url=$_SERVER['REQUEST_URI'];
		$isCustom=false;
		
		if(count(self::$rules)){
			foreach(self::$rules as $ruleKey=> $ruleData){
				self::initRouteRegexp($ruleKey);
				$params=self::ruleMatch($ruleKey,$url);
				if($params){
					self::$controller=$ruleData['controller'];
					self::$action=$ruleData['action'];
					self::$template=$ruleData['template'];
					if(is_array($params)){
						self::$params=$params;
					}else{
						self::$params=array();
					}
					$isCustom=true;
					break;
				}
			 }
		}
 
		if(!$isCustom){
			self::defaultRoutes($url);
		}
 
		if(!strlen(self::$controller)){
			self::$controller='home';
		}
		if(!strlen(self::$action)){
			self::$action='index';
		}
		if(!strlen(self::$template)){
			self::$template='default';
		}
	}
 
	public static function addRule($rule, $target){
		self::$rules[$rule]=$target;
	}
 
	public static function getController(){
		return self::$controller;
	}
	public static function getAction(){
		return self::$action;
	}
	public static function getTemplate(){
		return self::$template;
	}
	public static function getParams(){
		return self::$params;
	}
	public static function getParam($id){
		return self::$params[$id];
	}
}
?>