Source for file UrlHandler.php

Documentation is available at UrlHandler.php

  1. <?php
  2. // vim: foldmethod=marker tabstop=4 shiftwidth=4 autoindent
  3. /**
  4.  *  UrlHandler.php
  5.  *
  6.  *  @author     Masaki Fujimoto <fujimoto@php.net>
  7.  *  @package    Ethna
  8.  *  @version    $Id: 15329bf269eadb0c7cf5769fdc47612386364a22 $
  9.  */
  10.  
  11. /**
  12.  *  URLハンドラクラス
  13.  *
  14.  *  @author     Masaki Fujimoto <fujimoto@php.net>
  15.  *  @access     public
  16.  *  @package    Ethna
  17.  */
  18. class Ethna_UrlHandler
  19. {
  20.     /** @var    array   アクションマッピング */
  21.     protected $action_map = array(
  22.         /*
  23.          * 'user'   => array(
  24.          *  'user_login' => array(
  25.          *      'path'          => 'login',
  26.          *      'path_regexp'   => false,
  27.          *      'path_ext'      => false,
  28.          *      'option'        => array(),
  29.          *  ),
  30.          * ),
  31.          */
  32.     );
  33.  
  34.     /**
  35.      *  Ethna_UrlHandlerクラスのコンストラクタ
  36.      *
  37.      *  @access public
  38.      */
  39.     public function __construct()
  40.     {
  41.     }
  42.  
  43.     /**
  44.      *  Ethna_UrlHandlerクラスのインスタンスを取得する
  45.      *
  46.      *  $name がクラス名 ('_'を含む) の場合はそのクラスを、
  47.      *  そうでないときはプラグイン名とみなしてインスタンスを返す
  48.      *
  49.      *  @access public
  50.      */
  51.     public static function getInstance($name = null)
  52.     {
  53.         static $instance = array();
  54.         if ($name === null) {
  55.             $name = __CLASS__;
  56.         }
  57.         if (isset($instance[$name])) {
  58.             return $instance[$name];
  59.         }
  60.  
  61.         if (strpos($name, '_') !== false) {
  62.             $instance[$name] = new $name();
  63.         } else {
  64.             // get instance with plugin
  65.             $ctl = Ethna_Controller::getInstance();
  66.             $plugin = $ctl->getPlugin();
  67.             $instance[$name] = $plugin->getPlugin('Urlhandler', $name);
  68.         }
  69.  
  70.         return $instance[$name];
  71.     }
  72.  
  73.     /**
  74.      *  アクションをユーザリクエストに変換する
  75.      *
  76.      *  @access public
  77.      */
  78.     public function actionToRequest($action, $param)
  79.     {
  80.         $url_handler = null;
  81.         $action_value = null;
  82.         foreach ($this->action_map as $key => $value) {
  83.             if (isset($value[$action])) {
  84.                 $url_handler = $key;
  85.                 $action_value = $value[$action];
  86.                 break;
  87.             }
  88.         }
  89.         if (is_null($url_handler)) {
  90.             return null;
  91.         }
  92.  
  93.         // url_handler specific path
  94.         $method = sprintf("_getPath_%s", ucfirst($url_handler));
  95.         if (method_exists($this, $method) === false) {
  96.             return null;
  97.         }
  98.         list($path, $path_key) = $this->$method($action, $param);
  99.         if ($path == "") {
  100.             return null;
  101.         }
  102.  
  103.         // append action path
  104.         if ($action_value['path']) {
  105.             $path .= "/" . $action_value['path'];
  106.         }
  107.  
  108.         // path_ext candidate list
  109.         if (is_array($action_value['path_regexp'])) {
  110.             // try most matcher
  111.             $tmp = array_map('count', $action_value['path_ext']);
  112.             arsort($tmp);
  113.             $path_ext_list_indices = array_keys($tmp);
  114.             $path_ext_list = $action_value['path_ext'];
  115.         } else {
  116.             $path_ext_list_indices = array(0);
  117.             $path_ext_list = array(0 => $action_value['path_ext']);
  118.         }
  119.  
  120.         // fix path_ext to use
  121.         foreach ($path_ext_list_indices as $index) {
  122.             if (is_array($path_ext_list[$index]) === false) {
  123.                 // no parameters needed.
  124.                 $path_ext = $path_ext_list[$index];
  125.                 break;
  126.             }
  127.             $path_ext_match = true;
  128.             foreach ($path_ext_list[$index] as $key => $value) {
  129.                 if (isset($param[$key]) === false) {
  130.                     $path_ext_match = false;
  131.                     break;
  132.                 }
  133.             }
  134.             if ($path_ext_match) {
  135.                 $path_ext = $path_ext_list[$index];
  136.                 break;
  137.             }
  138.         }
  139.         if (isset($path_ext) === false) {
  140.             return null;
  141.         }
  142.  
  143.         // append extra parameters to path.
  144.         if (is_array($path_ext)) {
  145.             foreach ($path_ext as $key => $value) {
  146.                 $path_key[] = $key;
  147.                 $ext_param = $param[$key];
  148.  
  149.                 // output filter
  150.                 if (isset($value['output_filter']) && $value['output_filter'] != "") {
  151.                     $method = $value['output_filter'];
  152.                     if (method_exists($this, $method)) {
  153.                         $ext_param = $this->$method($ext_param);
  154.                     }
  155.                 }
  156.  
  157.                 // remove form (pre|suf)fix
  158.                 if (isset($value['form_prefix']) && $value['form_prefix'] != "") {
  159.                     $s = $value['form_prefix'];
  160.                     if (substr($ext_param, 0, strlen($s)) == $s) {
  161.                         $ext_param = substr($ext_param, strlen($s));
  162.                     }
  163.                 }
  164.                 if (isset($value['form_suffix']) && $value['form_suffix'] != "") {
  165.                     $s = $value['form_suffix'];
  166.                     if (substr($ext_param, -strlen($s)) == $s) {
  167.                         $ext_param = substr($ext_param, 0, -strlen($s));
  168.                     }
  169.                 }
  170.  
  171.                 // rawurlencode (url (pre|suf)fixes need not to be encoded.)
  172.                 $ext_param = rawurlencode($ext_param);
  173.  
  174.                 // add url (pre|suf)fix
  175.                 if (isset($value['url_prefix']) && $value['url_prefix'] != "") {
  176.                     $ext_param = $value['url_prefix'] . $ext_param;
  177.                 }
  178.                 if (isset($value['url_suffix']) && $value['url_suffix'] != "") {
  179.                     $ext_param = $ext_param . $value['url_suffix'];
  180.                 }
  181.  
  182.                 $path .= '/' . $ext_param;
  183.             }
  184.         }
  185.  
  186.         list($path, $is_slash) = $this->_normalizePath($path);
  187.         return array($path, $path_key);
  188.     }
  189.  
  190.     /**
  191.      *  ユーザリクエストをアクションに変換する
  192.      *
  193.      *  @access public
  194.      */
  195.     public function requestToAction($http_vars)
  196.     {
  197.         if (isset($http_vars['__url_handler__']) == false
  198.             || isset($this->action_map[$http_vars['__url_handler__']]) == false) {
  199.             return array();
  200.         }
  201.  
  202.         $url_handler = $http_vars['__url_handler__'];
  203.         $action_map = $this->action_map[$url_handler];
  204.  
  205.         // parameter fix
  206.         $method = sprintf("_normalizeRequest_%s", ucfirst($url_handler));
  207.         if (method_exists($this, $method)) {
  208.             $http_vars = $this->$method($http_vars);
  209.         }
  210.  
  211.         // normalize
  212.         if (isset($http_vars['__url_info__'])) {
  213.             $path = $http_vars['__url_info__'];
  214.         } else {
  215.             $path = "";
  216.         }
  217.         list($path, $is_slash) = $this->_normalizePath($path);
  218.  
  219.         // match
  220.         $action = null;
  221.         $action_value = null;
  222.         $action_match = null;
  223.         $action_regexp_index = null;
  224.         foreach ($action_map as $key => $value) {
  225.             if (isset($value['path'])) {
  226.                 $match_length = strlen($value['path']);
  227.  
  228.                 // check necessary match
  229.                 if (strncmp($path, $value['path'], $match_length) != 0) {
  230.                     continue;
  231.                 }
  232.  
  233.                 // try exact match
  234.                 if ($path == $value['path']) {
  235.                     $action = $key;
  236.                     break;
  237.                 }
  238.  
  239.                 // continue in case w/ incomplete match
  240.                 if ($path != "" && $match_length > 0 && $path{$match_length} != "/") {
  241.                     continue;
  242.                 }
  243.                 if ($is_slash && $path{strlen($path)-1} == "/") {
  244.                     continue;
  245.                 }
  246.             }
  247.  
  248.             if (isset($value['path_regexp']) && $value['path_regexp']) {
  249.                 if (is_array($value['path_regexp'])) {
  250.                     foreach ($value['path_regexp'] as $index => $regexp) {
  251.                         if (preg_match($regexp, $path, $tmp)) {
  252.                             $action = $key;
  253.                             $action_match = $tmp;
  254.                             $action_regexp_index = $index;
  255.                             break;
  256.                         }
  257.                     }
  258.                 } else {
  259.                     if (preg_match($value['path_regexp'], $path, $tmp)) {
  260.                         $action = $key;
  261.                         $action_match = $tmp;
  262.                         break;
  263.                     }
  264.                 }
  265.             }
  266.  
  267.             // else, continue
  268.         }
  269.         if (is_null($action)) {
  270.             return array();
  271.         }
  272.         $action_value = $action_map[$action];
  273.  
  274.         // build parameters
  275.         $http_vars = $this->buildActionParameter($http_vars, $action);
  276.  
  277.         // extra parameters
  278.         $path_ext = is_null($action_regexp_index)
  279.                     ? $action_value['path_ext']
  280.                     : $action_value['path_ext'][$action_regexp_index];
  281.         if (is_array($path_ext) && is_array($action_match)) {
  282.             $n = 1;
  283.             foreach ($path_ext as $key => $value) {
  284.                 if (isset($action_match[$n]) == false) {
  285.                     break;
  286.                 }
  287.  
  288.                 // remove url (pre|suf)fix
  289.                 if (isset($value['url_prefix']) && $value['url_prefix'] != "") {
  290.                     $s = $value['url_prefix'];
  291.                     if (substr($action_match[$n], 0, strlen($s)) == $s) {
  292.                         $action_match[$n] = substr($action_match[$n], strlen($s));
  293.                     }
  294.                 }
  295.                 if (isset($value['url_suffix']) && $value['url_suffix'] != "") {
  296.                     $s = $value['url_suffix'];
  297.                     if (substr($action_match[$n], -strlen($s)) == $s) {
  298.                         $action_match[$n] = substr($action_match[$n], 0, -strlen($s));
  299.                     }
  300.                 }
  301.  
  302.                 // add form (pre|suf)fix
  303.                 if (isset($value['form_prefix']) && $value['form_prefix'] != "") {
  304.                     $action_match[$n] = $value['form_prefix'] . $action_match[$n];
  305.                 }
  306.                 if (isset($value['form_suffix']) && $value['form_suffix'] != "") {
  307.                     $action_match[$n] = $action_match[$n] . $value['form_suffix'];
  308.                 }
  309.  
  310.                 // input filter
  311.                 if (isset($value['input_filter']) && $value['input_filter'] != "") {
  312.                     $method = $value['input_filter'];
  313.                     if (method_exists($this, $method)) {
  314.                         $action_match[$n] = $this->$method($action_match[$n]);
  315.                     }
  316.                 }
  317.  
  318.                 $http_vars[$key] = $action_match[$n];
  319.                 $n++;
  320.             }
  321.         }
  322.  
  323.         return $http_vars;
  324.     }
  325.  
  326.     /**
  327.      *  ゲートウェイパスを正規化する
  328.      *
  329.      *  @access private
  330.      */
  331.     protected function _normalizePath($path)
  332.     {
  333.         if ($path == "") {
  334.             return array($path, false);
  335.         }
  336.  
  337.         $is_slash = false;
  338.         $path = preg_replace('|/+|', '/', $path);
  339.  
  340.         if ($path{0} == '/') {
  341.             $path = substr($path, 1);
  342.         }
  343.         if ($path{strlen($path)-1} == '/') {
  344.             $path = substr($path, 0, strlen($path)-1);
  345.             $is_slash = true;
  346.         }
  347.  
  348.         return array($path, $is_slash);
  349.     }
  350.  
  351.     /**
  352.      *  アクションをリクエストパラメータに変換する
  353.      *
  354.      *  @access public
  355.      */
  356.     public function buildActionParameter($http_vars, $action)
  357.     {
  358.         if ($action == "") {
  359.             return $http_vars;
  360.         }
  361.         $key = sprintf('action_%s', $action);
  362.         $http_vars[$key] = 'true';
  363.         return $http_vars;
  364.     }
  365.  
  366.     /**
  367.      *  パラメータをURLに変換する
  368.      *
  369.      *  @access public
  370.      */
  371.     public function buildQueryParameter($query)
  372.     {
  373.         $param = '';
  374.  
  375.         foreach ($query as $key => $value) {
  376.             if (is_array($value)) {
  377.                 foreach ($value as $k => $v) {
  378.                     if (is_numeric($k)) {
  379.                         $k = '';
  380.                     }
  381.                     $param .= sprintf('%s=%s&',
  382.                                       urlencode(sprintf('%s[%s]', $key, $k)),
  383.                                       urlencode($v));
  384.                 }
  385.             } else if (is_null($value) == false) {
  386.                 $param .= sprintf('%s=%s&', urlencode($key), urlencode($value));
  387.             }
  388.         }
  389.  
  390.         return substr($param, 0, -1);
  391.     }
  392.  
  393.     // {{{ ゲートウェイリクエスト正規化
  394.     // }}}
  395.  
  396.     // {{{ ゲートウェイパス生成
  397.     // }}}
  398.  
  399.     // {{{ フィルタ
  400.     // }}}
  401. }

Documentation generated on Fri, 11 Nov 2011 03:59:15 +0900 by phpDocumentor 1.4.3