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