source: Dev/branches/cakephp/cake/libs/string.php @ 126

Last change on this file since 126 was 126, checked in by fpvanagthoven, 14 years ago

Cakephp branch.

File size: 8.9 KB
RevLine 
[126]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-2011, 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-2011, 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 */
28class 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}
Note: See TracBrowser for help on using the repository browser.