1. sfToolkit.class.php
  2. /**
 * sfToolkit provides basic utility methods.
 *
 * @package    symfony
 * @subpackage util
 * @author     Fabien Potencier 
 * @author     Sean Kerr 
 * @version    SVN: $Id: sfToolkit.class.php 23945 2009-11-14 18:12:41Z fabien $
 */
  3. class sfToolkit
  4. {
  5.   /**
  6.    * Extract the class or interface name from filename.
  7.    *
  8.    * @param  string $filename  A filename.
  9.    *
  10.    * @return string A class or interface name, if one can be extracted, otherwise null.
  11.    */
  12.   public static function extractClassName($filename)
  13.   {
  14.     $retval = null;
  16.     if (self::isPathAbsolute($filename))
  17.     {
  18.       $filename = basename($filename);
  19.     }
  21.     $pattern = '/(.*?)\.(class|interface)\.php/i';
  23.     if (preg_match($pattern, $filename, $match))
  24.     {
  25.       $retval = $match[1];
  26.     }
  28.     return $retval;
  29.   }
  31.   /**
  32.    * Clear all files in a given directory.
  33.    *
  34.    * @param string $directory  An absolute filesystem path to a directory.
  35.    */
  36.   public static function clearDirectory($directory)
  37.   {
  38.     if (!is_dir($directory))
  39.     {
  40.       return;
  41.     }
  43.     // open a file point to the cache dir
  44.     $fp = opendir($directory);
  46.     // ignore names
  47.     $ignore = array('.', '..', 'CVS', '.svn');
  49.     while (($file = readdir($fp)) !== false)
  50.     {
  51.       if (!in_array($file, $ignore))
  52.       {
  53.         if (is_link($directory.'/'.$file))
  54.         {
  55.           // delete symlink
  56.           unlink($directory.'/'.$file);
  57.         }
  58.         else if (is_dir($directory.'/'.$file))
  59.         {
  60.           // recurse through directory
  61.           self::clearDirectory($directory.'/'.$file);
  63.           // delete the directory
  64.           rmdir($directory.'/'.$file);
  65.         }
  66.         else
  67.         {
  68.           // delete the file
  69.           unlink($directory.'/'.$file);
  70.         }
  71.       }
  72.     }
  74.     // close file pointer
  75.     closedir($fp);
  76.   }
  78.   /**
  79.    * Clear all files and directories corresponding to a glob pattern.
  80.    *
  81.    * @param string $pattern  An absolute filesystem pattern.
  82.    */
  83.   public static function clearGlob($pattern)
  84.   {
  85.     $files = glob($pattern);
  87.     // order is important when removing directories
  88.     sort($files);
  90.     foreach ($files as $file)
  91.     {
  92.       if (is_dir($file))
  93.       {
  94.         // delete directory
  95.         self::clearDirectory($file);
  96.       }
  97.       else
  98.       {
  99.         // delete file
  100.         unlink($file);
  101.       }
  102.     }
  103.   }
  105.   /**
  106.    * Determine if a filesystem path is absolute.
  107.    *
  108.    * @param  path $path  A filesystem path.
  109.    *
  110.    * @return bool true, if the path is absolute, otherwise false.
  111.    */
  112.   public static function isPathAbsolute($path)
  113.   {
  114.     if ($path[0] == '/' || $path[0] == '\\' ||
  115.         (strlen($path) > 3 && ctype_alpha($path[0]) &&
  116.          $path[1] == ':' &&
  117.          ($path[2] == '\\' || $path[2] == '/')
  118.         )
  119.        )
  120.     {
  121.       return true;
  122.     }
  124.     return false;
  125.   }
  127.   /**
  128.    * Strips comments from php source code
  129.    *
  130.    * @param  string $source  PHP source code.
  131.    *
  132.    * @return string Comment free source code.
  133.    */
  134.   public static function stripComments($source)
  135.   {
  136.     if (!function_exists('token_get_all'))
  137.     {
  138.       return $source;
  139.     }
  141.     $ignore = array(T_COMMENT => true, T_DOC_COMMENT => true);
  142.     $output = '';
  144.     foreach (token_get_all($source) as $token)
  145.     {
  146.       // array
  147.       if (isset($token[1]))
  148.       {
  149.         // no action on comments
  150.         if (!isset($ignore[$token[0]]))
  151.         {
  152.           // anything else -> output "as is"
  153.           $output .= $token[1];
  154.         }
  155.       }
  156.       else
  157.       {
  158.         // simple 1-character token
  159.         $output .= $token;
  160.       }
  161.     }
  163.     return $output;
  164.   }
  166.   /**
  167.    * Strip slashes recursively from array
  168.    *
  169.    * @param  array $value  the value to strip
  170.    *
  171.    * @return array clean value with slashes stripped
  172.    */
  173.   public static function stripslashesDeep($value)
  174.   {
  175.     return is_array($value) ? array_map(array('sfToolkit', 'stripslashesDeep'), $value) : stripslashes($value);
  176.   }
  178.   // code from php at moechofe dot com (array_merge comment on php.net)
  179.   /*
  180.    * array arrayDeepMerge ( array array1 [, array array2 [, array ...]] )
  181.    *
  182.    * Like array_merge
  183.    *
  184.    *  arrayDeepMerge() merges the elements of one or more arrays together so
  185.    * that the values of one are appended to the end of the previous one. It
  186.    * returns the resulting array.
  187.    *  If the input arrays have the same string keys, then the later value for
  188.    * that key will overwrite the previous one. If, however, the arrays contain
  189.    * numeric keys, the later value will not overwrite the original value, but
  190.    * will be appended.
  191.    *  If only one array is given and the array is numerically indexed, the keys
  192.    * get reindexed in a continuous way.
  193.    *
  194.    * Different from array_merge
  195.    *  If string keys have arrays for values, these arrays will merge recursively.
  196.    */
  197.   public static function arrayDeepMerge()
  198.   {
  199.     switch (func_num_args())
  200.     {
  201.       case 0:
  202.         return false;
  203.       case 1:
  204.         return func_get_arg(0);
  205.       case 2:
  206.         $args = func_get_args();
  207.         $args[2] = array();
  208.         if (is_array($args[0]) && is_array($args[1]))
  209.         {
  210.           foreach (array_unique(array_merge(array_keys($args[0]),array_keys($args[1]))) as $key)
  211.           {
  212.             $isKey0 = array_key_exists($key, $args[0]);
  213.             $isKey1 = array_key_exists($key, $args[1]);
  214.             if ($isKey0 && $isKey1 && is_array($args[0][$key]) && is_array($args[1][$key]))
  215.             {
  216.               $args[2][$key] = self::arrayDeepMerge($args[0][$key], $args[1][$key]);
  217.             }
  218.             else if ($isKey0 && $isKey1)
  219.             {
  220.               $args[2][$key] = $args[1][$key];
  221.             }
  222.             else if (!$isKey1)
  223.             {
  224.               $args[2][$key] = $args[0][$key];
  225.             }
  226.             else if (!$isKey0)
  227.             {
  228.               $args[2][$key] = $args[1][$key];
  229.             }
  230.           }
  231.           return $args[2];
  232.         }
  233.         else
  234.         {
  235.           return $args[1];
  236.         }
  237.       default :
  238.         $args = func_get_args();
  239.         $args[1] = sfToolkit::arrayDeepMerge($args[0], $args[1]);
  240.         array_shift($args);
  241.         return call_user_func_array(array('sfToolkit', 'arrayDeepMerge'), $args);
  242.         break;
  243.     }
  244.   }
  246.   /**
  247.    * Converts string to array
  248.    *
  249.    * @param  string $string  the value to convert to array
  250.    *
  251.    * @return array
  252.    */
  253.   public static function stringToArray($string)
  254.   {
  255.     preg_match_all('/
  256.       \s*(\w+)              # key                               \\1
  257.       \s*=\s*               # =
  258.       (\'|")?               # values may be included in \' or " \\2
  259.       (.*?)                 # value                             \\3
  260.       (?(2) \\2)            # matching \' or " if needed        \\4
  261.       \s*(?:
  262.         (?=\w+\s*=) | \s*$  # followed by another key= or the end of the string
  263.       )
  264.     /x', $string, $matches, PREG_SET_ORDER);
  266.     $attributes = array();
  267.     foreach ($matches as $val)
  268.     {
  269.       $attributes[$val[1]] = self::literalize($val[3]);
  270.     }
  272.     return $attributes;
  273.   }
  275.   /**
  276.    * Finds the type of the passed value, returns the value as the new type.
  277.    *
  278.    * @param  string $value
  279.    * @param  bool   $quoted  Quote?
  280.    *
  281.    * @return mixed
  282.    */
  283.   public static function literalize($value, $quoted = false)
  284.   {
  285.     // lowercase our value for comparison
  286.     $value  = trim($value);
  287.     $lvalue = strtolower($value);
  289.     if (in_array($lvalue, array('null', '~', '')))
  290.     {
  291.       $value = null;
  292.     }
  293.     else if (in_array($lvalue, array('true', 'on', '+', 'yes')))
  294.     {
  295.       $value = true;
  296.     }
  297.     else if (in_array($lvalue, array('false', 'off', '-', 'no')))
  298.     {
  299.       $value = false;
  300.     }
  301.     else if (ctype_digit($value))
  302.     {
  303.       $value = (int) $value;
  304.     }
  305.     else if (is_numeric($value))
  306.     {
  307.       $value = (float) $value;
  308.     }
  309.     else
  310.     {
  311.       $value = self::replaceConstants($value);
  312.       if ($quoted)
  313.       {
  314.         $value = '\''.str_replace('\'', '\\\'', $value).'\'';
  315.       }
  316.     }
  318.     return $value;
  319.   }
  321.   /**
  322.    * Replaces constant identifiers in a scalar value.
  323.    *
  324.    * @param  string $value  the value to perform the replacement on
  325.    *
  326.    * @return string the value with substitutions made
  327.    */
  328.   public static function replaceConstants($value)
  329.   {
  330.     return is_string($value) ? preg_replace_callback('/%(.+?)%/', create_function('$v', 'return sfConfig::has(strtolower($v[1])) ? sfConfig::get(strtolower($v[1])) : "%{$v[1]}%";'), $value) : $value;
  331.   }
  333.   /**
  334.    * Returns subject replaced with regular expression matchs
  335.    *
  336.    * @param mixed $search        subject to search
  337.    * @param array $replacePairs  array of search => replace pairs
  338.    */
  339.   public static function pregtr($search, $replacePairs)
  340.   {
  341.     return preg_replace(array_keys($replacePairs), array_values($replacePairs), $search);
  342.   }
  344.   /**
  345.    * Checks if array values are empty
  346.    *
  347.    * @param  array $array  the array to check
  348.    * @return boolean true if empty, otherwise false
  349.    */
  350.   public static function isArrayValuesEmpty($array)
  351.   {
  352.     static $isEmpty = true;
  353.     foreach ($array as $value)
  354.     {
  355.       $isEmpty = (is_array($value)) ? self::isArrayValuesEmpty($value) : (strlen($value) == 0);
  356.       if (!$isEmpty)
  357.       {
  358.         break;
  359.       }
  360.     }
  362.     return $isEmpty;
  363.   }
  365.   /**
  366.    * Checks if a string is an utf8.
  367.    *
  368.    * Yi Stone Li<yili@yahoo-inc.com>
  369.    * Copyright (c) 2007 Yahoo! Inc. All rights reserved.
  370.    * Licensed under the BSD open source license
  371.    *
  372.    * @param string
  373.    *
  374.    * @return bool true if $string is valid UTF-8 and false otherwise.
  375.    */
  376.   public static function isUTF8($string)
  377.   {
  378.     for ($idx = 0, $strlen = strlen($string); $idx < $strlen; $idx++)
  379.     {
  380.       $byte = ord($string[$idx]);
  382.       if ($byte & 0x80)
  383.       {
  384.         if (($byte & 0xE0) == 0xC0)
  385.         {
  386.           // 2 byte char
  387.           $bytes_remaining = 1;
  388.         }
  389.         else if (($byte & 0xF0) == 0xE0)
  390.         {
  391.           // 3 byte char
  392.           $bytes_remaining = 2;
  393.         }
  394.         else if (($byte & 0xF8) == 0xF0)
  395.         {
  396.           // 4 byte char
  397.           $bytes_remaining = 3;
  398.         }
  399.         else
  400.         {
  401.           return false;
  402.         }
  404.         if ($idx + $bytes_remaining >= $strlen)
  405.         {
  406.           return false;
  407.         }
  409.         while ($bytes_remaining--)
  410.         {
  411.           if ((ord($string[++$idx]) & 0xC0) != 0x80)
  412.           {
  413.             return false;
  414.           }
  415.         }
  416.       }
  417.     }
  419.     return true;
  420.   }
  422.   /**
  423.    * Returns an array value for a path.
  424.    *
  425.    * @param array  $values   The values to search
  426.    * @param string $name     The token name
  427.    * @param array  $default  Default if not found
  428.    *
  429.    * @return array
  430.    */
  431.   public static function getArrayValueForPath($values, $name, $default = null)
  432.   {
  433.     if (false === $offset = strpos($name, '['))
  434.     {
  435.       return isset($values[$name]) ? $values[$name] : $default;
  436.     }
  438.     if (!isset($values[substr($name, 0, $offset)]))
  439.     {
  440.       return $default;
  441.     }
  443.     $array = $values[substr($name, 0, $offset)];
  445.     while (false !== $pos = strpos($name, '[', $offset))
  446.     {
  447.       $end = strpos($name, ']', $pos);
  448.       if ($end == $pos + 1)
  449.       {
  450.         // reached a []
  451.         if (!is_array($array))
  452.         {
  453.           return $default;
  454.         }
  455.         break;
  456.       }
  457.       else if (!isset($array[substr($name, $pos + 1, $end - $pos - 1)]))
  458.       {
  459.         return $default;
  460.       }
  461.       else if (is_array($array))
  462.       {
  463.         $array = $array[substr($name, $pos + 1, $end - $pos - 1)];
  464.         $offset = $end;
  465.       }
  466.       else
  467.       {
  468.         return $default;
  469.       }
  470.     }
  472.     return $array;
  473.   }
  475.   /**
  476.    * Get path to php cli.
  477.    *
  478.    * @throws sfException If no php cli found
  479.    * @return string
  480.    */
  481.   public static function getPhpCli()
  482.   {
  483.     $path = getenv('PATH') ? getenv('PATH') : getenv('Path');
  484.     $suffixes = DIRECTORY_SEPARATOR == '\\' ? (getenv('PATHEXT') ? explode(PATH_SEPARATOR, getenv('PATHEXT')) : array('.exe', '.bat', '.cmd', '.com')) : array('');
  485.     foreach (array('php5', 'php') as $phpCli)
  486.     {
  487.       foreach ($suffixes as $suffix)
  488.       {
  489.         foreach (explode(PATH_SEPARATOR, $path) as $dir)
  490.         {
  491.           if (is_file($file = $dir.DIRECTORY_SEPARATOR.$phpCli.$suffix) && is_executable($file))
  492.           {
  493.             return $file;
  494.           }
  495.         }
  496.       }
  497.     }
  499.     throw new sfException('Unable to find PHP executable.');
  500.   }
  502.   /**
  503.    * Converts strings to UTF-8 via iconv. NB, the result may not by UTF-8 if the conversion failed.
  504.    *
  505.    * This file comes from Prado (BSD License)
  506.    *
  507.    * @param  string $string string to convert to UTF-8
  508.    * @param  string $from   current encoding
  509.    *
  510.    * @return string UTF-8 encoded string, original string if iconv failed.
  511.    */
  512.   static public function I18N_toUTF8($string, $from)
  513.   {
  514.     $from = strtoupper($from);
  515.     if ($from != 'UTF-8')
  516.     {
  517.       $s = iconv($from,'UTF-8',$string);  // to UTF-8
  519.       return $s !== false ? $s : $string; // it could return false
  520.     }
  522.     return $string;
  523.   }
  525.   /**
  526.    * Converts UTF-8 strings to a different encoding. NB. The result may not have been encoded if iconv fails.
  527.    *
  528.    * This file comes from Prado (BSD License)
  529.    *
  530.    * @param  string $string  the UTF-8 string for conversion
  531.    * @param  string $to      new encoding
  532.    *
  533.    * @return string encoded string.
  534.    */
  535.   static public function I18N_toEncoding($string, $to)
  536.   {
  537.     $to = strtoupper($to);
  538.     if ($to != 'UTF-8')
  539.     {
  540.       $s = iconv('UTF-8', $to, $string);
  542.       return $s !== false ? $s : $string;
  543.     }
  545.     return $string;
  546.   }
  548.   /**
  549.    * Adds a path to the PHP include_path setting.
  550.    *
  551.    * @param   mixed  $path     Single string path or an array of paths
  552.    * @param   string $position Either 'front' or 'back'
  553.    *
  554.    * @return  string The old include path
  555.    */
  556.   static public function addIncludePath($path, $position = 'front')
  557.   {
  558.     if (is_array($path))
  559.     {
  560.       foreach ('front' == $position ? array_reverse($path) : $path as $p)
  561.       {
  562.         self::addIncludePath($p, $position);
  563.       }
  565.       return;
  566.     }
  568.     $paths = explode(PATH_SEPARATOR, get_include_path());
  570.     // remove what's already in the include_path
  571.     if (false !== $key = array_search(realpath($path), array_map('realpath', $paths)))
  572.     {
  573.       unset($paths[$key]);
  574.     }
  576.     switch ($position)
  577.     {
  578.       case 'front':
  579.         array_unshift($paths, $path);
  580.         break;
  581.       case 'back':
  582.         $paths[] = $path;
  583.         break;
  584.       default:
  585.         throw new InvalidArgumentException(sprintf('Unrecognized position: "%s"', $position));
  586.     }
  588.     return set_include_path(join(PATH_SEPARATOR, $paths));
  589.   }
  590. }
Debug toolbar