| /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")); |
| } |
| } |
