From 537389f033833cecc534a931498cada07a8b11d1 Mon Sep 17 00:00:00 2001 From: cjhardee Date: Tue, 8 Nov 2011 18:33:23 +0000 Subject: [PATCH] json source, makefile and readme Former-commit-id: 16cd3ac688ba0ebd1cc5749e6aebcbe9bf90e057 --- json/Makefile.PL | 143 +++ json/README | 1552 ++++++++++++++++++++++++++++++ json/perl-JSON-2.50-1.rf.src.rpm | Bin 0 -> 82650 bytes 3 files changed, 1695 insertions(+) create mode 100644 json/Makefile.PL create mode 100644 json/README create mode 100644 json/perl-JSON-2.50-1.rf.src.rpm diff --git a/json/Makefile.PL b/json/Makefile.PL new file mode 100644 index 0000000..79fd214 --- /dev/null +++ b/json/Makefile.PL @@ -0,0 +1,143 @@ +require 5.00503; +use strict; +use ExtUtils::MakeMaker; + +use lib qw( ./lib ); + +$| = 1; + +eval q| require JSON |; + +# B module can't install? I'm not careful for such a problem. +# Leave us alone today? +if ($@) { + print "We try to look up lib/JSON.pm, but in vain. B module can't install?\n"; + print "Set the environmental variable 'PERL_DL_NONLAZY' with 0.\n"; + print "And see to ExtUtils::MM_Unix.\n"; + print "perl says : $@"; + print "We do not make Makefile by requiring Perl version 7.0.\n"; + require 7.0000; +} + + +my $version = JSON->VERSION; +my $req_xs_ver = JSON->require_xs_version; +my $has_xs = 0; +my $xs_ver_is_ok; +my $message; +my $pp_only = $ENV{ PERL_ONLY } || $ENV{ NO_XS }; + +eval q| require JSON::XS |; + +$has_xs = 1 unless ($@); + + +if ($has_xs) { + my $xs_version = JSON::XS->VERSION; + if ($xs_version >= $req_xs_ver) { + $message = "You have JSON::XS (v.$xs_version), so JSON can work very fast!!"; + $xs_ver_is_ok++; + } + else { + $message = "Your JSON::XS version is $xs_version, but if you install v.$req_xs_ver,\n" + . "JSON will work faster."; + } +} +else { + $message = "If you install JSON::XS v.$req_xs_ver, it makes JSON faster."; +} + +print < $req_xs_ver ); + } + +} + + +WriteMakefile( + 'NAME' => 'JSON', + 'VERSION_FROM' => 'lib/JSON.pm', # finds $VERSION + 'PREREQ_PM' => { + 'Test::More' => 0, + @prereq_pm, + }, + ($] >= 5.005 ? ## Add these new keywords supported since 5.005 + (ABSTRACT_FROM => 'lib/JSON.pm', # retrieve abstract from module + AUTHOR => 'Makamaka Hannyaharamitu, Emakamaka[at]cpan.orgE') : ()), + ( $ExtUtils::MakeMaker::VERSION >= 6.3002 ? ('LICENSE' => 'perl', ) : () ), + + ( $ExtUtils::MakeMaker::VERSION >= 6.46 ? ( + 'META_MERGE' => { + resources => { + repository => 'http://github.com/makamaka/JSON', + }, + } ) : () + ), +); + + +if ($] < 5.006) { # I saw to http://d.hatena.ne.jp/asakusabashi/20051231/p1 + open(IN, "Makefile"); + open(OUT,">Makefile.tmp") || die; + while() { + s/PERL_DL_NONLAZY=1//g; + print OUT; + } + close(OUT); + close(IN); + rename("Makefile.tmp" => "Makefile"); +} + + + + +sub can_auto_xs_install { + return 0 if $] < 5.008002; # JSON::XS requires + return 0 unless ( $ENV{PERL5_CPAN_IS_RUNNING} or $ENV{PERL5_CPANM_IS_RUNNING} ); # not cpan/cpanm running + return can_cc(); +} + + +# copied from http://cpansearch.perl.org/src/GBARR/Scalar-List-Utils-1.23/Makefile.PL + +use Config; + + +sub can_cc { + + require File::Spec; + + foreach my $cmd (split(/ /, $Config::Config{cc})) { + my $_cmd = $cmd; + + return $_cmd if (-x $_cmd or $_cmd = MM->maybe_command($_cmd)); + + for my $dir ((split /$Config::Config{path_sep}/, $ENV{PATH}), '.') { + my $abs = File::Spec->catfile($dir, $_[1]); + return $abs if (-x $abs or $abs = MM->maybe_command($abs)); + } + } + + return; +} diff --git a/json/README b/json/README new file mode 100644 index 0000000..f24a15b --- /dev/null +++ b/json/README @@ -0,0 +1,1552 @@ +JSON version 2.53 +================= + +JSON::PP was inculded in JSON distribution (CPAN module). +It comes to be a perl core module in Perl 5.14. +And JSON::PP well be split away it. + +This developer-versoin is for the preparation. + + * JSON distribution will inculde yet another JSON::PP modules. + They are JSNO::backportPP. So JSON.pm should work as it did at all! + +================= + +INSTALLATION + +To install this module type the following: + + perl Makefile.PL + make + make test + make install + +NAME + JSON - JSON (JavaScript Object Notation) encoder/decoder + +SYNOPSIS + use JSON; # imports encode_json, decode_json, to_json and from_json. + + # simple and fast interfaces (expect/generate UTF-8) + + $utf8_encoded_json_text = encode_json $perl_hash_or_arrayref; + $perl_hash_or_arrayref = decode_json $utf8_encoded_json_text; + + # OO-interface + + $json = JSON->new->allow_nonref; + + $json_text = $json->encode( $perl_scalar ); + $perl_scalar = $json->decode( $json_text ); + + $pretty_printed = $json->pretty->encode( $perl_scalar ); # pretty-printing + + # If you want to use PP only support features, call with '-support_by_pp' + # When XS unsupported feature is enable, using PP (de|en)code instead of XS ones. + + use JSON -support_by_pp; + + # option-acceptable interfaces (expect/generate UNICODE by default) + + $json_text = to_json( $perl_scalar, { ascii => 1, pretty => 1 } ); + $perl_scalar = from_json( $json_text, { utf8 => 1 } ); + + # Between (en|de)code_json and (to|from)_json, if you want to write + # a code which communicates to an outer world (encoded in UTF-8), + # recommend to use (en|de)code_json. + +VERSION + 2.53 + + This version is compatible with JSON::XS 2.27 and later. + +NOTE + JSON::PP was inculded in "JSON" distribution. It comes to be a perl core + module in Perl 5.14. And JSON::PP will be split away it. + + "JSON" distribution will inculde yet another JSON::PP modules. They are + JSNO::backportPP and so on. JSON.pm should work as it did at all. + +DESCRIPTION + ************************** CAUTION ******************************** + * This is 'JSON module version 2' and there are many differences * + * to version 1.xx * + * Please check your applications useing old version. * + * See to 'INCOMPATIBLE CHANGES TO OLD VERSION' * + ******************************************************************* + + JSON (JavaScript Object Notation) is a simple data format. See to + and + "RFC4627"(). + + This module converts Perl data structures to JSON and vice versa using + either JSON::XS or JSON::PP. + + JSON::XS is the fastest and most proper JSON module on CPAN which must + be compiled and installed in your environment. JSON::PP is a pure-Perl + module which is bundled in this distribution and has a strong + compatibility to JSON::XS. + + This module try to use JSON::XS by default and fail to it, use JSON::PP + instead. So its features completely depend on JSON::XS or JSON::PP. + + See to "BACKEND MODULE DECISION". + + To distinguish the module name 'JSON' and the format type JSON, the + former is quoted by C<> (its results vary with your using media), and + the latter is left just as it is. + + Module name : "JSON" + + Format type : JSON + + FEATURES + * correct unicode handling + + This module (i.e. backend modules) knows how to handle Unicode, + documents how and when it does so, and even documents what "correct" + means. + + Even though there are limitations, this feature is available since + Perl version 5.6. + + JSON::XS requires Perl 5.8.2 (but works correctly in 5.8.8 or + later), so in older versions "JSON" sholud call JSON::PP as the + backend which can be used since Perl 5.005. + + With Perl 5.8.x JSON::PP works, but from 5.8.0 to 5.8.2, because of + a Perl side problem, JSON::PP works slower in the versions. And in + 5.005, the Unicode handling is not available. See to "UNICODE + HANDLING ON PERLS" in JSON::PP for more information. + + See also to "A FEW NOTES ON UNICODE AND PERL" in JSON::XS and + "ENCODING/CODESET_FLAG_NOTES" in JSON::XS. + + * round-trip integrity + + When you serialise a perl data structure using only data types + supported by JSON and Perl, the deserialised data structure is + identical on the Perl level. (e.g. the string "2.0" doesn't suddenly + become "2" just because it looks like a number). There *are* minor + exceptions to this, read the "MAPPING" section below to learn about + those. + + * strict checking of JSON correctness + + There is no guessing, no generating of illegal JSON texts by + default, and only JSON is accepted as input by default (the latter + is a security feature). + + See to "FEATURES" in JSON::XS and "FEATURES" in JSON::PP. + + * fast + + This module returns a JSON::XS object itself if available. Compared + to other JSON modules and other serialisers such as Storable, + JSON::XS usually compares favourably in terms of speed, too. + + If not available, "JSON" returns a JSON::PP object instead of + JSON::XS and it is very slow as pure-Perl. + + * simple to use + + This module has both a simple functional interface as well as an + object oriented interface interface. + + * reasonably versatile output formats + + You can choose between the most compact guaranteed-single-line + format possible (nice for simple line-based protocols), a pure-ASCII + format (for when your transport is not 8-bit clean, still supports + the whole Unicode range), or a pretty-printed format (for when you + want to read that stuff). Or you can combine those features in + whatever way you like. + +FUNCTIONAL INTERFACE + Some documents are copied and modified from "FUNCTIONAL INTERFACE" in + JSON::XS. "to_json" and "from_json" are additional functions. + + encode_json + $json_text = encode_json $perl_scalar + + Converts the given Perl data structure to a UTF-8 encoded, binary + string. + + This function call is functionally identical to: + + $json_text = JSON->new->utf8->encode($perl_scalar) + + decode_json + $perl_scalar = decode_json $json_text + + The opposite of "encode_json": expects an UTF-8 (binary) string and + tries to parse that as an UTF-8 encoded JSON text, returning the + resulting reference. + + This function call is functionally identical to: + + $perl_scalar = JSON->new->utf8->decode($json_text) + + to_json + $json_text = to_json($perl_scalar) + + Converts the given Perl data structure to a json string. + + This function call is functionally identical to: + + $json_text = JSON->new->encode($perl_scalar) + + Takes a hash reference as the second. + + $json_text = to_json($perl_scalar, $flag_hashref) + + So, + + $json_text = to_json($perl_scalar, {utf8 => 1, pretty => 1}) + + equivalent to: + + $json_text = JSON->new->utf8(1)->pretty(1)->encode($perl_scalar) + + If you want to write a modern perl code which communicates to outer + world, you should use "encode_json" (supposed that JSON data are encoded + in UTF-8). + + from_json + $perl_scalar = from_json($json_text) + + The opposite of "to_json": expects a json string and tries to parse it, + returning the resulting reference. + + This function call is functionally identical to: + + $perl_scalar = JSON->decode($json_text) + + Takes a hash reference as the second. + + $perl_scalar = from_json($json_text, $flag_hashref) + + So, + + $perl_scalar = from_json($json_text, {utf8 => 1}) + + equivalent to: + + $perl_scalar = JSON->new->utf8(1)->decode($json_text) + + If you want to write a modern perl code which communicates to outer + world, you should use "decode_json" (supposed that JSON data are encoded + in UTF-8). + + JSON::is_bool + $is_boolean = JSON::is_bool($scalar) + + Returns true if the passed scalar represents either JSON::true or + JSON::false, two constants that act like 1 and 0 respectively and are + also used to represent JSON "true" and "false" in Perl strings. + + JSON::true + Returns JSON true value which is blessed object. It "isa" JSON::Boolean + object. + + JSON::false + Returns JSON false value which is blessed object. It "isa" JSON::Boolean + object. + + JSON::null + Returns "undef". + + See MAPPING, below, for more information on how JSON values are mapped + to Perl. + +HOW DO I DECODE A DATA FROM OUTER AND ENCODE TO OUTER + This section supposes that your perl vresion is 5.8 or later. + + If you know a JSON text from an outer world - a network, a file content, + and so on, is encoded in UTF-8, you should use "decode_json" or "JSON" + module object with "utf8" enable. And the decoded result will contain + UNICODE characters. + + # from network + my $json = JSON->new->utf8; + my $json_text = CGI->new->param( 'json_data' ); + my $perl_scalar = $json->decode( $json_text ); + + # from file content + local $/; + open( my $fh, '<', 'json.data' ); + $json_text = <$fh>; + $perl_scalar = decode_json( $json_text ); + + If an outer data is not encoded in UTF-8, firstly you should "decode" + it. + + use Encode; + local $/; + open( my $fh, '<', 'json.data' ); + my $encoding = 'cp932'; + my $unicode_json_text = decode( $encoding, <$fh> ); # UNICODE + + # or you can write the below code. + # + # open( my $fh, "<:encoding($encoding)", 'json.data' ); + # $unicode_json_text = <$fh>; + + In this case, $unicode_json_text is of course UNICODE string. So you + cannot use "decode_json" nor "JSON" module object with "utf8" enable. + Instead of them, you use "JSON" module object with "utf8" disable or + "from_json". + + $perl_scalar = $json->utf8(0)->decode( $unicode_json_text ); + # or + $perl_scalar = from_json( $unicode_json_text ); + + Or "encode 'utf8'" and "decode_json": + + $perl_scalar = decode_json( encode( 'utf8', $unicode_json_text ) ); + # this way is not efficient. + + And now, you want to convert your $perl_scalar into JSON data and send + it to an outer world - a network or a file content, and so on. + + Your data usually contains UNICODE strings and you want the converted + data to be encoded in UTF-8, you should use "encode_json" or "JSON" + module object with "utf8" enable. + + print encode_json( $perl_scalar ); # to a network? file? or display? + # or + print $json->utf8->encode( $perl_scalar ); + + If $perl_scalar does not contain UNICODE but $encoding-encoded strings + for some reason, then its characters are regarded as latin1 for perl + (because it does not concern with your $encoding). You cannot use + "encode_json" nor "JSON" module object with "utf8" enable. Instead of + them, you use "JSON" module object with "utf8" disable or "to_json". + Note that the resulted text is a UNICODE string but no problem to print + it. + + # $perl_scalar contains $encoding encoded string values + $unicode_json_text = $json->utf8(0)->encode( $perl_scalar ); + # or + $unicode_json_text = to_json( $perl_scalar ); + # $unicode_json_text consists of characters less than 0x100 + print $unicode_json_text; + + Or "decode $encoding" all string values and "encode_json": + + $perl_scalar->{ foo } = decode( $encoding, $perl_scalar->{ foo } ); + # ... do it to each string values, then encode_json + $json_text = encode_json( $perl_scalar ); + + This method is a proper way but probably not efficient. + + See to Encode, perluniintro. + +COMMON OBJECT-ORIENTED INTERFACE + new + $json = JSON->new + + Returns a new "JSON" object inherited from either JSON::XS or JSON::PP + that can be used to de/encode JSON strings. + + All boolean flags described below are by default *disabled*. + + The mutators for flags all return the JSON object again and thus calls + can be chained: + + my $json = JSON->new->utf8->space_after->encode({a => [1,2]}) + => {"a": [1, 2]} + + ascii + $json = $json->ascii([$enable]) + + $enabled = $json->get_ascii + + If $enable is true (or missing), then the encode method will not + generate characters outside the code range 0..127. Any Unicode + characters outside that range will be escaped using either a single + \uXXXX or a double \uHHHH\uLLLLL escape sequence, as per RFC4627. + + If $enable is false, then the encode method will not escape Unicode + characters unless required by the JSON syntax or other flags. This + results in a faster and more compact format. + + This feature depends on the used Perl version and environment. + + See to "UNICODE HANDLING ON PERLS" in JSON::PP if the backend is PP. + + JSON->new->ascii(1)->encode([chr 0x10401]) + => ["\ud801\udc01"] + + latin1 + $json = $json->latin1([$enable]) + + $enabled = $json->get_latin1 + + If $enable is true (or missing), then the encode method will encode the + resulting JSON text as latin1 (or iso-8859-1), escaping any characters + outside the code range 0..255. + + If $enable is false, then the encode method will not escape Unicode + characters unless required by the JSON syntax or other flags. + + JSON->new->latin1->encode (["\x{89}\x{abc}"] + => ["\x{89}\\u0abc"] # (perl syntax, U+abc escaped, U+89 not) + + utf8 + $json = $json->utf8([$enable]) + + $enabled = $json->get_utf8 + + If $enable is true (or missing), then the encode method will encode the + JSON result into UTF-8, as required by many protocols, while the decode + method expects to be handled an UTF-8-encoded string. Please note that + UTF-8-encoded strings do not contain any characters outside the range + 0..255, they are thus useful for bytewise/binary I/O. + + In future versions, enabling this option might enable autodetection of + the UTF-16 and UTF-32 encoding families, as described in RFC4627. + + If $enable is false, then the encode method will return the JSON string + as a (non-encoded) Unicode string, while decode expects thus a Unicode + string. Any decoding or encoding (e.g. to UTF-8 or UTF-16) needs to be + done yourself, e.g. using the Encode module. + + Example, output UTF-16BE-encoded JSON: + + use Encode; + $jsontext = encode "UTF-16BE", JSON::XS->new->encode ($object); + + Example, decode UTF-32LE-encoded JSON: + + use Encode; + $object = JSON::XS->new->decode (decode "UTF-32LE", $jsontext); + + See to "UNICODE HANDLING ON PERLS" in JSON::PP if the backend is PP. + + pretty + $json = $json->pretty([$enable]) + + This enables (or disables) all of the "indent", "space_before" and + "space_after" (and in the future possibly more) flags in one call to + generate the most readable (or most compact) form possible. + + Equivalent to: + + $json->indent->space_before->space_after + + The indent space length is three and JSON::XS cannot change the indent + space length. + + indent + $json = $json->indent([$enable]) + + $enabled = $json->get_indent + + If $enable is true (or missing), then the "encode" method will use a + multiline format as output, putting every array member or object/hash + key-value pair into its own line, identing them properly. + + If $enable is false, no newlines or indenting will be produced, and the + resulting JSON text is guarenteed not to contain any "newlines". + + This setting has no effect when decoding JSON texts. + + The indent space length is three. With JSON::PP, you can also access + "indent_length" to change indent space length. + + space_before + $json = $json->space_before([$enable]) + + $enabled = $json->get_space_before + + If $enable is true (or missing), then the "encode" method will add an + extra optional space before the ":" separating keys from values in JSON + objects. + + If $enable is false, then the "encode" method will not add any extra + space at those places. + + This setting has no effect when decoding JSON texts. + + Example, space_before enabled, space_after and indent disabled: + + {"key" :"value"} + + space_after + $json = $json->space_after([$enable]) + + $enabled = $json->get_space_after + + If $enable is true (or missing), then the "encode" method will add an + extra optional space after the ":" separating keys from values in JSON + objects and extra whitespace after the "," separating key-value pairs + and array members. + + If $enable is false, then the "encode" method will not add any extra + space at those places. + + This setting has no effect when decoding JSON texts. + + Example, space_before and indent disabled, space_after enabled: + + {"key": "value"} + + relaxed + $json = $json->relaxed([$enable]) + + $enabled = $json->get_relaxed + + If $enable is true (or missing), then "decode" will accept some + extensions to normal JSON syntax (see below). "encode" will not be + affected in anyway. *Be aware that this option makes you accept invalid + JSON texts as if they were valid!*. I suggest only to use this option to + parse application-specific files written by humans (configuration files, + resource files etc.) + + If $enable is false (the default), then "decode" will only accept valid + JSON texts. + + Currently accepted extensions are: + + * list items can have an end-comma + + JSON *separates* array elements and key-value pairs with commas. + This can be annoying if you write JSON texts manually and want to be + able to quickly append elements, so this extension accepts comma at + the end of such items not just between them: + + [ + 1, + 2, <- this comma not normally allowed + ] + { + "k1": "v1", + "k2": "v2", <- this comma not normally allowed + } + + * shell-style '#'-comments + + Whenever JSON allows whitespace, shell-style comments are + additionally allowed. They are terminated by the first + carriage-return or line-feed character, after which more white-space + and comments are allowed. + + [ + 1, # this comment not allowed in JSON + # neither this one... + ] + + canonical + $json = $json->canonical([$enable]) + + $enabled = $json->get_canonical + + If $enable is true (or missing), then the "encode" method will output + JSON objects by sorting their keys. This is adding a comparatively high + overhead. + + If $enable is false, then the "encode" method will output key-value + pairs in the order Perl stores them (which will likely change between + runs of the same script). + + This option is useful if you want the same data structure to be encoded + as the same JSON text (given the same overall settings). If it is + disabled, the same hash might be encoded differently even if contains + the same data, as key-value pairs have no inherent ordering in Perl. + + This setting has no effect when decoding JSON texts. + + allow_nonref + $json = $json->allow_nonref([$enable]) + + $enabled = $json->get_allow_nonref + + If $enable is true (or missing), then the "encode" method can convert a + non-reference into its corresponding string, number or null JSON value, + which is an extension to RFC4627. Likewise, "decode" will accept those + JSON values instead of croaking. + + If $enable is false, then the "encode" method will croak if it isn't + passed an arrayref or hashref, as JSON texts must either be an object or + array. Likewise, "decode" will croak if given something that is not a + JSON object or array. + + JSON->new->allow_nonref->encode ("Hello, World!") + => "Hello, World!" + + allow_unknown + $json = $json->allow_unknown ([$enable]) + + $enabled = $json->get_allow_unknown + + If $enable is true (or missing), then "encode" will *not* throw an + exception when it encounters values it cannot represent in JSON (for + example, filehandles) but instead will encode a JSON "null" value. Note + that blessed objects are not included here and are handled separately by + c. + + If $enable is false (the default), then "encode" will throw an exception + when it encounters anything it cannot encode as JSON. + + This option does not affect "decode" in any way, and it is recommended + to leave it off unless you know your communications partner. + + allow_blessed + $json = $json->allow_blessed([$enable]) + + $enabled = $json->get_allow_blessed + + If $enable is true (or missing), then the "encode" method will not barf + when it encounters a blessed reference. Instead, the value of the + convert_blessed option will decide whether "null" ("convert_blessed" + disabled or no "TO_JSON" method found) or a representation of the object + ("convert_blessed" enabled and "TO_JSON" method found) is being encoded. + Has no effect on "decode". + + If $enable is false (the default), then "encode" will throw an exception + when it encounters a blessed object. + + convert_blessed + $json = $json->convert_blessed([$enable]) + + $enabled = $json->get_convert_blessed + + If $enable is true (or missing), then "encode", upon encountering a + blessed object, will check for the availability of the "TO_JSON" method + on the object's class. If found, it will be called in scalar context and + the resulting scalar will be encoded instead of the object. If no + "TO_JSON" method is found, the value of "allow_blessed" will decide what + to do. + + The "TO_JSON" method may safely call die if it wants. If "TO_JSON" + returns other blessed objects, those will be handled in the same way. + "TO_JSON" must take care of not causing an endless recursion cycle (== + crash) in this case. The name of "TO_JSON" was chosen because other + methods called by the Perl core (== not by the user of the object) are + usually in upper case letters and to avoid collisions with the "to_json" + function or method. + + This setting does not yet influence "decode" in any way. + + If $enable is false, then the "allow_blessed" setting will decide what + to do when a blessed object is found. + + convert_blessed_universally mode + If use "JSON" with "-convert_blessed_universally", the + "UNIVERSAL::TO_JSON" subroutine is defined as the below code: + + *UNIVERSAL::TO_JSON = sub { + my $b_obj = B::svref_2object( $_[0] ); + return $b_obj->isa('B::HV') ? { %{ $_[0] } } + : $b_obj->isa('B::AV') ? [ @{ $_[0] } ] + : undef + ; + } + + This will cause that "encode" method converts simple blessed objects + into JSON objects as non-blessed object. + + JSON -convert_blessed_universally; + $json->allow_blessed->convert_blessed->encode( $blessed_object ) + + This feature is experimental and may be removed in the future. + + filter_json_object + $json = $json->filter_json_object([$coderef]) + + When $coderef is specified, it will be called from "decode" each time it + decodes a JSON object. The only argument passed to the coderef is a + reference to the newly-created hash. If the code references returns a + single scalar (which need not be a reference), this value (i.e. a copy + of that scalar to avoid aliasing) is inserted into the deserialised data + structure. If it returns an empty list (NOTE: *not* "undef", which is a + valid scalar), the original deserialised hash will be inserted. This + setting can slow down decoding considerably. + + When $coderef is omitted or undefined, any existing callback will be + removed and "decode" will not change the deserialised hash in any way. + + Example, convert all JSON objects into the integer 5: + + my $js = JSON->new->filter_json_object (sub { 5 }); + # returns [5] + $js->decode ('[{}]'); # the given subroutine takes a hash reference. + # throw an exception because allow_nonref is not enabled + # so a lone 5 is not allowed. + $js->decode ('{"a":1, "b":2}'); + + filter_json_single_key_object + $json = $json->filter_json_single_key_object($key [=> $coderef]) + + Works remotely similar to "filter_json_object", but is only called for + JSON objects having a single key named $key. + + This $coderef is called before the one specified via + "filter_json_object", if any. It gets passed the single value in the + JSON object. If it returns a single value, it will be inserted into the + data structure. If it returns nothing (not even "undef" but the empty + list), the callback from "filter_json_object" will be called next, as if + no single-key callback were specified. + + If $coderef is omitted or undefined, the corresponding callback will be + disabled. There can only ever be one callback for a given key. + + As this callback gets called less often then the "filter_json_object" + one, decoding speed will not usually suffer as much. Therefore, + single-key objects make excellent targets to serialise Perl objects + into, especially as single-key JSON objects are as close to the + type-tagged value concept as JSON gets (it's basically an ID/VALUE + tuple). Of course, JSON does not support this in any way, so you need to + make sure your data never looks like a serialised Perl hash. + + Typical names for the single object key are "__class_whatever__", or + "$__dollars_are_rarely_used__$" or "}ugly_brace_placement", or even + things like "__class_md5sum(classname)__", to reduce the risk of + clashing with real hashes. + + Example, decode JSON objects of the form "{ "__widget__" => }" into + the corresponding $WIDGET{} object: + + # return whatever is in $WIDGET{5}: + JSON + ->new + ->filter_json_single_key_object (__widget__ => sub { + $WIDGET{ $_[0] } + }) + ->decode ('{"__widget__": 5') + + # this can be used with a TO_JSON method in some "widget" class + # for serialisation to json: + sub WidgetBase::TO_JSON { + my ($self) = @_; + + unless ($self->{id}) { + $self->{id} = ..get..some..id..; + $WIDGET{$self->{id}} = $self; + } + + { __widget__ => $self->{id} } + } + + shrink + $json = $json->shrink([$enable]) + + $enabled = $json->get_shrink + + With JSON::XS, this flag resizes strings generated by either "encode" or + "decode" to their minimum size possible. This can save memory when your + JSON texts are either very very long or you have many short strings. It + will also try to downgrade any strings to octet-form if possible: perl + stores strings internally either in an encoding called UTF-X or in + octet-form. The latter cannot store everything but uses less space in + general (and some buggy Perl or C code might even rely on that internal + representation being used). + + With JSON::PP, it is noop about resizing strings but tries + "utf8::downgrade" to the returned string by "encode". See to utf8. + + See to "OBJECT-ORIENTED INTERFACE" in JSON::XS and "METHODS" in + JSON::PP. + + max_depth + $json = $json->max_depth([$maximum_nesting_depth]) + + $max_depth = $json->get_max_depth + + Sets the maximum nesting level (default 512) accepted while encoding or + decoding. If a higher nesting level is detected in JSON text or a Perl + data structure, then the encoder and decoder will stop and croak at that + point. + + Nesting level is defined by number of hash- or arrayrefs that the + encoder needs to traverse to reach a given point or the number of "{" or + "[" characters without their matching closing parenthesis crossed to + reach a given character in a string. + + If no argument is given, the highest possible setting will be used, + which is rarely useful. + + Note that nesting is implemented by recursion in C. The default value + has been chosen to be as large as typical operating systems allow + without crashing. (JSON::XS) + + With JSON::PP as the backend, when a large value (100 or more) was set + and it de/encodes a deep nested object/text, it may raise a warning + 'Deep recursion on subroutin' at the perl runtime phase. + + See "SECURITY CONSIDERATIONS" in JSON::XS for more info on why this is + useful. + + max_size + $json = $json->max_size([$maximum_string_size]) + + $max_size = $json->get_max_size + + Set the maximum length a JSON text may have (in bytes) where decoding is + being attempted. The default is 0, meaning no limit. When "decode" is + called on a string that is longer then this many bytes, it will not + attempt to decode the string but throw an exception. This setting has no + effect on "encode" (yet). + + If no argument is given, the limit check will be deactivated (same as + when 0 is specified). + + See "SECURITY CONSIDERATIONS" in JSON::XS, below, for more info on why + this is useful. + + encode + $json_text = $json->encode($perl_scalar) + + Converts the given Perl data structure (a simple scalar or a reference + to a hash or array) to its JSON representation. Simple scalars will be + converted into JSON string or number sequences, while references to + arrays become JSON arrays and references to hashes become JSON objects. + Undefined Perl values (e.g. "undef") become JSON "null" values. + References to the integers 0 and 1 are converted into "true" and + "false". + + decode + $perl_scalar = $json->decode($json_text) + + The opposite of "encode": expects a JSON text and tries to parse it, + returning the resulting simple scalar or reference. Croaks on error. + + JSON numbers and strings become simple Perl scalars. JSON arrays become + Perl arrayrefs and JSON objects become Perl hashrefs. "true" becomes 1 + ("JSON::true"), "false" becomes 0 ("JSON::false") and "null" becomes + "undef". + + decode_prefix + ($perl_scalar, $characters) = $json->decode_prefix($json_text) + + This works like the "decode" method, but instead of raising an exception + when there is trailing garbage after the first JSON object, it will + silently stop parsing there and return the number of characters consumed + so far. + + JSON->new->decode_prefix ("[1] the tail") + => ([], 3) + + See to "OBJECT-ORIENTED INTERFACE" in JSON::XS + + property + $boolean = $json->property($property_name) + + Returns a boolean value about above some properties. + + The available properties are "ascii", "latin1", "utf8", + "indent","space_before", "space_after", "relaxed", "canonical", + "allow_nonref", "allow_unknown", "allow_blessed", "convert_blessed", + "shrink", "max_depth" and "max_size". + + $boolean = $json->property('utf8'); + => 0 + $json->utf8; + $boolean = $json->property('utf8'); + => 1 + + Sets the property with a given boolean value. + + $json = $json->property($property_name => $boolean); + + With no argumnt, it returns all the above properties as a hash + reference. + + $flag_hashref = $json->property(); + +INCREMENTAL PARSING + Most of this section are copied and modified from "INCREMENTAL PARSING" + in JSON::XS. + + In some cases, there is the need for incremental parsing of JSON texts. + This module does allow you to parse a JSON stream incrementally. It does + so by accumulating text until it has a full JSON object, which it then + can decode. This process is similar to using "decode_prefix" to see if a + full JSON object is available, but is much more efficient (and can be + implemented with a minimum of method calls). + + The backend module will only attempt to parse the JSON text once it is + sure it has enough text to get a decisive result, using a very simple + but truly incremental parser. This means that it sometimes won't stop as + early as the full parser, for example, it doesn't detect parenthese + mismatches. The only thing it guarantees is that it starts decoding as + soon as a syntactically valid JSON text has been seen. This means you + need to set resource limits (e.g. "max_size") to ensure the parser will + stop parsing in the presence if syntax errors. + + The following methods implement this incremental parser. + + incr_parse + $json->incr_parse( [$string] ) # void context + + $obj_or_undef = $json->incr_parse( [$string] ) # scalar context + + @obj_or_empty = $json->incr_parse( [$string] ) # list context + + This is the central parsing function. It can both append new text and + extract objects from the stream accumulated so far (both of these + functions are optional). + + If $string is given, then this string is appended to the already + existing JSON fragment stored in the $json object. + + After that, if the function is called in void context, it will simply + return without doing anything further. This can be used to add more text + in as many chunks as you want. + + If the method is called in scalar context, then it will try to extract + exactly *one* JSON object. If that is successful, it will return this + object, otherwise it will return "undef". If there is a parse error, + this method will croak just as "decode" would do (one can then use + "incr_skip" to skip the errornous part). This is the most common way of + using the method. + + And finally, in list context, it will try to extract as many objects + from the stream as it can find and return them, or the empty list + otherwise. For this to work, there must be no separators between the + JSON objects or arrays, instead they must be concatenated back-to-back. + If an error occurs, an exception will be raised as in the scalar context + case. Note that in this case, any previously-parsed JSON texts will be + lost. + + Example: Parse some JSON arrays/objects in a given string and return + them. + + my @objs = JSON->new->incr_parse ("[5][7][1,2]"); + + incr_text + $lvalue_string = $json->incr_text + + This method returns the currently stored JSON fragment as an lvalue, + that is, you can manipulate it. This *only* works when a preceding call + to "incr_parse" in *scalar context* successfully returned an object. + Under all other circumstances you must not call this function (I mean + it. although in simple tests it might actually work, it *will* fail + under real world conditions). As a special exception, you can also call + this method before having parsed anything. + + This function is useful in two cases: a) finding the trailing text after + a JSON object or b) parsing multiple JSON objects separated by non-JSON + text (such as commas). + + $json->incr_text =~ s/\s*,\s*//; + + In Perl 5.005, "lvalue" attribute is not available. You must write codes + like the below: + + $string = $json->incr_text; + $string =~ s/\s*,\s*//; + $json->incr_text( $string ); + + incr_skip + $json->incr_skip + + This will reset the state of the incremental parser and will remove the + parsed text from the input buffer. This is useful after "incr_parse" + died, in which case the input buffer and incremental parser state is + left unchanged, to skip the text parsed so far and to reset the parse + state. + + incr_reset + $json->incr_reset + + This completely resets the incremental parser, that is, after this call, + it will be as if the parser had never parsed anything. + + This is useful if you want ot repeatedly parse JSON objects and want to + ignore any trailing data, which means you have to reset the parser after + each successful decode. + + See to "INCREMENTAL PARSING" in JSON::XS for examples. + +JSON::PP SUPPORT METHODS + The below methods are JSON::PP own methods, so when "JSON" works with + JSON::PP (i.e. the created object is a JSON::PP object), available. See + to "JSON::PP OWN METHODS" in JSON::PP in detail. + + If you use "JSON" with additonal "-support_by_pp", some methods are + available even with JSON::XS. See to "USE PP FEATURES EVEN THOUGH XS + BACKEND". + + BEING { $ENV{PERL_JSON_BACKEND} = 'JSON::XS' } + + use JSON -support_by_pp; + + my $json = new JSON; + $json->allow_nonref->escape_slash->encode("/"); + + # functional interfaces too. + print to_json(["/"], {escape_slash => 1}); + print from_json('["foo"]', {utf8 => 1}); + + If you do not want to all functions but "-support_by_pp", use + "-no_export". + + use JSON -support_by_pp, -no_export; + # functional interfaces are not exported. + + allow_singlequote + $json = $json->allow_singlequote([$enable]) + + If $enable is true (or missing), then "decode" will accept any JSON + strings quoted by single quotations that are invalid JSON format. + + $json->allow_singlequote->decode({"foo":'bar'}); + $json->allow_singlequote->decode({'foo':"bar"}); + $json->allow_singlequote->decode({'foo':'bar'}); + + As same as the "relaxed" option, this option may be used to parse + application-specific files written by humans. + + allow_barekey + $json = $json->allow_barekey([$enable]) + + If $enable is true (or missing), then "decode" will accept bare keys of + JSON object that are invalid JSON format. + + As same as the "relaxed" option, this option may be used to parse + application-specific files written by humans. + + $json->allow_barekey->decode('{foo:"bar"}'); + + allow_bignum + $json = $json->allow_bignum([$enable]) + + If $enable is true (or missing), then "decode" will convert the big + integer Perl cannot handle as integer into a Math::BigInt object and + convert a floating number (any) into a Math::BigFloat. + + On the contary, "encode" converts "Math::BigInt" objects and + "Math::BigFloat" objects into JSON numbers with "allow_blessed" enable. + + $json->allow_nonref->allow_blessed->allow_bignum; + $bigfloat = $json->decode('2.000000000000000000000000001'); + print $json->encode($bigfloat); + # => 2.000000000000000000000000001 + + See to MAPPING aboout the conversion of JSON number. + + loose + $json = $json->loose([$enable]) + + The unescaped [\x00-\x1f\x22\x2f\x5c] strings are invalid in JSON + strings and the module doesn't allow to "decode" to these (except for + \x2f). If $enable is true (or missing), then "decode" will accept these + unescaped strings. + + $json->loose->decode(qq|["abc + def"]|); + + See to "JSON::PP OWN METHODS" in JSON::PP. + + escape_slash + $json = $json->escape_slash([$enable]) + + According to JSON Grammar, *slash* (U+002F) is escaped. But by default + JSON backend modules encode strings without escaping slash. + + If $enable is true (or missing), then "encode" will escape slashes. + + indent_length + $json = $json->indent_length($length) + + With JSON::XS, The indent space length is 3 and cannot be changed. With + JSON::PP, it sets the indent space length with the given $length. The + default is 3. The acceptable range is 0 to 15. + + sort_by + $json = $json->sort_by($function_name) + $json = $json->sort_by($subroutine_ref) + + If $function_name or $subroutine_ref are set, its sort routine are used. + + $js = $pc->sort_by(sub { $JSON::PP::a cmp $JSON::PP::b })->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + $js = $pc->sort_by('own_sort')->encode($obj); + # is($js, q|{"a":1,"b":2,"c":3,"d":4,"e":5,"f":6,"g":7,"h":8,"i":9}|); + + sub JSON::PP::own_sort { $JSON::PP::a cmp $JSON::PP::b } + + As the sorting routine runs in the JSON::PP scope, the given subroutine + name and the special variables $a, $b will begin with 'JSON::PP::'. + + If $integer is set, then the effect is same as "canonical" on. + + See to "JSON::PP OWN METHODS" in JSON::PP. + +MAPPING + This section is copied from JSON::XS and modified to "JSON". JSON::XS + and JSON::PP mapping mechanisms are almost equivalent. + + See to "MAPPING" in JSON::XS. + + JSON -> PERL + object + A JSON object becomes a reference to a hash in Perl. No ordering of + object keys is preserved (JSON does not preserver object key + ordering itself). + + array + A JSON array becomes a reference to an array in Perl. + + string + A JSON string becomes a string scalar in Perl - Unicode codepoints + in JSON are represented by the same codepoints in the Perl string, + so no manual decoding is necessary. + + number + A JSON number becomes either an integer, numeric (floating point) or + string scalar in perl, depending on its range and any fractional + parts. On the Perl level, there is no difference between those as + Perl handles all the conversion details, but an integer may take + slightly less memory and might represent more values exactly than + floating point numbers. + + If the number consists of digits only, "JSON" will try to represent + it as an integer value. If that fails, it will try to represent it + as a numeric (floating point) value if that is possible without loss + of precision. Otherwise it will preserve the number as a string + value (in which case you lose roundtripping ability, as the JSON + number will be re-encoded toa JSON string). + + Numbers containing a fractional or exponential part will always be + represented as numeric (floating point) values, possibly at a loss + of precision (in which case you might lose perfect roundtripping + ability, but the JSON number will still be re-encoded as a JSON + number). + + Note that precision is not accuracy - binary floating point values + cannot represent most decimal fractions exactly, and when converting + from and to floating point, "JSON" only guarantees precision up to + but not including the leats significant bit. + + If the backend is JSON::PP and "allow_bignum" is enable, the big + integers and the numeric can be optionally converted into + Math::BigInt and Math::BigFloat objects. + + true, false + These JSON atoms become "JSON::true" and "JSON::false", + respectively. They are overloaded to act almost exactly like the + numbers 1 and 0. You can check wether a scalar is a JSON boolean by + using the "JSON::is_bool" function. + + If "JSON::true" and "JSON::false" are used as strings or compared as + strings, they represent as "true" and "false" respectively. + + print JSON::true . "\n"; + => true + print JSON::true + 1; + => 1 + + ok(JSON::true eq 'true'); + ok(JSON::true eq '1'); + ok(JSON::true == 1); + + "JSON" will install these missing overloading features to the + backend modules. + + null + A JSON null atom becomes "undef" in Perl. + + "JSON::null" returns "unddef". + + PERL -> JSON + The mapping from Perl to JSON is slightly more difficult, as Perl is a + truly typeless language, so we can only guess which JSON type is meant + by a Perl value. + + hash references + Perl hash references become JSON objects. As there is no inherent + ordering in hash keys (or JSON objects), they will usually be + encoded in a pseudo-random order that can change between runs of the + same program but stays generally the same within a single run of a + program. "JSON" optionally sort the hash keys (determined by the + *canonical* flag), so the same datastructure will serialise to the + same JSON text (given same settings and version of JSON::XS), but + this incurs a runtime overhead and is only rarely useful, e.g. when + you want to compare some JSON text against another for equality. + + In future, the ordered object feature will be added to JSON::PP + using "tie" mechanism. + + array references + Perl array references become JSON arrays. + + other references + Other unblessed references are generally not allowed and will cause + an exception to be thrown, except for references to the integers 0 + and 1, which get turned into "false" and "true" atoms in JSON. You + can also use "JSON::false" and "JSON::true" to improve readability. + + to_json [\0,JSON::true] # yields [false,true] + + JSON::true, JSON::false, JSON::null + These special values become JSON true and JSON false values, + respectively. You can also use "\1" and "\0" directly if you want. + + JSON::null returns "undef". + + blessed objects + Blessed objects are not directly representable in JSON. See the + "allow_blessed" and "convert_blessed" methods on various options on + how to deal with this: basically, you can choose between throwing an + exception, encoding the reference as if it weren't blessed, or + provide your own serialiser method. + + With "convert_blessed_universally" mode, "encode" converts blessed + hash references or blessed array references (contains other blessed + references) into JSON members and arrays. + + use JSON -convert_blessed_universally; + JSON->new->allow_blessed->convert_blessed->encode( $blessed_object ); + + See to convert_blessed. + + simple scalars + Simple Perl scalars (any scalar that is not a reference) are the + most difficult objects to encode: JSON::XS and JSON::PP will encode + undefined scalars as JSON "null" values, scalars that have last been + used in a string context before encoding as JSON strings, and + anything else as number value: + + # dump as number + encode_json [2] # yields [2] + encode_json [-3.0e17] # yields [-3e+17] + my $value = 5; encode_json [$value] # yields [5] + + # used as string, so dump as string + print $value; + encode_json [$value] # yields ["5"] + + # undef becomes null + encode_json [undef] # yields [null] + + You can force the type to be a string by stringifying it: + + my $x = 3.1; # some variable containing a number + "$x"; # stringified + $x .= ""; # another, more awkward way to stringify + print $x; # perl does it for you, too, quite often + + You can force the type to be a number by numifying it: + + my $x = "3"; # some variable containing a string + $x += 0; # numify it, ensuring it will be dumped as a number + $x *= 1; # same thing, the choise is yours. + + You can not currently force the type in other, less obscure, ways. + + Note that numerical precision has the same meaning as under Perl (so + binary to decimal conversion follows the same rules as in Perl, + which can differ to other languages). Also, your perl interpreter + might expose extensions to the floating point numbers of your + platform, such as infinities or NaN's - these cannot be represented + in JSON, and it is an error to pass those in. + + Big Number + If the backend is JSON::PP and "allow_bignum" is enable, "encode" + converts "Math::BigInt" objects and "Math::BigFloat" objects into + JSON numbers. + +JSON and ECMAscript + See to "JSON and ECMAscript" in JSON::XS. + +JSON and YAML + JSON is not a subset of YAML. See to "JSON and YAML" in JSON::XS. + +BACKEND MODULE DECISION + When you use "JSON", "JSON" tries to "use" JSON::XS. If this call + failed, it will "uses" JSON::PP. The required JSON::XS version is *2.2* + or later. + + The "JSON" constructor method returns an object inherited from the + backend module, and JSON::XS object is a blessed scaler reference while + JSON::PP is a blessed hash reference. + + So, your program should not depend on the backend module, especially + returned objects should not be modified. + + my $json = JSON->new; # XS or PP? + $json->{stash} = 'this is xs object'; # this code may raise an error! + + To check the backend module, there are some methods - "backend", "is_pp" + and "is_xs". + + JSON->backend; # 'JSON::XS' or 'JSON::PP' + + JSON->backend->is_pp: # 0 or 1 + + JSON->backend->is_xs: # 1 or 0 + + $json->is_xs; # 1 or 0 + + $json->is_pp; # 0 or 1 + + If you set an enviornment variable "PERL_JSON_BACKEND", The calling + action will be changed. + + PERL_JSON_BACKEND = 0 or PERL_JSON_BACKEND = 'JSON::PP' + Always use JSON::PP + + PERL_JSON_BACKEND == 1 or PERL_JSON_BACKEND = 'JSON::XS,JSON::PP' + (The default) Use compiled JSON::XS if it is properly compiled & + installed, otherwise use JSON::PP. + + PERL_JSON_BACKEND == 2 or PERL_JSON_BACKEND = 'JSON::XS' + Always use compiled JSON::XS, die if it isn't properly compiled & + installed. + + PERL_JSON_BACKEND = 'JSON::backportPP' + Always use JSON::backportPP. JSON::backportPP is JSON::PP back port + module. "JSON" includs JSON::backportPP instead of JSON::PP. + + These ideas come from DBI::PurePerl mechanism. + + example: + + BEGIN { $ENV{PERL_JSON_BACKEND} = 'JSON::PP' } + use JSON; # always uses JSON::PP + + In future, it may be able to specify another module. + +USE PP FEATURES EVEN THOUGH XS BACKEND + Many methods are available with either JSON::XS or JSON::PP and when the + backend module is JSON::XS, if any JSON::PP specific (i.e. JSON::XS + unspported) method is called, it will "warn" and be noop. + + But If you "use" "JSON" passing the optional string "-support_by_pp", it + makes a part of those unupported methods available. This feature is + achieved by using JSON::PP in "de/encode". + + BEGIN { $ENV{PERL_JSON_BACKEND} = 2 } # with JSON::XS + use JSON -support_by_pp; + my $json = new JSON; + $json->allow_nonref->escape_slash->encode("/"); + + At this time, the returned object is a "JSON::Backend::XS::Supportable" + object (re-blessed XS object), and by checking JSON::XS unsupported + flags in de/encoding, can support some unsupported methods - "loose", + "allow_bignum", "allow_barekey", "allow_singlequote", "escape_slash" and + "indent_length". + + When any unsupported methods are not enable, "XS de/encode" will be used + as is. The switch is achieved by changing the symbolic tables. + + "-support_by_pp" is effective only when the backend module is JSON::XS + and it makes the de/encoding speed down a bit. + + See to "JSON::PP SUPPORT METHODS". + +INCOMPATIBLE CHANGES TO OLD VERSION + There are big incompatibility between new version (2.00) and old (1.xx). + If you use old "JSON" 1.xx in your code, please check it. + + See to "Transition ways from 1.xx to 2.xx." + + jsonToObj and objToJson are obsoleted. + Non Perl-style name "jsonToObj" and "objToJson" are obsoleted (but + not yet deleted from the source). If you use these functions in your + code, please replace them with "from_json" and "to_json". + + Global variables are no longer available. + "JSON" class variables - $JSON::AUTOCONVERT, $JSON::BareKey, etc... + - are not available any longer. Instead, various features can be + used through object methods. + + Package JSON::Converter and JSON::Parser are deleted. + Now "JSON" bundles with JSON::PP which can handle JSON more properly + than them. + + Package JSON::NotString is deleted. + There was "JSON::NotString" class which represents JSON value + "true", "false", "null" and numbers. It was deleted and replaced by + "JSON::Boolean". + + "JSON::Boolean" represents "true" and "false". + + "JSON::Boolean" does not represent "null". + + "JSON::null" returns "undef". + + "JSON" makes JSON::XS::Boolean and JSON::PP::Boolean is-a relation + to JSON::Boolean. + + function JSON::Number is obsoleted. + "JSON::Number" is now needless because JSON::XS and JSON::PP have + round-trip integrity. + + JSONRPC modules are deleted. + Perl implementation of JSON-RPC protocol - "JSONRPC ", + "JSONRPC::Transport::HTTP" and "Apache::JSONRPC " are deleted in + this distribution. Instead of them, there is JSON::RPC which + supports JSON-RPC protocol version 1.1. + + Transition ways from 1.xx to 2.xx. + You should set "suport_by_pp" mode firstly, because it is always + successful for the below codes even with JSON::XS. + + use JSON -support_by_pp; + + Exported jsonToObj (simple) + from_json($json_text); + + Exported objToJson (simple) + to_json($perl_scalar); + + Exported jsonToObj (advanced) + $flags = {allow_barekey => 1, allow_singlequote => 1}; + from_json($json_text, $flags); + + equivalent to: + + $JSON::BareKey = 1; + $JSON::QuotApos = 1; + jsonToObj($json_text); + + Exported objToJson (advanced) + $flags = {allow_blessed => 1, allow_barekey => 1}; + to_json($perl_scalar, $flags); + + equivalent to: + + $JSON::BareKey = 1; + objToJson($perl_scalar); + + jsonToObj as object method + $json->decode($json_text); + + objToJson as object method + $json->encode($perl_scalar); + + new method with parameters + The "new" method in 2.x takes any parameters no longer. You can set + parameters instead; + + $json = JSON->new->pretty; + + $JSON::Pretty, $JSON::Indent, $JSON::Delimiter + If "indent" is enable, that means $JSON::Pretty flag set. And + $JSON::Delimiter was substituted by "space_before" and + "space_after". In conclusion: + + $json->indent->space_before->space_after; + + Equivalent to: + + $json->pretty; + + To change indent length, use "indent_length". + + (Only with JSON::PP, if "-support_by_pp" is not used.) + + $json->pretty->indent_length(2)->encode($perl_scalar); + + $JSON::BareKey + (Only with JSON::PP, if "-support_by_pp" is not used.) + + $json->allow_barekey->decode($json_text) + + $JSON::ConvBlessed + use "-convert_blessed_universally". See to convert_blessed. + + $JSON::QuotApos + (Only with JSON::PP, if "-support_by_pp" is not used.) + + $json->allow_singlequote->decode($json_text) + + $JSON::SingleQuote + Disable. "JSON" does not make such a invalid JSON string any longer. + + $JSON::KeySort + $json->canonical->encode($perl_scalar) + + This is the ascii sort. + + If you want to use with your own sort routine, check the "sort_by" + method. + + (Only with JSON::PP, even if "-support_by_pp" is used currently.) + + $json->sort_by($sort_routine_ref)->encode($perl_scalar) + + $json->sort_by(sub { $JSON::PP::a <=> $JSON::PP::b })->encode($perl_scalar) + + Can't access $a and $b but $JSON::PP::a and $JSON::PP::b. + + $JSON::SkipInvalid + $json->allow_unknown + + $JSON::AUTOCONVERT + Needless. "JSON" backend modules have the round-trip integrity. + + $JSON::UTF8 + Needless because "JSON" (JSON::XS/JSON::PP) sets the UTF8 flag on + properly. + + # With UTF8-flagged strings + + $json->allow_nonref; + $str = chr(1000); # UTF8-flagged + + $json_text = $json->utf8(0)->encode($str); + utf8::is_utf8($json_text); + # true + $json_text = $json->utf8(1)->encode($str); + utf8::is_utf8($json_text); + # false + + $str = '"' . chr(1000) . '"'; # UTF8-flagged + + $perl_scalar = $json->utf8(0)->decode($str); + utf8::is_utf8($perl_scalar); + # true + $perl_scalar = $json->utf8(1)->decode($str); + # died because of 'Wide character in subroutine' + + See to "A FEW NOTES ON UNICODE AND PERL" in JSON::XS. + + $JSON::UnMapping + Disable. See to MAPPING. + + $JSON::SelfConvert + This option was deleted. Instead of it, if a givien blessed object + has the "TO_JSON" method, "TO_JSON" will be executed with + "convert_blessed". + + $json->convert_blessed->encode($bleesed_hashref_or_arrayref) + # if need, call allow_blessed + + Note that it was "toJson" in old version, but now not "toJson" but + "TO_JSON". + +TODO + example programs + +THREADS + No test with JSON::PP. If with JSON::XS, See to "THREADS" in JSON::XS. + +BUGS + Please report bugs relevant to "JSON" to . + +SEE ALSO + Most of the document is copied and modified from JSON::XS doc. + + JSON::XS, JSON::PP + + "RFC4627"() + +AUTHOR + Makamaka Hannyaharamitu, + + JSON::XS was written by Marc Lehmann + + The relese of this new version owes to the courtesy of Marc Lehmann. + +COPYRIGHT AND LICENSE + Copyright 2005-2011 by Makamaka Hannyaharamitu + + This library is free software; you can redistribute it and/or modify it + under the same terms as Perl itself. + diff --git a/json/perl-JSON-2.50-1.rf.src.rpm b/json/perl-JSON-2.50-1.rf.src.rpm new file mode 100644 index 0000000000000000000000000000000000000000..64241ba06cc3f9d6ea4b904e738f6631fdd2755d GIT binary patch literal 82650 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 z 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

^;wTQFQj@U7pnFXUX7Oiihn6OS82&BRcV&I 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 literal 0 HcmV?d00001