Router.php

Go to the documentation of this file.

<?php

namespace Rsi\Fred;

class Router extends Component{

  const CACHE_HASH = 'hash';
  const CACHE_ROUTES = 'routes';
  const CACHE_HASHED = 'hashed';

  public $prefix = '/'; //!< Prefix to add before each route.
  public $routes = []; //!< Available routes (key = route, value = controller data). Parameters can be present in a route (e.g.
    // [id]). These will be added to the $_GET. Parameters can be appended with a reg-ex pattern (e.g. [id:\\d+] = numeric
    // only). Component properties can be linked by using a parameter format like [@component.property]. Parameters can be
    // enumerated by adding a semicolon seperated list like [id*internal=external;i2=x2;default] (default is optional). In this
    // case a reg-ex pattern should match the external values. The controller data can be either a direct controller name
    // (string) or an array. In the case of a string static parameters can be added to the controller name as query parameters
    // (e.g. ?key=value), and  a specific action as a fragment (e.g. #action). The fragment must come before the parameters
    // (e.g. #action?key=value). When the controller data is in the shape of an array all these items have their own key (all
    // optional unless noted otherwise):
    // - name: Controller name (required).
    // - action: Specific action.
    // - extra: Extra parameters that will be added to the $_POST.
    // - match: Callback function for extra fine grained matching. Parameters for the function are:
    //   - router (object): Reference to this component.
    //   - route (string): Route to check against.
    //   - path (string): Path from the request.
    //   - values (array): Paramter values from the match against the route.
    // - hash: Data for calculating a checksum hash (all optional):
    //   - key (string): Key to use to add the hash to the parameters (defaults to see @hashKey).
    //   - algo (string): Hashing algorithm to use (defaults to see @hashAlgo).
    //   - salt (string): Salt to use for the hashing (defaults to the key of the encrypt component).
    //   - keys (array): Keys of the parameters to include in the hash (defaults to all).
    //   When the provided hash doesn't match with the calculated hash, all parameters (in the keys array) are set to null.
  public $defaultParams = []; //!< Default params for routes.
  public $regexShortcuts = [
    '*' => '\\d+', //integer, 0 and up
    '+' => '[1-9]\\d*' //integer, 1 and up
  ];
  public $hashKey = 'hash'; //!< Default hash key.
  public $hashAlgo = 'sha256'; //!< Default hash algo.

  protected $_sharedCacheFile = null; //!< Shared cache file for compiled routes.

  protected $_cache = null;
  protected $_save = false;
  protected $_viewType = null;
  protected $_controllerName = null;
  protected $_hashed = false;

  protected function done(){
    if($this->_save){
      if($this->_sharedCacheFile) try{
        file_put_contents(
          $temp = $this->_sharedCacheFile . \Rsi\Str::random() . '.tmp',
          '<?php return ' . var_export($this->_cache,true) . ';'
        );
        if(!rename($temp,$this->_sharedCacheFile)) throw new \Exception("Could not rename('$temp','{$this->_sharedCacheFile}')");
        chmod($this->_sharedCacheFile,0666);
      }
      catch(\Exception $e){
        $this->component('log')->info($e);
        \Rsi\File::unlink($temp);
      }
      else $this->session->cache = $this->_cache;
    }
    parent::done();
  }
  /**
   * Retrieve data from the route cache.
   * @param string $route
   * @param string $key
   * @return mixed  Data for this route + key.
   */
  protected function cache($route,$key){
    if($this->_cache === null){
      $this->_cache = [];
      if($this->_sharedCacheFile) try{
        $this->_cache = include($this->_sharedCacheFile);
        if(($this->_cache[self::CACHE_HASH] ?? null) != ($hash = crc32('v4' . serialize($this->routes)))){
          $this->_cache = [self::CACHE_HASH => $hash,self::CACHE_ROUTES => [],self::CACHE_HASHED => []];
          $this->session->lastPath = $this->session->lastRoute = null;
        }
      }
      catch(\Throwable $e){
        \Rsi\File::unlink($this->_sharedCacheFile);
        $this->component('log')->info($e);
      }
      else $this->_cache = $this->session->cache ?: [];
    }
    if(!array_key_exists($route,$this->_cache[self::CACHE_ROUTES])) $this->_cache[self::CACHE_ROUTES][$route] = [];
    return $this->_cache[self::CACHE_ROUTES][$route][$key] ?? null;
  }
  /**
   * Save data to the route cache.
   * @param string $route
   * @param string $key
   * @param mixed $value  Data for this route + key.
   */
  protected function save($route,$key,$value){
    $this->_cache[self::CACHE_ROUTES][$route][$key] = $value;
    $this->_save = true;
  }
  /**
   * Parse a route and generate a mask (regex).
   * @param string $route
   * @param string $mask  Resulting regex.
   * @param array $slots  Slots for every paramter in the route.
   */
  protected function mask($route,&$mask,&$slots){
    if($cache = $this->cache($route,'mask')) extract($cache);
    else{
      preg_match_all('/\\[(.+?)(|\\*.+?)(|:[^\\[\\]]*(\\[.+?\\])*[^\\[\\]]*)\\]/',$mask = '/^' . str_replace('/','\\/',$route) . '$/i',$matches,PREG_SET_ORDER); //parameters in the route
      $slots = [];
      foreach($matches as list($full,$key,$enum,$regex)){
        $slot = 'slot' . count($slots);
        if($enum){
          if(substr($enum,0,2) == '*@'){
            $trans = $this->component('trans');
            $str_id = substr($enum,2);
            $enum = [];
            foreach($trans->langs() as $lang_id => $descr) $enum[$lang_id] = $trans->str("[@$str_id.$lang_id]");
          }
          else $enum = \Rsi\Record::explode(substr($enum,1),';','=');
        }
        if($regex && array_key_exists($regex = substr($regex,1),$this->regexShortcuts)) $regex = $this->regexShortcuts[$regex];
        if($component = preg_match('/^@(\\w+)\\.(\\w+)$/',$key,$match)) $key = 'component' . count($slots);
        $slots[$key] =
          compact('full','regex','slot','enum') +
          ($component ? ['component' => $match[1],'property' => $match[2]] : []);
        $mask = str_replace($full,"(?<$slot>.*?)",$mask);
      }
      $mask = strtr($mask,['{' => '(?:','}' => ')?']);
      foreach($slots as $slot) if($slot['regex'] && extract($slot))
        $mask = str_replace("<$slot>.*?","<$slot>$regex",$mask);
      $this->save($route,'mask',compact('mask','slots'));
    }
  }
  /**
   * Parsed data for route.
   * @param string $route
   * @return array  Data.
   */
  protected function data($route){
    if($data = $this->cache($route,'data')) return $data;
    if(!is_array($name = $data = $this->routes[$route])){
      parse_str(\Rsi\Str::pop($name,'?'),$extra);
      $action = \Rsi\Str::pop($name,'#');
      $data = compact('name','action','extra');
    }
    $this->save($route,'data',$data);
    return $data;
  }
  /**
   * Calculate the hash for a set of parameters.
   * @param array $hash  Hash configuration.
   * @param array $parameters  Route parameters (values).
   * @return string  Hash.
   */
  protected function hash($hash,$params){
    unset($params[$hash['key'] ?? $this->hashKey]);
    ksort($params);
    return hash(
      $hash['algo'] ?? $this->hashAlgo,
      ($hash['salt'] ?? $this->component('encrypt')->key) .
      print_r(array_key_exists('keys',$hash) ? \Rsi\Record::select($params,$hash['keys']) : $params,true)
    );
  }
  /**
   * Check if the current controller (+ action) has a hashed version.
   * @param string $key  Cache key.
   * @return array  Keys for the parametes in the hash (or false if not found).
   */
  protected function hashed(&$key = null){
    return array_key_exists($key = strtolower($this->_controllerName . '#' . ($_POST['action'] ?? null)),$this->_cache[self::CACHE_HASHED])
      ? $this->_cache[self::CACHE_HASHED][$key]
      : false;
  }
  /**
   * Check if a path matches a route and extract the parameters.
   * @param string $path  Path to check.
   * @param string $route  Route to check against.
   * @return string  Controller name on match.
   */
  protected function match($path,$route){
    if(array_key_exists($route,$this->routes)){
      $data = $this->data($route);
      $this->mask($route,$mask,$slots);
      if(preg_match($mask,$path,$values) && (!array_key_exists('match',$data) || call_user_func($data['match'],$this,$route,$path,$values))){ //path fits this route
        $name = $data['name'];
        foreach($slots as $key => $slot) if(array_key_exists($slot['slot'],$values)){
          $component = $property = null;
          if(extract($slot) && (($value = $values[$slot]) || !$regex || preg_match("/^$regex$/",$value))){
            $value = urldecode($values[$slot]);
            if($component) $component = $this->component($component);
            if($enum && (!$component || (($enum[$component->get($property)] ?? null) != $value))) $value = array_search($value,$enum);
            if($component) $component->set($property,$value);
            else \Rsi\Record::set($_GET,explode('.',$key),$value);
            if(preg_match('/^\\w+$/',$value)) $name = str_replace("[$key]",$value,$name);
          }
        }
        $this->_controllerName = $name;
        if($action = $data['action'] ?? null) $_POST['action'] = $action;
        if(array_key_exists('hash',$data)){
          $hash = $data['hash'];
          $keys = $hash['keys'] ?: null;
          if($this->hashed($cache) === false){
            $this->_cache[self::CACHE_HASHED][$cache] = $keys;
            $this->_save = true;
          }
          if(hash_equals($this->hash($hash,$_GET),$_GET[$hash['key'] ?? $this->hashKey] ?? null)) $this->_hashed = true;
          else foreach(($keys ?: array_keys($_GET)) as $key) $_GET[$key] = $_POST[$key] = null;
        }
        $_POST = array_merge($_POST,$data['extra'] ?? []);
        return $this->_controllerName;
      }
    }
  }
  /**
   * Determine controller name and type.
   * If the controller name matches a route, the name will be translated to this route, and parameters present will be added to
   * the $_GET.
   * @param string $path  If the path is not given, then the path after the script itself ('foo/bar' in '/index.php/foo/bar')
   *   will be used.
   */
  public function execute($path = null){
    $this->_viewType = $this->_controllerName = $this->_hashed = null;
    if($path === null) $path = $this->pathInfo;
    if($path = trim(preg_replace('/^' . preg_quote($this->prefix,'/') . '/i','',$path),'/')){
      if($this->_viewType = strtolower(pathinfo($path,PATHINFO_EXTENSION)))
        $path = substr($path,0,-(1 + strlen($this->_viewType)));
      if($path != $this->session->lastPath){
        $this->session->lastPath = $path;
        $this->session->lastRoute = null;
        foreach($this->routes as $route => $data) if($this->match($path,$route)){
          $this->session->lastRoute = $route;
          break;
        }
      }
      elseif($route = $this->session->lastRoute) $this->match($path,$route);
      if(!$this->_controllerName) $this->_controllerName = ucwords(strtolower($path),'/');
    }
    if(!$this->_hashed && (($keys = $this->hashed()) !== false)){
      if($keys) foreach($keys as $key) $_GET[$key] = $_POST[$key] = null;
      else $_GET = $_POST = [];
    }
    $_GET += $this->defaultParams;
  }
  /**
   * Format a (default) route.
   * @param string $route  Base route.
   * @return string  Formatted route.
   */
  protected function format($route){
    return strtolower($route);
  }
  /**
   * Determine a route from a controller name and type.
   * @param string $controller_name (empty = current)
   * @param string $type
   * @param array $params  Parameters to use with the route.
   * @param bool $strict  Whether too check the format of the parameters.
   * @return string  Found route. Parameters that were not used in the route are added in the query.
   */
  public function reverse($controller_name = null,$type = null,$params = null,$strict = true){
    if(!$controller_name) $controller_name = $this->controllerName;
    $link = $this->format($controller_name);
    $query = $params = ($params ?: []) + $this->defaultParams;
    foreach($this->routes as $route => $data){
      $data = $this->data($route);
      if($data['name'] == $controller_name){
        if(array_key_exists('extra',$data)) foreach($data['extra'] as $key => $value){
          if(($query[$key] ?? null) != $value) continue 2;
          unset($query[$key]);
        }
        if(array_key_exists('hash',$data)) $query[$data['hash']['key'] ?? $this->hashKey] = $this->hash($data['hash'],$params);
        $this->mask($route,$mask,$slots);
        foreach($slots as $key => $slot) if($slot['component'] ?? null)
          $query[$key] = $this->component($slot['component'])->get($slot['property']);
        foreach($query as $key => $value) if(array_key_exists($key,$slots) && is_scalar($value) && extract($slots[$key])){
          if($enum) $value = $enum[$value] ?? $enum[null] ?? null;
          if(!$strict || !$regex || preg_match("/^$regex$/",$value)){
            $route = str_replace($full,urlencode($value),$route);
            unset($query[$key]);
          }
        }
        do($route = preg_replace('/{[^{}]*?\\[[^\\[]*?\\][^{}]*?}/','',$route,-1,$count)); //remove optional parts with missing params
        while($count);
        if(strpos($route,'[') === false){
          $link = str_replace(['{','}'],'',$route);
          break;
        }
        else $query = $params;
      }
    }
    if($type) $link .= '.' . $type;
    if($query = http_build_query($query)) $link .= (strpos($link,'?') === false ? '?' : '&') . $query;
    return $this->prefix . $link;
  }

  protected function getControllerName(){
    if($this->_controllerName === null) $this->execute();
    return $this->_controllerName;
  }

  protected function getPathInfo(){
    return parse_url($_SERVER['REQUEST_URI'] ?? null,PHP_URL_PATH);
  }

  protected function getViewType(){
    if($this->_controllerName === null) $this->execute();
    return $this->_viewType;
  }

}