web/public_php/webtt/cake/libs/string.php

   1 <?php
   2 /**
   3  * String handling methods.
   4  *
   5  * PHP versions 4 and 5
   6  *
   7  * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
   8  * Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org)
   9  *
  10  * Licensed under The MIT License
  11  * Redistributions of files must retain the above copyright notice.
  12  *
  13  * @copyright     Copyright 2005-2010, Cake Software Foundation, Inc. (http://cakefoundation.org)
  14  * @link          http://cakephp.org CakePHP(tm) Project
  15  * @package       cake
  16  * @subpackage    cake.cake.libs
  17  * @since         CakePHP(tm) v 1.2.0.5551
  18  * @license       MIT License (http://www.opensource.org/licenses/mit-license.php)
  19  */
  20
  21 /**
  22  * String handling methods.
  23  *
  24  *
  25  * @package       cake
  26  * @subpackage    cake.cake.libs
  27  */
  28 class String {
  29
  30 /**
  31  * Generate a random UUID
  32  *
  33  * @see http://www.ietf.org/rfc/rfc4122.txt
  34  * @return RFC 4122 UUID
  35  * @static
  36  */
  37         function uuid() {
  38                 $node = env('SERVER_ADDR');
  39                 $pid = null;
  40
  41                 if (strpos($node, ':') !== false) {
  42                         if (substr_count($node, '::')) {
  43                                 $node = str_replace(
  44                                         '::', str_repeat(':0000', 8 - substr_count($node, ':')) . ':', $node
  45                                 );
  46                         }
  47                         $node = explode(':', $node) ;
  48                         $ipv6 = '' ;
  49
  50                         foreach ($node as $id) {
  51                                 $ipv6 .= str_pad(base_convert($id, 16, 2), 16, 0, STR_PAD_LEFT);
  52                         }
  53                         $node =  base_convert($ipv6, 2, 10);
  54
  55                         if (strlen($node) < 38) {
  56                                 $node = null;
  57                         } else {
  58                                 $node = crc32($node);
  59                         }
  60                 } elseif (empty($node)) {
  61                         $host = env('HOSTNAME');
  62
  63                         if (empty($host)) {
  64                                 $host = env('HOST');
  65                         }
  66
  67                         if (!empty($host)) {
  68                                 $ip = gethostbyname($host);
  69
  70                                 if ($ip === $host) {
  71                                         $node = crc32($host);
  72                                 } else {
  73                                         $node = ip2long($ip);
  74                                 }
  75                         }
  76                 } elseif ($node !== '127.0.0.1') {
  77                         $node = ip2long($node);
  78                 } else {
  79                         $node = null;
  80                 }
  81
  82                 if (empty($node)) {
  83                         $node = crc32(Configure::read('Security.salt'));
  84                 }
  85
  86                 if (function_exists('zend_thread_id')) {
  87                         $pid = zend_thread_id();
  88                 } else {
  89                         $pid = getmypid();
  90                 }
  91
  92                 if (!$pid || $pid > 65535) {
  93                         $pid = mt_rand(0, 0xfff) | 0x4000;
  94                 }
  95
  96                 list($timeMid, $timeLow) = explode(' ', microtime());
  97                 $uuid = sprintf(
  98                         "%08x-%04x-%04x-%02x%02x-%04x%08x", (int)$timeLow, (int)substr($timeMid, 2) & 0xffff,
  99                         mt_rand(0, 0xfff) | 0x4000, mt_rand(0, 0x3f) | 0x80, mt_rand(0, 0xff), $pid, $node
 100                 );
 101
 102                 return $uuid;
 103         }
 104
 105 /**
 106  * Tokenizes a string using $separator, ignoring any instance of $separator that appears between
 107  * $leftBound and $rightBound
 108  *
 109  * @param string $data The data to tokenize
 110  * @param string $separator The token to split the data on.
 111  * @param string $leftBound The left boundary to ignore separators in.
 112  * @param string $rightBound The right boundary to ignore separators in.
 113  * @return array Array of tokens in $data.
 114  * @access public
 115  * @static
 116  */
 117         function tokenize($data, $separator = ',', $leftBound = '(', $rightBound = ')') {
 118                 if (empty($data) || is_array($data)) {
 119                         return $data;
 120                 }
 121
 122                 $depth = 0;
 123                 $offset = 0;
 124                 $buffer = '';
 125                 $results = array();
 126                 $length = strlen($data);
 127                 $open = false;
 128
 129                 while ($offset <= $length) {
 130                         $tmpOffset = -1;
 131                         $offsets = array(
 132                                 strpos($data, $separator, $offset),
 133                                 strpos($data, $leftBound, $offset),
 134                                 strpos($data, $rightBound, $offset)
 135                         );
 136                         for ($i = 0; $i < 3; $i++) {
 137                                 if ($offsets[$i] !== false && ($offsets[$i] < $tmpOffset || $tmpOffset == -1)) {
 138                                         $tmpOffset = $offsets[$i];
 139                                 }
 140                         }
 141                         if ($tmpOffset !== -1) {
 142                                 $buffer .= substr($data, $offset, ($tmpOffset - $offset));
 143                                 if ($data{$tmpOffset} == $separator && $depth == 0) {
 144                                         $results[] = $buffer;
 145                                         $buffer = '';
 146                                 } else {
 147                                         $buffer .= $data{$tmpOffset};
 148                                 }
 149                                 if ($leftBound != $rightBound) {
 150                                         if ($data{$tmpOffset} == $leftBound) {
 151                                                 $depth++;
 152                                         }
 153                                         if ($data{$tmpOffset} == $rightBound) {
 154                                                 $depth--;
 155                                         }
 156                                 } else {
 157                                         if ($data{$tmpOffset} == $leftBound) {
 158                                                 if (!$open) {
 159                                                         $depth++;
 160                                                         $open = true;
 161                                                 } else {
 162                                                         $depth--;
 163                                                         $open = false;
 164                                                 }
 165                                         }
 166                                 }
 167                                 $offset = ++$tmpOffset;
 168                         } else {
 169                                 $results[] = $buffer . substr($data, $offset);
 170                                 $offset = $length + 1;
 171                         }
 172                 }
 173                 if (empty($results) && !empty($buffer)) {
 174                         $results[] = $buffer;
 175                 }
 176
 177                 if (!empty($results)) {
 178                         $data = array_map('trim', $results);
 179                 } else {
 180                         $data = array();
 181                 }
 182                 return $data;
 183         }
 184
 185 /**
 186  * Replaces variable placeholders inside a $str with any given $data. Each key in the $data array
 187  * corresponds to a variable placeholder name in $str.
 188  * Example: `String::insert(':name is :age years old.', array('name' => 'Bob', '65'));`
 189  * Returns: Bob is 65 years old.
 190  *
 191  * Available $options are:
 192  *
 193  * - before: The character or string in front of the name of the variable placeholder (Defaults to `:`)
 194  * - after: The character or string after the name of the variable placeholder (Defaults to null)
 195  * - escape: The character or string used to escape the before character / string (Defaults to `\`)
 196  * - format: A regex to use for matching variable placeholders. Default is: `/(?<!\\)\:%s/`
 197  *   (Overwrites before, after, breaks escape / clean)
 198  * - clean: A boolean or array with instructions for String::cleanInsert
 199  *
 200  * @param string $str A string containing variable placeholders
 201  * @param string $data A key => val array where each key stands for a placeholder variable name
 202  *     to be replaced with val
 203  * @param string $options An array of options, see description above
 204  * @return string
 205  * @access public
 206  * @static
 207  */
 208         function insert($str, $data, $options = array()) {
 209                 $defaults = array(
 210                         'before' => ':', 'after' => null, 'escape' => '\\', 'format' => null, 'clean' => false
 211                 );
 212                 $options += $defaults;
 213                 $format = $options['format'];
 214                 $data = (array)$data;
 215                 if (empty($data)) {
 216                         return ($options['clean']) ? String::cleanInsert($str, $options) : $str;
 217                 }
 218
 219                 if (!isset($format)) {
 220                         $format = sprintf(
 221                                 '/(?<!%s)%s%%s%s/',
 222                                 preg_quote($options['escape'], '/'),
 223                                 str_replace('%', '%%', preg_quote($options['before'], '/')),
 224                                 str_replace('%', '%%', preg_quote($options['after'], '/'))
 225                         );
 226                 }
 227
 228                 if (strpos($str, '?') !== false && is_numeric(key($data))) {
 229                         $offset = 0;
 230                         while (($pos = strpos($str, '?', $offset)) !== false) {
 231                                 $val = array_shift($data);
 232                                 $offset = $pos + strlen($val);
 233                                 $str = substr_replace($str, $val, $pos, 1);
 234                         }
 235                         return ($options['clean']) ? String::cleanInsert($str, $options) : $str;
 236                 } else {
 237                         asort($data);
 238
 239                         $hashKeys = array();
 240                         foreach ($data as $key => $value) {
 241                                 $hashKeys[] = crc32($key);
 242                         }
 243
 244                         $tempData = array_combine(array_keys($data), array_values($hashKeys));
 245                         krsort($tempData);
 246                         foreach ($tempData as $key => $hashVal) {
 247                                 $key = sprintf($format, preg_quote($key, '/'));
 248                                 $str = preg_replace($key, $hashVal, $str);
 249                         }
 250                         $dataReplacements = array_combine($hashKeys, array_values($data));
 251                         foreach ($dataReplacements as $tmpHash => $tmpValue) {
 252                                 $tmpValue = (is_array($tmpValue)) ? '' : $tmpValue;
 253                                 $str = str_replace($tmpHash, $tmpValue, $str);
 254                         }
 255                 }
 256
 257                 if (!isset($options['format']) && isset($options['before'])) {
 258                         $str = str_replace($options['escape'].$options['before'], $options['before'], $str);
 259                 }
 260                 return ($options['clean']) ? String::cleanInsert($str, $options) : $str;
 261         }
 262
 263 /**
 264  * Cleans up a String::insert() formated string with given $options depending on the 'clean' key in
 265  * $options. The default method used is text but html is also available. The goal of this function
 266  * is to replace all whitespace and uneeded markup around placeholders that did not get replaced
 267  * by String::insert().
 268  *
 269  * @param string $str
 270  * @param string $options
 271  * @return string
 272  * @access public
 273  * @static
 274  * @see String::insert()
 275  */
 276         function cleanInsert($str, $options) {
 277                 $clean = $options['clean'];
 278                 if (!$clean) {
 279                         return $str;
 280                 }
 281                 if ($clean === true) {
 282                         $clean = array('method' => 'text');
 283                 }
 284                 if (!is_array($clean)) {
 285                         $clean = array('method' => $options['clean']);
 286                 }
 287                 switch ($clean['method']) {
 288                         case 'html':
 289                                 $clean = array_merge(array(
 290                                         'word' => '[\w,.]+',
 291                                         'andText' => true,
 292                                         'replacement' => '',
 293                                 ), $clean);
 294                                 $kleenex = sprintf(
 295                                         '/[\s]*[a-z]+=(")(%s%s%s[\s]*)+\\1/i',
 296                                         preg_quote($options['before'], '/'),
 297                                         $clean['word'],
 298                                         preg_quote($options['after'], '/')
 299                                 );
 300                                 $str = preg_replace($kleenex, $clean['replacement'], $str);
 301                                 if ($clean['andText']) {
 302                                         $options['clean'] = array('method' => 'text');
 303                                         $str = String::cleanInsert($str, $options);
 304                                 }
 305                                 break;
 306                         case 'text':
 307                                 $clean = array_merge(array(
 308                                         'word' => '[\w,.]+',
 309                                         'gap' => '[\s]*(?:(?:and|or)[\s]*)?',
 310                                         'replacement' => '',
 311                                 ), $clean);
 312
 313                                 $kleenex = sprintf(
 314                                         '/(%s%s%s%s|%s%s%s%s)/',
 315                                         preg_quote($options['before'], '/'),
 316                                         $clean['word'],
 317                                         preg_quote($options['after'], '/'),
 318                                         $clean['gap'],
 319                                         $clean['gap'],
 320                                         preg_quote($options['before'], '/'),
 321                                         $clean['word'],
 322                                         preg_quote($options['after'], '/')
 323                                 );
 324                                 $str = preg_replace($kleenex, $clean['replacement'], $str);
 325                                 break;
 326                 }
 327                 return $str;
 328         }
 329 }