Home » Source code of drupal 6.2 » includes

includes.path.inc

Submitted by Anonymous on Wed, 05/28/2008 - 10:38
  1. <?php
  2. // $Id: path.inc,v 1.19 2007/11/04 16:42:45 goba Exp $
  4. /**
  5.  * @file
  6.  * Functions to handle paths in Drupal, including path aliasing.
  7.  *
  8.  * These functions are not loaded for cached pages, but modules that need
  9.  * to use them in hook_init() or hook exit() can make them available, by
  10.  * executing "drupal_bootstrap(DRUPAL_BOOTSTRAP_PATH);".
  11.  */
  13. /**
  14.  * Initialize the $_GET['q'] variable to the proper normal path.
  15.  */
  16. function drupal_init_path() {
  17.   if (!empty($_GET['q'])) {
  18.     $_GET['q'] = drupal_get_normal_path(trim($_GET['q'], '/'));
  19.   }
  20.   else {
  21.     $_GET['q'] = drupal_get_normal_path(variable_get('site_frontpage', 'node'));
  22.   }
  23. }
  25. /**
  26.  * Given an alias, return its Drupal system URL if one exists. Given a Drupal
  27.  * system URL return one of its aliases if such a one exists. Otherwise,
  28.  * return FALSE.
  29.  *
  30.  * @param $action
  31.  *   One of the following values:
  32.  *   - wipe: delete the alias cache.
  33.  *   - alias: return an alias for a given Drupal system path (if one exists).
  34.  *   - source: return the Drupal system URL for a path alias (if one exists).
  35.  * @param $path
  36.  *   The path to investigate for corresponding aliases or system URLs.
  37.  * @param $path_language
  38.  *   Optional language code to search the path with. Defaults to the page language.
  39.  *   If there's no path defined for that language it will search paths without
  40.  *   language.
  41.  *
  42.  * @return
  43.  *   Either a Drupal system path, an aliased path, or FALSE if no path was
  44.  *   found.
  45.  */
  46. function drupal_lookup_path($action, $path = '', $path_language = '') {
  47.   global $language;
  48.   // $map is an array with language keys, holding arrays of Drupal paths to alias relations
  49.   static $map = array(), $no_src = array(), $count;
  51.   $path_language = $path_language ? $path_language : $language->language;
  53.   // Use $count to avoid looking up paths in subsequent calls if there simply are no aliases
  54.   if (!isset($count)) {
  55.     $count = db_result(db_query('SELECT COUNT(pid) FROM {url_alias}'));
  56.   }
  58.   if ($action == 'wipe') {
  59.     $map = array();
  60.     $no_src = array();
  61.   }
  62.   elseif ($count > 0 && $path != '') {
  63.     if ($action == 'alias') {
  64.       if (isset($map[$path_language][$path])) {
  65.         return $map[$path_language][$path];
  66.       }
  67.       // Get the most fitting result falling back with alias without language
  68.       $alias = db_result(db_query("SELECT dst FROM {url_alias} WHERE src = '%s' AND language IN('%s', '') ORDER BY language DESC", $path, $path_language));
  69.       $map[$path_language][$path] = $alias;
  70.       return $alias;
  71.     }
  72.     // Check $no_src for this $path in case we've already determined that there
  73.     // isn't a path that has this alias
  74.     elseif ($action == 'source' && !isset($no_src[$path_language][$path])) {
  75.       // Look for the value $path within the cached $map
  76.       $src = '';
  77.       if (!isset($map[$path_language]) || !($src = array_search($path, $map[$path_language]))) {
  78.         // Get the most fitting result falling back with alias without language
  79.         if ($src = db_result(db_query("SELECT src FROM {url_alias} WHERE dst = '%s' AND language IN('%s', '') ORDER BY language DESC", $path, $path_language))) {
  80.           $map[$path_language][$src] = $path;
  81.         }
  82.         else {
  83.           // We can't record anything into $map because we do not have a valid
  84.           // index and there is no need because we have not learned anything
  85.           // about any Drupal path. Thus cache to $no_src.
  86.           $no_src[$path_language][$path] = TRUE;
  87.         }
  88.       }
  89.       return $src;
  90.     }
  91.   }
  93.   return FALSE;
  94. }
  96. /**
  97.  * Given an internal Drupal path, return the alias set by the administrator.
  98.  *
  99.  * @param $path
  100.  *   An internal Drupal path.
  101.  * @param $path_language
  102.  *   An optional language code to look up the path in.
  103.  *
  104.  * @return
  105.  *   An aliased path if one was found, or the original path if no alias was
  106.  *   found.
  107.  */
  108. function drupal_get_path_alias($path, $path_language = '') {
  109.   $result = $path;
  110.   if ($alias = drupal_lookup_path('alias', $path, $path_language)) {
  111.     $result = $alias;
  112.   }
  113.   return $result;
  114. }
  116. /**
  117.  * Given a path alias, return the internal path it represents.
  118.  *
  119.  * @param $path
  120.  *   A Drupal path alias.
  121.  * @param $path_language
  122.  *   An optional language code to look up the path in.
  123.  *
  124.  * @return
  125.  *   The internal path represented by the alias, or the original alias if no
  126.  *   internal path was found.
  127.  */
  128. function drupal_get_normal_path($path, $path_language = '') {
  129.   $result = $path;
  130.   if ($src = drupal_lookup_path('source', $path, $path_language)) {
  131.     $result = $src;
  132.   }
  133.   if (function_exists('custom_url_rewrite_inbound')) {
  134.     // Modules may alter the inbound request path by reference.
  135.     custom_url_rewrite_inbound($result, $path, $path_language);
  136.   }
  137.   return $result;
  138. }
  140. /**
  141.  * Return a component of the current Drupal path.
  142.  *
  143.  * When viewing a page at the path "admin/content/types", for example, arg(0)
  144.  * would return "admin", arg(1) would return "content", and arg(2) would return
  145.  * "types".
  146.  *
  147.  * Avoid use of this function where possible, as resulting code is hard to read.
  148.  * Instead, attempt to use named arguments in menu callback functions. See the
  149.  * explanation in menu.inc for how to construct callbacks that take arguments.
  150.  *
  151.  * @param $index
  152.  *   The index of the component, where each component is separated by a '/'
  153.  *   (forward-slash), and where the first component has an index of 0 (zero).
  154.  *
  155.  * @return
  156.  *   The component specified by $index, or NULL if the specified component was
  157.  *   not found.
  158.  */
  159. function arg($index = NULL, $path = NULL) {
  160.   static $arguments;
  162.   if (!isset($path)) {
  163.     $path = $_GET['q'];
  164.   }
  165.   if (!isset($arguments[$path])) {
  166.     $arguments[$path] = explode('/', $path);
  167.   }
  168.   if (!isset($index)) {
  169.     return $arguments[$path];
  170.   }
  171.   if (isset($arguments[$path][$index])) {
  172.     return $arguments[$path][$index];
  173.   }
  174. }
  176. /**
  177.  * Get the title of the current page, for display on the page and in the title bar.
  178.  *
  179.  * @return
  180.  *   The current page's title.
  181.  */
  182. function drupal_get_title() {
  183.   $title = drupal_set_title();
  185.   // during a bootstrap, menu.inc is not included and thus we cannot provide a title
  186.   if (!isset($title) && function_exists('menu_get_active_title')) {
  187.     $title = check_plain(menu_get_active_title());
  188.   }
  190.   return $title;
  191. }
  193. /**
  194.  * Set the title of the current page, for display on the page and in the title bar.
  195.  *
  196.  * @param $title
  197.  *   Optional string value to assign to the page title; or if set to NULL
  198.  *   (default), leaves the current title unchanged.
  199.  *
  200.  * @return
  201.  *   The updated title of the current page.
  202.  */
  203. function drupal_set_title($title = NULL) {
  204.   static $stored_title;
  206.   if (isset($title)) {
  207.     $stored_title = $title;
  208.   }
  209.   return $stored_title;
  210. }
  212. /**
  213.  * Check if the current page is the front page.
  214.  *
  215.  * @return
  216.  *   Boolean value: TRUE if the current page is the front page; FALSE if otherwise.
  217.  */
  218. function drupal_is_front_page() {
  219.   // As drupal_init_path updates $_GET['q'] with the 'site_frontpage' path,
  220.   // we can check it against the 'site_frontpage' variable.
  221.   return $_GET['q'] == drupal_get_normal_path(variable_get('site_frontpage', 'node'));
  222. }
  224. /**
  225.  * Check if a path matches any pattern in a set of patterns.
  226.  *
  227.  * @param $path
  228.  *   The path to match.
  229.  * @param $patterns
  230.  *   String containing a set of patterns separated by \n, \r or \r\n.
  231.  *
  232.  * @return
  233.  *   Boolean value: TRUE if the path matches a pattern, FALSE otherwise.
  234.  */
  235. function drupal_match_path($path, $patterns) {
  236.   static $regexps;
  238.   if (!isset($regexps[$patterns])) {
  239.     $regexps[$patterns] = '/^('. preg_replace(array('/(\r\n?|\n)/', '/\\\\\*/', '/(^|\|)\\\\<front\\\\>($|\|)/'), array('|', '.*', '\1'. preg_quote(variable_get('site_frontpage', 'node'), '/') .'\2'), preg_quote($patterns, '/')) .')$/';
  240.   }
  241.   return preg_match($regexps[$patterns], $path);
  242. }