1 |
<?php |
2 |
/** |
3 |
* Spyc -- A Simple PHP YAML Class |
4 |
* @version 0.5 |
5 |
* @author Vlad Andersen <vlad.andersen@gmail.com> |
6 |
* @author Chris Wanstrath <chris@ozmm.org> |
7 |
* @link http://code.google.com/p/spyc/ |
8 |
* @copyright Copyright 2005-2006 Chris Wanstrath, 2006-2011 Vlad Andersen |
9 |
* @license http://www.opensource.org/licenses/mit-license.php MIT License |
10 |
* @package Spyc |
11 |
*/ |
12 |
|
13 |
if (!function_exists('spyc_load')) { |
14 |
/** |
15 |
* Parses YAML to array. |
16 |
* @param string $string YAML string. |
17 |
* @return array |
18 |
*/ |
19 |
function spyc_load ($string) { |
20 |
return Spyc::YAMLLoadString($string); |
21 |
} |
22 |
} |
23 |
|
24 |
if (!function_exists('spyc_load_file')) { |
25 |
/** |
26 |
* Parses YAML to array. |
27 |
* @param string $file Path to YAML file. |
28 |
* @return array |
29 |
*/ |
30 |
function spyc_load_file ($file) { |
31 |
return Spyc::YAMLLoad($file); |
32 |
} |
33 |
} |
34 |
|
35 |
/** |
36 |
* The Simple PHP YAML Class. |
37 |
* |
38 |
* This class can be used to read a YAML file and convert its contents |
39 |
* into a PHP array. It currently supports a very limited subsection of |
40 |
* the YAML spec. |
41 |
* |
42 |
* Usage: |
43 |
* <code> |
44 |
* $Spyc = new Spyc; |
45 |
* $array = $Spyc->load($file); |
46 |
* </code> |
47 |
* or: |
48 |
* <code> |
49 |
* $array = Spyc::YAMLLoad($file); |
50 |
* </code> |
51 |
* or: |
52 |
* <code> |
53 |
* $array = spyc_load_file($file); |
54 |
* </code> |
55 |
* @package Spyc |
56 |
*/ |
57 |
class Spyc { |
58 |
|
59 |
// SETTINGS |
60 |
|
61 |
const REMPTY = "\0\0\0\0\0"; |
62 |
|
63 |
/** |
64 |
* Setting this to true will force YAMLDump to enclose any string value in |
65 |
* quotes. False by default. |
66 |
* |
67 |
* @var bool |
68 |
*/ |
69 |
public $setting_dump_force_quotes = false; |
70 |
|
71 |
/** |
72 |
* Setting this to true will forse YAMLLoad to use syck_load function when |
73 |
* possible. False by default. |
74 |
* @var bool |
75 |
*/ |
76 |
public $setting_use_syck_is_possible = false; |
77 |
|
78 |
|
79 |
|
80 |
/**#@+ |
81 |
* @access private |
82 |
* @var mixed |
83 |
*/ |
84 |
private $_dumpIndent; |
85 |
private $_dumpWordWrap; |
86 |
private $_containsGroupAnchor = false; |
87 |
private $_containsGroupAlias = false; |
88 |
private $path; |
89 |
private $result; |
90 |
private $LiteralPlaceHolder = '___YAML_Literal_Block___'; |
91 |
private $SavedGroups = array(); |
92 |
private $indent; |
93 |
/** |
94 |
* Path modifier that should be applied after adding current element. |
95 |
* @var array |
96 |
*/ |
97 |
private $delayedPath = array(); |
98 |
|
99 |
/**#@+ |
100 |
* @access public |
101 |
* @var mixed |
102 |
*/ |
103 |
public $_nodeId; |
104 |
|
105 |
/** |
106 |
* Load a valid YAML string to Spyc. |
107 |
* @param string $input |
108 |
* @return array |
109 |
*/ |
110 |
public function load ($input) { |
111 |
return $this->__loadString($input); |
112 |
} |
113 |
|
114 |
/** |
115 |
* Load a valid YAML file to Spyc. |
116 |
* @param string $file |
117 |
* @return array |
118 |
*/ |
119 |
public function loadFile ($file) { |
120 |
return $this->__load($file); |
121 |
} |
122 |
|
123 |
/** |
124 |
* Load YAML into a PHP array statically |
125 |
* |
126 |
* The load method, when supplied with a YAML stream (string or file), |
127 |
* will do its best to convert YAML in a file into a PHP array. Pretty |
128 |
* simple. |
129 |
* Usage: |
130 |
* <code> |
131 |
* $array = Spyc::YAMLLoad('lucky.yaml'); |
132 |
* print_r($array); |
133 |
* </code> |
134 |
* @access public |
135 |
* @return array |
136 |
* @param string $input Path of YAML file or string containing YAML |
137 |
*/ |
138 |
public static function YAMLLoad($input) { |
139 |
$Spyc = new Spyc; |
140 |
return $Spyc->__load($input); |
141 |
} |
142 |
|
143 |
/** |
144 |
* Load a string of YAML into a PHP array statically |
145 |
* |
146 |
* The load method, when supplied with a YAML string, will do its best |
147 |
* to convert YAML in a string into a PHP array. Pretty simple. |
148 |
* |
149 |
* Note: use this function if you don't want files from the file system |
150 |
* loaded and processed as YAML. This is of interest to people concerned |
151 |
* about security whose input is from a string. |
152 |
* |
153 |
* Usage: |
154 |
* <code> |
155 |
* $array = Spyc::YAMLLoadString("---\n0: hello world\n"); |
156 |
* print_r($array); |
157 |
* </code> |
158 |
* @access public |
159 |
* @return array |
160 |
* @param string $input String containing YAML |
161 |
*/ |
162 |
public static function YAMLLoadString($input) { |
163 |
$Spyc = new Spyc; |
164 |
return $Spyc->__loadString($input); |
165 |
} |
166 |
|
167 |
/** |
168 |
* Dump YAML from PHP array statically |
169 |
* |
170 |
* The dump method, when supplied with an array, will do its best |
171 |
* to convert the array into friendly YAML. Pretty simple. Feel free to |
172 |
* save the returned string as nothing.yaml and pass it around. |
173 |
* |
174 |
* Oh, and you can decide how big the indent is and what the wordwrap |
175 |
* for folding is. Pretty cool -- just pass in 'false' for either if |
176 |
* you want to use the default. |
177 |
* |
178 |
* Indent's default is 2 spaces, wordwrap's default is 40 characters. And |
179 |
* you can turn off wordwrap by passing in 0. |
180 |
* |
181 |
* @access public |
182 |
* @return string |
183 |
* @param array $array PHP array |
184 |
* @param int $indent Pass in false to use the default, which is 2 |
185 |
* @param int $wordwrap Pass in 0 for no wordwrap, false for default (40) |
186 |
*/ |
187 |
public static function YAMLDump($array,$indent = false,$wordwrap = false) { |
188 |
$spyc = new Spyc; |
189 |
return $spyc->dump($array,$indent,$wordwrap); |
190 |
} |
191 |
|
192 |
|
193 |
/** |
194 |
* Dump PHP array to YAML |
195 |
* |
196 |
* The dump method, when supplied with an array, will do its best |
197 |
* to convert the array into friendly YAML. Pretty simple. Feel free to |
198 |
* save the returned string as tasteful.yaml and pass it around. |
199 |
* |
200 |
* Oh, and you can decide how big the indent is and what the wordwrap |
201 |
* for folding is. Pretty cool -- just pass in 'false' for either if |
202 |
* you want to use the default. |
203 |
* |
204 |
* Indent's default is 2 spaces, wordwrap's default is 40 characters. And |
205 |
* you can turn off wordwrap by passing in 0. |
206 |
* |
207 |
* @access public |
208 |
* @return string |
209 |
* @param array $array PHP array |
210 |
* @param int $indent Pass in false to use the default, which is 2 |
211 |
* @param int $wordwrap Pass in 0 for no wordwrap, false for default (40) |
212 |
*/ |
213 |
public function dump($array,$indent = false,$wordwrap = false) { |
214 |
// Dumps to some very clean YAML. We'll have to add some more features |
215 |
// and options soon. And better support for folding. |
216 |
|
217 |
// New features and options. |
218 |
if ($indent === false or !is_numeric($indent)) { |
219 |
$this->_dumpIndent = 2; |
220 |
} else { |
221 |
$this->_dumpIndent = $indent; |
222 |
} |
223 |
|
224 |
if ($wordwrap === false or !is_numeric($wordwrap)) { |
225 |
$this->_dumpWordWrap = 40; |
226 |
} else { |
227 |
$this->_dumpWordWrap = $wordwrap; |
228 |
} |
229 |
|
230 |
// New YAML document |
231 |
$string = "---\n"; |
232 |
|
233 |
// Start at the base of the array and move through it. |
234 |
if ($array) { |
235 |
$array = (array)$array; |
236 |
$previous_key = -1; |
237 |
foreach ($array as $key => $value) { |
238 |
if (!isset($first_key)) $first_key = $key; |
239 |
$string .= $this->_yamlize($key,$value,0,$previous_key, $first_key, $array); |
240 |
$previous_key = $key; |
241 |
} |
242 |
} |
243 |
return $string; |
244 |
} |
245 |
|
246 |
/** |
247 |
* Attempts to convert a key / value array item to YAML |
248 |
* @access private |
249 |
* @return string |
250 |
* @param $key The name of the key |
251 |
* @param $value The value of the item |
252 |
* @param $indent The indent of the current node |
253 |
*/ |
254 |
private function _yamlize($key,$value,$indent, $previous_key = -1, $first_key = 0, $source_array = null) { |
255 |
if (is_array($value)) { |
256 |
if (empty ($value)) |
257 |
return $this->_dumpNode($key, array(), $indent, $previous_key, $first_key, $source_array); |
258 |
// It has children. What to do? |
259 |
// Make it the right kind of item |
260 |
$string = $this->_dumpNode($key, self::REMPTY, $indent, $previous_key, $first_key, $source_array); |
261 |
// Add the indent |
262 |
$indent += $this->_dumpIndent; |
263 |
// Yamlize the array |
264 |
$string .= $this->_yamlizeArray($value,$indent); |
265 |
} elseif (!is_array($value)) { |
266 |
// It doesn't have children. Yip. |
267 |
$string = $this->_dumpNode($key, $value, $indent, $previous_key, $first_key, $source_array); |
268 |
} |
269 |
return $string; |
270 |
} |
271 |
|
272 |
/** |
273 |
* Attempts to convert an array to YAML |
274 |
* @access private |
275 |
* @return string |
276 |
* @param $array The array you want to convert |
277 |
* @param $indent The indent of the current level |
278 |
*/ |
279 |
private function _yamlizeArray($array,$indent) { |
280 |
if (is_array($array)) { |
281 |
$string = ''; |
282 |
$previous_key = -1; |
283 |
foreach ($array as $key => $value) { |
284 |
if (!isset($first_key)) $first_key = $key; |
285 |
$string .= $this->_yamlize($key, $value, $indent, $previous_key, $first_key, $array); |
286 |
$previous_key = $key; |
287 |
} |
288 |
return $string; |
289 |
} else { |
290 |
return false; |
291 |
} |
292 |
} |
293 |
|
294 |
/** |
295 |
* Returns YAML from a key and a value |
296 |
* @access private |
297 |
* @return string |
298 |
* @param $key The name of the key |
299 |
* @param $value The value of the item |
300 |
* @param $indent The indent of the current node |
301 |
*/ |
302 |
private function _dumpNode($key, $value, $indent, $previous_key = -1, $first_key = 0, $source_array = null) { |
303 |
// do some folding here, for blocks |
304 |
if (is_string ($value) && ((strpos($value,"\n") !== false || strpos($value,": ") !== false || strpos($value,"- ") !== false || |
305 |
strpos($value,"*") !== false || strpos($value,"#") !== false || strpos($value,"<") !== false || strpos($value,">") !== false || strpos ($value, ' ') !== false || |
306 |
strpos($value,"[") !== false || strpos($value,"]") !== false || strpos($value,"{") !== false || strpos($value,"}") !== false) || strpos($value,"&") !== false || strpos($value, "'") !== false || strpos($value, "!") === 0 || |
307 |
substr ($value, -1, 1) == ':') |
308 |
) { |
309 |
$value = $this->_doLiteralBlock($value,$indent); |
310 |
} else { |
311 |
$value = $this->_doFolding($value,$indent); |
312 |
} |
313 |
|
314 |
if ($value === array()) $value = '[ ]'; |
315 |
if (in_array ($value, array ('true', 'TRUE', 'false', 'FALSE', 'y', 'Y', 'n', 'N', 'null', 'NULL'), true)) { |
316 |
$value = $this->_doLiteralBlock($value,$indent); |
317 |
} |
318 |
if (trim ($value) != $value) |
319 |
$value = $this->_doLiteralBlock($value,$indent); |
320 |
|
321 |
if (is_bool($value)) { |
322 |
$value = ($value) ? "true" : "false"; |
323 |
} |
324 |
|
325 |
if ($value === null) $value = 'null'; |
326 |
if ($value === "'" . self::REMPTY . "'") $value = null; |
327 |
|
328 |
$spaces = str_repeat(' ',$indent); |
329 |
|
330 |
//if (is_int($key) && $key - 1 == $previous_key && $first_key===0) { |
331 |
if (is_array ($source_array) && array_keys($source_array) === range(0, count($source_array) - 1)) { |
332 |
// It's a sequence |
333 |
$string = $spaces.'- '.$value."\n"; |
334 |
} else { |
335 |
// if ($first_key===0) throw new Exception('Keys are all screwy. The first one was zero, now it\'s "'. $key .'"'); |
336 |
// It's mapped |
337 |
if (strpos($key, ":") !== false || strpos($key, "#") !== false) { $key = '"' . $key . '"'; } |
338 |
$string = rtrim ($spaces.$key.': '.$value)."\n"; |
339 |
} |
340 |
return $string; |
341 |
} |
342 |
|
343 |
/** |
344 |
* Creates a literal block for dumping |
345 |
* @access private |
346 |
* @return string |
347 |
* @param $value |
348 |
* @param $indent int The value of the indent |
349 |
*/ |
350 |
private function _doLiteralBlock($value,$indent) { |
351 |
if ($value === "\n") return '\n'; |
352 |
if (strpos($value, "\n") === false && strpos($value, "'") === false) { |
353 |
return sprintf ("'%s'", $value); |
354 |
} |
355 |
if (strpos($value, "\n") === false && strpos($value, '"') === false) { |
356 |
return sprintf ('"%s"', $value); |
357 |
} |
358 |
$exploded = explode("\n",$value); |
359 |
$newValue = '|'; |
360 |
$indent += $this->_dumpIndent; |
361 |
$spaces = str_repeat(' ',$indent); |
362 |
foreach ($exploded as $line) { |
363 |
$newValue .= "\n" . $spaces . ($line); |
364 |
} |
365 |
return $newValue; |
366 |
} |
367 |
|
368 |
/** |
369 |
* Folds a string of text, if necessary |
370 |
* @access private |
371 |
* @return string |
372 |
* @param $value The string you wish to fold |
373 |
*/ |
374 |
private function _doFolding($value,$indent) { |
375 |
// Don't do anything if wordwrap is set to 0 |
376 |
|
377 |
if ($this->_dumpWordWrap !== 0 && is_string ($value) && strlen($value) > $this->_dumpWordWrap) { |
378 |
$indent += $this->_dumpIndent; |
379 |
$indent = str_repeat(' ',$indent); |
380 |
$wrapped = wordwrap($value,$this->_dumpWordWrap,"\n$indent"); |
381 |
$value = ">\n".$indent.$wrapped; |
382 |
} else { |
383 |
if ($this->setting_dump_force_quotes && is_string ($value) && $value !== self::REMPTY) |
384 |
$value = '"' . $value . '"'; |
385 |
} |
386 |
|
387 |
|
388 |
return $value; |
389 |
} |
390 |
|
391 |
// LOADING FUNCTIONS |
392 |
|
393 |
private function __load($input) { |
394 |
$Source = $this->loadFromSource($input); |
395 |
return $this->loadWithSource($Source); |
396 |
} |
397 |
|
398 |
private function __loadString($input) { |
399 |
$Source = $this->loadFromString($input); |
400 |
return $this->loadWithSource($Source); |
401 |
} |
402 |
|
403 |
private function loadWithSource($Source) { |
404 |
if (empty ($Source)) return array(); |
405 |
if ($this->setting_use_syck_is_possible && function_exists ('syck_load')) { |
406 |
$array = syck_load (implode ('', $Source)); |
407 |
return is_array($array) ? $array : array(); |
408 |
} |
409 |
|
410 |
$this->path = array(); |
411 |
$this->result = array(); |
412 |
|
413 |
$cnt = count($Source); |
414 |
for ($i = 0; $i < $cnt; $i++) { |
415 |
$line = $Source[$i]; |
416 |
|
417 |
$this->indent = strlen($line) - strlen(ltrim($line)); |
418 |
$tempPath = $this->getParentPathByIndent($this->indent); |
419 |
$line = self::stripIndent($line, $this->indent); |
420 |
if (self::isComment($line)) continue; |
421 |
if (self::isEmpty($line)) continue; |
422 |
$this->path = $tempPath; |
423 |
|
424 |
$literalBlockStyle = self::startsLiteralBlock($line); |
425 |
if ($literalBlockStyle) { |
426 |
$line = rtrim ($line, $literalBlockStyle . " \n"); |
427 |
$literalBlock = ''; |
428 |
$line .= $this->LiteralPlaceHolder; |
429 |
$literal_block_indent = strlen($Source[$i+1]) - strlen(ltrim($Source[$i+1])); |
430 |
while (++$i < $cnt && $this->literalBlockContinues($Source[$i], $this->indent)) { |
431 |
$literalBlock = $this->addLiteralLine($literalBlock, $Source[$i], $literalBlockStyle, $literal_block_indent); |
432 |
} |
433 |
$i--; |
434 |
} |
435 |
|
436 |
while (++$i < $cnt && self::greedilyNeedNextLine($line)) { |
437 |
$line = rtrim ($line, " \n\t\r") . ' ' . ltrim ($Source[$i], " \t"); |
438 |
} |
439 |
$i--; |
440 |
|
441 |
|
442 |
|
443 |
if (strpos ($line, '#')) { |
444 |
if (strpos ($line, '"') === false && strpos ($line, "'") === false) |
445 |
$line = preg_replace('/\s+#(.+)$/','',$line); |
446 |
} |
447 |
|
448 |
$lineArray = $this->_parseLine($line); |
449 |
|
450 |
if ($literalBlockStyle) |
451 |
$lineArray = $this->revertLiteralPlaceHolder ($lineArray, $literalBlock); |
452 |
|
453 |
$this->addArray($lineArray, $this->indent); |
454 |
|
455 |
foreach ($this->delayedPath as $indent => $delayedPath) |
456 |
$this->path[$indent] = $delayedPath; |
457 |
|
458 |
$this->delayedPath = array(); |
459 |
|
460 |
} |
461 |
return $this->result; |
462 |
} |
463 |
|
464 |
private function loadFromSource ($input) { |
465 |
if (!empty($input) && strpos($input, "\n") === false && file_exists($input)) |
466 |
return file($input); |
467 |
|
468 |
return $this->loadFromString($input); |
469 |
} |
470 |
|
471 |
private function loadFromString ($input) { |
472 |
$lines = explode("\n",$input); |
473 |
foreach ($lines as $k => $_) { |
474 |
$lines[$k] = rtrim ($_, "\r"); |
475 |
} |
476 |
return $lines; |
477 |
} |
478 |
|
479 |
/** |
480 |
* Parses YAML code and returns an array for a node |
481 |
* @access private |
482 |
* @return array |
483 |
* @param string $line A line from the YAML file |
484 |
*/ |
485 |
private function _parseLine($line) { |
486 |
if (!$line) return array(); |
487 |
$line = trim($line); |
488 |
if (!$line) return array(); |
489 |
|
490 |
$array = array(); |
491 |
|
492 |
$group = $this->nodeContainsGroup($line); |
493 |
if ($group) { |
494 |
$this->addGroup($line, $group); |
495 |
$line = $this->stripGroup ($line, $group); |
496 |
} |
497 |
|
498 |
if ($this->startsMappedSequence($line)) |
499 |
return $this->returnMappedSequence($line); |
500 |
|
501 |
if ($this->startsMappedValue($line)) |
502 |
return $this->returnMappedValue($line); |
503 |
|
504 |
if ($this->isArrayElement($line)) |
505 |
return $this->returnArrayElement($line); |
506 |
|
507 |
if ($this->isPlainArray($line)) |
508 |
return $this->returnPlainArray($line); |
509 |
|
510 |
|
511 |
return $this->returnKeyValuePair($line); |
512 |
|
513 |
} |
514 |
|
515 |
/** |
516 |
* Finds the type of the passed value, returns the value as the new type. |
517 |
* @access private |
518 |
* @param string $value |
519 |
* @return mixed |
520 |
*/ |
521 |
private function _toType($value) { |
522 |
if ($value === '') return null; |
523 |
$first_character = $value[0]; |
524 |
$last_character = substr($value, -1, 1); |
525 |
|
526 |
$is_quoted = false; |
527 |
do { |
528 |
if (!$value) break; |
529 |
if ($first_character != '"' && $first_character != "'") break; |
530 |
if ($last_character != '"' && $last_character != "'") break; |
531 |
$is_quoted = true; |
532 |
} while (0); |
533 |
|
534 |
if ($is_quoted) |
535 |
return strtr(substr ($value, 1, -1), array ('\\"' => '"', '\'\'' => '\'', '\\\'' => '\'')); |
536 |
|
537 |
if (strpos($value, ' #') !== false && !$is_quoted) |
538 |
$value = preg_replace('/\s+#(.+)$/','',$value); |
539 |
|
540 |
if (!$is_quoted) $value = str_replace('\n', "\n", $value); |
541 |
|
542 |
if ($first_character == '[' && $last_character == ']') { |
543 |
// Take out strings sequences and mappings |
544 |
$innerValue = trim(substr ($value, 1, -1)); |
545 |
if ($innerValue === '') return array(); |
546 |
$explode = $this->_inlineEscape($innerValue); |
547 |
// Propagate value array |
548 |
$value = array(); |
549 |
foreach ($explode as $v) { |
550 |
$value[] = $this->_toType($v); |
551 |
} |
552 |
return $value; |
553 |
} |
554 |
|
555 |
if (strpos($value,': ')!==false && $first_character != '{') { |
556 |
$array = explode(': ',$value); |
557 |
$key = trim($array[0]); |
558 |
array_shift($array); |
559 |
$value = trim(implode(': ',$array)); |
560 |
$value = $this->_toType($value); |
561 |
return array($key => $value); |
562 |
} |
563 |
|
564 |
if ($first_character == '{' && $last_character == '}') { |
565 |
$innerValue = trim(substr ($value, 1, -1)); |
566 |
if ($innerValue === '') return array(); |
567 |
// Inline Mapping |
568 |
// Take out strings sequences and mappings |
569 |
$explode = $this->_inlineEscape($innerValue); |
570 |
// Propagate value array |
571 |
$array = array(); |
572 |
foreach ($explode as $v) { |
573 |
$SubArr = $this->_toType($v); |
574 |
if (empty($SubArr)) continue; |
575 |
if (is_array ($SubArr)) { |
576 |
$array[key($SubArr)] = $SubArr[key($SubArr)]; continue; |
577 |
} |
578 |
$array[] = $SubArr; |
579 |
} |
580 |
return $array; |
581 |
} |
582 |
|
583 |
if ($value == 'null' || $value == 'NULL' || $value == 'Null' || $value == '' || $value == '~') { |
584 |
return null; |
585 |
} |
586 |
|
587 |
if ( is_numeric($value) && preg_match ('/^(-|)[1-9]+[0-9]*$/', $value) ){ |
588 |
$intvalue = (int)$value; |
589 |
if ($intvalue != PHP_INT_MAX) |
590 |
$value = $intvalue; |
591 |
return $value; |
592 |
} |
593 |
|
594 |
if (in_array($value, |
595 |
array('true', 'on', '+', 'yes', 'y', 'True', 'TRUE', 'On', 'ON', 'YES', 'Yes', 'Y'))) { |
596 |
return true; |
597 |
} |
598 |
|
599 |
if (in_array(strtolower($value), |
600 |
array('false', 'off', '-', 'no', 'n'))) { |
601 |
return false; |
602 |
} |
603 |
|
604 |
if (is_numeric($value)) { |
605 |
if ($value === '0') return 0; |
606 |
if (rtrim ($value, 0) === $value) |
607 |
$value = (float)$value; |
608 |
return $value; |
609 |
} |
610 |
|
611 |
return $value; |
612 |
} |
613 |
|
614 |
/** |
615 |
* Used in inlines to check for more inlines or quoted strings |
616 |
* @access private |
617 |
* @return array |
618 |
*/ |
619 |
private function _inlineEscape($inline) { |
620 |
// There's gotta be a cleaner way to do this... |
621 |
// While pure sequences seem to be nesting just fine, |
622 |
// pure mappings and mappings with sequences inside can't go very |
623 |
// deep. This needs to be fixed. |
624 |
|
625 |
$seqs = array(); |
626 |
$maps = array(); |
627 |
$saved_strings = array(); |
628 |
|
629 |
// Check for strings |
630 |
$regex = '/(?:(")|(?:\'))((?(1)[^"]+|[^\']+))(?(1)"|\')/'; |
631 |
if (preg_match_all($regex,$inline,$strings)) { |
632 |
$saved_strings = $strings[0]; |
633 |
$inline = preg_replace($regex,'YAMLString',$inline); |
634 |
} |
635 |
unset($regex); |
636 |
|
637 |
$i = 0; |
638 |
do { |
639 |
|
640 |
// Check for sequences |
641 |
while (preg_match('/\[([^{}\[\]]+)\]/U',$inline,$matchseqs)) { |
642 |
$seqs[] = $matchseqs[0]; |
643 |
$inline = preg_replace('/\[([^{}\[\]]+)\]/U', ('YAMLSeq' . (count($seqs) - 1) . 's'), $inline, 1); |
644 |
} |
645 |
|
646 |
// Check for mappings |
647 |
while (preg_match('/{([^\[\]{}]+)}/U',$inline,$matchmaps)) { |
648 |
$maps[] = $matchmaps[0]; |
649 |
$inline = preg_replace('/{([^\[\]{}]+)}/U', ('YAMLMap' . (count($maps) - 1) . 's'), $inline, 1); |
650 |
} |
651 |
|
652 |
if ($i++ >= 10) break; |
653 |
|
654 |
} while (strpos ($inline, '[') !== false || strpos ($inline, '{') !== false); |
655 |
|
656 |
$explode = explode(', ',$inline); |
657 |
$stringi = 0; $i = 0; |
658 |
|
659 |
while (1) { |
660 |
|
661 |
// Re-add the sequences |
662 |
if (!empty($seqs)) { |
663 |
foreach ($explode as $key => $value) { |
664 |
if (strpos($value,'YAMLSeq') !== false) { |
665 |
foreach ($seqs as $seqk => $seq) { |
666 |
$explode[$key] = str_replace(('YAMLSeq'.$seqk.'s'),$seq,$value); |
667 |
$value = $explode[$key]; |
668 |
} |
669 |
} |
670 |
} |
671 |
} |
672 |
|
673 |
// Re-add the mappings |
674 |
if (!empty($maps)) { |
675 |
foreach ($explode as $key => $value) { |
676 |
if (strpos($value,'YAMLMap') !== false) { |
677 |
foreach ($maps as $mapk => $map) { |
678 |
$explode[$key] = str_replace(('YAMLMap'.$mapk.'s'), $map, $value); |
679 |
$value = $explode[$key]; |
680 |
} |
681 |
} |
682 |
} |
683 |
} |
684 |
|
685 |
|
686 |
// Re-add the strings |
687 |
if (!empty($saved_strings)) { |
688 |
foreach ($explode as $key => $value) { |
689 |
while (strpos($value,'YAMLString') !== false) { |
690 |
$explode[$key] = preg_replace('/YAMLString/',$saved_strings[$stringi],$value, 1); |
691 |
unset($saved_strings[$stringi]); |
692 |
++$stringi; |
693 |
$value = $explode[$key]; |
694 |
} |
695 |
} |
696 |
} |
697 |
|
698 |
$finished = true; |
699 |
foreach ($explode as $key => $value) { |
700 |
if (strpos($value,'YAMLSeq') !== false) { |
701 |
$finished = false; break; |
702 |
} |
703 |
if (strpos($value,'YAMLMap') !== false) { |
704 |
$finished = false; break; |
705 |
} |
706 |
if (strpos($value,'YAMLString') !== false) { |
707 |
$finished = false; break; |
708 |
} |
709 |
} |
710 |
if ($finished) break; |
711 |
|
712 |
$i++; |
713 |
if ($i > 10) |
714 |
break; // Prevent infinite loops. |
715 |
} |
716 |
|
717 |
return $explode; |
718 |
} |
719 |
|
720 |
private function literalBlockContinues ($line, $lineIndent) { |
721 |
if (!trim($line)) return true; |
722 |
if (strlen($line) - strlen(ltrim($line)) > $lineIndent) return true; |
723 |
return false; |
724 |
} |
725 |
|
726 |
private function referenceContentsByAlias ($alias) { |
727 |
do { |
728 |
if (!isset($this->SavedGroups[$alias])) { echo "Bad group name: $alias."; break; } |
729 |
$groupPath = $this->SavedGroups[$alias]; |
730 |
$value = $this->result; |
731 |
foreach ($groupPath as $k) { |
732 |
$value = $value[$k]; |
733 |
} |
734 |
} while (false); |
735 |
return $value; |
736 |
} |
737 |
|
738 |
private function addArrayInline ($array, $indent) { |
739 |
$CommonGroupPath = $this->path; |
740 |
if (empty ($array)) return false; |
741 |
|
742 |
foreach ($array as $k => $_) { |
743 |
$this->addArray(array($k => $_), $indent); |
744 |
$this->path = $CommonGroupPath; |
745 |
} |
746 |
return true; |
747 |
} |
748 |
|
749 |
private function addArray ($incoming_data, $incoming_indent) { |
750 |
|
751 |
// print_r ($incoming_data); |
752 |
|
753 |
if (count ($incoming_data) > 1) |
754 |
return $this->addArrayInline ($incoming_data, $incoming_indent); |
755 |
|
756 |
$key = key ($incoming_data); |
757 |
$value = isset($incoming_data[$key]) ? $incoming_data[$key] : null; |
758 |
if ($key === '__!YAMLZero') $key = '0'; |
759 |
|
760 |
if ($incoming_indent == 0 && !$this->_containsGroupAlias && !$this->_containsGroupAnchor) { // Shortcut for root-level values. |
761 |
if ($key || $key === '' || $key === '0') { |
762 |
$this->result[$key] = $value; |
763 |
} else { |
764 |
$this->result[] = $value; end ($this->result); $key = key ($this->result); |
765 |
} |
766 |
$this->path[$incoming_indent] = $key; |
767 |
return; |
768 |
} |
769 |
|
770 |
|
771 |
|
772 |
$history = array(); |
773 |
// Unfolding inner array tree. |
774 |
$history[] = $_arr = $this->result; |
775 |
foreach ($this->path as $k) { |
776 |
$history[] = $_arr = $_arr[$k]; |
777 |
} |
778 |
|
779 |
if ($this->_containsGroupAlias) { |
780 |
$value = $this->referenceContentsByAlias($this->_containsGroupAlias); |
781 |
$this->_containsGroupAlias = false; |
782 |
} |
783 |
|
784 |
|
785 |
// Adding string or numeric key to the innermost level or $this->arr. |
786 |
if (is_string($key) && $key == '<<') { |
787 |
if (!is_array ($_arr)) { $_arr = array (); } |
788 |
|
789 |
$_arr = array_merge ($_arr, $value); |
790 |
} else if ($key || $key === '' || $key === '0') { |
791 |
if (!is_array ($_arr)) |
792 |
$_arr = array ($key=>$value); |
793 |
else |
794 |
$_arr[$key] = $value; |
795 |
} else { |
796 |
if (!is_array ($_arr)) { $_arr = array ($value); $key = 0; } |
797 |
else { $_arr[] = $value; end ($_arr); $key = key ($_arr); } |
798 |
} |
799 |
|
800 |
$reverse_path = array_reverse($this->path); |
801 |
$reverse_history = array_reverse ($history); |
802 |
$reverse_history[0] = $_arr; |
803 |
$cnt = count($reverse_history) - 1; |
804 |
for ($i = 0; $i < $cnt; $i++) { |
805 |
$reverse_history[$i+1][$reverse_path[$i]] = $reverse_history[$i]; |
806 |
} |
807 |
$this->result = $reverse_history[$cnt]; |
808 |
|
809 |
$this->path[$incoming_indent] = $key; |
810 |
|
811 |
if ($this->_containsGroupAnchor) { |
812 |
$this->SavedGroups[$this->_containsGroupAnchor] = $this->path; |
813 |
if (is_array ($value)) { |
814 |
$k = key ($value); |
815 |
if (!is_int ($k)) { |
816 |
$this->SavedGroups[$this->_containsGroupAnchor][$incoming_indent + 2] = $k; |
817 |
} |
818 |
} |
819 |
$this->_containsGroupAnchor = false; |
820 |
} |
821 |
|
822 |
} |
823 |
|
824 |
private static function startsLiteralBlock ($line) { |
825 |
$lastChar = substr (trim($line), -1); |
826 |
if ($lastChar != '>' && $lastChar != '|') return false; |
827 |
if ($lastChar == '|') return $lastChar; |
828 |
// HTML tags should not be counted as literal blocks. |
829 |
if (preg_match ('#<.*?>$#', $line)) return false; |
830 |
return $lastChar; |
831 |
} |
832 |
|
833 |
private static function greedilyNeedNextLine($line) { |
834 |
$line = trim ($line); |
835 |
if (!strlen($line)) return false; |
836 |
if (substr ($line, -1, 1) == ']') return false; |
837 |
if ($line[0] == '[') return true; |
838 |
if (preg_match ('#^[^:]+?:\s*\[#', $line)) return true; |
839 |
return false; |
840 |
} |
841 |
|
842 |
private function addLiteralLine ($literalBlock, $line, $literalBlockStyle, $indent = -1) { |
843 |
$line = self::stripIndent($line, $indent); |
844 |
if ($literalBlockStyle !== '|') { |
845 |
$line = self::stripIndent($line); |
846 |
} |
847 |
$line = rtrim ($line, "\r\n\t ") . "\n"; |
848 |
if ($literalBlockStyle == '|') { |
849 |
return $literalBlock . $line; |
850 |
} |
851 |
if (strlen($line) == 0) |
852 |
return rtrim($literalBlock, ' ') . "\n"; |
853 |
if ($line == "\n" && $literalBlockStyle == '>') { |
854 |
return rtrim ($literalBlock, " \t") . "\n"; |
855 |
} |
856 |
if ($line != "\n") |
857 |
$line = trim ($line, "\r\n ") . " "; |
858 |
return $literalBlock . $line; |
859 |
} |
860 |
|
861 |
function revertLiteralPlaceHolder ($lineArray, $literalBlock) { |
862 |
foreach ($lineArray as $k => $_) { |
863 |
if (is_array($_)) |
864 |
$lineArray[$k] = $this->revertLiteralPlaceHolder ($_, $literalBlock); |
865 |
else if (substr($_, -1 * strlen ($this->LiteralPlaceHolder)) == $this->LiteralPlaceHolder) |
866 |
$lineArray[$k] = rtrim ($literalBlock, " \r\n"); |
867 |
} |
868 |
return $lineArray; |
869 |
} |
870 |
|
871 |
private static function stripIndent ($line, $indent = -1) { |
872 |
if ($indent == -1) $indent = strlen($line) - strlen(ltrim($line)); |
873 |
return substr ($line, $indent); |
874 |
} |
875 |
|
876 |
private function getParentPathByIndent ($indent) { |
877 |
if ($indent == 0) return array(); |
878 |
$linePath = $this->path; |
879 |
do { |
880 |
end($linePath); $lastIndentInParentPath = key($linePath); |
881 |
if ($indent <= $lastIndentInParentPath) array_pop ($linePath); |
882 |
} while ($indent <= $lastIndentInParentPath); |
883 |
return $linePath; |
884 |
} |
885 |
|
886 |
|
887 |
private function clearBiggerPathValues ($indent) { |
888 |
|
889 |
|
890 |
if ($indent == 0) $this->path = array(); |
891 |
if (empty ($this->path)) return true; |
892 |
|
893 |
foreach ($this->path as $k => $_) { |
894 |
if ($k > $indent) unset ($this->path[$k]); |
895 |
} |
896 |
|
897 |
return true; |
898 |
} |
899 |
|
900 |
|
901 |
private static function isComment ($line) { |
902 |
if (!$line) return false; |
903 |
if ($line[0] == '#') return true; |
904 |
if (trim($line, " \r\n\t") == '---') return true; |
905 |
return false; |
906 |
} |
907 |
|
908 |
private static function isEmpty ($line) { |
909 |
return (trim ($line) === ''); |
910 |
} |
911 |
|
912 |
|
913 |
private function isArrayElement ($line) { |
914 |
if (!$line) return false; |
915 |
if ($line[0] != '-') return false; |
916 |
if (strlen ($line) > 3) |
917 |
if (substr($line,0,3) == '---') return false; |
918 |
|
919 |
return true; |
920 |
} |
921 |
|
922 |
private function isHashElement ($line) { |
923 |
return strpos($line, ':'); |
924 |
} |
925 |
|
926 |
private function isLiteral ($line) { |
927 |
if ($this->isArrayElement($line)) return false; |
928 |
if ($this->isHashElement($line)) return false; |
929 |
return true; |
930 |
} |
931 |
|
932 |
|
933 |
private static function unquote ($value) { |
934 |
if (!$value) return $value; |
935 |
if (!is_string($value)) return $value; |
936 |
if ($value[0] == '\'') return trim ($value, '\''); |
937 |
if ($value[0] == '"') return trim ($value, '"'); |
938 |
return $value; |
939 |
} |
940 |
|
941 |
private function startsMappedSequence ($line) { |
942 |
return ($line[0] == '-' && substr ($line, -1, 1) == ':'); |
943 |
} |
944 |
|
945 |
private function returnMappedSequence ($line) { |
946 |
$array = array(); |
947 |
$key = self::unquote(trim(substr($line,1,-1))); |
948 |
$array[$key] = array(); |
949 |
$this->delayedPath = array(strpos ($line, $key) + $this->indent => $key); |
950 |
return array($array); |
951 |
} |
952 |
|
953 |
private function returnMappedValue ($line) { |
954 |
$array = array(); |
955 |
$key = self::unquote (trim(substr($line,0,-1))); |
956 |
$array[$key] = ''; |
957 |
return $array; |
958 |
} |
959 |
|
960 |
private function startsMappedValue ($line) { |
961 |
return (substr ($line, -1, 1) == ':'); |
962 |
} |
963 |
|
964 |
private function isPlainArray ($line) { |
965 |
return ($line[0] == '[' && substr ($line, -1, 1) == ']'); |
966 |
} |
967 |
|
968 |
private function returnPlainArray ($line) { |
969 |
return $this->_toType($line); |
970 |
} |
971 |
|
972 |
private function returnKeyValuePair ($line) { |
973 |
$array = array(); |
974 |
$key = ''; |
975 |
if (strpos ($line, ':')) { |
976 |
// It's a key/value pair most likely |
977 |
// If the key is in double quotes pull it out |
978 |
if (($line[0] == '"' || $line[0] == "'") && preg_match('/^(["\'](.*)["\'](\s)*:)/',$line,$matches)) { |
979 |
$value = trim(str_replace($matches[1],'',$line)); |
980 |
$key = $matches[2]; |
981 |
} else { |
982 |
// Do some guesswork as to the key and the value |
983 |
$explode = explode(':',$line); |
984 |
$key = trim($explode[0]); |
985 |
array_shift($explode); |
986 |
$value = trim(implode(':',$explode)); |
987 |
} |
988 |
// Set the type of the value. Int, string, etc |
989 |
$value = $this->_toType($value); |
990 |
if ($key === '0') $key = '__!YAMLZero'; |
991 |
$array[$key] = $value; |
992 |
} else { |
993 |
$array = array ($line); |
994 |
} |
995 |
return $array; |
996 |
|
997 |
} |
998 |
|
999 |
|
1000 |
private function returnArrayElement ($line) { |
1001 |
if (strlen($line) <= 1) return array(array()); // Weird %) |
1002 |
$array = array(); |
1003 |
$value = trim(substr($line,1)); |
1004 |
$value = $this->_toType($value); |
1005 |
$array[] = $value; |
1006 |
return $array; |
1007 |
} |
1008 |
|
1009 |
|
1010 |
private function nodeContainsGroup ($line) { |
1011 |
$symbolsForReference = 'A-z0-9_\-'; |
1012 |
if (strpos($line, '&') === false && strpos($line, '*') === false) return false; // Please die fast ;-) |
1013 |
if ($line[0] == '&' && preg_match('/^(&['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1]; |
1014 |
if ($line[0] == '*' && preg_match('/^(\*['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1]; |
1015 |
if (preg_match('/(&['.$symbolsForReference.']+)$/', $line, $matches)) return $matches[1]; |
1016 |
if (preg_match('/(\*['.$symbolsForReference.']+$)/', $line, $matches)) return $matches[1]; |
1017 |
if (preg_match ('#^\s*<<\s*:\s*(\*[^\s]+).*$#', $line, $matches)) return $matches[1]; |
1018 |
return false; |
1019 |
|
1020 |
} |
1021 |
|
1022 |
private function addGroup ($line, $group) { |
1023 |
if ($group[0] == '&') $this->_containsGroupAnchor = substr ($group, 1); |
1024 |
if ($group[0] == '*') $this->_containsGroupAlias = substr ($group, 1); |
1025 |
//print_r ($this->path); |
1026 |
} |
1027 |
|
1028 |
private function stripGroup ($line, $group) { |
1029 |
$line = trim(str_replace($group, '', $line)); |
1030 |
return $line; |
1031 |
} |
1032 |
} |
1033 |
|
1034 |
// Enable use of Spyc from command line |
1035 |
// The syntax is the following: php spyc.php spyc.yaml |
1036 |
|
1037 |
define ('SPYC_FROM_COMMAND_LINE', false); |
1038 |
|
1039 |
do { |
1040 |
if (!SPYC_FROM_COMMAND_LINE) break; |
1041 |
if (empty ($_SERVER['argc']) || $_SERVER['argc'] < 2) break; |
1042 |
if (empty ($_SERVER['PHP_SELF']) || $_SERVER['PHP_SELF'] != 'spyc.php') break; |
1043 |
$file = $argv[1]; |
1044 |
printf ("Spyc loading file: %s\n", $file); |
1045 |
print_r (spyc_load_file ($file)); |
1046 |
} while (0); |