Source for file jUrl.class.php

Documentation is available at jUrl.class.php

  1. <?php
  2. /**
  3. @package     jelix
  4. @subpackage  core_url
  5. @author      Laurent Jouanneau
  6. @contributor Thibault Piront (nuKs)
  7. @contributor Loic Mathaud
  8. @contributor Hadrien Lanneau
  9. @copyright   2005-2013 Laurent Jouanneau
  10. @copyright   2007 Thibault Piront
  11. @copyright   2006 Loic Mathaud, 2010 Hadrien Lanneau
  12. *  Some parts of this file are took from an experimental branch of the Copix project (CopixUrl.class.php, Copix 2.3dev20050901, http://www.copix.org),
  13. *  Some lines of code are still copyrighted 2001-2005 CopixTeam (LGPL licence).
  14. *  Initial authors of this parts are Gerald Croes and Laurent Jouanneau,
  15. *  and this parts were adapted for Jelix by Laurent Jouanneau
  16. @link        http://jelix.org
  17. @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
  18. */
  19.  
  20.  
  21. /**
  22.  * Object that contains url data, and which provides static method helpers
  23.  * @package  jelix
  24.  * @subpackage core_url
  25.  * @author      Laurent Jouanneau (for the original code from Copix and enhancement for jelix)
  26.  * @author      Gerald Croes (for the original code from Copix)
  27.  * @contributor Loic Mathaud
  28.  * @contributor Thibault Piront (nuKs)
  29.  */
  30. class jUrl extends jUrlBase {
  31.  
  32.      /**#@+
  33.      * constant for get() method
  34.      * @var integer
  35.      */
  36.     const STRING=0;
  37.     const XMLSTRING=1;
  38.     const JURL=2;
  39.     const JURLACTION=3;
  40.     /**#@-*/
  41.  
  42.     /**
  43.     * script name including its path
  44.     * @var string 
  45.     */
  46.     public $scriptName;
  47.  
  48.     /**
  49.     * path info part of the url
  50.     * @var string 
  51.     */
  52.     public $pathInfo = '';
  53.  
  54.     /**
  55.     * constructor
  56.     * @param    string    $scriptname    script name
  57.     * @param    array    $params    parameters
  58.     * @param    string    $pathInfo    path info contents
  59.     */
  60.     function __construct ($scriptname=''$params=array ()$pathInfo=''){
  61.         $this->params      = $params;
  62.         $this->scriptName  = $scriptname;
  63.         $this->pathInfo    = $pathInfo;
  64.     }
  65.  
  66.  
  67.     /**
  68.     * converts the url to a string
  69.     * @param boolean $forxml  true: some characters will be escaped
  70.     * @return string 
  71.     */
  72.     public function toString ($forxml false){
  73.         return $this->getPath().$this->getQuery($forxml);
  74.     }
  75.  
  76.     /**
  77.      * get the path part of the url (scriptName + pathinfo)
  78.      * @return string 
  79.      * @since 1.0.4
  80.      */
  81.     public function getPath({
  82.         $url $this->scriptName;
  83.         if(substr($this->scriptName,-1== '/')
  84.             $url.=ltrim($this->pathInfo,'/');
  85.         else
  86.             $url.= $this->pathInfo;
  87.         return $url;
  88.     }
  89.  
  90.     /**
  91.      * get the query part of the url
  92.      * @param boolean $forxml  true: some characters will be escaped
  93.      * @return string 
  94.      * @since 1.0.4
  95.      */
  96.     public function getQuery($forxml false{
  97.         if (count ($this->params)>0){
  98.             $q http_build_query($this->params''($forxml?'&amp;':'&'));
  99.             if(!$q)
  100.                 return '';
  101.             if(strpos($q'%3A')!==false)
  102.                 $q str_replace'%3A'':'$q);
  103.             return '?'.$q;
  104.         }
  105.         return '';
  106.     }
  107.  
  108.     //============================== static helper methods
  109.  
  110.     /**
  111.     * returns the current Url.
  112.     *
  113.     * The URL is the URL for the frontend HTTP server, if your app is behind a proxy.
  114.     * @param boolean $forxml if true, escape some characters to include the url into an html/xml document
  115.     * @return string the url
  116.     */
  117.     static function getCurrentUrl ($forxml false$full false{
  118.         // we don't take $_SERVER["REQUEST_URI"] because it doesn't correspond to the real URI
  119.         // if the app is behind a proxy with a different basePath than the frontend
  120.         $req jApp::coord()->request;
  121.         $sel $req->module.'~'.$req->action;
  122.         if ($full{
  123.             $url self::getFull($sel$req->params($forxml?self::XMLSTRING:self::STRING));
  124.          }
  125.         else {
  126.             $url self::get($sel$req->params($forxml?self::XMLSTRING:self::STRING));
  127.         }
  128.         return $url;
  129.     }
  130.  
  131.     /**
  132.     * Adds parameters to the given url
  133.     * @param string $url  an URL
  134.     * @param array $params some parameters to append to the url
  135.     * @param boolean $forxml if true, escape some characters to include the url into an html/xml document
  136.     * @return string the url
  137.     */
  138.     static function appendToUrlString ($url$params array ()$forxml false){
  139.         $q http_build_query($params''($forxml?'&amp;':'&'));
  140.         if(strpos($q'%3A')!==false)
  141.             $q str_replace'%3A'':'$q);
  142.         if ((($pos strpos $url'?')) !== false&& ($pos !== (strlen ($url)-1))){
  143.             return $url ($forxml '&amp;' '&').$q;
  144.         }else{
  145.             return $url '?'.$q;
  146.         }
  147.     }
  148.  
  149.     /**
  150.     * Gets the url corresponding to an action, in the given format
  151.     * @param string $actSel  action selector. You can use # instead of the module
  152.     *                 or the action name, to specify the current url.
  153.     * @param array $params associative array with the parameters
  154.     * @param integer $what the format you want : one of the jUrl const,
  155.     *                                      STRING XMLSTRING JURL JURLACTION
  156.     * @return mixed a value, depending of the $what parameter
  157.     */
  158.     static function get ($actSel$params array ()$what=0{
  159.  
  160.         $sel new jSelectorAct($actSel,truetrue);
  161.         $params['module'$sel->module;
  162.         $params['action'$sel->resource;
  163.         $ua new jUrlAction($params$sel->request);
  164.  
  165.         if($what == 3return $ua;
  166.  
  167.         $url jUrl::getEngine()->create($ua);
  168.  
  169.         if($what == 2return $url;
  170.  
  171.         return $url->toString($what != 0);
  172.     }
  173.  
  174.     /**
  175.     * Gets the absolute url corresponding to an action, in the given format with
  176.     * the domainName in defaultConfig or current
  177.     * @param string $actSel  action selector. You can use # instead of the module
  178.     *                 or the action name, to specify the current url.
  179.     * @param array $params associative array with the parameters
  180.     * @param integer $what the format you want : only jUrl::STRING or jUrl::XMLSTRING
  181.     * @param string $domainName Customized domain name
  182.     * @return string the url string
  183.     */
  184.     static function getFull ($actSel$params array ()$what=0$domainName null{
  185.  
  186.         $domain '';
  187.         $req jApp::coord()->request;
  188.         $url self::get($actSel$params($what != self::XMLSTRING?self::STRING:$what));
  189.         if (!preg_match('/^http/'$url)) {
  190.             if ($domainName{
  191.                 $domain $domainName;
  192.                 if (!preg_match('/^http/'$domainName))
  193.                     $domain $req->getProtocol($domain;
  194.             }
  195.             else {
  196.                 $domain $req->getServerURI();
  197.             }
  198.  
  199.             if ($domain == ''{
  200.                 throw new jException('jelix~errors.urls.domain.void');
  201.             }
  202.         }
  203.         else if ($domainName != ''{
  204.             $url str_replace($req->getDomainName()$domainName$url);
  205.         }
  206.  
  207.         return $domain.$url;
  208.     }
  209.  
  210.     /**
  211.      * Parse a url
  212.      * @param string $scriptNamePath    /path/index.php
  213.      * @param string $pathinfo          the path info of the url.
  214.      * @param array  $params            url parameter ($_REQUEST)
  215.      * @return jUrlAction 
  216.      */
  217.     static function parse($scriptNamePath$pathinfo$params ){
  218.          return jUrl::getEngine()->parse($scriptNamePath,$pathinfo$params);
  219.     }
  220.  
  221.     /**
  222.      * escape and simplier a string to be a part of an url path
  223.      * remove or replace not allowed characters etc..
  224.      * @param string $str the string to escape
  225.      * @param boolean $highlevel false : just to a urlencode. true, replace some characters
  226.      * @return string escaped string
  227.      */
  228.     static function escape($str$highlevel=false){
  229.         static $url_escape_from null;
  230.         static $url_escape_to null;
  231.  
  232.         if($highlevel){
  233.             if($url_escape_from == null){
  234.                 $url_escape_from explode(' ',jLocale::get('jelix~format.url_escape_from'));
  235.                 $url_escape_to explode(' ',jLocale::get('jelix~format.url_escape_to'));
  236.             }
  237.             // first, we do transliteration.
  238.             // we don't use iconv because it is system dependant
  239.             // we don't use strtr because it is not utf8 compliant
  240.             $str str_replace($url_escape_from$url_escape_to$str);
  241.             // then we replace all non word characters by a space
  242.             $str preg_replace("/([^\w])/"," ",$str);
  243.             // then we remove words of 2 letters
  244.             //$str=preg_replace("/(?<=\s)\w{1,2}(?=\s)/"," ",$str);
  245.             // then we replace all spaces by a -
  246.             $str preg_replace("/( +)/","-",trim($str));
  247.             // we convert all character to lower case
  248.             $str urlencode(strtolower($str));
  249.             return $str;
  250.         }else{
  251.             return urlencode (str_replace (array ('-'' ')array ('--','-')$str));
  252.         }
  253.     }
  254.  
  255.     /**
  256.      * perform the opposit of escape
  257.      * @param string $str the string to escape
  258.      * @return string 
  259.      */
  260.     static function unescape($str){
  261.         return strtr ($strarray ('--'=>'-''-'=>' '));
  262.     }
  263.  
  264.     /**
  265.      * return the current url engine
  266.      * @return jIUrlEngine 
  267.      * @internal call with true parameter, to force to re-instancy the engine. useful for test suite
  268.      */
  269.     static function getEngine($reset=false){
  270.         static $engine null;
  271.  
  272.         if($engine === null || $reset){
  273.             $name jApp::config()->urlengine['engine'];
  274.             $engine jApp::loadPlugin($name'urls''.urls.php'$name.'UrlEngine');
  275.             if(is_null($engine))
  276.                 throw new jException('jelix~errors.urls.engine.notfound'$name);
  277.         }
  278.         return $engine;
  279.     }
  280.  
  281.  
  282.  
  283.  
  284.     /**
  285.     * get the root url for a given ressource type. Root URLs are stored in config file.
  286.     * @param string $ressourceType Name of the ressource
  287.     * @return string the root URL corresponding to this ressource, or basePath if unknown
  288.     */
  289.     public static function getRootUrl($ressourceType){
  290.  
  291.         $rootUrl jUrl::getRootUrlRessourceValue($ressourceType);
  292.         if$rootUrl !== null {
  293.             ifsubstr($rootUrl07!== 'http://' && substr($rootUrl08!== 'https://' // url is not absolute.
  294.                 && substr($rootUrl01!== '/' //and is not relative to root
  295.                    // so let's prepend basePath :
  296.                     $rootUrl jApp::config()->urlengine['basePath'$rootUrl;
  297.             }
  298.         else {
  299.             // basePath by default :
  300.             $rootUrl jApp::config()->urlengine['basePath'];
  301.         }
  302.  
  303.         return $rootUrl;
  304.     }
  305.  
  306.  
  307.     /**
  308.     * get the config value of an item in [rootUrls] section of config
  309.     * @param string $ressourceType Name of the ressource
  310.     * @return string the config value of this value, null if it does not exist
  311.     */
  312.     public static function getRootUrlRessourceValue($ressourceType{
  313.  
  314.         ifisset(jApp::config()->rootUrls[$ressourceType]) ) {
  315.             return null;
  316.         else {
  317.             return jApp::config()->rootUrls[$ressourceType];
  318.         }
  319.     }
  320.  
  321. }

Documentation generated on Mon, 26 Oct 2015 21:56:42 +0100 by phpDocumentor 1.4.3