1: <?php
2:
3: 4: 5: 6: 7: 8: 9: 10:
11:
12: namespace Nette\Utils;
13:
14: use Nette;
15:
16:
17:
18: 19: 20: 21: 22:
23: class Strings
24: {
25:
26: 27: 28:
29: final public function __construct()
30: {
31: throw new Nette\StaticClassException;
32: }
33:
34:
35:
36: 37: 38: 39: 40: 41:
42: public static function checkEncoding($s, $encoding = 'UTF-8')
43: {
44: return $s === self::fixEncoding($s, $encoding);
45: }
46:
47:
48:
49: 50: 51: 52: 53: 54:
55: public static function fixEncoding($s, $encoding = 'UTF-8')
56: {
57:
58: $s = @iconv('UTF-16', $encoding . '//IGNORE', iconv($encoding, 'UTF-16//IGNORE', $s));
59: return str_replace("\xEF\xBB\xBF", '', $s);
60: }
61:
62:
63:
64: 65: 66: 67: 68: 69:
70: public static function chr($code, $encoding = 'UTF-8')
71: {
72: return iconv('UTF-32BE', $encoding . '//IGNORE', pack('N', $code));
73: }
74:
75:
76:
77: 78: 79: 80: 81: 82:
83: public static function startsWith($haystack, $needle)
84: {
85: return strncmp($haystack, $needle, strlen($needle)) === 0;
86: }
87:
88:
89:
90: 91: 92: 93: 94: 95:
96: public static function endsWith($haystack, $needle)
97: {
98: return strlen($needle) === 0 || substr($haystack, -strlen($needle)) === $needle;
99: }
100:
101:
102:
103: 104: 105: 106: 107: 108:
109: public static function contains($haystack, $needle)
110: {
111: return strpos($haystack, $needle) !== FALSE;
112: }
113:
114:
115:
116: 117: 118: 119: 120: 121: 122:
123: public static function substring($s, $start, $length = NULL)
124: {
125: if ($length === NULL) {
126: $length = self::length($s);
127: }
128: return function_exists('mb_substr') ? mb_substr($s, $start, $length, 'UTF-8') : iconv_substr($s, $start, $length, 'UTF-8');
129: }
130:
131:
132:
133: 134: 135: 136: 137:
138: public static function normalize($s)
139: {
140:
141: $s = str_replace("\r\n", "\n", $s);
142: $s = strtr($s, "\r", "\n");
143:
144:
145: $s = preg_replace('#[\x00-\x08\x0B-\x1F\x7F]+#', '', $s);
146:
147:
148: $s = preg_replace("#[\t ]+$#m", '', $s);
149:
150:
151: $s = trim($s, "\n");
152:
153: return $s;
154: }
155:
156:
157:
158: 159: 160: 161: 162:
163: public static function toAscii($s)
164: {
165: $s = preg_replace('#[^\x09\x0A\x0D\x20-\x7E\xA0-\x{10FFFF}]#u', '', $s);
166: $s = strtr($s, '`\'"^~', "\x01\x02\x03\x04\x05");
167: if (ICONV_IMPL === 'glibc') {
168: $s = @iconv('UTF-8', 'WINDOWS-1250//TRANSLIT', $s);
169: $s = strtr($s, "\xa5\xa3\xbc\x8c\xa7\x8a\xaa\x8d\x8f\x8e\xaf\xb9\xb3\xbe\x9c\x9a\xba\x9d\x9f\x9e"
170: . "\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3"
171: . "\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8"
172: . "\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf8\xf9\xfa\xfb\xfc\xfd\xfe",
173: "ALLSSSSTZZZallssstzzzRAAAALCCCEEEEIIDDNNOOOOxRUUUUYTsraaaalccceeeeiiddnnooooruuuuyt");
174: } else {
175: $s = @iconv('UTF-8', 'ASCII//TRANSLIT', $s);
176: }
177: $s = str_replace(array('`', "'", '"', '^', '~'), '', $s);
178: return strtr($s, "\x01\x02\x03\x04\x05", '`\'"^~');
179: }
180:
181:
182:
183: 184: 185: 186: 187: 188: 189:
190: public static function webalize($s, $charlist = NULL, $lower = TRUE)
191: {
192: $s = self::toAscii($s);
193: if ($lower) {
194: $s = strtolower($s);
195: }
196: $s = preg_replace('#[^a-z0-9' . preg_quote($charlist, '#') . ']+#i', '-', $s);
197: $s = trim($s, '-');
198: return $s;
199: }
200:
201:
202:
203: 204: 205: 206: 207: 208: 209:
210: public static function truncate($s, $maxLen, $append = "\xE2\x80\xA6")
211: {
212: if (self::length($s) > $maxLen) {
213: $maxLen = $maxLen - self::length($append);
214: if ($maxLen < 1) {
215: return $append;
216:
217: } elseif ($matches = self::match($s, '#^.{1,'.$maxLen.'}(?=[\s\x00-/:-@\[-`{-~])#us')) {
218: return $matches[0] . $append;
219:
220: } else {
221: return self::substring($s, 0, $maxLen) . $append;
222: }
223: }
224: return $s;
225: }
226:
227:
228:
229: 230: 231: 232: 233: 234: 235:
236: public static function indent($s, $level = 1, $chars = "\t")
237: {
238: return $level < 1 ? $s : self::replace($s, '#(?:^|[\r\n]+)(?=[^\r\n])#', '$0' . str_repeat($chars, $level));
239: }
240:
241:
242:
243: 244: 245: 246: 247:
248: public static function lower($s)
249: {
250: return mb_strtolower($s, 'UTF-8');
251: }
252:
253:
254:
255: 256: 257: 258: 259:
260: public static function upper($s)
261: {
262: return mb_strtoupper($s, 'UTF-8');
263: }
264:
265:
266:
267: 268: 269: 270: 271:
272: public static function firstUpper($s)
273: {
274: return self::upper(self::substring($s, 0, 1)) . self::substring($s, 1);
275: }
276:
277:
278:
279: 280: 281: 282: 283:
284: public static function capitalize($s)
285: {
286: return mb_convert_case($s, MB_CASE_TITLE, 'UTF-8');
287: }
288:
289:
290:
291: 292: 293: 294: 295: 296: 297:
298: public static function compare($left, $right, $len = NULL)
299: {
300: if ($len < 0) {
301: $left = self::substring($left, $len, -$len);
302: $right = self::substring($right, $len, -$len);
303: } elseif ($len !== NULL) {
304: $left = self::substring($left, 0, $len);
305: $right = self::substring($right, 0, $len);
306: }
307: return self::lower($left) === self::lower($right);
308: }
309:
310:
311:
312: 313: 314: 315: 316:
317: public static function length($s)
318: {
319: return strlen(utf8_decode($s));
320: }
321:
322:
323:
324: 325: 326: 327: 328: 329:
330: public static function trim($s, $charlist = " \t\n\r\0\x0B\xC2\xA0")
331: {
332: $charlist = preg_quote($charlist, '#');
333: return self::replace($s, '#^['.$charlist.']+|['.$charlist.']+$#u', '');
334: }
335:
336:
337:
338: 339: 340: 341: 342: 343: 344:
345: public static function padLeft($s, $length, $pad = ' ')
346: {
347: $length = max(0, $length - self::length($s));
348: $padLen = self::length($pad);
349: return str_repeat($pad, $length / $padLen) . self::substring($pad, 0, $length % $padLen) . $s;
350: }
351:
352:
353:
354: 355: 356: 357: 358: 359: 360:
361: public static function padRight($s, $length, $pad = ' ')
362: {
363: $length = max(0, $length - self::length($s));
364: $padLen = self::length($pad);
365: return $s . str_repeat($pad, $length / $padLen) . self::substring($pad, 0, $length % $padLen);
366: }
367:
368:
369:
370: 371: 372: 373: 374:
375: public static function reverse($s)
376: {
377: return @iconv('UTF-32LE', 'UTF-8', strrev(@iconv('UTF-8', 'UTF-32BE', $s)));
378: }
379:
380:
381:
382: 383: 384: 385: 386: 387:
388: public static function random($length = 10, $charlist = '0-9a-z')
389: {
390: $charlist = str_shuffle(preg_replace_callback('#.-.#', function($m) {
391: return implode('', range($m[0][0], $m[0][2]));
392: }, $charlist));
393: $chLen = strlen($charlist);
394:
395: $s = '';
396: for ($i = 0; $i < $length; $i++) {
397: if ($i % 5 === 0) {
398: $rand = lcg_value();
399: $rand2 = microtime(TRUE);
400: }
401: $rand *= $chLen;
402: $s .= $charlist[($rand + $rand2) % $chLen];
403: $rand -= (int) $rand;
404: }
405: return $s;
406: }
407:
408:
409:
410: 411: 412: 413: 414: 415: 416:
417: public static function split($subject, $pattern, $flags = 0)
418: {
419: Nette\Diagnostics\Debugger::tryError();
420: $res = preg_split($pattern, $subject, -1, $flags | PREG_SPLIT_DELIM_CAPTURE);
421: self::catchPregError($pattern);
422: return $res;
423: }
424:
425:
426:
427: 428: 429: 430: 431: 432: 433: 434:
435: public static function match($subject, $pattern, $flags = 0, $offset = 0)
436: {
437: if ($offset > strlen($subject)) {
438: return NULL;
439: }
440: Nette\Diagnostics\Debugger::tryError();
441: $res = preg_match($pattern, $subject, $m, $flags, $offset);
442: self::catchPregError($pattern);
443: if ($res) {
444: return $m;
445: }
446: }
447:
448:
449:
450: 451: 452: 453: 454: 455: 456: 457:
458: public static function matchAll($subject, $pattern, $flags = 0, $offset = 0)
459: {
460: if ($offset > strlen($subject)) {
461: return array();
462: }
463: Nette\Diagnostics\Debugger::tryError();
464: $res = preg_match_all(
465: $pattern, $subject, $m,
466: ($flags & PREG_PATTERN_ORDER) ? $flags : ($flags | PREG_SET_ORDER),
467: $offset
468: );
469: self::catchPregError($pattern);
470: return $m;
471: }
472:
473:
474:
475: 476: 477: 478: 479: 480: 481: 482:
483: public static function replace($subject, $pattern, $replacement = NULL, $limit = -1)
484: {
485: Nette\Diagnostics\Debugger::tryError();
486: if (is_object($replacement) || is_array($replacement)) {
487: if ($replacement instanceof Nette\Callback) {
488: $replacement = $replacement->getNative();
489: }
490: if (!is_callable($replacement, FALSE, $textual)) {
491: Nette\Diagnostics\Debugger::catchError($foo);
492: throw new Nette\InvalidStateException("Callback '$textual' is not callable.");
493: }
494: $res = preg_replace_callback($pattern, $replacement, $subject, $limit);
495:
496: if (Nette\Diagnostics\Debugger::catchError($e)) {
497: $trace = $e->getTrace();
498: if (isset($trace[2]['class']) && $trace[2]['class'] === __CLASS__) {
499: throw new RegexpException($e->getMessage() . " in pattern: $pattern");
500: }
501: }
502:
503: } elseif (is_array($pattern)) {
504: $res = preg_replace(array_keys($pattern), array_values($pattern), $subject, $limit);
505:
506: } else {
507: $res = preg_replace($pattern, $replacement, $subject, $limit);
508: }
509: self::catchPregError($pattern);
510: return $res;
511: }
512:
513:
514:
515:
516: public static function catchPregError($pattern)
517: {
518: if (Nette\Diagnostics\Debugger::catchError($e)) {
519: throw new RegexpException($e->getMessage() . " in pattern: $pattern");
520:
521: } elseif (preg_last_error()) {
522: static $messages = array(
523: PREG_INTERNAL_ERROR => 'Internal error',
524: PREG_BACKTRACK_LIMIT_ERROR => 'Backtrack limit was exhausted',
525: PREG_RECURSION_LIMIT_ERROR => 'Recursion limit was exhausted',
526: PREG_BAD_UTF8_ERROR => 'Malformed UTF-8 data',
527: 5 => 'Offset didn\'t correspond to the begin of a valid UTF-8 code point',
528: );
529: $code = preg_last_error();
530: throw new RegexpException((isset($messages[$code]) ? $messages[$code] : 'Unknown error') . " (pattern: $pattern)", $code);
531: }
532: }
533:
534: }
535:
536:
537:
538: 539: 540:
541: class RegexpException extends \Exception
542: {
543: }
544: