| 1 | <?php |
|---|
| 2 | require_once('class.utils.php'); |
|---|
| 3 | /** |
|---|
| 4 | * Contains useful methods for string handling that extend standard PHP set and include new tools |
|---|
| 5 | * @author Carlos Eduardo Nogueira Gonçalves |
|---|
| 6 | * @author Marcos Pont |
|---|
| 7 | * @version 1.0 |
|---|
| 8 | * @link http://workflow.celepar.parana/doc-workflow/classes/stringutils Complete reference |
|---|
| 9 | * @package Workflow |
|---|
| 10 | * @license http://www.gnu.org/copyleft/gpl.html GPL |
|---|
| 11 | */ |
|---|
| 12 | class StringUtils extends Utils |
|---|
| 13 | { |
|---|
| 14 | /** |
|---|
| 15 | * Strips all blank characters from the beginning and end of a string |
|---|
| 16 | * @param string $str |
|---|
| 17 | * @return result string |
|---|
| 18 | * @access public |
|---|
| 19 | */ |
|---|
| 20 | function allTrim($str) { |
|---|
| 21 | return $this->stripBlank(trim($str)); |
|---|
| 22 | } |
|---|
| 23 | |
|---|
| 24 | /** |
|---|
| 25 | * Replace all blank characters |
|---|
| 26 | * @param string $str |
|---|
| 27 | * @param string $replace replace string |
|---|
| 28 | * @return string result string |
|---|
| 29 | * @access public |
|---|
| 30 | */ |
|---|
| 31 | function stripBlank($str, $replace=' ') { |
|---|
| 32 | return ereg_replace("[[:blank:]]{1,}", $replace, $str); |
|---|
| 33 | } |
|---|
| 34 | |
|---|
| 35 | /** |
|---|
| 36 | * Return the first n chars of the string |
|---|
| 37 | * @param string $str base string |
|---|
| 38 | * @param int $chars number of chars to return |
|---|
| 39 | * @return string result substring |
|---|
| 40 | * @access public |
|---|
| 41 | */ |
|---|
| 42 | function left($str, $chars = 0) { |
|---|
| 43 | if (!$this->isInteger($chars)) { |
|---|
| 44 | return $str; |
|---|
| 45 | } else if ($chars == 0) { |
|---|
| 46 | return ''; |
|---|
| 47 | } else { |
|---|
| 48 | return substr($str, 0, $chars); |
|---|
| 49 | } |
|---|
| 50 | } |
|---|
| 51 | |
|---|
| 52 | /** |
|---|
| 53 | * Return the last n chars of the string |
|---|
| 54 | * @param string $str base string |
|---|
| 55 | * @param int $chars number of chars to return |
|---|
| 56 | * @return string result substring |
|---|
| 57 | * @access public |
|---|
| 58 | */ |
|---|
| 59 | function right($str, $chars=0) { |
|---|
| 60 | if (!$this->isInteger($chars)) { |
|---|
| 61 | return $str; |
|---|
| 62 | } else if ($chars == 0) { |
|---|
| 63 | return ''; |
|---|
| 64 | } else { |
|---|
| 65 | return substr($str, strlen($str) - $chars, strlen($str)-1); |
|---|
| 66 | } |
|---|
| 67 | } |
|---|
| 68 | |
|---|
| 69 | /** |
|---|
| 70 | * Return parts of the current string |
|---|
| 71 | * @param string $str base string |
|---|
| 72 | * @param int $startAt |
|---|
| 73 | * @param int $chars |
|---|
| 74 | * @return string result substring |
|---|
| 75 | * @access public |
|---|
| 76 | */ |
|---|
| 77 | function mid($str, $startAt=1, $chars=0) { |
|---|
| 78 | if (!$this->isInteger($chars)) { |
|---|
| 79 | return $str; |
|---|
| 80 | } else if ($str == '' || $chars == 0) { |
|---|
| 81 | return ''; |
|---|
| 82 | } else if (($startAt + $chars) > strlen($str)) { |
|---|
| 83 | return $str; |
|---|
| 84 | } else { |
|---|
| 85 | if ($startAt == 0) $startAt = 1; |
|---|
| 86 | return substr($str, $startAt-1, $chars); |
|---|
| 87 | } |
|---|
| 88 | } |
|---|
| 89 | |
|---|
| 90 | /** |
|---|
| 91 | * Returns the character at position |
|---|
| 92 | * @param string $str reference string |
|---|
| 93 | * @param $index |
|---|
| 94 | * @return string string value of a variable |
|---|
| 95 | * @access public |
|---|
| 96 | */ |
|---|
| 97 | function charAt($str, $index) { |
|---|
| 98 | if (!$this->isInteger($index)) { |
|---|
| 99 | return ''; |
|---|
| 100 | } else if ($str == '' || $index < 0 || $index >= strlen($str)) { |
|---|
| 101 | return ''; |
|---|
| 102 | } else { |
|---|
| 103 | $strTranslated = strval($str); |
|---|
| 104 | return $strTranslated{$index}; |
|---|
| 105 | } |
|---|
| 106 | } |
|---|
| 107 | /** |
|---|
| 108 | * Search a string in another string |
|---|
| 109 | * @param string $str reference string |
|---|
| 110 | * @param $sValue search string |
|---|
| 111 | * @param $caseSensitive caseSensitive true or false |
|---|
| 112 | * @return string position of first occurrence of sValue in str |
|---|
| 113 | * @access public |
|---|
| 114 | */ |
|---|
| 115 | function match($str, $sValue, $caseSensitive=TRUE) { |
|---|
| 116 | if (!$caseSensitive) $sValue = strtolower($sValue); |
|---|
| 117 | if (strlen($sValue) == 0) { |
|---|
| 118 | return FALSE; |
|---|
| 119 | } else { |
|---|
| 120 | $pos = strpos($str, $sValue); |
|---|
| 121 | return ($pos !== FALSE); |
|---|
| 122 | } |
|---|
| 123 | } |
|---|
| 124 | /** |
|---|
| 125 | * Return all string starts with the substring |
|---|
| 126 | * @param string $str referenfe string |
|---|
| 127 | * @param $slice |
|---|
| 128 | * @param bool $caseSensitive caseSensitive true or false |
|---|
| 129 | * @param bool $ignSpaces ignore spaces |
|---|
| 130 | * @return string |
|---|
| 131 | * @access public |
|---|
| 132 | */ |
|---|
| 133 | function startsWith($str, $slice, $caseSensitive=TRUE, $ignSpaces=TRUE) { |
|---|
| 134 | if (!$caseSensitive) { |
|---|
| 135 | $strUsed = ($ignSpaces) ? ltrim(strtolower($str)) : strtolower($str); |
|---|
| 136 | $sliceUsed = strtolower($slice); |
|---|
| 137 | } else { |
|---|
| 138 | $strUsed = ($ignSpaces) ? ltrim($str) : $str; |
|---|
| 139 | $sliceUsed = $slice; |
|---|
| 140 | } |
|---|
| 141 | return ($this->left($strUsed, strlen($sliceUsed)) == $sliceUsed); |
|---|
| 142 | } |
|---|
| 143 | |
|---|
| 144 | /** |
|---|
| 145 | * Return all string ends with the substring |
|---|
| 146 | * @param string $str |
|---|
| 147 | * @param $slice |
|---|
| 148 | * @param bool $caseSensitive caseSensitive true or false |
|---|
| 149 | * @param bool $ignSpaces ignore spaces |
|---|
| 150 | * @return string |
|---|
| 151 | * @access public |
|---|
| 152 | */ |
|---|
| 153 | function endsWith($str, $slice, $caseSensitive=TRUE, $ignSpaces=TRUE) { |
|---|
| 154 | if (!$caseSensitive) { |
|---|
| 155 | $strUsed = ($ignSpaces) ? rtrim(strtolower($str)) : strtolower($str); |
|---|
| 156 | $sliceUsed = strtolower($slice); |
|---|
| 157 | } else { |
|---|
| 158 | $strUsed = ($ignSpaces) ? rtrim($str) : $str; |
|---|
| 159 | $sliceUsed = $slice; |
|---|
| 160 | } |
|---|
| 161 | return ($this->right($strUsed, strlen($sliceUsed)) == $sliceUsed); |
|---|
| 162 | } |
|---|
| 163 | |
|---|
| 164 | /** |
|---|
| 165 | * Checks with the all characters of string is upper case |
|---|
| 166 | * @param string $str |
|---|
| 167 | * @return bool |
|---|
| 168 | * @access public |
|---|
| 169 | */ |
|---|
| 170 | function isAllUpper($str) { |
|---|
| 171 | return (preg_match("/[a-z]/", $str) !== FALSE); |
|---|
| 172 | } |
|---|
| 173 | |
|---|
| 174 | /** |
|---|
| 175 | * Checks with the all characters of string is lower case |
|---|
| 176 | * @param string $str |
|---|
| 177 | * @return bool |
|---|
| 178 | * @access public |
|---|
| 179 | * |
|---|
| 180 | */ |
|---|
| 181 | function isAllLower($str) { |
|---|
| 182 | return (preg_match("/[A-Z]/", $str) !== FALSE); |
|---|
| 183 | } |
|---|
| 184 | |
|---|
| 185 | /** |
|---|
| 186 | * Checks with the values is empty |
|---|
| 187 | * @param string $value |
|---|
| 188 | * @return bool |
|---|
| 189 | * @access public |
|---|
| 190 | */ |
|---|
| 191 | function isEmpty($value) { |
|---|
| 192 | $value = strval($value); |
|---|
| 193 | return (empty($value) && strlen($value) == 0); |
|---|
| 194 | } |
|---|
| 195 | |
|---|
| 196 | /** |
|---|
| 197 | * If the $values replace with the $replacement parameter |
|---|
| 198 | * @param mixed $value |
|---|
| 199 | * @param mixed $replacement |
|---|
| 200 | * @return bool |
|---|
| 201 | * @access public |
|---|
| 202 | */ |
|---|
| 203 | function ifEmpty($value, $replacement) { |
|---|
| 204 | return (empty($value) ? $replacement : $value); |
|---|
| 205 | } |
|---|
| 206 | |
|---|
| 207 | /** |
|---|
| 208 | * Concat two strings |
|---|
| 209 | * @param string $str first string |
|---|
| 210 | * @param string $concat second string |
|---|
| 211 | * @return result string |
|---|
| 212 | */ |
|---|
| 213 | function concat($str, $concat) { |
|---|
| 214 | return $str . $concat; |
|---|
| 215 | } |
|---|
| 216 | |
|---|
| 217 | /** |
|---|
| 218 | * Adds a prefix and suffix to a string |
|---|
| 219 | * @param string $str reference string |
|---|
| 220 | * @param string $prefix prefix string |
|---|
| 221 | * @param string $suffix suffix string |
|---|
| 222 | * @return string result string |
|---|
| 223 | * @access public |
|---|
| 224 | */ |
|---|
| 225 | function surround($str, $prefix, $suffix) { |
|---|
| 226 | return $prefix . $str . $suffix; |
|---|
| 227 | } |
|---|
| 228 | |
|---|
| 229 | /** |
|---|
| 230 | * Insert a value in a determined position in a string |
|---|
| 231 | * @param $str reference string |
|---|
| 232 | * @param $insValue value to insert |
|---|
| 233 | * @param $insPos insert position |
|---|
| 234 | * @return string |
|---|
| 235 | * @access public |
|---|
| 236 | */ |
|---|
| 237 | function insert($str, $insValue = '', $insPos = 0) { |
|---|
| 238 | if (($insValue == '') || ($insPos < 0) || ($insPos > strlen($str))) { |
|---|
| 239 | return $str; |
|---|
| 240 | } else if ($insPos == 0) { |
|---|
| 241 | return $insValue . $str; |
|---|
| 242 | } else if ($insPos == strlen($str)) { |
|---|
| 243 | return $str . $insValue; |
|---|
| 244 | } else { |
|---|
| 245 | return $this->left($str, $insPos) . $insValue . $this->right($str, $insPos, strlen($str) - $insPos); |
|---|
| 246 | } |
|---|
| 247 | } |
|---|
| 248 | |
|---|
| 249 | /** |
|---|
| 250 | * Replace all occurrences of search in haystack with replace |
|---|
| 251 | * |
|---|
| 252 | * @param string $str reference string |
|---|
| 253 | * @param string $from string to search |
|---|
| 254 | * @param string $to string to replace |
|---|
| 255 | * @return mixed |
|---|
| 256 | * @access public |
|---|
| 257 | */ |
|---|
| 258 | function replace($str, $from, $to) { |
|---|
| 259 | return str_replace($from, $to, $str); |
|---|
| 260 | } |
|---|
| 261 | |
|---|
| 262 | /** |
|---|
| 263 | * Replace the pattern with a parameter string |
|---|
| 264 | * |
|---|
| 265 | * @param string $str reference string |
|---|
| 266 | * @param string $pattern pattern to search |
|---|
| 267 | * @param string $replacement string to replace |
|---|
| 268 | * @return string |
|---|
| 269 | * @access public |
|---|
| 270 | */ |
|---|
| 271 | function regexReplace($str, $pattern, $replacement) { |
|---|
| 272 | if (empty($pattern)) |
|---|
| 273 | return $str; |
|---|
| 274 | $matches = array(); |
|---|
| 275 | if (preg_match('!\W(\w+)$!s', $pattern, $matches) && (strpos($matches[1], 'e') !== FALSE)) |
|---|
| 276 | $pattern = substr($pattern, 0, -strlen($matches[1])) . str_replace('e', '', $matches[1]); |
|---|
| 277 | return preg_replace($pattern, $replacement, $str); |
|---|
| 278 | } |
|---|
| 279 | |
|---|
| 280 | /** |
|---|
| 281 | * Explode a string in array of components |
|---|
| 282 | * |
|---|
| 283 | * @param string $str reference string |
|---|
| 284 | * @param string $sep separator |
|---|
| 285 | * @return array array of components |
|---|
| 286 | * @access public |
|---|
| 287 | */ |
|---|
| 288 | function explode($str, $sep) { |
|---|
| 289 | $arr = explode($sep, $str); |
|---|
| 290 | return $arr; |
|---|
| 291 | } |
|---|
| 292 | |
|---|
| 293 | /** |
|---|
| 294 | * Join elements array in one string |
|---|
| 295 | * @param string $str reference string |
|---|
| 296 | * @param string $glue glue string |
|---|
| 297 | * @return string result string |
|---|
| 298 | * @access public |
|---|
| 299 | */ |
|---|
| 300 | function implode($values, $glue) { |
|---|
| 301 | return implode($glue, (array)$values); |
|---|
| 302 | } |
|---|
| 303 | |
|---|
| 304 | /** |
|---|
| 305 | * Encode the string with encodetype |
|---|
| 306 | * |
|---|
| 307 | * @param string $str reference string |
|---|
| 308 | * @param string $encodeType encode type: 'base64', 'utf8' ,'7bit' , '8bit' or 'quoted-printable' |
|---|
| 309 | * @param array $params |
|---|
| 310 | * @return string encoded string |
|---|
| 311 | * @access public |
|---|
| 312 | */ |
|---|
| 313 | function encode($str, $encodeType, $params=NULL) { |
|---|
| 314 | switch(strtolower($encodeType)) { |
|---|
| 315 | case 'base64' : |
|---|
| 316 | $encoded = chunk_split(base64_encode($str)); |
|---|
| 317 | break; |
|---|
| 318 | case 'utf8' : |
|---|
| 319 | $encoded = utf8_encode($str); |
|---|
| 320 | break; |
|---|
| 321 | case '7bit' : |
|---|
| 322 | case '8bit' : |
|---|
| 323 | $nl = $this->ifNull($params['nl'], "\n"); |
|---|
| 324 | $str = str_replace(array("\r\n", "\r"), array("\n", "\n"), $str); |
|---|
| 325 | $encoded = str_replace("\n", $nl, $str); |
|---|
| 326 | if (!$this->endsWith($encoded, $nl)) |
|---|
| 327 | $encoded .= $nl; |
|---|
| 328 | break; |
|---|
| 329 | case 'quoted-printable' : |
|---|
| 330 | static $qpChars; |
|---|
| 331 | if (!isset($qpChars)) |
|---|
| 332 | $qpChars = array_merge(array(64, 61, 46), range(0, 31), range(127, 255)); |
|---|
| 333 | $charset = $this->ifNull($params['charset'], 'iso-8859-1'); |
|---|
| 334 | $replace = array(' ' => '_'); |
|---|
| 335 | foreach ($qpChars as $char) |
|---|
| 336 | $replace[chr($char)] = '=' . strtoupper(dechex($char)); |
|---|
| 337 | return sprintf("=?%s?Q?%s=", $charset, strtr($str, $replace)); |
|---|
| 338 | default: |
|---|
| 339 | $encoded = $str; |
|---|
| 340 | break; |
|---|
| 341 | } |
|---|
| 342 | return $encoded; |
|---|
| 343 | } |
|---|
| 344 | /** |
|---|
| 345 | * Decode the string parameter with encodetype |
|---|
| 346 | * |
|---|
| 347 | * @param string $str reference string |
|---|
| 348 | * @param string $encodetype 'base64', 'base64', 'quoted-printable' |
|---|
| 349 | * @return string decode string |
|---|
| 350 | * @access public |
|---|
| 351 | */ |
|---|
| 352 | function decode($str, $encodeType) { |
|---|
| 353 | switch(strtolower($encodeType)) { |
|---|
| 354 | case 'base64' : |
|---|
| 355 | $decoded = base64_decode($str); |
|---|
| 356 | break; |
|---|
| 357 | case 'base64' : |
|---|
| 358 | $decoded = utf8_decode($str); |
|---|
| 359 | break; |
|---|
| 360 | case 'quoted-printable' : |
|---|
| 361 | $decoded = quoted_printable_decode($str); |
|---|
| 362 | break; |
|---|
| 363 | default : |
|---|
| 364 | $decoded = $str; |
|---|
| 365 | break; |
|---|
| 366 | } |
|---|
| 367 | return $decoded; |
|---|
| 368 | } |
|---|
| 369 | |
|---|
| 370 | /** |
|---|
| 371 | * Map |
|---|
| 372 | * |
|---|
| 373 | * @access public |
|---|
| 374 | */ |
|---|
| 375 | function map() { |
|---|
| 376 | $argc = func_num_args(); |
|---|
| 377 | $argv = func_get_args(); |
|---|
| 378 | if ($argc == 0) |
|---|
| 379 | return NULL; |
|---|
| 380 | $base = $argv[0]; |
|---|
| 381 | for ($i=1,$s=sizeof($argv); $i<$s; $i+=2) { |
|---|
| 382 | if (array_key_exists($i+1, $argv)) { |
|---|
| 383 | if ($base == $argv[$i]) |
|---|
| 384 | return $argv[$i+1]; |
|---|
| 385 | } else { |
|---|
| 386 | return $argv[$i]; |
|---|
| 387 | } |
|---|
| 388 | } |
|---|
| 389 | return $base; |
|---|
| 390 | } |
|---|
| 391 | |
|---|
| 392 | /** |
|---|
| 393 | * Filter the selected strings |
|---|
| 394 | * |
|---|
| 395 | * @param string $str string reference |
|---|
| 396 | * @param string $filtertype regex expression |
|---|
| 397 | * @param string $replaceStr string to replace |
|---|
| 398 | * |
|---|
| 399 | * @return string |
|---|
| 400 | * @access public |
|---|
| 401 | * |
|---|
| 402 | */ |
|---|
| 403 | function filter($str, $filterType='alphanum', $replaceStr='') { |
|---|
| 404 | $replaceStr = strval($replaceStr); |
|---|
| 405 | switch ($filterType) { |
|---|
| 406 | case 'alpha' : |
|---|
| 407 | return (ereg_replace("[^a-zA-Z]", $replaceStr, $str)); |
|---|
| 408 | case 'alphalower' : |
|---|
| 409 | return (ereg_replace("[^a-z]", $replaceStr, $str)); |
|---|
| 410 | case 'alphaupper' : |
|---|
| 411 | return (ereg_replace("[^A-Z]", $replaceStr, $str)); |
|---|
| 412 | case 'num' : |
|---|
| 413 | return (ereg_replace("[^0-9]", $replaceStr, $str)); |
|---|
| 414 | case 'alphanum' : |
|---|
| 415 | return (ereg_replace("[^0-9a-zA-Z]", $replaceStr, $str)); |
|---|
| 416 | case 'htmlentities' : |
|---|
| 417 | return (ereg_replace("&[[:alnum:]]{0,};", $replaceStr, $str)); |
|---|
| 418 | case 'blank' : |
|---|
| 419 | return (ereg_replace("[[:blank:]]{1,}", $replaceStr, $str)); |
|---|
| 420 | default : |
|---|
| 421 | return $str; |
|---|
| 422 | } |
|---|
| 423 | } |
|---|
| 424 | |
|---|
| 425 | /** |
|---|
| 426 | * Escape special characters |
|---|
| 427 | * |
|---|
| 428 | * @param string $str reference string |
|---|
| 429 | * @param string $conversionType 'html', 'htmlall' ,'url' ,'quotes', 'javascript' 'mail' |
|---|
| 430 | * @access public |
|---|
| 431 | * @return string |
|---|
| 432 | */ |
|---|
| 433 | function escape($str, $conversionType='html') { |
|---|
| 434 | switch ($conversionType) { |
|---|
| 435 | case 'html': |
|---|
| 436 | return htmlspecialchars($str, ENT_QUOTES); |
|---|
| 437 | case 'htmlall' : |
|---|
| 438 | return htmlentities($str, ENT_QUOTES); |
|---|
| 439 | case 'url' : |
|---|
| 440 | return rawurlencode($str); |
|---|
| 441 | case 'quotes' : |
|---|
| 442 | return preg_replace("%(?<!\\\\)'%", "\\'", $str); |
|---|
| 443 | case 'javascript' : |
|---|
| 444 | $expressions = array( |
|---|
| 445 | "/(<scr)(ipt)/i" => "$1\"+\"$2", // quebrar tags "<script" |
|---|
| 446 | '/\\\\/' => '\\\\', // backslashes |
|---|
| 447 | '/\'/' => "\'", // single quotes |
|---|
| 448 | '/"/' => '\\"', // double quotes |
|---|
| 449 | "/\r/"=>'\\r', // caractere CR |
|---|
| 450 | "/\n/"=>'\\n', // caractere LF |
|---|
| 451 | "/\t/" => "\\t" // tabulaￜￜes |
|---|
| 452 | ); |
|---|
| 453 | $str = str_replace("\\", "\\\\", $str); |
|---|
| 454 | $str = preg_replace(array_keys($expressions), array_values($expressions), $str); |
|---|
| 455 | return $str; |
|---|
| 456 | case 'mail' : |
|---|
| 457 | return str_replace(array('@', '.'), array(' at ', ' dot '), $str); |
|---|
| 458 | default : |
|---|
| 459 | return $str; |
|---|
| 460 | } |
|---|
| 461 | } |
|---|
| 462 | |
|---|
| 463 | /** |
|---|
| 464 | * Camelize a string |
|---|
| 465 | * |
|---|
| 466 | * @param string $str |
|---|
| 467 | * @return string camelized string |
|---|
| 468 | * @access public |
|---|
| 469 | */ |
|---|
| 470 | function camelize($str) { |
|---|
| 471 | return preg_replace("/[_|\s]([a-z0-9])/e", "strtoupper('\\1')", strtolower($str)); |
|---|
| 472 | } |
|---|
| 473 | |
|---|
| 474 | /** |
|---|
| 475 | * Capitalize the parameter string |
|---|
| 476 | * @param string $str parameterstring |
|---|
| 477 | * @return string result string |
|---|
| 478 | * @access public |
|---|
| 479 | */ |
|---|
| 480 | function capitalize($str) { |
|---|
| 481 | if (!empty($str)) { |
|---|
| 482 | $w = preg_split("/\s+/", $str); |
|---|
| 483 | for ($i=0, $s=sizeof($w); $i<$s; $i++) { |
|---|
| 484 | if (empty($w[$i])) |
|---|
| 485 | continue; |
|---|
| 486 | $f = strtoupper($w[$i][0]); |
|---|
| 487 | $r = strtolower(substr($w[$i], 1)); |
|---|
| 488 | $w[$i] = $f . $r; |
|---|
| 489 | } |
|---|
| 490 | return implode(' ', $w); |
|---|
| 491 | } |
|---|
| 492 | return $str; |
|---|
| 493 | } |
|---|
| 494 | |
|---|
| 495 | /** |
|---|
| 496 | * Normalize the string |
|---|
| 497 | * @param string $str reference string |
|---|
| 498 | * @return string normalized string |
|---|
| 499 | * @access public |
|---|
| 500 | */ |
|---|
| 501 | function normalize($str) { |
|---|
| 502 | $ts = array("/[ￜ-ￜ]/", "/ￜ/", "/ￜ/", "/[ￜ-ￜ]/", "/[ￜ-ￜ]/", "/ￜ/", "/ￜ/", "/[ￜ-ￜￜ]/", "/ￜ/", "/[ￜ-ￜ]/", "/ￜ/", "/ￜ/", "/[ￜ-ￜ]/", "/ￜ/", "/ￜ/", "/[ￜ-ￜ]/", "/[ￜ-ￜ]/", "/ￜ/", "/ￜ/", "/[ￜ-ￜￜ]/", "/ￜ/", "/[ￜ-ￜ]/", "/[ￜ-ￜ]/"); |
|---|
| 503 | $tn = array("A", "AE", "C", "E", "I", "D", "N", "O", "X", "U", "Y", "ss", "a", "ae", "c", "e", "i", "d", "n", "o", "x", "u", "y"); |
|---|
| 504 | return preg_replace($ts, $tn, $str); |
|---|
| 505 | } |
|---|
| 506 | |
|---|
| 507 | /** |
|---|
| 508 | * Cut before |
|---|
| 509 | * @param string $string |
|---|
| 510 | * @param string $token string to match |
|---|
| 511 | * @param bool |
|---|
| 512 | * @return string |
|---|
| 513 | * @access public |
|---|
| 514 | */ |
|---|
| 515 | function cutBefore($string, $token, $caseSensitive=TRUE) { |
|---|
| 516 | if ($this->match($caseSensitive ? $string : strtolower($string), $token, $caseSensitive)) { |
|---|
| 517 | return stristr($string, $token); |
|---|
| 518 | } |
|---|
| 519 | return $string; |
|---|
| 520 | } |
|---|
| 521 | |
|---|
| 522 | /** |
|---|
| 523 | * Cut last occurrence |
|---|
| 524 | * @param string $string |
|---|
| 525 | * @param string $cutOff |
|---|
| 526 | * @param bool $caseSensitive |
|---|
| 527 | * @param bool |
|---|
| 528 | * @return string |
|---|
| 529 | * @access public |
|---|
| 530 | */ |
|---|
| 531 | function cutLastOcurrence($string, $cutOff, $caseSensitive=TRUE) { |
|---|
| 532 | if (!$this->match($caseSensitive ? $string : strtolower($string), $cutOff, $caseSensitive)) |
|---|
| 533 | return $string; |
|---|
| 534 | else |
|---|
| 535 | return strrev(substr(stristr(strrev($string), strrev($cutOff)),strlen($cutOff))); |
|---|
| 536 | } |
|---|
| 537 | |
|---|
| 538 | /** |
|---|
| 539 | * Ident a string |
|---|
| 540 | * @param string $str string reference |
|---|
| 541 | * @access public |
|---|
| 542 | * @return string |
|---|
| 543 | */ |
|---|
| 544 | function indent($str, $nChars, $iChar=' ') { |
|---|
| 545 | if (!$this->isInteger($nChars) || $nChars < 1) { |
|---|
| 546 | $nChars = 1; |
|---|
| 547 | } |
|---|
| 548 | return preg_replace('!^!m', str_repeat($iChar, $nChars), $str); |
|---|
| 549 | } |
|---|
| 550 | |
|---|
| 551 | /** |
|---|
| 552 | * Truncate ..... |
|---|
| 553 | * @param string $str reference string |
|---|
| 554 | * @param int $lenght |
|---|
| 555 | * @param string $truncSufix truncate sufix |
|---|
| 556 | * @param bool $forcebreak |
|---|
| 557 | * @return string |
|---|
| 558 | * @access public |
|---|
| 559 | */ |
|---|
| 560 | function truncate($str, $length, $truncSufix='...', $forceBreak=TRUE) { |
|---|
| 561 | if (!$this->isInteger($length) || $length < 1) { |
|---|
| 562 | return ''; |
|---|
| 563 | } else { |
|---|
| 564 | if (strlen($str) > $length) { |
|---|
| 565 | $length -= strlen($truncSufix); |
|---|
| 566 | if (!$forceBreak) |
|---|
| 567 | $str = preg_replace('/\s+?(\S+)?$/', '', substr($str, 0, $length+1)); |
|---|
| 568 | return substr($str, 0, $length) . $truncSufix; |
|---|
| 569 | } else { |
|---|
| 570 | return $str; |
|---|
| 571 | } |
|---|
| 572 | } |
|---|
| 573 | } |
|---|
| 574 | |
|---|
| 575 | /** |
|---|
| 576 | * Insert Char in string |
|---|
| 577 | * @param $str reference string |
|---|
| 578 | * @param bool $stringEmpty |
|---|
| 579 | * @param string $char |
|---|
| 580 | * @return string |
|---|
| 581 | * @access public |
|---|
| 582 | */ |
|---|
| 583 | function insertChar($str, $char = ' ', $stripEmpty = TRUE) { |
|---|
| 584 | if ($stripEmpty) { |
|---|
| 585 | $strChars = preg_split('//', $str, -1, PREG_SPLIT_NO_EMPTY); |
|---|
| 586 | } else { |
|---|
| 587 | $strChars = preg_split('//', $str, -1); |
|---|
| 588 | } |
|---|
| 589 | return implode($char, $strChars); |
|---|
| 590 | } |
|---|
| 591 | |
|---|
| 592 | /** |
|---|
| 593 | * Wrap line |
|---|
| 594 | * @param string $str reference string |
|---|
| 595 | * @param int $num num of line to wrap |
|---|
| 596 | * @param string $breakstring |
|---|
| 597 | * @return string |
|---|
| 598 | * @access public |
|---|
| 599 | */ |
|---|
| 600 | function wrapLine($str, $num, $breakString="\n") { |
|---|
| 601 | $line = ''; |
|---|
| 602 | $processed = ''; |
|---|
| 603 | $token = strtok($str, ' '); |
|---|
| 604 | while($token) { |
|---|
| 605 | if (strlen($line) + strlen($token) < ($num + 2)) { |
|---|
| 606 | $line .= " $token"; |
|---|
| 607 | } else { |
|---|
| 608 | $processed .= "$line$breakString"; |
|---|
| 609 | $line = $token; |
|---|
| 610 | } |
|---|
| 611 | $token = strtok(' '); |
|---|
| 612 | } |
|---|
| 613 | $processed .= $line; |
|---|
| 614 | $processed = trim($processed); |
|---|
| 615 | return $processed; |
|---|
| 616 | } |
|---|
| 617 | |
|---|
| 618 | /** |
|---|
| 619 | * Wrap .... |
|---|
| 620 | * |
|---|
| 621 | * @param $str reference string |
|---|
| 622 | * @param string $breakString separator |
|---|
| 623 | * @return string $processed |
|---|
| 624 | * @access public |
|---|
| 625 | */ |
|---|
| 626 | function wrap($str, $num, $breakString="\n") { |
|---|
| 627 | $str = ereg_replace("([^\r\n])\r\n([^\r\n])", "\\1 \\2", $str); |
|---|
| 628 | $str = ereg_replace("[\r\n]*\r\n[\r\n]*", "\r\n\r\n", $str); |
|---|
| 629 | $str = ereg_replace("[ ]* [ ]*", ' ', $str); |
|---|
| 630 | $str = stripslashes($str); |
|---|
| 631 | $processed = ''; |
|---|
| 632 | $paragraphs = explode("\n", $str); |
|---|
| 633 | for ($i=0; $i<sizeof($paragraphs); $i++) { |
|---|
| 634 | $processed .= $this->wrapLine($paragraphs[$i], $num, $breakString) . $breakString; |
|---|
| 635 | } |
|---|
| 636 | $processed = trim($processed); |
|---|
| 637 | return $processed; |
|---|
| 638 | } |
|---|
| 639 | |
|---|
| 640 | /** |
|---|
| 641 | * Add line numbers |
|---|
| 642 | * |
|---|
| 643 | * @param string $str reference string |
|---|
| 644 | * @param string $start character to start |
|---|
| 645 | * @param string $indent indent size |
|---|
| 646 | * @param string $afternumberChar char to place after number |
|---|
| 647 | * @return string $processed result string |
|---|
| 648 | * @access public |
|---|
| 649 | */ |
|---|
| 650 | function addLineNumbers(&$str, $start = 1, $indent = 3, $afterNumberChar = ':', $glue='\n') { |
|---|
| 651 | // divide a string em linhas de um array |
|---|
| 652 | $line = explode("\n", $str); |
|---|
| 653 | $size = sizeof($line); |
|---|
| 654 | // calcula a largura maxima da numeraçao de acordo com o numero de linhas |
|---|
| 655 | $width = strlen((string)($start + $size -1)); |
|---|
| 656 | $indent = max($width, $indent); |
|---|
| 657 | // gera a numeraￜￜo de linhas da string |
|---|
| 658 | for ($i = 0; $i < $size; $i++) { |
|---|
| 659 | $line[$i] = str_pad((string)($i + $start), $indent, ' ', STR_PAD_LEFT) . $afterNumberChar . ' ' . trim($line[$i]); |
|---|
| 660 | } |
|---|
| 661 | return implode($glue, $line); |
|---|
| 662 | } |
|---|
| 663 | |
|---|
| 664 | /** |
|---|
| 665 | * Count Chars |
|---|
| 666 | * @param string $str reference string |
|---|
| 667 | * @param bool $includeSpaces spaces too |
|---|
| 668 | * @return int number of chars |
|---|
| 669 | * @access public |
|---|
| 670 | */ |
|---|
| 671 | function countChars($str, $includeSpaces = FALSE) { |
|---|
| 672 | if ($includeSpaces) { |
|---|
| 673 | return strlen($str); |
|---|
| 674 | } else { |
|---|
| 675 | $match = array(); |
|---|
| 676 | return preg_match_all('/[^\s]/', $str, $match); |
|---|
| 677 | } |
|---|
| 678 | } |
|---|
| 679 | |
|---|
| 680 | /** |
|---|
| 681 | * Count Words in a string |
|---|
| 682 | * @param string $str reference string |
|---|
| 683 | * @return mixed array or string |
|---|
| 684 | * @access public |
|---|
| 685 | */ |
|---|
| 686 | function countWords($str) { |
|---|
| 687 | return str_word_count($str); |
|---|
| 688 | } |
|---|
| 689 | |
|---|
| 690 | /** |
|---|
| 691 | * Count Sentences in a string |
|---|
| 692 | * @param string $str reference string |
|---|
| 693 | * @return mixed number of sentences |
|---|
| 694 | * @access public |
|---|
| 695 | */ |
|---|
| 696 | function countSentences($str) { |
|---|
| 697 | $matches = array(); |
|---|
| 698 | return preg_match_all('/[^\s]\.(?!\w)/', $str, $matches); |
|---|
| 699 | } |
|---|
| 700 | |
|---|
| 701 | /** |
|---|
| 702 | * Count Paragraphs in a string |
|---|
| 703 | * @param string $str reference string |
|---|
| 704 | * @return int number of paragraphs |
|---|
| 705 | * @access public |
|---|
| 706 | */ |
|---|
| 707 | function countParagraphs($str) { |
|---|
| 708 | return count(preg_split('/[\r\n]+/', $str)); |
|---|
| 709 | } |
|---|
| 710 | |
|---|
| 711 | /** |
|---|
| 712 | * Create a random string |
|---|
| 713 | * |
|---|
| 714 | * @param mixed $size size of the string |
|---|
| 715 | * @param bool $upper upper case permitted |
|---|
| 716 | * @param bool $digit digits included |
|---|
| 717 | * @return string result string |
|---|
| 718 | * @access public |
|---|
| 719 | */ |
|---|
| 720 | function randomString($size, $upper=TRUE, $digit=TRUE) { |
|---|
| 721 | $pSize = max(1, $size); |
|---|
| 722 | $start = $digit ? 48 : 65; |
|---|
| 723 | $end = 122; |
|---|
| 724 | $result = ''; |
|---|
| 725 | while (strlen($result) < $size) { |
|---|
| 726 | $random = $this->randomize($start, $end); |
|---|
| 727 | if (($digit && $random >= 48 && $random <= 57) || |
|---|
| 728 | ($upper && $random >= 65 && $random <= 90) || |
|---|
| 729 | ($random >= 97 && $random <= 122)) { |
|---|
| 730 | $result .= chr($random); |
|---|
| 731 | } |
|---|
| 732 | } |
|---|
| 733 | return $result; |
|---|
| 734 | } |
|---|
| 735 | } |
|---|
| 736 | ?> |
|---|
