ugrás a tartalomhoz

URL router osztály melyik?

Tanul0 · 2012. Jan. 12. (Cs), 19.45
Üdvözletem!

Szeretnék használni egy url router osztályt, csak nem tudom, hogy melyiket. Teljes keretrendszer nem játszik.

Amiket megnéztem eddig és a véleményem

Ez nem túl szimpatikus



Ez az egyszerűsége miatt, valamint az, hogy üresen hagyták nekem hogy hogyan hívom meg az adott kéréshez tartozó osztályt és metódust, eddig ez befutó



Abszolút nem szeretem azt ami a PEAR-el kapcsolatos, de ha nincs más út akkor ok.




Tudtok esetleg ajánlani valamit? Vagy fogjak bele egy sajátba? Véleményeket tapasztalatokat, tanácsokat, ötleteket várok :)

Üdv!
 
1

Credit

Poetro · 2012. Jan. 12. (Cs), 22.26
Az Ez azért kicsit durva egy könyvtár linkelésére, legalább a nevét leírhattad volna mindnek (mert elárulom, azért van nekik). Amit én találtam, az Rob Apodaca PHP Router-e, ami kicsi, de kellően rugalmas.
Danny van Kooten PHP Router class-a is kellően rugalmas, és szintén mini, bár a kódot nem olvastam, de az API mindenesetre tetszik, és van benne REST támogatás.
2

https://github.com/symfony/Ro

duplabe · 2012. Jan. 13. (P), 01.42
https://github.com/symfony/Routing
3

Üdv!Nos megvan a

Tanul0 · 2012. Jan. 15. (V), 12.39
Üdv!

Nos megvan a választásom, + kicsit beleírtam, hogy lehessen mintaillesztéssel is. Gondoltam megosztom hátha jól jön valakinek.

Használat:

$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];
	}
}
?>