/vendor/composer/ClassLoader.php |
@@ -0,0 +1,445 @@ |
<?php |
|
/* |
* This file is part of Composer. |
* |
* (c) Nils Adermann <naderman@naderman.de> |
* Jordi Boggiano <j.boggiano@seld.be> |
* |
* For the full copyright and license information, please view the LICENSE |
* file that was distributed with this source code. |
*/ |
|
namespace Composer\Autoload; |
|
/** |
* ClassLoader implements a PSR-0, PSR-4 and classmap class loader. |
* |
* $loader = new \Composer\Autoload\ClassLoader(); |
* |
* // register classes with namespaces |
* $loader->add('Symfony\Component', __DIR__.'/component'); |
* $loader->add('Symfony', __DIR__.'/framework'); |
* |
* // activate the autoloader |
* $loader->register(); |
* |
* // to enable searching the include path (eg. for PEAR packages) |
* $loader->setUseIncludePath(true); |
* |
* In this example, if you try to use a class in the Symfony\Component |
* namespace or one of its children (Symfony\Component\Console for instance), |
* the autoloader will first look for the class under the component/ |
* directory, and it will then fallback to the framework/ directory if not |
* found before giving up. |
* |
* This class is loosely based on the Symfony UniversalClassLoader. |
* |
* @author Fabien Potencier <fabien@symfony.com> |
* @author Jordi Boggiano <j.boggiano@seld.be> |
* @see http://www.php-fig.org/psr/psr-0/ |
* @see http://www.php-fig.org/psr/psr-4/ |
*/ |
class ClassLoader |
{ |
// PSR-4 |
private $prefixLengthsPsr4 = array(); |
private $prefixDirsPsr4 = array(); |
private $fallbackDirsPsr4 = array(); |
|
// PSR-0 |
private $prefixesPsr0 = array(); |
private $fallbackDirsPsr0 = array(); |
|
private $useIncludePath = false; |
private $classMap = array(); |
private $classMapAuthoritative = false; |
private $missingClasses = array(); |
private $apcuPrefix; |
|
public function getPrefixes() |
{ |
if (!empty($this->prefixesPsr0)) { |
return call_user_func_array('array_merge', $this->prefixesPsr0); |
} |
|
return array(); |
} |
|
public function getPrefixesPsr4() |
{ |
return $this->prefixDirsPsr4; |
} |
|
public function getFallbackDirs() |
{ |
return $this->fallbackDirsPsr0; |
} |
|
public function getFallbackDirsPsr4() |
{ |
return $this->fallbackDirsPsr4; |
} |
|
public function getClassMap() |
{ |
return $this->classMap; |
} |
|
/** |
* @param array $classMap Class to filename map |
*/ |
public function addClassMap(array $classMap) |
{ |
if ($this->classMap) { |
$this->classMap = array_merge($this->classMap, $classMap); |
} else { |
$this->classMap = $classMap; |
} |
} |
|
/** |
* Registers a set of PSR-0 directories for a given prefix, either |
* appending or prepending to the ones previously set for this prefix. |
* |
* @param string $prefix The prefix |
* @param array|string $paths The PSR-0 root directories |
* @param bool $prepend Whether to prepend the directories |
*/ |
public function add($prefix, $paths, $prepend = false) |
{ |
if (!$prefix) { |
if ($prepend) { |
$this->fallbackDirsPsr0 = array_merge( |
(array) $paths, |
$this->fallbackDirsPsr0 |
); |
} else { |
$this->fallbackDirsPsr0 = array_merge( |
$this->fallbackDirsPsr0, |
(array) $paths |
); |
} |
|
return; |
} |
|
$first = $prefix[0]; |
if (!isset($this->prefixesPsr0[$first][$prefix])) { |
$this->prefixesPsr0[$first][$prefix] = (array) $paths; |
|
return; |
} |
if ($prepend) { |
$this->prefixesPsr0[$first][$prefix] = array_merge( |
(array) $paths, |
$this->prefixesPsr0[$first][$prefix] |
); |
} else { |
$this->prefixesPsr0[$first][$prefix] = array_merge( |
$this->prefixesPsr0[$first][$prefix], |
(array) $paths |
); |
} |
} |
|
/** |
* Registers a set of PSR-4 directories for a given namespace, either |
* appending or prepending to the ones previously set for this namespace. |
* |
* @param string $prefix The prefix/namespace, with trailing '\\' |
* @param array|string $paths The PSR-4 base directories |
* @param bool $prepend Whether to prepend the directories |
* |
* @throws \InvalidArgumentException |
*/ |
public function addPsr4($prefix, $paths, $prepend = false) |
{ |
if (!$prefix) { |
// Register directories for the root namespace. |
if ($prepend) { |
$this->fallbackDirsPsr4 = array_merge( |
(array) $paths, |
$this->fallbackDirsPsr4 |
); |
} else { |
$this->fallbackDirsPsr4 = array_merge( |
$this->fallbackDirsPsr4, |
(array) $paths |
); |
} |
} elseif (!isset($this->prefixDirsPsr4[$prefix])) { |
// Register directories for a new namespace. |
$length = strlen($prefix); |
if ('\\' !== $prefix[$length - 1]) { |
throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator."); |
} |
$this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length; |
$this->prefixDirsPsr4[$prefix] = (array) $paths; |
} elseif ($prepend) { |
// Prepend directories for an already registered namespace. |
$this->prefixDirsPsr4[$prefix] = array_merge( |
(array) $paths, |
$this->prefixDirsPsr4[$prefix] |
); |
} else { |
// Append directories for an already registered namespace. |
$this->prefixDirsPsr4[$prefix] = array_merge( |
$this->prefixDirsPsr4[$prefix], |
(array) $paths |
); |
} |
} |
|
/** |
* Registers a set of PSR-0 directories for a given prefix, |
* replacing any others previously set for this prefix. |
* |
* @param string $prefix The prefix |
* @param array|string $paths The PSR-0 base directories |
*/ |
public function set($prefix, $paths) |
{ |
if (!$prefix) { |
$this->fallbackDirsPsr0 = (array) $paths; |
} else { |
$this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths; |
} |
} |
|
/** |
* Registers a set of PSR-4 directories for a given namespace, |
* replacing any others previously set for this namespace. |
* |
* @param string $prefix The prefix/namespace, with trailing '\\' |
* @param array|string $paths The PSR-4 base directories |
* |
* @throws \InvalidArgumentException |
*/ |
public function setPsr4($prefix, $paths) |
{ |
if (!$prefix) { |
$this->fallbackDirsPsr4 = (array) $paths; |
} else { |
$length = strlen($prefix); |
if ('\\' !== $prefix[$length - 1]) { |
throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator."); |
} |
$this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length; |
$this->prefixDirsPsr4[$prefix] = (array) $paths; |
} |
} |
|
/** |
* Turns on searching the include path for class files. |
* |
* @param bool $useIncludePath |
*/ |
public function setUseIncludePath($useIncludePath) |
{ |
$this->useIncludePath = $useIncludePath; |
} |
|
/** |
* Can be used to check if the autoloader uses the include path to check |
* for classes. |
* |
* @return bool |
*/ |
public function getUseIncludePath() |
{ |
return $this->useIncludePath; |
} |
|
/** |
* Turns off searching the prefix and fallback directories for classes |
* that have not been registered with the class map. |
* |
* @param bool $classMapAuthoritative |
*/ |
public function setClassMapAuthoritative($classMapAuthoritative) |
{ |
$this->classMapAuthoritative = $classMapAuthoritative; |
} |
|
/** |
* Should class lookup fail if not found in the current class map? |
* |
* @return bool |
*/ |
public function isClassMapAuthoritative() |
{ |
return $this->classMapAuthoritative; |
} |
|
/** |
* APCu prefix to use to cache found/not-found classes, if the extension is enabled. |
* |
* @param string|null $apcuPrefix |
*/ |
public function setApcuPrefix($apcuPrefix) |
{ |
$this->apcuPrefix = function_exists('apcu_fetch') && ini_get('apc.enabled') ? $apcuPrefix : null; |
} |
|
/** |
* The APCu prefix in use, or null if APCu caching is not enabled. |
* |
* @return string|null |
*/ |
public function getApcuPrefix() |
{ |
return $this->apcuPrefix; |
} |
|
/** |
* Registers this instance as an autoloader. |
* |
* @param bool $prepend Whether to prepend the autoloader or not |
*/ |
public function register($prepend = false) |
{ |
spl_autoload_register(array($this, 'loadClass'), true, $prepend); |
} |
|
/** |
* Unregisters this instance as an autoloader. |
*/ |
public function unregister() |
{ |
spl_autoload_unregister(array($this, 'loadClass')); |
} |
|
/** |
* Loads the given class or interface. |
* |
* @param string $class The name of the class |
* @return bool|null True if loaded, null otherwise |
*/ |
public function loadClass($class) |
{ |
if ($file = $this->findFile($class)) { |
includeFile($file); |
|
return true; |
} |
} |
|
/** |
* Finds the path to the file where the class is defined. |
* |
* @param string $class The name of the class |
* |
* @return string|false The path if found, false otherwise |
*/ |
public function findFile($class) |
{ |
// class map lookup |
if (isset($this->classMap[$class])) { |
return $this->classMap[$class]; |
} |
if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) { |
return false; |
} |
if (null !== $this->apcuPrefix) { |
$file = apcu_fetch($this->apcuPrefix.$class, $hit); |
if ($hit) { |
return $file; |
} |
} |
|
$file = $this->findFileWithExtension($class, '.php'); |
|
// Search for Hack files if we are running on HHVM |
if (false === $file && defined('HHVM_VERSION')) { |
$file = $this->findFileWithExtension($class, '.hh'); |
} |
|
if (null !== $this->apcuPrefix) { |
apcu_add($this->apcuPrefix.$class, $file); |
} |
|
if (false === $file) { |
// Remember that this class does not exist. |
$this->missingClasses[$class] = true; |
} |
|
return $file; |
} |
|
private function findFileWithExtension($class, $ext) |
{ |
// PSR-4 lookup |
$logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext; |
|
$first = $class[0]; |
if (isset($this->prefixLengthsPsr4[$first])) { |
$subPath = $class; |
while (false !== $lastPos = strrpos($subPath, '\\')) { |
$subPath = substr($subPath, 0, $lastPos); |
$search = $subPath.'\\'; |
if (isset($this->prefixDirsPsr4[$search])) { |
foreach ($this->prefixDirsPsr4[$search] as $dir) { |
$length = $this->prefixLengthsPsr4[$first][$search]; |
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $length))) { |
return $file; |
} |
} |
} |
} |
} |
|
// PSR-4 fallback dirs |
foreach ($this->fallbackDirsPsr4 as $dir) { |
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) { |
return $file; |
} |
} |
|
// PSR-0 lookup |
if (false !== $pos = strrpos($class, '\\')) { |
// namespaced class name |
$logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1) |
. strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR); |
} else { |
// PEAR-like class name |
$logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext; |
} |
|
if (isset($this->prefixesPsr0[$first])) { |
foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) { |
if (0 === strpos($class, $prefix)) { |
foreach ($dirs as $dir) { |
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) { |
return $file; |
} |
} |
} |
} |
} |
|
// PSR-0 fallback dirs |
foreach ($this->fallbackDirsPsr0 as $dir) { |
if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) { |
return $file; |
} |
} |
|
// PSR-0 include paths. |
if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) { |
return $file; |
} |
|
return false; |
} |
} |
|
/** |
* Scope isolated include. |
* |
* Prevents access to $this/self from included files. |
*/ |
function includeFile($file) |
{ |
include $file; |
} |
/vendor/mustangostang/spyc/Spyc.php |
@@ -0,0 +1,1161 @@ |
<?php |
/** |
* Spyc -- A Simple PHP YAML Class |
* @version 0.6.2 |
* @author Vlad Andersen <vlad.andersen@gmail.com> |
* @author Chris Wanstrath <chris@ozmm.org> |
* @link https://github.com/mustangostang/spyc/ |
* @copyright Copyright 2005-2006 Chris Wanstrath, 2006-2011 Vlad Andersen |
* @license http://www.opensource.org/licenses/mit-license.php MIT License |
* @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); |
} |
} |
|
if (!function_exists('spyc_dump')) { |
/** |
* Dumps array to YAML. |
* @param array $data Array. |
* @return string |
*/ |
function spyc_dump ($data) { |
return Spyc::YAMLDump($data, false, false, true); |
} |
} |
|
if (!class_exists('Spyc')) { |
|
/** |
* 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 |
|
const REMPTY = "\0\0\0\0\0"; |
|
/** |
* 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); |
} |
|
/** |
* Load YAML into a PHP array statically |
* |
* The load method, when supplied with a YAML stream (string or file), |
* 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 |
* @param string $input Path of YAML file or string containing YAML |
*/ |
public static function YAMLLoad($input) { |
$Spyc = new Spyc; |
return $Spyc->_load($input); |
} |
|
/** |
* Load a string of YAML into a PHP array statically |
* |
* The load method, when supplied with a YAML string, will do its best |
* 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 |
* @param string $input String containing YAML |
*/ |
public static function YAMLLoadString($input) { |
$Spyc = new Spyc; |
return $Spyc->_loadString($input); |
} |
|
/** |
* Dump YAML from PHP array statically |
* |
* 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 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 |
* @param array|\stdClass $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) |
* @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); |
} |
|
|
/** |
* 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; |
} |
|
/** |
* 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; |
} |
|
/** |
* Attempts to convert an array to YAML |
* @access private |
* @return string |
* @param $array The array you want to convert |
* @param $indent The indent of the current level |
*/ |
private function _yamlizeArray($array,$indent) { |
if (is_array($array)) { |
$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; |
} |
} |
|
/** |
* 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, $source_array = null) { |
// 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 || strpos($value,"{") !== false || strpos($value,"}") !== false) || strpos($value,"&") !== false || strpos($value, "'") !== false || strpos($value, "!") === 0 || |
substr ($value, -1, 1) == ':') |
) { |
$value = $this->_doLiteralBlock($value,$indent); |
} else { |
$value = $this->_doFolding($value,$indent); |
} |
|
if ($value === array()) $value = '[ ]'; |
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; |
} |
|
/** |
* Creates a literal block for dumping |
* @access private |
* @return string |
* @param $value |
* @param $indent int The value of the indent |
*/ |
private function _doLiteralBlock($value,$indent) { |
if ($value === "\n") return '\n'; |
if (strpos($value, "\n") === false && strpos($value, "'") === false) { |
return sprintf ("'%s'", $value); |
} |
if (strpos($value, "\n") === false && strpos($value, '"') === false) { |
return sprintf ('"%s"', $value); |
} |
$exploded = explode("\n",$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); |
} |
|
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 |
|
private function _load($input) { |
$Source = $this->loadFromSource($input); |
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 ("\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); |
} |
|
private function loadFromString ($input) { |
$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(); |
|
$group = $this->nodeContainsGroup($line); |
if ($group) { |
$this->addGroup($line, $group); |
$line = $this->stripGroup ($line, $group); |
} |
|
if ($this->startsMappedSequence($line)) |
return $this->returnMappedSequence($line); |
|
if ($this->startsMappedValue($line)) |
return $this->returnMappedValue($line); |
|
if ($this->isArrayElement($line)) |
return $this->returnArrayElement($line); |
|
if ($this->isPlainArray($line)) |
return $this->returnPlainArray($line); |
|
|
return $this->returnKeyValuePair($line); |
|
} |
|
/** |
* 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; |
} |
|
/** |
* 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(); |
$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; |
} |
|
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; |
} |
|
|
|
$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; |
} |
|
} |
|
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, $indent = -1) { |
$line = self::stripIndent($line, $indent); |
if ($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 static function isComment ($line) { |
if (!$line) return false; |
if ($line[0] == '#') return true; |
if (trim($line, " \r\n\t") == '---') return true; |
return false; |
} |
|
private static function isEmpty ($line) { |
return (trim ($line) === ''); |
} |
|
|
private function isArrayElement ($line) { |
if (!$line || !is_scalar($line)) return false; |
if (substr($line, 0, 2) != '- ') return false; |
if (strlen ($line) > 3) |
if (substr($line,0,3) == '---') return false; |
|
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 (substr($line, 0, 2) == '- ' && 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 checkKeysInValue($value) { |
if (strchr('[{"\'', $value[0]) === false) { |
if (strchr($value, ': ') !== false) { |
throw new Exception('Too many keys: '.$value); |
} |
} |
} |
|
private function returnMappedValue ($line) { |
$this->checkKeysInValue($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(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; |
|
} |
|
|
private function returnArrayElement ($line) { |
if (strlen($line) <= 1) return array(array()); // Weird %) |
$array = array(); |
$value = trim(substr($line,1)); |
$value = $this->_toType($value); |
if ($this->isArrayElement($value)) { |
$value = $this->returnArrayElement($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 |
// The syntax is the following: php Spyc.php spyc.yaml |
|
do { |
if (PHP_SAPI != 'cli') break; |
if (empty ($_SERVER['argc']) || $_SERVER['argc'] < 2) break; |
if (empty ($_SERVER['PHP_SELF']) || FALSE === strpos ($_SERVER['PHP_SELF'], 'Spyc.php') ) break; |
$file = $argv[1]; |
echo json_encode (spyc_load_file ($file)); |
} while (0); |
/vendor/mustangostang/spyc/php4/spyc.php4 |
@@ -0,0 +1,1023 @@ |
<?php |
/** |
* Spyc -- A Simple PHP YAML Class |
* @version 0.4.5 |
* @author Vlad Andersen <vlad.andersen@gmail.com> |
* @author Chris Wanstrath <chris@ozmm.org> |
* @link http://code.google.com/p/spyc/ |
* @copyright Copyright 2005-2006 Chris Wanstrath, 2006-2009 Vlad Andersen |
* @license http://www.opensource.org/licenses/mit-license.php MIT License |
* @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 |
*/ |
var $setting_dump_force_quotes = false; |
|
/** |
* Setting this to true will forse YAMLLoad to use syck_load function when |
* possible. False by default. |
* @var bool |
*/ |
var $setting_use_syck_is_possible = false; |
|
|
|
/**#@+ |
* @access private |
* @var mixed |
*/ |
var $_dumpIndent; |
var $_dumpWordWrap; |
var $_containsGroupAnchor = false; |
var $_containsGroupAlias = false; |
var $path; |
var $result; |
var $LiteralPlaceHolder = '___YAML_Literal_Block___'; |
var $SavedGroups = array(); |
var $indent; |
/** |
* Path modifier that should be applied after adding current element. |
* @var array |
*/ |
var $delayedPath = array(); |
|
/**#@+ |
* @access public |
* @var mixed |
*/ |
var $_nodeId; |
|
/** |
* Load a valid YAML string to Spyc. |
* @param string $input |
* @return array |
*/ |
function load ($input) { |
return $this->__loadString($input); |
} |
|
/** |
* Load a valid YAML file to Spyc. |
* @param string $file |
* @return array |
*/ |
function loadFile ($file) { |
return $this->__load($file); |
} |
|
/** |
* Load YAML into a PHP array statically |
* |
* The load method, when supplied with a YAML stream (string or file), |
* 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 |
* @param string $input Path of YAML file or string containing YAML |
*/ |
function YAMLLoad($input) { |
$Spyc = new Spyc; |
return $Spyc->__load($input); |
} |
|
/** |
* Load a string of YAML into a PHP array statically |
* |
* The load method, when supplied with a YAML string, will do its best |
* 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 |
* @param string $input String containing YAML |
*/ |
function YAMLLoadString($input) { |
$Spyc = new Spyc; |
return $Spyc->__loadString($input); |
} |
|
/** |
* Dump YAML from PHP array statically |
* |
* 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 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 |
* @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) |
*/ |
function YAMLDump($array,$indent = false,$wordwrap = false) { |
$spyc = new Spyc; |
return $spyc->dump($array,$indent,$wordwrap); |
} |
|
|
/** |
* 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) |
*/ |
function dump($array,$indent = false,$wordwrap = 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 = "---\n"; |
|
// Start at the base of the array and move through it. |
if ($array) { |
$array = (array)$array; |
$first_key = key($array); |
|
$previous_key = -1; |
foreach ($array as $key => $value) { |
$string .= $this->_yamlize($key,$value,0,$previous_key, $first_key); |
$previous_key = $key; |
} |
} |
return $string; |
} |
|
/** |
* 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 |
*/ |
function _yamlize($key,$value,$indent, $previous_key = -1, $first_key = 0) { |
if (is_array($value)) { |
if (empty ($value)) |
return $this->_dumpNode($key, array(), $indent, $previous_key, $first_key); |
// It has children. What to do? |
// Make it the right kind of item |
$string = $this->_dumpNode($key, NULL, $indent, $previous_key, $first_key); |
// 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); |
} |
return $string; |
} |
|
/** |
* Attempts to convert an array to YAML |
* @access private |
* @return string |
* @param $array The array you want to convert |
* @param $indent The indent of the current level |
*/ |
function _yamlizeArray($array,$indent) { |
if (is_array($array)) { |
$string = ''; |
$previous_key = -1; |
$first_key = key($array); |
foreach ($array as $key => $value) { |
$string .= $this->_yamlize($key, $value, $indent, $previous_key, $first_key); |
$previous_key = $key; |
} |
return $string; |
} else { |
return false; |
} |
} |
|
/** |
* 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 |
*/ |
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 = '[ ]'; |
|
$spaces = str_repeat(' ',$indent); |
|
if (is_int($key) && $key - 1 == $previous_key && $first_key===0) { |
// 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) { $key = '"' . $key . '"'; } |
$string = $spaces.$key.': '.$value."\n"; |
} |
return $string; |
} |
|
/** |
* Creates a literal block for dumping |
* @access private |
* @return string |
* @param $value |
* @param $indent int The value of the indent |
*/ |
function _doLiteralBlock($value,$indent) { |
if (strpos($value, "\n") === false && strpos($value, "'") === false) { |
return sprintf ("'%s'", $value); |
} |
if (strpos($value, "\n") === false && strpos($value, '"') === false) { |
return sprintf ('"%s"', $value); |
} |
$exploded = explode("\n",$value); |
$newValue = '|'; |
$indent += $this->_dumpIndent; |
$spaces = str_repeat(' ',$indent); |
foreach ($exploded as $line) { |
$newValue .= "\n" . $spaces . trim($line); |
} |
return $newValue; |
} |
|
/** |
* Folds a string of text, if necessary |
* @access private |
* @return string |
* @param $value The string you wish to fold |
*/ |
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 = '"' . $value . '"'; |
} |
|
|
return $value; |
} |
|
// LOADING FUNCTIONS |
|
function __load($input) { |
$Source = $this->loadFromSource($input); |
return $this->loadWithSource($Source); |
} |
|
function __loadString($input) { |
$Source = $this->loadFromString($input); |
return $this->loadWithSource($Source); |
} |
|
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(); |
$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 = $this->stripIndent($line, $this->indent); |
if ($this->isComment($line)) continue; |
if ($this->isEmpty($line)) continue; |
$this->path = $tempPath; |
|
$literalBlockStyle = $this->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 && $this->greedilyNeedNextLine($line)) { |
$line = rtrim ($line, " \n\t\r") . ' ' . ltrim ($Source[$i], " \t"); |
} |
$i--; |
|
|
|
if (strpos ($line, '#')) { |
if (strpos ($line, '"') === false && strpos ($line, "'") === false) |
$line = preg_replace('/\s+#(.+)$/','',$line); |
} |
|
$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; |
} |
|
function loadFromSource ($input) { |
if (!empty($input) && strpos($input, "\n") === false && file_exists($input)) |
return file($input); |
|
return $this->loadFromString($input); |
} |
|
function loadFromString ($input) { |
$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 |
*/ |
function _parseLine($line) { |
if (!$line) return array(); |
$line = trim($line); |
|
if (!$line) return array(); |
$array = array(); |
|
$group = $this->nodeContainsGroup($line); |
if ($group) { |
$this->addGroup($line, $group); |
$line = $this->stripGroup ($line, $group); |
} |
|
if ($this->startsMappedSequence($line)) |
return $this->returnMappedSequence($line); |
|
if ($this->startsMappedValue($line)) |
return $this->returnMappedValue($line); |
|
if ($this->isArrayElement($line)) |
return $this->returnArrayElement($line); |
|
if ($this->isPlainArray($line)) |
return $this->returnPlainArray($line); |
|
|
return $this->returnKeyValuePair($line); |
|
} |
|
/** |
* Finds the type of the passed value, returns the value as the new type. |
* @access private |
* @param string $value |
* @return mixed |
*/ |
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 != '{') { |
$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 (intval($first_character) > 0 && preg_match ('/^[1-9]+[0-9]*$/', $value)) { |
$intvalue = (int)$value; |
if ($intvalue != PHP_INT_MAX) |
$value = $intvalue; |
return $value; |
} |
|
if (in_array($value, |
array('true', 'on', '+', 'yes', 'y', 'True', 'TRUE', 'On', 'ON', 'YES', 'Yes', 'Y'))) { |
return true; |
} |
|
if (in_array(strtolower($value), |
array('false', 'off', '-', 'no', 'n'))) { |
return false; |
} |
|
if (is_numeric($value)) { |
if ($value === '0') return 0; |
if (trim ($value, 0) === $value) |
$value = (float)$value; |
return $value; |
} |
|
return $value; |
} |
|
/** |
* Used in inlines to check for more inlines or quoted strings |
* @access private |
* @return array |
*/ |
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; |
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); |
$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]; |
} |
} |
} |
|
$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++; |
if ($i > 10) |
break; // Prevent infinite loops. |
} |
|
return $explode; |
} |
|
function literalBlockContinues ($line, $lineIndent) { |
if (!trim($line)) return true; |
if (strlen($line) - strlen(ltrim($line)) > $lineIndent) return true; |
return false; |
} |
|
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; |
} |
|
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; |
} |
|
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') { |
$_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; |
} |
|
} |
|
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; |
} |
|
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; |
} |
|
function addLiteralLine ($literalBlock, $line, $literalBlockStyle) { |
$line = $this->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; |
} |
|
function stripIndent ($line, $indent = -1) { |
if ($indent == -1) $indent = strlen($line) - strlen(ltrim($line)); |
return substr ($line, $indent); |
} |
|
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; |
} |
|
|
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; |
} |
|
|
function isComment ($line) { |
if (!$line) return false; |
if ($line[0] == '#') return true; |
if (trim($line, " \r\n\t") == '---') return true; |
return false; |
} |
|
function isEmpty ($line) { |
return (trim ($line) === ''); |
} |
|
|
function isArrayElement ($line) { |
if (!$line) return false; |
if ($line[0] != '-') return false; |
if (strlen ($line) > 3) |
if (substr($line,0,3) == '---') return false; |
|
return true; |
} |
|
function isHashElement ($line) { |
return strpos($line, ':'); |
} |
|
function isLiteral ($line) { |
if ($this->isArrayElement($line)) return false; |
if ($this->isHashElement($line)) return false; |
return true; |
} |
|
|
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; |
} |
|
function startsMappedSequence ($line) { |
return ($line[0] == '-' && substr ($line, -1, 1) == ':'); |
} |
|
function returnMappedSequence ($line) { |
$array = array(); |
$key = $this->unquote(trim(substr($line,1,-1))); |
$array[$key] = array(); |
$this->delayedPath = array(strpos ($line, $key) + $this->indent => $key); |
return array($array); |
} |
|
function returnMappedValue ($line) { |
$array = array(); |
$key = $this->unquote (trim(substr($line,0,-1))); |
$array[$key] = ''; |
return $array; |
} |
|
function startsMappedValue ($line) { |
return (substr ($line, -1, 1) == ':'); |
} |
|
function isPlainArray ($line) { |
return ($line[0] == '[' && substr ($line, -1, 1) == ']'); |
} |
|
function returnPlainArray ($line) { |
return $this->_toType($line); |
} |
|
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; |
|
} |
|
|
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; |
} |
|
|
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; |
|
} |
|
function addGroup ($line, $group) { |
if ($group[0] == '&') $this->_containsGroupAnchor = substr ($group, 1); |
if ($group[0] == '*') $this->_containsGroupAlias = substr ($group, 1); |
//print_r ($this->path); |
} |
|
function stripGroup ($line, $group) { |
$line = trim(str_replace($group, '', $line)); |
return $line; |
} |
} |
|
// Enable use of Spyc from command line |
// The syntax is the following: php spyc.php spyc.yaml |
|
define ('SPYC_FROM_COMMAND_LINE', false); |
|
do { |
if (!SPYC_FROM_COMMAND_LINE) break; |
if (empty ($_SERVER['argc']) || $_SERVER['argc'] < 2) break; |
if (empty ($_SERVER['PHP_SELF']) || $_SERVER['PHP_SELF'] != 'spyc.php') break; |
$file = $argv[1]; |
printf ("Spyc loading file: %s\n", $file); |
print_r (spyc_load_file ($file)); |
} while (0); |
/vendor/mustangostang/spyc/tests/DumpTest.php |
@@ -0,0 +1,196 @@ |
<?php |
|
require_once ("../Spyc.php"); |
|
class DumpTest extends PHPUnit_Framework_TestCase { |
|
private $files_to_test = array(); |
|
public function setUp() { |
$this->files_to_test = array ('../spyc.yaml', 'failing1.yaml', 'indent_1.yaml', 'quotes.yaml'); |
} |
|
public function testShortSyntax() { |
$dump = spyc_dump(array ('item1', 'item2', 'item3')); |
$awaiting = "- item1\n- item2\n- item3\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testDump() { |
foreach ($this->files_to_test as $file) { |
$yaml = spyc_load(file_get_contents($file)); |
$dump = Spyc::YAMLDump ($yaml); |
$yaml_after_dump = Spyc::YAMLLoad ($dump); |
$this->assertEquals ($yaml, $yaml_after_dump); |
} |
} |
|
public function testDumpWithQuotes() { |
$Spyc = new Spyc(); |
$Spyc->setting_dump_force_quotes = true; |
foreach ($this->files_to_test as $file) { |
$yaml = $Spyc->load(file_get_contents($file)); |
$dump = $Spyc->dump ($yaml); |
$yaml_after_dump = Spyc::YAMLLoad ($dump); |
$this->assertEquals ($yaml, $yaml_after_dump); |
} |
} |
|
public function testDumpArrays() { |
$dump = Spyc::YAMLDump(array ('item1', 'item2', 'item3')); |
$awaiting = "---\n- item1\n- item2\n- item3\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testNull() { |
$dump = Spyc::YAMLDump(array('a' => 1, 'b' => null, 'c' => 3)); |
$awaiting = "---\na: 1\nb: null\nc: 3\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testNext() { |
$array = array("aaa", "bbb", "ccc"); |
#set arrays internal pointer to next element |
next($array); |
$dump = Spyc::YAMLDump($array); |
$awaiting = "---\n- aaa\n- bbb\n- ccc\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testDumpingMixedArrays() { |
$array = array(); |
$array[] = 'Sequence item'; |
$array['The Key'] = 'Mapped value'; |
$array[] = array('A sequence','of a sequence'); |
$array[] = array('first' => 'A sequence','second' => 'of mapped values'); |
$array['Mapped'] = array('A sequence','which is mapped'); |
$array['A Note'] = 'What if your text is too long?'; |
$array['Another Note'] = 'If that is the case, the dumper will probably fold your text by using a block. Kinda like this.'; |
$array['The trick?'] = 'The trick is that we overrode the default indent, 2, to 4 and the default wordwrap, 40, to 60.'; |
$array['Old Dog'] = "And if you want\n to preserve line breaks, \ngo ahead!"; |
$array['key:withcolon'] = "Should support this to"; |
|
$yaml = Spyc::YAMLDump($array,4,60); |
} |
|
public function testMixed() { |
$dump = Spyc::YAMLDump(array(0 => 1, 'b' => 2, 1 => 3)); |
$awaiting = "---\n0: 1\nb: 2\n1: 3\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testDumpNumerics() { |
$dump = Spyc::YAMLDump(array ('404', '405', '500')); |
$awaiting = "---\n- \"404\"\n- \"405\"\n- \"500\"\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testDumpAsterisks() { |
$dump = Spyc::YAMLDump(array ('*')); |
$awaiting = "---\n- '*'\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testDumpAmpersands() { |
$dump = Spyc::YAMLDump(array ('some' => '&foo')); |
$awaiting = "---\nsome: '&foo'\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testDumpExclamations() { |
$dump = Spyc::YAMLDump(array ('some' => '!foo')); |
$awaiting = "---\nsome: '!foo'\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testDumpExclamations2() { |
$dump = Spyc::YAMLDump(array ('some' => 'foo!')); |
$awaiting = "---\nsome: foo!\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testDumpApostrophes() { |
$dump = Spyc::YAMLDump(array ('some' => "'Biz' pimpt bedrijventerreinen")); |
$awaiting = "---\nsome: \"'Biz' pimpt bedrijventerreinen\"\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testDumpNumericHashes() { |
$dump = Spyc::YAMLDump(array ("titel"=> array("0" => "", 1 => "Dr.", 5 => "Prof.", 6 => "Prof. Dr."))); |
$awaiting = "---\ntitel:\n 0: \"\"\n 1: Dr.\n 5: Prof.\n 6: Prof. Dr.\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testEmpty() { |
$dump = Spyc::YAMLDump(array("foo" => array())); |
$awaiting = "---\nfoo: [ ]\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testHashesInKeys() { |
$dump = Spyc::YAMLDump(array ('#color' => '#ffffff')); |
$awaiting = "---\n\"#color\": '#ffffff'\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testParagraph() { |
$dump = Spyc::YAMLDump(array ('key' => "|\n value")); |
$awaiting = "---\nkey: |\n value\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testParagraphTwo() { |
$dump = Spyc::YAMLDump(array ('key' => 'Congrats, pimpt bedrijventerreinen pimpt bedrijventerreinen pimpt bedrijventerreinen!')); |
$awaiting = "---\nkey: >\n Congrats, pimpt bedrijventerreinen pimpt\n bedrijventerreinen pimpt\n bedrijventerreinen!\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testString() { |
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => 'Congrats, pimpt bedrijventerreinen!'))); |
$awaiting = "---\nkey:\n key_one: Congrats, pimpt bedrijventerreinen!\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testStringLong() { |
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => 'Congrats, pimpt bedrijventerreinen pimpt bedrijventerreinen pimpt bedrijventerreinen!'))); |
$awaiting = "---\nkey:\n key_one: >\n Congrats, pimpt bedrijventerreinen pimpt\n bedrijventerreinen pimpt\n bedrijventerreinen!\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testStringDoubleQuote() { |
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => array('key_two' => '"Système d\'e-réservation"')))); |
$awaiting = "---\nkey:\n key_one:\n key_two: |\n Système d'e-réservation\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testLongStringDoubleQuote() { |
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => array('key_two' => '"Système d\'e-réservation bedrijventerreinen pimpt" bedrijventerreinen!')))); |
$awaiting = "---\nkey:\n key_one:\n key_two: |\n \"Système d'e-réservation bedrijventerreinen pimpt\" bedrijventerreinen!\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testStringStartingWithSpace() { |
$dump = Spyc::YAMLDump(array ('key' => array('key_one' => " Congrats, pimpt bedrijventerreinen \n pimpt bedrijventerreinen pimpt bedrijventerreinen!"))); |
$awaiting = "---\nkey:\n key_one: |\n Congrats, pimpt bedrijventerreinen\n pimpt bedrijventerreinen pimpt bedrijventerreinen!\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testPerCentOne() { |
$dump = Spyc::YAMLDump(array ('key' => "%name%, pimpts bedrijventerreinen!")); |
$awaiting = "---\nkey: '%name%, pimpts bedrijventerreinen!'\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testPerCentAndSimpleQuote() { |
$dump = Spyc::YAMLDump(array ('key' => "%name%, pimpt's bedrijventerreinen!")); |
$awaiting = "---\nkey: \"%name%, pimpt's bedrijventerreinen!\"\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
public function testPerCentAndDoubleQuote() { |
$dump = Spyc::YAMLDump(array ('key' => '%name%, pimpt\'s "bed"rijventerreinen!')); |
$awaiting = "---\nkey: |\n %name%, pimpt's \"bed\"rijventerreinen!\n"; |
$this->assertEquals ($awaiting, $dump); |
} |
|
} |
/vendor/mustangostang/spyc/tests/ParseTest.php |
@@ -0,0 +1,401 @@ |
<?php |
|
require_once ("../Spyc.php"); |
|
class ParseTest extends PHPUnit_Framework_TestCase { |
|
protected $yaml; |
|
protected function setUp() { |
$this->yaml = spyc_load_file('../spyc.yaml'); |
} |
|
public function testMergeHashKeys() { |
$Expected = array ( |
array ('step' => array('instrument' => 'Lasik 2000', 'pulseEnergy' => 5.4, 'pulseDuration' => 12, 'repetition' => 1000, 'spotSize' => '1mm')), |
array ('step' => array('instrument' => 'Lasik 2000', 'pulseEnergy' => 5.4, 'pulseDuration' => 12, 'repetition' => 1000, 'spotSize' => '2mm')), |
); |
$Actual = spyc_load_file ('indent_1.yaml'); |
$this->assertEquals ($Expected, $Actual['steps']); |
} |
|
public function testDeathMasks() { |
$Expected = array ('sad' => 2, 'magnificent' => 4); |
$Actual = spyc_load_file ('indent_1.yaml'); |
$this->assertEquals ($Expected, $Actual['death masks are']); |
} |
|
public function testDevDb() { |
$Expected = array ('adapter' => 'mysql', 'host' => 'localhost', 'database' => 'rails_dev'); |
$Actual = spyc_load_file ('indent_1.yaml'); |
$this->assertEquals ($Expected, $Actual['development']); |
} |
|
public function testNumericKey() { |
$this->assertEquals ("Ooo, a numeric key!", $this->yaml[1040]); |
} |
|
public function testMappingsString() { |
$this->assertEquals ("Anyone's name, really.", $this->yaml['String']); |
} |
|
public function testMappingsInt() { |
$this->assertSame (13, $this->yaml['Int']); |
} |
|
public function testMappingsHex() { |
$this->assertSame (243, $this->yaml['Hex']); |
$this->assertSame ('f0xf3', $this->yaml['BadHex']); |
} |
|
public function testMappingsBooleanTrue() { |
$this->assertSame (true, $this->yaml['True']); |
} |
|
public function testMappingsBooleanFalse() { |
$this->assertSame (false, $this->yaml['False']); |
} |
|
public function testMappingsZero() { |
$this->assertSame (0, $this->yaml['Zero']); |
} |
|
public function testMappingsNull() { |
$this->assertSame (null, $this->yaml['Null']); |
} |
|
public function testMappingsNotNull() { |
$this->assertSame ('null', $this->yaml['NotNull']); |
} |
|
public function testMappingsFloat() { |
$this->assertSame (5.34, $this->yaml['Float']); |
} |
|
public function testMappingsNegative() { |
$this->assertSame (-90, $this->yaml['Negative']); |
} |
|
public function testMappingsSmallFloat() { |
$this->assertSame (0.7, $this->yaml['SmallFloat']); |
} |
|
public function testNewline() { |
$this->assertSame ('\n', $this->yaml['NewLine']); |
} |
|
public function testQuotedNewline() { |
$this->assertSame ("\n", $this->yaml['QuotedNewLine']); |
} |
|
public function testSeq0() { |
$this->assertEquals ("PHP Class", $this->yaml[0]); |
} |
|
public function testSeq1() { |
$this->assertEquals ("Basic YAML Loader", $this->yaml[1]); |
} |
|
public function testSeq2() { |
$this->assertEquals ("Very Basic YAML Dumper", $this->yaml[2]); |
} |
|
public function testSeq3() { |
$this->assertEquals (array("YAML is so easy to learn.", |
"Your config files will never be the same."), $this->yaml[3]); |
} |
|
public function testSeqMap() { |
$this->assertEquals (array("cpu" => "1.5ghz", "ram" => "1 gig", |
"os" => "os x 10.4.1"), $this->yaml[4]); |
} |
|
public function testMappedSequence() { |
$this->assertEquals (array("yaml.org", "php.net"), $this->yaml['domains']); |
} |
|
public function testAnotherSequence() { |
$this->assertEquals (array("program" => "Adium", "platform" => "OS X", |
"type" => "Chat Client"), $this->yaml[5]); |
} |
|
public function testFoldedBlock() { |
$this->assertEquals ("There isn't any time for your tricks!\nDo you understand?", $this->yaml['no time']); |
} |
|
public function testLiteralAsMapped() { |
$this->assertEquals ("There is nothing but time\nfor your tricks.", $this->yaml['some time']); |
} |
|
public function testCrazy() { |
$this->assertEquals (array( array("name" => "spartan", "notes" => |
array( "Needs to be backed up", |
"Needs to be normalized" ), |
"type" => "mysql" )), $this->yaml['databases']); |
} |
|
public function testColons() { |
$this->assertEquals ("like", $this->yaml["if: you'd"]); |
} |
|
public function testInline() { |
$this->assertEquals (array("One", "Two", "Three", "Four"), $this->yaml[6]); |
} |
|
public function testNestedInline() { |
$this->assertEquals (array("One", array("Two", "And", "Three"), "Four", "Five"), $this->yaml[7]); |
} |
|
public function testNestedNestedInline() { |
$this->assertEquals (array( "This", array("Is", "Getting", array("Ridiculous", "Guys")), |
"Seriously", array("Show", "Mercy")), $this->yaml[8]); |
} |
|
public function testInlineMappings() { |
$this->assertEquals (array("name" => "chris", "age" => "young", "brand" => "lucky strike"), $this->yaml[9]); |
} |
|
public function testNestedInlineMappings() { |
$this->assertEquals (array("name" => "mark", "age" => "older than chris", |
"brand" => array("marlboro", "lucky strike")), $this->yaml[10]); |
} |
|
public function testReferences() { |
$this->assertEquals (array('Perl', 'Python', 'PHP', 'Ruby'), $this->yaml['dynamic languages']); |
} |
|
public function testReferences2() { |
$this->assertEquals (array('C/C++', 'Java'), $this->yaml['compiled languages']); |
} |
|
public function testReferences3() { |
$this->assertEquals (array( |
array('Perl', 'Python', 'PHP', 'Ruby'), |
array('C/C++', 'Java') |
), $this->yaml['all languages']); |
} |
|
public function testEscapedQuotes() { |
$this->assertEquals ("you know, this shouldn't work. but it does.", $this->yaml[11]); |
} |
|
public function testEscapedQuotes_2() { |
$this->assertEquals ( "that's my value.", $this->yaml[12]); |
} |
|
public function testEscapedQuotes_3() { |
$this->assertEquals ("again, that's my value.", $this->yaml[13]); |
} |
|
public function testQuotes() { |
$this->assertEquals ("here's to \"quotes\", boss.", $this->yaml[14]); |
} |
|
public function testQuoteSequence() { |
$this->assertEquals ( array( 'name' => "Foo, Bar's", 'age' => 20), $this->yaml[15]); |
} |
|
public function testShortSequence() { |
$this->assertEquals (array( 0 => "a", 1 => array (0 => 1, 1 => 2), 2 => "b"), $this->yaml[16]); |
} |
|
public function testQuotedNewlines() { |
$this->assertEquals ("First line\nSecond line\nThird line", $this->yaml[17]); |
} |
|
public function testHash_1() { |
$this->assertEquals ("Hash", $this->yaml['hash_1']); |
} |
|
public function testHash_2() { |
$this->assertEquals ('Hash #and a comment', $this->yaml['hash_2']); |
} |
|
public function testHash_3() { |
$this->assertEquals ('Hash (#) can appear in key too', $this->yaml['hash#3']); |
} |
|
public function testEndloop() { |
$this->assertEquals ("Does this line in the end indeed make Spyc go to an infinite loop?", $this->yaml['endloop']); |
} |
|
public function testReallyLargeNumber() { |
$this->assertEquals ('115792089237316195423570985008687907853269984665640564039457584007913129639936', $this->yaml['a_really_large_number']); |
} |
|
public function testFloatWithZeros() { |
$this->assertSame ('1.0', $this->yaml['float_test']); |
} |
|
public function testFloatWithQuotes() { |
$this->assertSame ('1.0', $this->yaml['float_test_with_quotes']); |
} |
|
public function testFloatInverse() { |
$this->assertEquals ('001', $this->yaml['float_inverse_test']); |
} |
|
public function testIntArray() { |
$this->assertEquals (array (1, 2, 3), $this->yaml['int array']); |
} |
|
public function testArrayOnSeveralLines() { |
$this->assertEquals (array (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19), $this->yaml['array on several lines']); |
} |
|
public function testArrayWithCommas() { |
$this->assertEquals(array (0, 1), $this->yaml['array with commas']); |
} |
|
public function testmoreLessKey() { |
$this->assertEquals ('<value>', $this->yaml['morelesskey']); |
} |
|
public function testArrayOfZero() { |
$this->assertSame (array(0), $this->yaml['array_of_zero']); |
} |
|
public function testSophisticatedArrayOfZero() { |
$this->assertSame (array('rx' => array ('tx' => array (0))), $this->yaml['sophisticated_array_of_zero']); |
} |
|
public function testSwitches() { |
$this->assertEquals (array (array ('row' => 0, 'col' => 0, 'func' => array ('tx' => array(0, 1)))), $this->yaml['switches']); |
} |
|
public function testEmptySequence() { |
$this->assertSame (array(), $this->yaml['empty_sequence']); |
} |
|
public function testEmptyHash() { |
$this->assertSame (array(), $this->yaml['empty_hash']); |
} |
|
public function testEmptykey() { |
$this->assertSame (array('' => array ('key' => 'value')), $this->yaml['empty_key']); |
} |
|
public function testMultilines() { |
$this->assertSame (array(array('type' => 'SomeItem', 'values' => array ('blah', 'blah', 'blah', 'blah'), 'ints' => array(2, 54, 12, 2143))), $this->yaml['multiline_items']); |
} |
|
public function testManyNewlines() { |
$this->assertSame ('A quick |
fox |
|
|
jumped |
over |
|
|
|
|
|
a lazy |
|
|
|
dog', $this->yaml['many_lines']); |
} |
|
public function testWerte() { |
$this->assertSame (array ('1' => 'nummer 1', '0' => 'Stunde 0'), $this->yaml['werte']); |
} |
|
/* public function testNoIndent() { |
$this->assertSame (array( |
array ('record1'=>'value1'), |
array ('record2'=>'value2') |
) |
, $this->yaml['noindent_records']); |
} */ |
|
public function testColonsInKeys() { |
$this->assertSame (array (1000), $this->yaml['a:1']); |
} |
|
public function testColonsInKeys2() { |
$this->assertSame (array (2000), $this->yaml['a:2']); |
} |
|
public function testUnquotedColonsInKeys() { |
$this->assertSame (array (3000), $this->yaml['a:3']); |
} |
|
public function testComplicatedKeyWithColon() { |
$this->assertSame(array("a:b:''test'" => 'value'), $this->yaml['complex_unquoted_key']); |
} |
|
public function testKeysInMappedValueException() { |
$this->setExpectedException('Exception'); |
Spyc::YAMLLoad('x: y: z:'); |
} |
|
public function testKeysInValueException() { |
$this->setExpectedException('Exception'); |
Spyc::YAMLLoad('x: y: z'); |
} |
|
public function testSpecialCharacters() { |
$this->assertSame ('[{]]{{]]', $this->yaml['special_characters']); |
} |
|
public function testAngleQuotes() { |
$Quotes = Spyc::YAMLLoad('quotes.yaml'); |
$this->assertEquals (array ('html_tags' => array ('<br>', '<p>'), 'html_content' => array ('<p>hello world</p>', 'hello<br>world'), 'text_content' => array ('hello world')), |
$Quotes); |
} |
|
public function testFailingColons() { |
$Failing = Spyc::YAMLLoad('failing1.yaml'); |
$this->assertSame (array ('MyObject' => array ('Prop1' => array ('key1:val1'))), |
$Failing); |
} |
|
public function testQuotesWithComments() { |
$Expected = 'bar'; |
$Actual = spyc_load_file ('comments.yaml'); |
$this->assertEquals ($Expected, $Actual['foo']); |
} |
|
public function testArrayWithComments() { |
$Expected = array ('x', 'y', 'z'); |
$Actual = spyc_load_file ('comments.yaml'); |
$this->assertEquals ($Expected, $Actual['arr']); |
} |
|
public function testAfterArrayWithKittens() { |
$Expected = 'kittens'; |
$Actual = spyc_load_file ('comments.yaml'); |
$this->assertEquals ($Expected, $Actual['bar']); |
} |
|
// Plain characters http://www.yaml.org/spec/1.2/spec.html#id2789510 |
public function testKai() { |
$Expected = array('-example' => 'value'); |
$Actual = spyc_load_file ('indent_1.yaml'); |
$this->assertEquals ($Expected, $Actual['kai']); |
} |
|
public function testKaiList() { |
$Expected = array ('-item', '-item', '-item'); |
$Actual = spyc_load_file ('indent_1.yaml'); |
$this->assertEquals ($Expected, $Actual['kai_list_of_items']); |
} |
|
public function testDifferentQuoteTypes() { |
$expected = array ('Something', "", "", "Something else"); |
$this->assertSame ($expected, $this->yaml['invoice']); |
} |
|
public function testDifferentQuoteTypes2() { |
$expected = array ('Something', "Nothing", "Anything", "Thing"); |
$this->assertSame ($expected, $this->yaml['quotes']); |
} |
|
// Separation spaces http://www.yaml.org/spec/1.2/spec.html#id2778394 |
public function testMultipleArrays() { |
$expected = array(array(array('x'))); |
$this->assertSame($expected, Spyc::YAMLLoad("- - - x")); |
} |
} |