434 lines
16 KiB
PHP
434 lines
16 KiB
PHP
<?php
|
|
/**
|
|
* Zend Framework
|
|
*
|
|
* LICENSE
|
|
*
|
|
* This source file is subject to the new BSD license that is bundled
|
|
* with this package in the file LICENSE.txt.
|
|
* It is also available through the world-wide-web at this URL:
|
|
* http://framework.zend.com/license/new-bsd
|
|
* If you did not receive a copy of the license and are unable to
|
|
* obtain it through the world-wide-web, please send an email
|
|
* to license@zend.com so we can send you a copy immediately.
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Json
|
|
* @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
* @version $Id$
|
|
*/
|
|
|
|
/**
|
|
* Zend_Json_Expr.
|
|
*
|
|
* @see Zend_Json_Expr
|
|
*/
|
|
|
|
/** @see Zend_Xml_Security */
|
|
|
|
/**
|
|
* Class for encoding to and decoding from JSON.
|
|
*
|
|
* @category Zend
|
|
* @package Zend_Json
|
|
* @uses Zend_Json_Expr
|
|
* @copyright Copyright (c) 2005-2015 Zend Technologies USA Inc. (http://www.zend.com)
|
|
* @license http://framework.zend.com/license/new-bsd New BSD License
|
|
*/
|
|
class Zend_Json
|
|
{
|
|
/**
|
|
* How objects should be encoded -- arrays or as StdClass. TYPE_ARRAY is 1
|
|
* so that it is a boolean true value, allowing it to be used with
|
|
* ext/json's functions.
|
|
*/
|
|
const TYPE_ARRAY = 1;
|
|
const TYPE_OBJECT = 0;
|
|
|
|
/**
|
|
* To check the allowed nesting depth of the XML tree during xml2json conversion.
|
|
*
|
|
* @var int
|
|
*/
|
|
public static $maxRecursionDepthAllowed=25;
|
|
|
|
/**
|
|
* @var bool
|
|
*/
|
|
public static $useBuiltinEncoderDecoder = false;
|
|
|
|
/**
|
|
* Decodes the given $encodedValue string which is
|
|
* encoded in the JSON format
|
|
*
|
|
* Uses ext/json's json_decode if available.
|
|
*
|
|
* @param string $encodedValue Encoded in JSON format
|
|
* @param int $objectDecodeType Optional; flag indicating how to decode
|
|
* objects. See {@link Zend_Json_Decoder::decode()} for details.
|
|
* @return mixed
|
|
*/
|
|
public static function decode($encodedValue, $objectDecodeType = Zend_Json::TYPE_ARRAY)
|
|
{
|
|
$encodedValue = (string) $encodedValue;
|
|
if (function_exists('json_decode') && self::$useBuiltinEncoderDecoder !== true) {
|
|
$decode = json_decode($encodedValue, $objectDecodeType);
|
|
|
|
// php < 5.3
|
|
if (!function_exists('json_last_error')) {
|
|
if (strtolower($encodedValue) === 'null') {
|
|
return null;
|
|
} elseif ($decode === null) {
|
|
throw new Zend_Json_Exception('Decoding failed');
|
|
}
|
|
// php >= 5.3
|
|
} elseif (($jsonLastErr = json_last_error()) != JSON_ERROR_NONE) {
|
|
switch ($jsonLastErr) {
|
|
case JSON_ERROR_DEPTH:
|
|
throw new Zend_Json_Exception('Decoding failed: Maximum stack depth exceeded');
|
|
case JSON_ERROR_CTRL_CHAR:
|
|
throw new Zend_Json_Exception('Decoding failed: Unexpected control character found');
|
|
case JSON_ERROR_SYNTAX:
|
|
throw new Zend_Json_Exception('Decoding failed: Syntax error');
|
|
default:
|
|
throw new Zend_Json_Exception('Decoding failed');
|
|
}
|
|
}
|
|
|
|
return $decode;
|
|
}
|
|
|
|
return Zend_Json_Decoder::decode($encodedValue, $objectDecodeType);
|
|
}
|
|
|
|
/**
|
|
* Encode the mixed $valueToEncode into the JSON format
|
|
*
|
|
* Encodes using ext/json's json_encode() if available.
|
|
*
|
|
* NOTE: Object should not contain cycles; the JSON format
|
|
* does not allow object reference.
|
|
*
|
|
* NOTE: Only public variables will be encoded
|
|
*
|
|
* NOTE: Encoding native javascript expressions are possible using Zend_Json_Expr.
|
|
* You can enable this by setting $options['enableJsonExprFinder'] = true
|
|
*
|
|
* @see Zend_Json_Expr
|
|
*
|
|
* @param mixed $valueToEncode
|
|
* @param boolean $cycleCheck Optional; whether or not to check for object recursion; off by default
|
|
* @param array $options Additional options used during encoding
|
|
* @return string JSON encoded object
|
|
*/
|
|
public static function encode($valueToEncode, $cycleCheck = false, $options = array())
|
|
{
|
|
if (is_object($valueToEncode)) {
|
|
if (method_exists($valueToEncode, 'toJson')) {
|
|
return $valueToEncode->toJson();
|
|
} elseif (method_exists($valueToEncode, 'toArray')) {
|
|
return self::encode($valueToEncode->toArray(), $cycleCheck, $options);
|
|
}
|
|
}
|
|
|
|
// Pre-encoding look for Zend_Json_Expr objects and replacing by tmp ids
|
|
$javascriptExpressions = array();
|
|
if(isset($options['enableJsonExprFinder'])
|
|
&& ($options['enableJsonExprFinder'] == true)
|
|
) {
|
|
/**
|
|
* @see Zend_Json_Encoder
|
|
*/
|
|
$valueToEncode = self::_recursiveJsonExprFinder($valueToEncode, $javascriptExpressions);
|
|
}
|
|
|
|
// Encoding
|
|
if (function_exists('json_encode') && self::$useBuiltinEncoderDecoder !== true) {
|
|
$encodedResult = json_encode($valueToEncode);
|
|
} else {
|
|
$encodedResult = Zend_Json_Encoder::encode($valueToEncode, $cycleCheck, $options);
|
|
}
|
|
|
|
//only do post-proccessing to revert back the Zend_Json_Expr if any.
|
|
if (count($javascriptExpressions) > 0) {
|
|
$count = count($javascriptExpressions);
|
|
for($i = 0; $i < $count; $i++) {
|
|
$magicKey = $javascriptExpressions[$i]['magicKey'];
|
|
$value = $javascriptExpressions[$i]['value'];
|
|
|
|
$encodedResult = str_replace(
|
|
//instead of replacing "key:magicKey", we replace directly magicKey by value because "key" never changes.
|
|
'"' . $magicKey . '"',
|
|
$value,
|
|
$encodedResult
|
|
);
|
|
}
|
|
}
|
|
|
|
return $encodedResult;
|
|
}
|
|
|
|
/**
|
|
* Check & Replace Zend_Json_Expr for tmp ids in the valueToEncode
|
|
*
|
|
* Check if the value is a Zend_Json_Expr, and if replace its value
|
|
* with a magic key and save the javascript expression in an array.
|
|
*
|
|
* NOTE this method is recursive.
|
|
*
|
|
* NOTE: This method is used internally by the encode method.
|
|
*
|
|
* @see encode
|
|
* @param array|object|Zend_Json_Expr $value a string - object property to be encoded
|
|
* @param array $javascriptExpressions
|
|
* @param null $currentKey
|
|
*
|
|
* @internal param mixed $valueToCheck
|
|
* @return void
|
|
*/
|
|
protected static function _recursiveJsonExprFinder(&$value, array &$javascriptExpressions, $currentKey = null)
|
|
{
|
|
if ($value instanceof Zend_Json_Expr) {
|
|
// TODO: Optimize with ascii keys, if performance is bad
|
|
$magicKey = "____" . $currentKey . "_" . (count($javascriptExpressions));
|
|
$javascriptExpressions[] = array(
|
|
|
|
//if currentKey is integer, encodeUnicodeString call is not required.
|
|
"magicKey" => (is_int($currentKey)) ? $magicKey : Zend_Json_Encoder::encodeUnicodeString($magicKey),
|
|
"value" => $value->__toString(),
|
|
);
|
|
$value = $magicKey;
|
|
} elseif (is_array($value)) {
|
|
foreach ($value as $k => $v) {
|
|
$value[$k] = self::_recursiveJsonExprFinder($value[$k], $javascriptExpressions, $k);
|
|
}
|
|
} elseif (is_object($value)) {
|
|
foreach ($value as $k => $v) {
|
|
$value->$k = self::_recursiveJsonExprFinder($value->$k, $javascriptExpressions, $k);
|
|
}
|
|
}
|
|
return $value;
|
|
}
|
|
|
|
/**
|
|
* Return the value of an XML attribute text or the text between
|
|
* the XML tags
|
|
*
|
|
* In order to allow Zend_Json_Expr from xml, we check if the node
|
|
* matchs the pattern that try to detect if it is a new Zend_Json_Expr
|
|
* if it matches, we return a new Zend_Json_Expr instead of a text node
|
|
*
|
|
* @param SimpleXMLElement $simpleXmlElementObject
|
|
* @return Zend_Json_Expr|string
|
|
*/
|
|
protected static function _getXmlValue($simpleXmlElementObject) {
|
|
$pattern = '/^[\s]*new Zend_Json_Expr[\s]*\([\s]*[\"\']{1}(.*)[\"\']{1}[\s]*\)[\s]*$/';
|
|
$matchings = array();
|
|
$match = preg_match ($pattern, $simpleXmlElementObject, $matchings);
|
|
if ($match) {
|
|
return new Zend_Json_Expr($matchings[1]);
|
|
} else {
|
|
return (trim(strval($simpleXmlElementObject)));
|
|
}
|
|
}
|
|
/**
|
|
* _processXml - Contains the logic for xml2json
|
|
*
|
|
* The logic in this function is a recursive one.
|
|
*
|
|
* The main caller of this function (i.e. fromXml) needs to provide
|
|
* only the first two parameters i.e. the SimpleXMLElement object and
|
|
* the flag for ignoring or not ignoring XML attributes. The third parameter
|
|
* will be used internally within this function during the recursive calls.
|
|
*
|
|
* This function converts the SimpleXMLElement object into a PHP array by
|
|
* calling a recursive (protected static) function in this class. Once all
|
|
* the XML elements are stored in the PHP array, it is returned to the caller.
|
|
*
|
|
* Throws a Zend_Json_Exception if the XML tree is deeper than the allowed limit.
|
|
*
|
|
* @param SimpleXMLElement $simpleXmlElementObject
|
|
* @param boolean $ignoreXmlAttributes
|
|
* @param integer $recursionDepth
|
|
* @return array
|
|
*/
|
|
protected static function _processXml($simpleXmlElementObject, $ignoreXmlAttributes, $recursionDepth=0)
|
|
{
|
|
// Keep an eye on how deeply we are involved in recursion.
|
|
if ($recursionDepth > self::$maxRecursionDepthAllowed) {
|
|
// XML tree is too deep. Exit now by throwing an exception.
|
|
throw new Zend_Json_Exception(
|
|
"Function _processXml exceeded the allowed recursion depth of " .
|
|
self::$maxRecursionDepthAllowed);
|
|
} // End of if ($recursionDepth > self::$maxRecursionDepthAllowed)
|
|
|
|
$children = $simpleXmlElementObject->children();
|
|
$name = $simpleXmlElementObject->getName();
|
|
$value = self::_getXmlValue($simpleXmlElementObject);
|
|
$attributes = (array) $simpleXmlElementObject->attributes();
|
|
|
|
if (count($children) == 0) {
|
|
if (!empty($attributes) && !$ignoreXmlAttributes) {
|
|
foreach ($attributes['@attributes'] as $k => $v) {
|
|
$attributes['@attributes'][$k]= self::_getXmlValue($v);
|
|
}
|
|
if (!empty($value)) {
|
|
$attributes['@text'] = $value;
|
|
}
|
|
return array($name => $attributes);
|
|
} else {
|
|
return array($name => $value);
|
|
}
|
|
} else {
|
|
$childArray= array();
|
|
foreach ($children as $child) {
|
|
$childname = $child->getName();
|
|
$element = self::_processXml($child,$ignoreXmlAttributes,$recursionDepth+1);
|
|
if (array_key_exists($childname, $childArray)) {
|
|
if (empty($subChild[$childname])) {
|
|
$childArray[$childname] = array($childArray[$childname]);
|
|
$subChild[$childname] = true;
|
|
}
|
|
$childArray[$childname][] = $element[$childname];
|
|
} else {
|
|
$childArray[$childname] = $element[$childname];
|
|
}
|
|
}
|
|
if (!empty($attributes) && !$ignoreXmlAttributes) {
|
|
foreach ($attributes['@attributes'] as $k => $v) {
|
|
$attributes['@attributes'][$k] = self::_getXmlValue($v);
|
|
}
|
|
$childArray['@attributes'] = $attributes['@attributes'];
|
|
}
|
|
if (!empty($value)) {
|
|
$childArray['@text'] = $value;
|
|
}
|
|
return array($name => $childArray);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* fromXml - Converts XML to JSON
|
|
*
|
|
* Converts a XML formatted string into a JSON formatted string.
|
|
* The value returned will be a string in JSON format.
|
|
*
|
|
* The caller of this function needs to provide only the first parameter,
|
|
* which is an XML formatted String. The second parameter is optional, which
|
|
* lets the user to select if the XML attributes in the input XML string
|
|
* should be included or ignored in xml2json conversion.
|
|
*
|
|
* This function converts the XML formatted string into a PHP array by
|
|
* calling a recursive (protected static) function in this class. Then, it
|
|
* converts that PHP array into JSON by calling the "encode" static funcion.
|
|
*
|
|
* Throws a Zend_Json_Exception if the input not a XML formatted string.
|
|
* NOTE: Encoding native javascript expressions via Zend_Json_Expr is not possible.
|
|
*
|
|
* @static
|
|
* @access public
|
|
* @param string $xmlStringContents XML String to be converted
|
|
* @param boolean $ignoreXmlAttributes Include or exclude XML attributes in
|
|
* the xml2json conversion process.
|
|
* @return mixed - JSON formatted string on success
|
|
* @throws Zend_Json_Exception
|
|
*/
|
|
public static function fromXml($xmlStringContents, $ignoreXmlAttributes=true)
|
|
{
|
|
// Load the XML formatted string into a Simple XML Element object.
|
|
$simpleXmlElementObject = Zend_Xml_Security::scan($xmlStringContents);
|
|
|
|
// If it is not a valid XML content, throw an exception.
|
|
if ($simpleXmlElementObject == null) {
|
|
throw new Zend_Json_Exception('Function fromXml was called with an invalid XML formatted string.');
|
|
} // End of if ($simpleXmlElementObject == null)
|
|
|
|
$resultArray = null;
|
|
|
|
// Call the recursive function to convert the XML into a PHP array.
|
|
$resultArray = self::_processXml($simpleXmlElementObject, $ignoreXmlAttributes);
|
|
|
|
// Convert the PHP array to JSON using Zend_Json encode method.
|
|
// It is just that simple.
|
|
$jsonStringOutput = self::encode($resultArray);
|
|
return($jsonStringOutput);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Pretty-print JSON string
|
|
*
|
|
* Use 'format' option to select output format - currently html and txt supported, txt is default
|
|
* Use 'indent' option to override the indentation string set in the format - by default for the 'txt' format it's a tab
|
|
*
|
|
* @param string $json Original JSON string
|
|
* @param array $options Encoding options
|
|
* @return string
|
|
*/
|
|
public static function prettyPrint($json, $options = array())
|
|
{
|
|
$tokens = preg_split('|([\{\}\]\[,])|', $json, -1, PREG_SPLIT_DELIM_CAPTURE);
|
|
$result = '';
|
|
$indent = 0;
|
|
|
|
$format= 'txt';
|
|
|
|
$ind = "\t";
|
|
|
|
if (isset($options['format'])) {
|
|
$format = $options['format'];
|
|
}
|
|
|
|
switch ($format) {
|
|
case 'html':
|
|
$lineBreak = '<br />';
|
|
$ind = ' ';
|
|
break;
|
|
default:
|
|
case 'txt':
|
|
$lineBreak = "\n";
|
|
$ind = "\t";
|
|
break;
|
|
}
|
|
|
|
// override the defined indent setting with the supplied option
|
|
if (isset($options['indent'])) {
|
|
$ind = $options['indent'];
|
|
}
|
|
|
|
$inLiteral = false;
|
|
foreach($tokens as $token) {
|
|
if($token == '') {
|
|
continue;
|
|
}
|
|
|
|
$prefix = str_repeat($ind, $indent);
|
|
if (!$inLiteral && ($token == '{' || $token == '[')) {
|
|
$indent++;
|
|
if (($result != '') && ($result[(strlen($result)-1)] == $lineBreak)) {
|
|
$result .= $prefix;
|
|
}
|
|
$result .= $token . $lineBreak;
|
|
} elseif (!$inLiteral && ($token == '}' || $token == ']')) {
|
|
$indent--;
|
|
$prefix = str_repeat($ind, $indent);
|
|
$result .= $lineBreak . $prefix . $token;
|
|
} elseif (!$inLiteral && $token == ',') {
|
|
$result .= $token . $lineBreak;
|
|
} else {
|
|
$result .= ( $inLiteral ? '' : $prefix ) . $token;
|
|
|
|
// Count # of unescaped double-quotes in token, subtract # of
|
|
// escaped double-quotes and if the result is odd then we are
|
|
// inside a string literal
|
|
if ((substr_count($token, "\"")-substr_count($token, "\\\"")) % 2 != 0) {
|
|
$inLiteral = !$inLiteral;
|
|
}
|
|
}
|
|
}
|
|
return $result;
|
|
}
|
|
}
|