Skip to content

E
EcomDev_PHPUnit

We will work on Apr 26th (Saturday) and will be off from Apr 30th (Wednesday) until May 2nd (Friday) for public holiday in our country

Commit 7e015df5 authored by Fabian Schmengler's avatar Fabian Schmengler
Browse files
Options

Update Spyc YAML lib to 0.5.1 for PHP 7.1 compatibility

parent ac76e595
Hide whitespace changes
Inline Side-by-side
Showing with 1062 additions and 925 deletions
lib/Spyc/spyc.php 100644 → 100755
View file @ 7e015df5
<?php <?php
/** /**
* Spyc -- A Simple PHP YAML Class * Spyc -- A Simple PHP YAML Class
* @version 0.4.5 * @version 0.5.1
* @author Vlad Andersen <vlad.andersen@gmail.com> * @author Vlad Andersen <vlad.andersen@gmail.com>
* @author Chris Wanstrath <chris@ozmm.org> * @author Chris Wanstrath <chris@ozmm.org>
* @link http://code.google.com/p/spyc/ * @link https://github.com/mustangostang/spyc/
* @copyright Copyright 2005-2006 Chris Wanstrath, 2006-2009 Vlad Andersen * @copyright Copyright 2005-2006 Chris Wanstrath, 2006-2011 Vlad Andersen
* @license http://www.opensource.org/licenses/mit-license.php MIT License * @license http://www.opensource.org/licenses/mit-license.php MIT License
* @package Spyc * @package Spyc
*/
if (!function_exists('spyc_load')) {
/**
* Parses YAML to array.
* @param string $string YAML string.
* @return array
*/
function spyc_load ($string) {
return Spyc::YAMLLoadString($string);
}
}
if (!function_exists('spyc_load_file')) {
/**
* Parses YAML to array.
* @param string $file Path to YAML file.
* @return array
*/
function spyc_load_file ($file) {
return Spyc::YAMLLoad($file);
}
}
/**
* The Simple PHP YAML Class.
*
* This class can be used to read a YAML file and convert its contents
* into a PHP array. It currently supports a very limited subsection of
* the YAML spec.
*
* Usage:
* <code>
* $Spyc = new Spyc;
* $array = $Spyc->load($file);
* </code>
* or:
* <code>
* $array = Spyc::YAMLLoad($file);
* </code>
* or:
* <code>
* $array = spyc_load_file($file);
* </code>
* @package Spyc
*/
class Spyc {
// SETTINGS
/**
* Setting this to true will force YAMLDump to enclose any string value in
* quotes. False by default.
*
* @var bool
*/
public $setting_dump_force_quotes = false;
/**
* Setting this to true will forse YAMLLoad to use syck_load function when
* possible. False by default.
* @var bool
*/
public $setting_use_syck_is_possible = false;
/**#@+
* @access private
* @var mixed
*/
private $_dumpIndent;
private $_dumpWordWrap;
private $_containsGroupAnchor = false;
private $_containsGroupAlias = false;
private $path;
private $result;
private $LiteralPlaceHolder = '___YAML_Literal_Block___';
private $SavedGroups = array();
private $indent;
/**
* Path modifier that should be applied after adding current element.
* @var array
*/
private $delayedPath = array();
/**#@+
* @access public
* @var mixed
*/
public $_nodeId;
/**
* Load a valid YAML string to Spyc.
* @param string $input
* @return array
*/ */
public function load ($input) {
return $this->__loadString($input);
}
/**
* Load a valid YAML file to Spyc.
* @param string $file
* @return array
*/
public function loadFile ($file) {
return $this->__load($file);
}
/** if (!function_exists('spyc_load')) {
* Load YAML into a PHP array statically /**
* * Parses YAML to array.
* The load method, when supplied with a YAML stream (string or file), * @param string $string YAML string.
* will do its best to convert YAML in a file into a PHP array. Pretty
* simple.
* Usage:
* <code>
* $array = Spyc::YAMLLoad('lucky.yaml');
* print_r($array);
* </code>
* @access public
* @return array * @return array
* @param string $input Path of YAML file or string containing YAML
*/ */
public static function YAMLLoad($input) { function spyc_load ($string) {
$Spyc = new Spyc; return Spyc::YAMLLoadString($string);
return $Spyc->__load($input); }
} }
/** if (!function_exists('spyc_load_file')) {
* Load a string of YAML into a PHP array statically /**
* * Parses YAML to array.
* The load method, when supplied with a YAML string, will do its best * @param string $file Path to YAML file.
* to convert YAML in a string into a PHP array. Pretty simple.
*
* Note: use this function if you don't want files from the file system
* loaded and processed as YAML. This is of interest to people concerned
* about security whose input is from a string.
*
* Usage:
* <code>
* $array = Spyc::YAMLLoadString("---\n0: hello world\n");
* print_r($array);
* </code>
* @access public
* @return array * @return array
* @param string $input String containing YAML
*/ */
public static function YAMLLoadString($input) { function spyc_load_file ($file) {
$Spyc = new Spyc; return Spyc::YAMLLoad($file);
return $Spyc->__loadString($input); }
} }
/** if (!function_exists('spyc_dump')) {
* Dump YAML from PHP array statically /**
* * Dumps array to YAML.
* The dump method, when supplied with an array, will do its best * @param array $data Array.
* to convert the array into friendly YAML. Pretty simple. Feel free to
* save the returned string as nothing.yaml and pass it around.
*
* Oh, and you can decide how big the indent is and what the wordwrap
* for folding is. Pretty cool -- just pass in 'false' for either if
* you want to use the default.
*
* Indent's default is 2 spaces, wordwrap's default is 40 characters. And
* you can turn off wordwrap by passing in 0.
*
* @access public
* @return string * @return string
* @param array $array PHP array
* @param int $indent Pass in false to use the default, which is 2
* @param int $wordwrap Pass in 0 for no wordwrap, false for default (40)
*/ */
public static function YAMLDump($array,$indent = false,$wordwrap = false) { function spyc_dump ($data) {
$spyc = new Spyc; return Spyc::YAMLDump($data, false, false, true);
return $spyc->dump($array,$indent,$wordwrap); }
} }
if (!class_exists('Spyc')) {
/** /**
* Dump PHP array to YAML * The Simple PHP YAML Class.
*
* The dump method, when supplied with an array, will do its best
* to convert the array into friendly YAML. Pretty simple. Feel free to
* save the returned string as tasteful.yaml and pass it around.
* *
* Oh, and you can decide how big the indent is and what the wordwrap * This class can be used to read a YAML file and convert its contents
* for folding is. Pretty cool -- just pass in 'false' for either if * into a PHP array. It currently supports a very limited subsection of
* you want to use the default. * the YAML spec.
* *
* Indent's default is 2 spaces, wordwrap's default is 40 characters. And * Usage:
* you can turn off wordwrap by passing in 0. * <code>
* * $Spyc = new Spyc;
* @access public * $array = $Spyc->load($file);
* @return string * </code>
* @param array $array PHP array * or:
* @param int $indent Pass in false to use the default, which is 2 * <code>
* @param int $wordwrap Pass in 0 for no wordwrap, false for default (40) * $array = Spyc::YAMLLoad($file);
* </code>
* or:
* <code>
* $array = spyc_load_file($file);
* </code>
* @package Spyc
*/ */
public function dump($array,$indent = false,$wordwrap = false) { class Spyc {
// Dumps to some very clean YAML. We'll have to add some more features
// and options soon. And better support for folding. // SETTINGS
// New features and options. const REMPTY = "\0\0\0\0\0";
if ($indent === false or !is_numeric($indent)) {
$this->_dumpIndent = 2; /**
} else { * Setting this to true will force YAMLDump to enclose any string value in
$this->_dumpIndent = $indent; * quotes. False by default.
} *
* @var bool
*/
public $setting_dump_force_quotes = false;
/**
* Setting this to true will forse YAMLLoad to use syck_load function when
* possible. False by default.
* @var bool
*/
public $setting_use_syck_is_possible = false;
/**#@+
* @access private
* @var mixed
*/
private $_dumpIndent;
private $_dumpWordWrap;
private $_containsGroupAnchor = false;
private $_containsGroupAlias = false;
private $path;
private $result;
private $LiteralPlaceHolder = '___YAML_Literal_Block___';
private $SavedGroups = array();
private $indent;
/**
* Path modifier that should be applied after adding current element.
* @var array
*/
private $delayedPath = array();
/**#@+
* @access public
* @var mixed
*/
public $_nodeId;
/**
* Load a valid YAML string to Spyc.
* @param string $input
* @return array
*/
public function load ($input) {
return $this->_loadString($input);
}
if ($wordwrap === false or !is_numeric($wordwrap)) { /**
$this->_dumpWordWrap = 40; * Load a valid YAML file to Spyc.
} else { * @param string $file
$this->_dumpWordWrap = $wordwrap; * @return array
} */
public function loadFile ($file) {
return $this->_load($file);
}
// New YAML document /**
$string = "---\n"; * Load YAML into a PHP array statically
*
// Start at the base of the array and move through it. * The load method, when supplied with a YAML stream (string or file),
if ($array) { * will do its best to convert YAML in a file into a PHP array. Pretty
$array = (array)$array; * simple.
$first_key = key($array); * Usage:
* <code>
$previous_key = -1; * $array = Spyc::YAMLLoad('lucky.yaml');
foreach ($array as $key => $value) { * print_r($array);
$string .= $this->_yamlize($key,$value,0,$previous_key, $first_key); * </code>
$previous_key = $key; * @access public
} * @return array
} * @param string $input Path of YAML file or string containing YAML
return $string; */
} public static function YAMLLoad($input) {
$Spyc = new Spyc;
return $Spyc->_load($input);
}
/** /**
* Attempts to convert a key / value array item to YAML * Load a string of YAML into a PHP array statically
* @access private *
* @return string * The load method, when supplied with a YAML string, will do its best
* @param $key The name of the key * to convert YAML in a string into a PHP array. Pretty simple.
* @param $value The value of the item *
* @param $indent The indent of the current node * Note: use this function if you don't want files from the file system
*/ * loaded and processed as YAML. This is of interest to people concerned
private function _yamlize($key,$value,$indent, $previous_key = -1, $first_key = 0) { * about security whose input is from a string.
if (is_array($value)) { *
if (empty ($value)) * Usage:
return $this->_dumpNode($key, array(), $indent, $previous_key, $first_key); * <code>
// It has children. What to do? * $array = Spyc::YAMLLoadString("---\n0: hello world\n");
// Make it the right kind of item * print_r($array);
$string = $this->_dumpNode($key, NULL, $indent, $previous_key, $first_key); * </code>
// Add the indent * @access public
$indent += $this->_dumpIndent; * @return array
// Yamlize the array * @param string $input String containing YAML
$string .= $this->_yamlizeArray($value,$indent); */
} elseif (!is_array($value)) { public static function YAMLLoadString($input) {
// It doesn't have children. Yip. $Spyc = new Spyc;
$string = $this->_dumpNode($key, $value, $indent, $previous_key, $first_key); return $Spyc->_loadString($input);
} }
return $string;
}
/** /**
* Attempts to convert an array to YAML * Dump YAML from PHP array statically
* @access private *
* @return string * The dump method, when supplied with an array, will do its best
* @param $array The array you want to convert * to convert the array into friendly YAML. Pretty simple. Feel free to
* @param $indent The indent of the current level * save the returned string as nothing.yaml and pass it around.
*/ *
private function _yamlizeArray($array,$indent) { * Oh, and you can decide how big the indent is and what the wordwrap
if (is_array($array)) { * for folding is. Pretty cool -- just pass in 'false' for either if
$string = ''; * you want to use the default.
$previous_key = -1; *
$first_key = key($array); * Indent's default is 2 spaces, wordwrap's default is 40 characters. And
foreach ($array as $key => $value) { * you can turn off wordwrap by passing in 0.
$string .= $this->_yamlize($key, $value, $indent, $previous_key, $first_key); *
$previous_key = $key; * @access public
} * @return string
return $string; * @param array|\stdClass $array PHP array
} else { * @param int $indent Pass in false to use the default, which is 2
return false; * @param int $wordwrap Pass in 0 for no wordwrap, false for default (40)
} * @param bool $no_opening_dashes Do not start YAML file with "---\n"
} */
public static function YAMLDump($array, $indent = false, $wordwrap = false, $no_opening_dashes = false) {
$spyc = new Spyc;
return $spyc->dump($array, $indent, $wordwrap, $no_opening_dashes);
}
/**
* Returns YAML from a key and a value
* @access private
* @return string
* @param $key The name of the key
* @param $value The value of the item
* @param $indent The indent of the current node
*/
private function _dumpNode($key, $value, $indent, $previous_key = -1, $first_key = 0) {
// do some folding here, for blocks
if (is_string ($value) && ((strpos($value,"\n") !== false || strpos($value,": ") !== false || strpos($value,"- ") !== false ||
strpos($value,"*") !== false || strpos($value,"#") !== false || strpos($value,"<") !== false || strpos($value,">") !== false ||
strpos($value,"[") !== false || strpos($value,"]") !== false || strpos($value,"{") !== false || strpos($value,"}") !== false) || substr ($value, -1, 1) == ':')) {
$value = $this->_doLiteralBlock($value,$indent);
} else {
$value = $this->_doFolding($value,$indent);
if (is_bool($value)) {
$value = ($value) ? "true" : "false";
}
}
if ($value === array()) $value = '[ ]'; /**
* Dump PHP array to YAML
*
* The dump method, when supplied with an array, will do its best
* to convert the array into friendly YAML. Pretty simple. Feel free to
* save the returned string as tasteful.yaml and pass it around.
*
* Oh, and you can decide how big the indent is and what the wordwrap
* for folding is. Pretty cool -- just pass in 'false' for either if
* you want to use the default.
*
* Indent's default is 2 spaces, wordwrap's default is 40 characters. And
* you can turn off wordwrap by passing in 0.
*
* @access public
* @return string
* @param array $array PHP array
* @param int $indent Pass in false to use the default, which is 2
* @param int $wordwrap Pass in 0 for no wordwrap, false for default (40)
*/
public function dump($array,$indent = false,$wordwrap = false, $no_opening_dashes = false) {
// Dumps to some very clean YAML. We'll have to add some more features
// and options soon. And better support for folding.
// New features and options.
if ($indent === false or !is_numeric($indent)) {
$this->_dumpIndent = 2;
} else {
$this->_dumpIndent = $indent;
}
if ($wordwrap === false or !is_numeric($wordwrap)) {
$this->_dumpWordWrap = 40;
} else {
$this->_dumpWordWrap = $wordwrap;
}
// New YAML document
$string = "";
if (!$no_opening_dashes) $string = "---\n";
// Start at the base of the array and move through it.
if ($array) {
$array = (array)$array;
$previous_key = -1;
foreach ($array as $key => $value) {
if (!isset($first_key)) $first_key = $key;
$string .= $this->_yamlize($key,$value,0,$previous_key, $first_key, $array);
$previous_key = $key;
}
}
return $string;
}
$spaces = str_repeat(' ',$indent); /**
* Attempts to convert a key / value array item to YAML
* @access private
* @return string
* @param $key The name of the key
* @param $value The value of the item
* @param $indent The indent of the current node
*/
private function _yamlize($key,$value,$indent, $previous_key = -1, $first_key = 0, $source_array = null) {
if(is_object($value)) $value = (array)$value;
if (is_array($value)) {
if (empty ($value))
return $this->_dumpNode($key, array(), $indent, $previous_key, $first_key, $source_array);
// It has children. What to do?
// Make it the right kind of item
$string = $this->_dumpNode($key, self::REMPTY, $indent, $previous_key, $first_key, $source_array);
// Add the indent
$indent += $this->_dumpIndent;
// Yamlize the array
$string .= $this->_yamlizeArray($value,$indent);
} elseif (!is_array($value)) {
// It doesn't have children. Yip.
$string = $this->_dumpNode($key, $value, $indent, $previous_key, $first_key, $source_array);
}
return $string;
}
if (is_int($key) && $key - 1 == $previous_key && $first_key===0) { /**
// It's a sequence * Attempts to convert an array to YAML
$string = $spaces.'- '.$value."\n"; * @access private
} else { * @return string
if ($first_key===0) throw new Exception('Keys are all screwy. The first one was zero, now it\'s "'. $key .'"'); * @param $array The array you want to convert
// It's mapped * @param $indent The indent of the current level
if (strpos($key, ":") !== false) { $key = '"' . $key . '"'; } */
$string = $spaces.$key.': '.$value."\n"; private function _yamlizeArray($array,$indent) {
} if (is_array($array)) {
return $string; $string = '';
} $previous_key = -1;
foreach ($array as $key => $value) {
if (!isset($first_key)) $first_key = $key;
$string .= $this->_yamlize($key, $value, $indent, $previous_key, $first_key, $array);
$previous_key = $key;
}
return $string;
} else {
return false;
}
}
/** /**
* Creates a literal block for dumping * Returns YAML from a key and a value
* @access private * @access private
* @return string * @return string
* @param $value * @param $key The name of the key
* @param $indent int The value of the indent * @param $value The value of the item
*/ * @param $indent The indent of the current node
private function _doLiteralBlock($value,$indent) { */
if (strpos($value, "\n") === false && strpos($value, "'") === false) { private function _dumpNode($key, $value, $indent, $previous_key = -1, $first_key = 0, $source_array = null) {
return sprintf ("'%s'", $value); // do some folding here, for blocks
} if (is_string ($value) && ((strpos($value,"\n") !== false || strpos($value,": ") !== false || strpos($value,"- ") !== false ||
if (strpos($value, "\n") === false && strpos($value, '"') === false) { strpos($value,"*") !== false || strpos($value,"#") !== false || strpos($value,"<") !== false || strpos($value,">") !== false || strpos ($value, '%') !== false || strpos ($value, ' ') !== false ||
return sprintf ('"%s"', $value); strpos($value,"[") !== false || strpos($value,"]") !== false || strpos($value,"{") !== false || strpos($value,"}") !== false) || strpos($value,"&") !== false || strpos($value, "'") !== false || strpos($value, "!") === 0 ||
} substr ($value, -1, 1) == ':')
$exploded = explode("\n",$value); ) {
$newValue = '|'; $value = $this->_doLiteralBlock($value,$indent);
$indent += $this->_dumpIndent; } else {
$spaces = str_repeat(' ',$indent); $value = $this->_doFolding($value,$indent);
foreach ($exploded as $line) { }
$newValue .= "\n" . $spaces . trim($line);
} if ($value === array()) $value = '[ ]';
return $newValue; if ($value === "") $value = '""';
} if (self::isTranslationWord($value)) {
$value = $this->_doLiteralBlock($value, $indent);
}
if (trim ($value) != $value)
$value = $this->_doLiteralBlock($value,$indent);
if (is_bool($value)) {
$value = $value ? "true" : "false";
}
if ($value === null) $value = 'null';
if ($value === "'" . self::REMPTY . "'") $value = null;
$spaces = str_repeat(' ',$indent);
//if (is_int($key) && $key - 1 == $previous_key && $first_key===0) {
if (is_array ($source_array) && array_keys($source_array) === range(0, count($source_array) - 1)) {
// It's a sequence
$string = $spaces.'- '.$value."\n";
} else {
// if ($first_key===0) throw new Exception('Keys are all screwy. The first one was zero, now it\'s "'. $key .'"');
// It's mapped
if (strpos($key, ":") !== false || strpos($key, "#") !== false) { $key = '"' . $key . '"'; }
$string = rtrim ($spaces.$key.': '.$value)."\n";
}
return $string;
}
/** /**
* Folds a string of text, if necessary * Creates a literal block for dumping
* @access private * @access private
* @return string * @return string
* @param $value The string you wish to fold * @param $value
*/ * @param $indent int The value of the indent
private function _doFolding($value,$indent) { */
// Don't do anything if wordwrap is set to 0 private function _doLiteralBlock($value,$indent) {
if ($value === "\n") return '\n';
if ($this->_dumpWordWrap !== 0 && is_string ($value) && strlen($value) > $this->_dumpWordWrap) { if (strpos($value, "\n") === false && strpos($value, "'") === false) {
$indent += $this->_dumpIndent; return sprintf ("'%s'", $value);
$indent = str_repeat(' ',$indent); }
$wrapped = wordwrap($value,$this->_dumpWordWrap,"\n$indent"); if (strpos($value, "\n") === false && strpos($value, '"') === false) {
$value = ">\n".$indent.$wrapped; return sprintf ('"%s"', $value);
} else { }
if ($this->setting_dump_force_quotes && is_string ($value)) $exploded = explode("\n",$value);
$value = '"' . $value . '"'; $newValue = '|';
} if (isset($exploded[0]) && ($exploded[0] == "|" || $exploded[0] == "|-" || $exploded[0] == ">")) {
$newValue = $exploded[0];
unset($exploded[0]);
}
$indent += $this->_dumpIndent;
$spaces = str_repeat(' ',$indent);
foreach ($exploded as $line) {
$line = trim($line);
if (strpos($line, '"') === 0 && strrpos($line, '"') == (strlen($line)-1) || strpos($line, "'") === 0 && strrpos($line, "'") == (strlen($line)-1)) {
$line = substr($line, 1, -1);
}
$newValue .= "\n" . $spaces . ($line);
}
return $newValue;
}
/**
* Folds a string of text, if necessary
* @access private
* @return string
* @param $value The string you wish to fold
*/
private function _doFolding($value,$indent) {
// Don't do anything if wordwrap is set to 0
if ($this->_dumpWordWrap !== 0 && is_string ($value) && strlen($value) > $this->_dumpWordWrap) {
$indent += $this->_dumpIndent;
$indent = str_repeat(' ',$indent);
$wrapped = wordwrap($value,$this->_dumpWordWrap,"\n$indent");
$value = ">\n".$indent.$wrapped;
} else {
if ($this->setting_dump_force_quotes && is_string ($value) && $value !== self::REMPTY)
$value = '"' . $value . '"';
if (is_numeric($value) && is_string($value))
$value = '"' . $value . '"';
}
return $value;
}
private function isTrueWord($value) {
$words = self::getTranslations(array('true', 'on', 'yes', 'y'));
return in_array($value, $words, true);
}
private function isFalseWord($value) {
$words = self::getTranslations(array('false', 'off', 'no', 'n'));
return in_array($value, $words, true);
}
return $value; private function isNullWord($value) {
} $words = self::getTranslations(array('null', '~'));
return in_array($value, $words, true);
}
private function isTranslationWord($value) {
return (
self::isTrueWord($value) ||
self::isFalseWord($value) ||
self::isNullWord($value)
);
}
/**
* Coerce a string into a native type
* Reference: http://yaml.org/type/bool.html
* TODO: Use only words from the YAML spec.
* @access private
* @param $value The value to coerce
*/
private function coerceValue(&$value) {
if (self::isTrueWord($value)) {
$value = true;
} else if (self::isFalseWord($value)) {
$value = false;
} else if (self::isNullWord($value)) {
$value = null;
}
}
/**
* Given a set of words, perform the appropriate translations on them to
* match the YAML 1.1 specification for type coercing.
* @param $words The words to translate
* @access private
*/
private static function getTranslations(array $words) {
$result = array();
foreach ($words as $i) {
$result = array_merge($result, array(ucfirst($i), strtoupper($i), strtolower($i)));
}
return $result;
}
// LOADING FUNCTIONS // LOADING FUNCTIONS
private function __load($input) { private function _load($input) {
$Source = $this->loadFromSource($input); $Source = $this->loadFromSource($input);
return $this->loadWithSource($Source); return $this->loadWithSource($Source);
} }
private function __loadString($input) {
$Source = $this->loadFromString($input);
return $this->loadWithSource($Source);
}
private function loadWithSource($Source) {
if (empty ($Source)) return array();
if ($this->setting_use_syck_is_possible && function_exists ('syck_load')) {
$array = syck_load (implode ('', $Source));
return is_array($array) ? $array : array();
}
$this->path = array(); private function _loadString($input) {
$this->result = array(); $Source = $this->loadFromString($input);
return $this->loadWithSource($Source);
$cnt = count($Source);
for ($i = 0; $i < $cnt; $i++) {
$line = $Source[$i];
$this->indent = strlen($line) - strlen(ltrim($line));
$tempPath = $this->getParentPathByIndent($this->indent);
$line = self::stripIndent($line, $this->indent);
if (self::isComment($line)) continue;
if (self::isEmpty($line)) continue;
$this->path = $tempPath;
$literalBlockStyle = self::startsLiteralBlock($line);
if ($literalBlockStyle) {
$line = rtrim ($line, $literalBlockStyle . " \n");
$literalBlock = '';
$line .= $this->LiteralPlaceHolder;
while (++$i < $cnt && $this->literalBlockContinues($Source[$i], $this->indent)) {
$literalBlock = $this->addLiteralLine($literalBlock, $Source[$i], $literalBlockStyle);
} }
$i--;
}
while (++$i < $cnt && self::greedilyNeedNextLine($line)) { private function loadWithSource($Source) {
$line = rtrim ($line, " \n\t\r") . ' ' . ltrim ($Source[$i], " \t"); if (empty ($Source)) return array();
} if ($this->setting_use_syck_is_possible && function_exists ('syck_load')) {
$i--; $array = syck_load (implode ("\n", $Source));
return is_array($array) ? $array : array();
}
$this->path = array();
$this->result = array();
$cnt = count($Source);
for ($i = 0; $i < $cnt; $i++) {
$line = $Source[$i];
$this->indent = strlen($line) - strlen(ltrim($line));
$tempPath = $this->getParentPathByIndent($this->indent);
$line = self::stripIndent($line, $this->indent);
if (self::isComment($line)) continue;
if (self::isEmpty($line)) continue;
$this->path = $tempPath;
$literalBlockStyle = self::startsLiteralBlock($line);
if ($literalBlockStyle) {
$line = rtrim ($line, $literalBlockStyle . " \n");
$literalBlock = '';
$line .= ' '.$this->LiteralPlaceHolder;
$literal_block_indent = strlen($Source[$i+1]) - strlen(ltrim($Source[$i+1]));
while (++$i < $cnt && $this->literalBlockContinues($Source[$i], $this->indent)) {
$literalBlock = $this->addLiteralLine($literalBlock, $Source[$i], $literalBlockStyle, $literal_block_indent);
}
$i--;
}
// Strip out comments
if (strpos ($line, '#')) {
$line = preg_replace('/\s*#([^"\']+)$/','',$line);
}
while (++$i < $cnt && self::greedilyNeedNextLine($line)) {
$line = rtrim ($line, " \n\t\r") . ' ' . ltrim ($Source[$i], " \t");
}
$i--;
$lineArray = $this->_parseLine($line);
if ($literalBlockStyle)
$lineArray = $this->revertLiteralPlaceHolder ($lineArray, $literalBlock);
$this->addArray($lineArray, $this->indent);
foreach ($this->delayedPath as $indent => $delayedPath)
$this->path[$indent] = $delayedPath;
$this->delayedPath = array();
}
return $this->result;
}
private function loadFromSource ($input) {
if (!empty($input) && strpos($input, "\n") === false && file_exists($input))
$input = file_get_contents($input);
return $this->loadFromString($input);
}
if (strpos ($line, '#')) { private function loadFromString ($input) {
if (strpos ($line, '"') === false && strpos ($line, "'") === false) $lines = explode("\n",$input);
$line = preg_replace('/\s+#(.+)$/','',$line); foreach ($lines as $k => $_) {
} $lines[$k] = rtrim ($_, "\r");
}
return $lines;
}
$lineArray = $this->_parseLine($line); /**
* Parses YAML code and returns an array for a node
* @access private
* @return array
* @param string $line A line from the YAML file
*/
private function _parseLine($line) {
if (!$line) return array();
$line = trim($line);
if (!$line) return array();
if ($literalBlockStyle) $array = array();
$lineArray = $this->revertLiteralPlaceHolder ($lineArray, $literalBlock);
$this->addArray($lineArray, $this->indent); $group = $this->nodeContainsGroup($line);
if ($group) {
$this->addGroup($line, $group);
$line = $this->stripGroup ($line, $group);
}
foreach ($this->delayedPath as $indent => $delayedPath) if ($this->startsMappedSequence($line))
$this->path[$indent] = $delayedPath; return $this->returnMappedSequence($line);
$this->delayedPath = array(); if ($this->startsMappedValue($line))
return $this->returnMappedValue($line);
} if ($this->isArrayElement($line))
return $this->result; return $this->returnArrayElement($line);
}
private function loadFromSource ($input) { if ($this->isPlainArray($line))
if (!empty($input) && strpos($input, "\n") === false && file_exists($input)) return $this->returnPlainArray($line);
return file($input);
return $this->loadFromString($input);
}
private function loadFromString ($input) { return $this->returnKeyValuePair($line);
$lines = explode("\n",$input);
foreach ($lines as $k => $_) {
$lines[$k] = rtrim ($_, "\r");
}
return $lines;
}
/** }
* Parses YAML code and returns an array for a node
* @access private
* @return array
* @param string $line A line from the YAML file
*/
private function _parseLine($line) {
if (!$line) return array();
$line = trim($line);
if (!$line) return array(); /**
$array = array(); * Finds the type of the passed value, returns the value as the new type.
* @access private
* @param string $value
* @return mixed
*/
private function _toType($value) {
if ($value === '') return "";
$first_character = $value[0];
$last_character = substr($value, -1, 1);
$is_quoted = false;
do {
if (!$value) break;
if ($first_character != '"' && $first_character != "'") break;
if ($last_character != '"' && $last_character != "'") break;
$is_quoted = true;
} while (0);
if ($is_quoted) {
$value = str_replace('\n', "\n", $value);
if ($first_character == "'")
return strtr(substr ($value, 1, -1), array ('\'\'' => '\'', '\\\''=> '\''));
return strtr(substr ($value, 1, -1), array ('\\"' => '"', '\\\''=> '\''));
}
if (strpos($value, ' #') !== false && !$is_quoted)
$value = preg_replace('/\s+#(.+)$/','',$value);
if ($first_character == '[' && $last_character == ']') {
// Take out strings sequences and mappings
$innerValue = trim(substr ($value, 1, -1));
if ($innerValue === '') return array();
$explode = $this->_inlineEscape($innerValue);
// Propagate value array
$value = array();
foreach ($explode as $v) {
$value[] = $this->_toType($v);
}
return $value;
}
if (strpos($value,': ')!==false && $first_character != '{') {
$array = explode(': ',$value);
$key = trim($array[0]);
array_shift($array);
$value = trim(implode(': ',$array));
$value = $this->_toType($value);
return array($key => $value);
}
if ($first_character == '{' && $last_character == '}') {
$innerValue = trim(substr ($value, 1, -1));
if ($innerValue === '') return array();
// Inline Mapping
// Take out strings sequences and mappings
$explode = $this->_inlineEscape($innerValue);
// Propagate value array
$array = array();
foreach ($explode as $v) {
$SubArr = $this->_toType($v);
if (empty($SubArr)) continue;
if (is_array ($SubArr)) {
$array[key($SubArr)] = $SubArr[key($SubArr)]; continue;
}
$array[] = $SubArr;
}
return $array;
}
if ($value == 'null' || $value == 'NULL' || $value == 'Null' || $value == '' || $value == '~') {
return null;
}
if ( is_numeric($value) && preg_match ('/^(-|)[1-9]+[0-9]*$/', $value) ){
$intvalue = (int)$value;
if ($intvalue != PHP_INT_MAX && $intvalue != ~PHP_INT_MAX)
$value = $intvalue;
return $value;
}
if ( is_string($value) && preg_match('/^0[xX][0-9a-fA-F]+$/', $value)) {
// Hexadecimal value.
return hexdec($value);
}
$this->coerceValue($value);
if (is_numeric($value)) {
if ($value === '0') return 0;
if (rtrim ($value, 0) === $value)
$value = (float)$value;
return $value;
}
return $value;
}
$group = $this->nodeContainsGroup($line); /**
if ($group) { * Used in inlines to check for more inlines or quoted strings
$this->addGroup($line, $group); * @access private
$line = $this->stripGroup ($line, $group); * @return array
} */
private function _inlineEscape($inline) {
// There's gotta be a cleaner way to do this...
// While pure sequences seem to be nesting just fine,
// pure mappings and mappings with sequences inside can't go very
// deep. This needs to be fixed.
$seqs = array();
$maps = array();
$saved_strings = array();
$saved_empties = array();
// Check for empty strings
$regex = '/("")|(\'\')/';
if (preg_match_all($regex,$inline,$strings)) {
$saved_empties = $strings[0];
$inline = preg_replace($regex,'YAMLEmpty',$inline);
}
unset($regex);
// Check for strings
$regex = '/(?:(")|(?:\'))((?(1)[^"]+|[^\']+))(?(1)"|\')/';
if (preg_match_all($regex,$inline,$strings)) {
$saved_strings = $strings[0];
$inline = preg_replace($regex,'YAMLString',$inline);
}
unset($regex);
// echo $inline;
$i = 0;
do {
// Check for sequences
while (preg_match('/\[([^{}\[\]]+)\]/U',$inline,$matchseqs)) {
$seqs[] = $matchseqs[0];
$inline = preg_replace('/\[([^{}\[\]]+)\]/U', ('YAMLSeq' . (count($seqs) - 1) . 's'), $inline, 1);
}
// Check for mappings
while (preg_match('/{([^\[\]{}]+)}/U',$inline,$matchmaps)) {
$maps[] = $matchmaps[0];
$inline = preg_replace('/{([^\[\]{}]+)}/U', ('YAMLMap' . (count($maps) - 1) . 's'), $inline, 1);
}
if ($i++ >= 10) break;
} while (strpos ($inline, '[') !== false || strpos ($inline, '{') !== false);
$explode = explode(',',$inline);
$explode = array_map('trim', $explode);
$stringi = 0; $i = 0;
while (1) {
// Re-add the sequences
if (!empty($seqs)) {
foreach ($explode as $key => $value) {
if (strpos($value,'YAMLSeq') !== false) {
foreach ($seqs as $seqk => $seq) {
$explode[$key] = str_replace(('YAMLSeq'.$seqk.'s'),$seq,$value);
$value = $explode[$key];
}
}
}
}
// Re-add the mappings
if (!empty($maps)) {
foreach ($explode as $key => $value) {
if (strpos($value,'YAMLMap') !== false) {
foreach ($maps as $mapk => $map) {
$explode[$key] = str_replace(('YAMLMap'.$mapk.'s'), $map, $value);
$value = $explode[$key];
}
}
}
}
// Re-add the strings
if (!empty($saved_strings)) {
foreach ($explode as $key => $value) {
while (strpos($value,'YAMLString') !== false) {
$explode[$key] = preg_replace('/YAMLString/',$saved_strings[$stringi],$value, 1);
unset($saved_strings[$stringi]);
++$stringi;
$value = $explode[$key];
}
}
}
// Re-add the empties
if (!empty($saved_empties)) {
foreach ($explode as $key => $value) {
while (strpos($value,'YAMLEmpty') !== false) {
$explode[$key] = preg_replace('/YAMLEmpty/', '', $value, 1);
$value = $explode[$key];
}
}
}
$finished = true;
foreach ($explode as $key => $value) {
if (strpos($value,'YAMLSeq') !== false) {
$finished = false; break;
}
if (strpos($value,'YAMLMap') !== false) {
$finished = false; break;
}
if (strpos($value,'YAMLString') !== false) {
$finished = false; break;
}
if (strpos($value,'YAMLEmpty') !== false) {
$finished = false; break;
}
}
if ($finished) break;
$i++;
if ($i > 10)
break; // Prevent infinite loops.
}
return $explode;
}
if ($this->startsMappedSequence($line)) private function literalBlockContinues ($line, $lineIndent) {
return $this->returnMappedSequence($line); if (!trim($line)) return true;
if (strlen($line) - strlen(ltrim($line)) > $lineIndent) return true;
return false;
}
if ($this->startsMappedValue($line)) private function referenceContentsByAlias ($alias) {
return $this->returnMappedValue($line); do {
if (!isset($this->SavedGroups[$alias])) { echo "Bad group name: $alias."; break; }
$groupPath = $this->SavedGroups[$alias];
$value = $this->result;
foreach ($groupPath as $k) {
$value = $value[$k];
}
} while (false);
return $value;
}
if ($this->isArrayElement($line)) private function addArrayInline ($array, $indent) {
return $this->returnArrayElement($line); $CommonGroupPath = $this->path;
if (empty ($array)) return false;
if ($this->isPlainArray($line)) foreach ($array as $k => $_) {
return $this->returnPlainArray($line); $this->addArray(array($k => $_), $indent);
$this->path = $CommonGroupPath;
}
return $this->returnKeyValuePair($line); return true;
}
} private function addArray ($incoming_data, $incoming_indent) {
// print_r ($incoming_data);
if (count ($incoming_data) > 1)
return $this->addArrayInline ($incoming_data, $incoming_indent);
$key = key ($incoming_data);
$value = isset($incoming_data[$key]) ? $incoming_data[$key] : null;
if ($key === '__!YAMLZero') $key = '0';
if ($incoming_indent == 0 && !$this->_containsGroupAlias && !$this->_containsGroupAnchor) { // Shortcut for root-level values.
if ($key || $key === '' || $key === '0') {
$this->result[$key] = $value;
} else {
$this->result[] = $value; end ($this->result); $key = key ($this->result);
}
$this->path[$incoming_indent] = $key;
return;
}
$history = array();
// Unfolding inner array tree.
$history[] = $_arr = $this->result;
foreach ($this->path as $k) {
$history[] = $_arr = $_arr[$k];
}
if ($this->_containsGroupAlias) {
$value = $this->referenceContentsByAlias($this->_containsGroupAlias);
$this->_containsGroupAlias = false;
}
// Adding string or numeric key to the innermost level or $this->arr.
if (is_string($key) && $key == '<<') {
if (!is_array ($_arr)) { $_arr = array (); }
$_arr = array_merge ($_arr, $value);
} else if ($key || $key === '' || $key === '0') {
if (!is_array ($_arr))
$_arr = array ($key=>$value);
else
$_arr[$key] = $value;
} else {
if (!is_array ($_arr)) { $_arr = array ($value); $key = 0; }
else { $_arr[] = $value; end ($_arr); $key = key ($_arr); }
}
$reverse_path = array_reverse($this->path);
$reverse_history = array_reverse ($history);
$reverse_history[0] = $_arr;
$cnt = count($reverse_history) - 1;
for ($i = 0; $i < $cnt; $i++) {
$reverse_history[$i+1][$reverse_path[$i]] = $reverse_history[$i];
}
$this->result = $reverse_history[$cnt];
$this->path[$incoming_indent] = $key;
if ($this->_containsGroupAnchor) {
$this->SavedGroups[$this->_containsGroupAnchor] = $this->path;
if (is_array ($value)) {
$k = key ($value);
if (!is_int ($k)) {
$this->SavedGroups[$this->_containsGroupAnchor][$incoming_indent + 2] = $k;
}
}
$this->_containsGroupAnchor = false;
}
/** }
* Finds the type of the passed value, returns the value as the new type.
* @access private
* @param string $value
* @return mixed
*/
private function _toType($value) {
if ($value === '') return null;
$first_character = $value[0];
$last_character = substr($value, -1, 1);
$is_quoted = false;
do {
if (!$value) break;
if ($first_character != '"' && $first_character != "'") break;
if ($last_character != '"' && $last_character != "'") break;
$is_quoted = true;
} while (0);
if ($is_quoted)
return strtr(substr ($value, 1, -1), array ('\\"' => '"', '\'\'' => '\'', '\\\'' => '\''));
if (strpos($value, ' #') !== false)
$value = preg_replace('/\s+#(.+)$/','',$value);
if ($first_character == '[' && $last_character == ']') {
// Take out strings sequences and mappings
$innerValue = trim(substr ($value, 1, -1));
if ($innerValue === '') return array();
$explode = $this->_inlineEscape($innerValue);
// Propagate value array
$value = array();
foreach ($explode as $v) {
$value[] = $this->_toType($v);
}
return $value;
}
if (strpos($value,': ')!==false && $first_character != '{') { private static function startsLiteralBlock ($line) {
$array = explode(': ',$value); $lastChar = substr (trim($line), -1);
$key = trim($array[0]); if ($lastChar != '>' && $lastChar != '|') return false;
array_shift($array); if ($lastChar == '|') return $lastChar;
$value = trim(implode(': ',$array)); // HTML tags should not be counted as literal blocks.
$value = $this->_toType($value); if (preg_match ('#<.*?>$#', $line)) return false;
return array($key => $value); return $lastChar;
}
if ($first_character == '{' && $last_character == '}') {
$innerValue = trim(substr ($value, 1, -1));
if ($innerValue === '') return array();
// Inline Mapping
// Take out strings sequences and mappings
$explode = $this->_inlineEscape($innerValue);
// Propagate value array
$array = array();
foreach ($explode as $v) {
$SubArr = $this->_toType($v);
if (empty($SubArr)) continue;
if (is_array ($SubArr)) {
$array[key($SubArr)] = $SubArr[key($SubArr)]; continue;
} }
$array[] = $SubArr;
}
return $array;
}
if ($value == 'null' || $value == 'NULL' || $value == 'Null' || $value == '' || $value == '~') { private static function greedilyNeedNextLine($line) {
return null; $line = trim ($line);
} if (!strlen($line)) return false;
if (substr ($line, -1, 1) == ']') return false;
if ($line[0] == '[') return true;
if (preg_match ('#^[^:]+?:\s*\[#', $line)) return true;
return false;
}
if (intval($first_character) > 0 && preg_match ('/^[1-9]+[0-9]*$/', $value)) { private function addLiteralLine ($literalBlock, $line, $literalBlockStyle, $indent = -1) {
$intvalue = (int)$value; $line = self::stripIndent($line, $indent);
if ($intvalue != PHP_INT_MAX) if ($literalBlockStyle !== '|') {
$value = $intvalue; $line = self::stripIndent($line);
return $value; }
} $line = rtrim ($line, "\r\n\t ") . "\n";
if ($literalBlockStyle == '|') {
return $literalBlock . $line;
}
if (strlen($line) == 0)
return rtrim($literalBlock, ' ') . "\n";
if ($line == "\n" && $literalBlockStyle == '>') {
return rtrim ($literalBlock, " \t") . "\n";
}
if ($line != "\n")
$line = trim ($line, "\r\n ") . " ";
return $literalBlock . $line;
}
if (in_array($value, function revertLiteralPlaceHolder ($lineArray, $literalBlock) {
array('true', 'on', '+', 'yes', 'y', 'True', 'TRUE', 'On', 'ON', 'YES', 'Yes', 'Y'))) { foreach ($lineArray as $k => $_) {
return true; if (is_array($_))
} $lineArray[$k] = $this->revertLiteralPlaceHolder ($_, $literalBlock);
else if (substr($_, -1 * strlen ($this->LiteralPlaceHolder)) == $this->LiteralPlaceHolder)
$lineArray[$k] = rtrim ($literalBlock, " \r\n");
}
return $lineArray;
}
if (in_array(strtolower($value), private static function stripIndent ($line, $indent = -1) {
array('false', 'off', '-', 'no', 'n'))) { if ($indent == -1) $indent = strlen($line) - strlen(ltrim($line));
return false; return substr ($line, $indent);
} }
if (is_numeric($value)) { private function getParentPathByIndent ($indent) {
if ($value === '0') return 0; if ($indent == 0) return array();
if (trim ($value, 0) === $value) $linePath = $this->path;
$value = (float)$value; do {
return $value; end($linePath); $lastIndentInParentPath = key($linePath);
} if ($indent <= $lastIndentInParentPath) array_pop ($linePath);
} while ($indent <= $lastIndentInParentPath);
return $value; return $linePath;
} }
/**
* Used in inlines to check for more inlines or quoted strings
* @access private
* @return array
*/
private function _inlineEscape($inline) {
// There's gotta be a cleaner way to do this...
// While pure sequences seem to be nesting just fine,
// pure mappings and mappings with sequences inside can't go very
// deep. This needs to be fixed.
$seqs = array();
$maps = array();
$saved_strings = array();
// Check for strings
$regex = '/(?:(")|(?:\'))((?(1)[^"]+|[^\']+))(?(1)"|\')/';
if (preg_match_all($regex,$inline,$strings)) {
$saved_strings = $strings[0];
$inline = preg_replace($regex,'YAMLString',$inline);
}
unset($regex);
$i = 0; private function clearBiggerPathValues ($indent) {
do {
// Check for sequences
while (preg_match('/\[([^{}\[\]]+)\]/U',$inline,$matchseqs)) {
$seqs[] = $matchseqs[0];
$inline = preg_replace('/\[([^{}\[\]]+)\]/U', ('YAMLSeq' . (count($seqs) - 1) . 's'), $inline, 1);
}
// Check for mappings if ($indent == 0) $this->path = array();
while (preg_match('/{([^\[\]{}]+)}/U',$inline,$matchmaps)) { if (empty ($this->path)) return true;
$maps[] = $matchmaps[0];
$inline = preg_replace('/{([^\[\]{}]+)}/U', ('YAMLMap' . (count($maps) - 1) . 's'), $inline, 1);
}
if ($i++ >= 10) break; foreach ($this->path as $k => $_) {
if ($k > $indent) unset ($this->path[$k]);
}
} while (strpos ($inline, '[') !== false || strpos ($inline, '{') !== false); return true;
}
$explode = explode(', ',$inline);
$stringi = 0; $i = 0;
while (1) { private static function isComment ($line) {
if (!$line) return false;
if ($line[0] == '#') return true;
if (trim($line, " \r\n\t") == '---') return true;
return false;
}
// Re-add the sequences private static function isEmpty ($line) {
if (!empty($seqs)) { return (trim ($line) === '');
foreach ($explode as $key => $value) {
if (strpos($value,'YAMLSeq') !== false) {
foreach ($seqs as $seqk => $seq) {
$explode[$key] = str_replace(('YAMLSeq'.$seqk.'s'),$seq,$value);
$value = $explode[$key];
}
} }
}
}
// Re-add the mappings
if (!empty($maps)) { private function isArrayElement ($line) {
foreach ($explode as $key => $value) { if (!$line || !is_scalar($line)) return false;
if (strpos($value,'YAMLMap') !== false) { if (substr($line, 0, 2) != '- ') return false;
foreach ($maps as $mapk => $map) { if (strlen ($line) > 3)
$explode[$key] = str_replace(('YAMLMap'.$mapk.'s'), $map, $value); if (substr($line,0,3) == '---') return false;
$value = $explode[$key];
} return true;
} }
}
}
private function isHashElement ($line) {
return strpos($line, ':');
}
// Re-add the strings private function isLiteral ($line) {
if (!empty($saved_strings)) { if ($this->isArrayElement($line)) return false;
foreach ($explode as $key => $value) { if ($this->isHashElement($line)) return false;
while (strpos($value,'YAMLString') !== false) { return true;
$explode[$key] = preg_replace('/YAMLString/',$saved_strings[$stringi],$value, 1);
unset($saved_strings[$stringi]);
++$stringi;
$value = $explode[$key];
} }
}
}
$finished = true;
foreach ($explode as $key => $value) {
if (strpos($value,'YAMLSeq') !== false) {
$finished = false; break;
}
if (strpos($value,'YAMLMap') !== false) {
$finished = false; break;
}
if (strpos($value,'YAMLString') !== false) {
$finished = false; break;
}
}
if ($finished) break;
$i++; private static function unquote ($value) {
if ($i > 10) if (!$value) return $value;
break; // Prevent infinite loops. if (!is_string($value)) return $value;
} if ($value[0] == '\'') return trim ($value, '\'');
if ($value[0] == '"') return trim ($value, '"');
return $value;
}
return $explode; private function startsMappedSequence ($line) {
} return (substr($line, 0, 2) == '- ' && substr ($line, -1, 1) == ':');
}
private function literalBlockContinues ($line, $lineIndent) {
if (!trim($line)) return true;
if (strlen($line) - strlen(ltrim($line)) > $lineIndent) return true;
return false;
}
private function referenceContentsByAlias ($alias) {
do {
if (!isset($this->SavedGroups[$alias])) { echo "Bad group name: $alias."; break; }
$groupPath = $this->SavedGroups[$alias];
$value = $this->result;
foreach ($groupPath as $k) {
$value = $value[$k];
}
} while (false);
return $value;
}
private function addArrayInline ($array, $indent) {
$CommonGroupPath = $this->path;
if (empty ($array)) return false;
foreach ($array as $k => $_) {
$this->addArray(array($k => $_), $indent);
$this->path = $CommonGroupPath;
}
return true;
}
private function addArray ($incoming_data, $incoming_indent) {
// print_r ($incoming_data);
if (count ($incoming_data) > 1)
return $this->addArrayInline ($incoming_data, $incoming_indent);
$key = key ($incoming_data);
$value = isset($incoming_data[$key]) ? $incoming_data[$key] : null;
if ($key === '__!YAMLZero') $key = '0';
if ($incoming_indent == 0 && !$this->_containsGroupAlias && !$this->_containsGroupAnchor) { // Shortcut for root-level values.
if ($key || $key === '' || $key === '0') {
$this->result[$key] = $value;
} else {
$this->result[] = $value; end ($this->result); $key = key ($this->result);
}
$this->path[$incoming_indent] = $key;
return;
}
private function returnMappedSequence ($line) {
$array = array();
$key = self::unquote(trim(substr($line,1,-1)));
$array[$key] = array();
$this->delayedPath = array(strpos ($line, $key) + $this->indent => $key);
return array($array);
}
private function checkKeysInValue($value) {
$history = array(); if (strchr('[{"\'', $value[0]) === false) {
// Unfolding inner array tree. if (strchr($value, ': ') !== false) {
$history[] = $_arr = $this->result; throw new Exception('Too many keys: '.$value);
foreach ($this->path as $k) { }
$history[] = $_arr = $_arr[$k]; }
} }
if ($this->_containsGroupAlias) { private function returnMappedValue ($line) {
$value = $this->referenceContentsByAlias($this->_containsGroupAlias); $this->checkKeysInValue($line);
$this->_containsGroupAlias = false; $array = array();
} $key = self::unquote (trim(substr($line,0,-1)));
$array[$key] = '';
return $array;
}
private function startsMappedValue ($line) {
return (substr ($line, -1, 1) == ':');
}
// Adding string or numeric key to the innermost level or $this->arr. private function isPlainArray ($line) {
if (is_string($key) && $key == '<<') { return ($line[0] == '[' && substr ($line, -1, 1) == ']');
if (!is_array ($_arr)) { $_arr = array (); } }
$_arr = array_merge ($_arr, $value); private function returnPlainArray ($line) {
} else if ($key || $key === '' || $key === '0') { return $this->_toType($line);
$_arr[$key] = $value; }
} else {
if (!is_array ($_arr)) { $_arr = array ($value); $key = 0; }
else { $_arr[] = $value; end ($_arr); $key = key ($_arr); }
}
$reverse_path = array_reverse($this->path); private function returnKeyValuePair ($line) {
$reverse_history = array_reverse ($history); $array = array();
$reverse_history[0] = $_arr; $key = '';
$cnt = count($reverse_history) - 1; if (strpos ($line, ': ')) {
for ($i = 0; $i < $cnt; $i++) { // It's a key/value pair most likely
$reverse_history[$i+1][$reverse_path[$i]] = $reverse_history[$i]; // If the key is in double quotes pull it out
} if (($line[0] == '"' || $line[0] == "'") && preg_match('/^(["\'](.*)["\'](\s)*:)/',$line,$matches)) {
$this->result = $reverse_history[$cnt]; $value = trim(str_replace($matches[1],'',$line));
$key = $matches[2];
} else {
// Do some guesswork as to the key and the value
$explode = explode(': ', $line);
$key = trim(array_shift($explode));
$value = trim(implode(': ', $explode));
$this->checkKeysInValue($value);
}
// Set the type of the value. Int, string, etc
$value = $this->_toType($value);
if ($key === '0') $key = '__!YAMLZero';
$array[$key] = $value;
} else {
$array = array ($line);
}
return $array;
}
$this->path[$incoming_indent] = $key;
if ($this->_containsGroupAnchor) { private function returnArrayElement ($line) {
$this->SavedGroups[$this->_containsGroupAnchor] = $this->path; if (strlen($line) <= 1) return array(array()); // Weird %)
if (is_array ($value)) { $array = array();
$k = key ($value); $value = trim(substr($line,1));
if (!is_int ($k)) { $value = $this->_toType($value);
$this->SavedGroups[$this->_containsGroupAnchor][$incoming_indent + 2] = $k; if ($this->isArrayElement($value)) {
$value = $this->returnArrayElement($value);
}
$array[] = $value;
return $array;
} }
}
$this->_containsGroupAnchor = false;
}
}
private static function startsLiteralBlock ($line) {
$lastChar = substr (trim($line), -1);
if ($lastChar != '>' && $lastChar != '|') return false;
if ($lastChar == '|') return $lastChar;
// HTML tags should not be counted as literal blocks.
if (preg_match ('#<.*?>$#', $line)) return false;
return $lastChar;
}
private static function greedilyNeedNextLine($line) {
$line = trim ($line);
if (!strlen($line)) return false;
if (substr ($line, -1, 1) == ']') return false;
if ($line[0] == '[') return true;
if (preg_match ('#^[^:]+?:\s*\[#', $line)) return true;
return false;
}
private function addLiteralLine ($literalBlock, $line, $literalBlockStyle) {
$line = self::stripIndent($line);
$line = rtrim ($line, "\r\n\t ") . "\n";
if ($literalBlockStyle == '|') {
return $literalBlock . $line;
}
if (strlen($line) == 0)
return rtrim($literalBlock, ' ') . "\n";
if ($line == "\n" && $literalBlockStyle == '>') {
return rtrim ($literalBlock, " \t") . "\n";
}
if ($line != "\n")
$line = trim ($line, "\r\n ") . " ";
return $literalBlock . $line;
}
function revertLiteralPlaceHolder ($lineArray, $literalBlock) {
foreach ($lineArray as $k => $_) {
if (is_array($_))
$lineArray[$k] = $this->revertLiteralPlaceHolder ($_, $literalBlock);
else if (substr($_, -1 * strlen ($this->LiteralPlaceHolder)) == $this->LiteralPlaceHolder)
$lineArray[$k] = rtrim ($literalBlock, " \r\n");
}
return $lineArray;
}
private static function stripIndent ($line, $indent = -1) {
if ($indent == -1) $indent = strlen($line) - strlen(ltrim($line));
return substr ($line, $indent);
}
private function getParentPathByIndent ($indent) {
if ($indent == 0) return array();
$linePath = $this->path;
do {
end($linePath); $lastIndentInParentPath = key($linePath);
if ($indent <= $lastIndentInParentPath) array_pop ($linePath);
} while ($indent <= $lastIndentInParentPath);
return $linePath;
}
private function clearBiggerPathValues ($indent) {
if ($indent == 0) $this->path = array();
if (empty ($this->path)) return true;
foreach ($this->path as $k => $_) {
if ($k > $indent) unset ($this->path[$k]);
}
return true; private function nodeContainsGroup ($line) {
} $symbolsForReference = 'A-z0-9_\-';
if (strpos($line, '&') === false && strpos($line, '*') === false) return false; // Please die fast ;-)
if ($line[0] == '&' && preg_match('/^(&['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
private static function isComment ($line) { if ($line[0] == '*' && preg_match('/^(\*['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
if (!$line) return false; if (preg_match('/(&['.$symbolsForReference.']+)$/', $line, $matches)) return $matches[1];
if ($line[0] == '#') return true; if (preg_match('/(\*['.$symbolsForReference.']+$)/', $line, $matches)) return $matches[1];
if (trim($line, " \r\n\t") == '---') return true; if (preg_match ('#^\s*<<\s*:\s*(\*[^\s]+).*$#', $line, $matches)) return $matches[1];
return false; return false;
}
}
private static function isEmpty ($line) {
return (trim ($line) === ''); private function addGroup ($line, $group) {
} if ($group[0] == '&') $this->_containsGroupAnchor = substr ($group, 1);
if ($group[0] == '*') $this->_containsGroupAlias = substr ($group, 1);
//print_r ($this->path);
private function isArrayElement ($line) { }
if (!$line) return false;
if ($line[0] != '-') return false; private function stripGroup ($line, $group) {
if (strlen ($line) > 3) $line = trim(str_replace($group, '', $line));
if (substr($line,0,3) == '---') return false; return $line;
}
return true;
}
private function isHashElement ($line) {
return strpos($line, ':');
}
private function isLiteral ($line) {
if ($this->isArrayElement($line)) return false;
if ($this->isHashElement($line)) return false;
return true;
}
private static function unquote ($value) {
if (!$value) return $value;
if (!is_string($value)) return $value;
if ($value[0] == '\'') return trim ($value, '\'');
if ($value[0] == '"') return trim ($value, '"');
return $value;
}
private function startsMappedSequence ($line) {
return ($line[0] == '-' && substr ($line, -1, 1) == ':');
}
private function returnMappedSequence ($line) {
$array = array();
$key = self::unquote(trim(substr($line,1,-1)));
$array[$key] = array();
$this->delayedPath = array(strpos ($line, $key) + $this->indent => $key);
return array($array);
}
private function returnMappedValue ($line) {
$array = array();
$key = self::unquote (trim(substr($line,0,-1)));
$array[$key] = '';
return $array;
}
private function startsMappedValue ($line) {
return (substr ($line, -1, 1) == ':');
}
private function isPlainArray ($line) {
return ($line[0] == '[' && substr ($line, -1, 1) == ']');
}
private function returnPlainArray ($line) {
return $this->_toType($line);
}
private function returnKeyValuePair ($line) {
$array = array();
$key = '';
if (strpos ($line, ':')) {
// It's a key/value pair most likely
// If the key is in double quotes pull it out
if (($line[0] == '"' || $line[0] == "'") && preg_match('/^(["\'](.*)["\'](\s)*:)/',$line,$matches)) {
$value = trim(str_replace($matches[1],'',$line));
$key = $matches[2];
} else {
// Do some guesswork as to the key and the value
$explode = explode(':',$line);
$key = trim($explode[0]);
array_shift($explode);
$value = trim(implode(':',$explode));
}
// Set the type of the value. Int, string, etc
$value = $this->_toType($value);
if ($key === '0') $key = '__!YAMLZero';
$array[$key] = $value;
} else {
$array = array ($line);
} }
return $array;
}
private function returnArrayElement ($line) {
if (strlen($line) <= 1) return array(array()); // Weird %)
$array = array();
$value = trim(substr($line,1));
$value = $this->_toType($value);
$array[] = $value;
return $array;
}
private function nodeContainsGroup ($line) {
$symbolsForReference = 'A-z0-9_\-';
if (strpos($line, '&') === false && strpos($line, '*') === false) return false; // Please die fast ;-)
if ($line[0] == '&' && preg_match('/^(&['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
if ($line[0] == '*' && preg_match('/^(\*['.$symbolsForReference.']+)/', $line, $matches)) return $matches[1];
if (preg_match('/(&['.$symbolsForReference.']+)$/', $line, $matches)) return $matches[1];
if (preg_match('/(\*['.$symbolsForReference.']+$)/', $line, $matches)) return $matches[1];
if (preg_match ('#^\s*<<\s*:\s*(\*[^\s]+).*$#', $line, $matches)) return $matches[1];
return false;
}
private function addGroup ($line, $group) {
if ($group[0] == '&') $this->_containsGroupAnchor = substr ($group, 1);
if ($group[0] == '*') $this->_containsGroupAlias = substr ($group, 1);
//print_r ($this->path);
}
private function stripGroup ($line, $group) {
$line = trim(str_replace($group, '', $line));
return $line;
}
} }
// Enable use of Spyc from command line // Enable use of Spyc from command line
// The syntax is the following: php spyc.php spyc.yaml // The syntax is the following: php Spyc.php spyc.yaml
define ('SPYC_FROM_COMMAND_LINE', false);
do { do {
if (!SPYC_FROM_COMMAND_LINE) break; if (PHP_SAPI != 'cli') break;
if (empty ($_SERVER['argc']) || $_SERVER['argc'] < 2) break; if (empty ($_SERVER['argc']) || $_SERVER['argc'] < 2) break;
if (empty ($_SERVER['PHP_SELF']) || $_SERVER['PHP_SELF'] != 'spyc.php') break; if (empty ($_SERVER['PHP_SELF']) || FALSE === strpos ($_SERVER['PHP_SELF'], 'Spyc.php') ) break;
$file = $argv[1]; $file = $argv[1];
printf ("Spyc loading file: %s\n", $file); echo json_encode (spyc_load_file ($file));
print_r (spyc_load_file ($file)); } while (0);
} while (0);
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment