Router.php

Go to the documentation of this file.

<?php
 
namespace Rsi\Fred;
 
class Router extends Component{
 
  const CACHE_HASH = 'hash';
  const CACHE_TIME = 'time';
  const CACHE_ROUTES = 'routes';
  const CACHE_HASHED = 'hashed';
 
  const ENUM_TRANS = '@';
  const ENUM_DYNAMIC = '#';
 
  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.
    // - reverse: Callback function for link generating. Parameters for the function are:
    //   - router (object): Reference to this component.
    //   - link (string, by reference): Generated link (without type and query).
    //   - type (string, by reference): View type.
    //   - query (array, by reference): Parameters to add to the link.
    // - encrypt: Data for encrypting parameters (all otional):
    //   - key (string): Key to use to add the encrypted data to the parameters (defaults to see @encryptKey).
    //   - salt (string): Custom key for encryption.
    //   - keys (array): Keys of the parameters to include in the encrypted data (defaults to all).
    //   When the provided data can't be decrypted, all parameters (in the keys array) are set to null.
    // - 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. A
    //   hash is only possible when there is no encrypted data.
  public $defaultParams = []; //!< Default params for routes.
  public $regexShortcuts = [
    '*' => '\\d+', //integer, 0 and up
    '+' => '[1-9]\\d*' //integer, 1 and up
  ];
  public $enumTransTtl = 3600; //!< Time-to-live for translated enum options.
  public $hashKey = 'hash'; //!< Default hash key.
  public $hashAlgo = 'sha256'; //!< Default hash algo.
  public $encryptKey = 'data'; //!<  Default encrypted data key.
 
  protected $_sharedCacheFile = null; //!< Shared cache file for compiled routes.
  protected $_sharedCacheTtlSpread = 10; //!< Random spread for TTL.
 
  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{
        \Rsi\File::export($temp = $this->_sharedCacheFile . \Rsi\Str::random() . '.tmp',$this->_cache);
        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();
  }
 
  protected function stripClosures($value){
    array_walk_recursive($value,function(&$item){
      if(is_object($item) && ($item instanceof \Closure)) $item = true;
    });
    return $value;
  }
  /**
   * 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 = [];
      $empty = [self::CACHE_ROUTES => [],self::CACHE_HASHED => []];
      if($this->_sharedCacheFile) try{
        $this->_cache = include($this->_sharedCacheFile);
        if(
          (($this->_cache[self::CACHE_HASH] ?? null) != ($hash = crc32('v4' . print_r($this->stripClosures($this->routes),true)))) ||
          (($time = $this->_cache[self::CACHE_TIME] ?? null) && ($time < time() + rand(0,1000) / 1000 * $this->_sharedCacheTtlSpread))
        ){
          $this->_cache = [self::CACHE_HASH => $hash] + $empty;
          $this->session->lastPath = $this->session->lastRoute = null;
        }
      }
      catch(\Throwable $e){
        \Rsi\File::unlink($this->_sharedCacheFile);
        $this->component('log')->info($e);
        $this->_cache = $empty;
        $this->_save = true;
      }
      else $this->_cache = $this->session->cache ?: $empty;
    }
    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  Route (set tot false for hash).
   * @param string $key
   * @param mixed $value  Data for this route + key.
   */
  protected function save($route,$key,$value){
    if($route === false) $this->_cache[self::CACHE_HASHED][$key] = $value;
    else $this->_cache[self::CACHE_ROUTES][$route][$key] = $this->stripClosures($value);
    $this->_save = true;
  }
 
  protected function enumLang($params){
    return $this->component('trans')->langs();
  }
  /**
   * 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){
          $ttl = false;
          switch(substr($enum,1,1)){
            case self::ENUM_TRANS:
              $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]");
              $ttl = $this->enumTransTtl;
              break;
            case self::ENUM_DYNAMIC:
              if(method_exists($this,$method = 'enum' . ucfirst(substr($enum,2)))) $enum = $method;
              break;
            default:
              $enum = \Rsi\Record::explode(substr($enum,1),';','=');
          }
          if($ttl) $this->_cache[self::CACHE_TIME] = ($time = $this->_cache[self::CACHE_TIME] ?? null) ? min($time,time() + $ttl) : time() + $ttl;
        }
        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;
  }
  /**
   * Parse an (dynamic) enum.
   * @param mixed $enum  Raw enum.
   * @param array $params  Current set of parameters.
   * @param array $data  Route data.
   * @return array
   */
  protected function enum($enum,$params,$data){
    return is_string($enum) ? call_user_func([$this,$enum],$params,$data) : $enum;
  }
  /**
   * Calculate the hash for a set of parameters.
   * @param array $hash  Hash configuration.
   * @param array $params  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)
    );
  }
  /**
   * Encrypt a set of parameters.
   * @param array $encrypt  Encryption parameters.
   * @param array $params  Route parameters (values).
   * @param array $keys  Keys encrypted (return).
   * @return string  Encrypted data (binary).
   */
  protected function encrypt($encrypt,$params,&$keys){
    return $this->component('encrypt')->str(
      serialize(\Rsi\Record::select($params,$keys = $encrypt['keys'] ?? array_keys($params))),
      $encrypt['salt'] ?? null
    );
  }
  /**
   * 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){
    if($this->_cache === null) $this->cache(null,null);
    return array_key_exists($key = strtolower($this->_controllerName . '#' . \Rsi\Str::check($_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 (null = no match, false = unsatisfied enum).
   */
  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($this->routes[$route]['match'],$this,$route,$path,$values))){ //path fits this route
        $name = $data['name'];
        $params = [];
        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){
              $enum = $this->enum($enum,$params,$data);
              if((!$component || (($enum[$component->get($property)] ?? null) != $value)) && (($value = \Rsi\Record::isearch($enum,$value)) === false)) return false;
            }
            if($component) $component->set($property,$value);
            else \Rsi\Record::set($params,explode('.',$key),$value);
            if(preg_match('/^\\w+$/',$value)) $name = str_replace("[$key]",$value,$name);
          }
        }
        $this->_controllerName = $name;
        $_GET = $params + $_GET;
        if($action = $data['action'] ?? null) $_POST['action'] = $action;
        if(array_key_exists('encrypt',$data) && ($value = \Rsi\Str::check($_GET[($encrypt = $data['encrypt'])['key'] ?? $this->encryptKey] ?? null))) try{
          if($this->hashed($cache,'encrypt') === false) $this->save(false,$cache,$encrypt['keys'] ?? null);
          $_GET = array_merge($_GET,unserialize($this->component('encrypt')->decrypt(hex2bin($value),$encrypt['salt'] ?? null)));
          $this->_hashed = true;
        }
        catch(\Exception $e){
          $this->component('log')->info($e);
        }
        elseif(array_key_exists('hash',$data)){
          $hash = $data['hash'];
          $keys = $hash['keys'] ?? null;
          if($this->hashed($cache) === false) $this->save(false,$cache,$keys);
          if(hash_equals($this->hash($hash,$_GET),strval(\Rsi\Str::check($_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;
      }
    }
    return null;
  }
  /**
   * 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 && ($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);
    $params = ($params ?: []) + $this->defaultParams;
    $match = false;
    foreach($this->routes as $route => $data){
      $data = $this->data($route);
      if($data['name'] == $controller_name){
        $query = $params;
        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('reverse',$data)) $data['reverse'] = $this->routes[$route]['reverse'];
        if(array_key_exists('encrypt',$data)){
          $value = $this->encrypt($data['encrypt'],$query,$keys);
          foreach($keys as $key) unset($query[$key]);
          $query[$data['encrypt']['key'] ?? $this->encryptKey] = bin2hex($value);
        }
        elseif(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){
            $enum = $this->enum($enum,$params,$data);
            $value = $enum[$value] ?? $enum[null] ?? null;
          }
          if(!$strict || !$regex || (($value !== null) && preg_match("/^$regex$/",$value))){
            $route = str_replace($full,rawurlencode($value ?? ''),$route);
            unset($query[$key]);
          }
        }
        do($route = preg_replace('/{[^{}]*?\\[[^\\[]*?\\][^{}]*?}/','',$route,-1,$count)); //remove optional parts with missing params
        while($count);
        if($match = strpos($route,'[') === false){
          $link = str_replace(['{','}'],'',$route);
          if(array_key_exists('reverse',$data)) call_user_func_array($data['reverse'],[$this,&$link,&$type,&$query]);
          break;
        }
      }
    }
    if($type) $link .= '.' . $type;
    if($query = http_build_query($match ? $query : $params)) $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;
  }
 
}