JSON::PP - JSON::XS compatible pure-Perl module.


NAME

JSON::PP - JSON::XS compatible pure-Perl module.


SYNOPSIS

 use JSON::PP;
 # exported functions, they croak on error
 # and 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
 $coder = JSON::PP->new->ascii->pretty->allow_nonref;
 $pretty_printed_unencoded = $coder->encode ($perl_scalar);
 $perl_scalar = $coder->decode ($unicode_json_text);
 # Note that JSON version 2.0 and above will automatically use
 # JSON::XS or JSON::PP, so you should be able to just:
 
 use JSON;


DESCRIPTION

This module is the JSON::XS manpage compatible pure Perl module. (Perl 5.8 or later is recommended)

JSON::XS is the fastest and most proper JSON module on CPAN. It is written by Marc Lehmann in C, so must be compiled and installed in the used environment.

JSON::PP is a pure-Perl module and has compatibility to JSON::XS.

FEATURES


FUNCTIONS

Basically, check to JSON or the JSON::XS manpage.

encode_json

    $json_text = encode_json $perl_scalar

decode_json

    $perl_scalar = decode_json $json_text

JSON::PP::true

Returns JSON true value which is blessed object. It isa JSON::PP::Boolean object.

JSON::PP::false

Returns JSON false value which is blessed object. It isa JSON::PP::Boolean object.

JSON::PP::null

Returns undef.


METHODS

Basically, check to JSON or the JSON::XS manpage.

new

    $json = new JSON::PP

Rturns a new JSON::PP object that can be used to de/encode JSON strings.

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. (See to OBJECT-ORIENTED INTERFACE in the JSON::XS manpage).

In Perl 5.005, there is no character having high value (more than 255). See to UNICODE HANDLING ON PERLS.

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.

  JSON::PP->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::XS->new->latin1->encode (["\x{89}\x{abc}"]
  => ["\x{89}\\u0abc"]    # (perl syntax, U+abc escaped, U+89 not)

See to UNICODE HANDLING ON PERLS.

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 Perl 5.005, any character outside the range 0..255 does not exist. See to UNICODE HANDLING ON PERLS.)

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);

pretty

    $json = $json->pretty([$enable])

This enables (or disables) all of the indent, space_before and space_after flags in one call to generate the most readable (or most compact) form possible.

indent

    $json = $json->indent([$enable])
    
    $enabled = $json->get_indent

The default indent space lenght is three. You can use indent_length to change the length.

space_before

    $json = $json->space_before([$enable])
    
    $enabled = $json->get_space_before

space_after

    $json = $json->space_after([$enable])
    
    $enabled = $json->get_space_after

relaxed

    $json = $json->relaxed([$enable])
    
    $enabled = $json->get_relaxed

canonical

    $json = $json->canonical([$enable])
    
    $enabled = $json->get_canonical

If you want your own sorting routine, you can give a code referece or a subroutine name to sort_by. See to JSON::PP OWN METHODS.

allow_nonref

    $json = $json->allow_nonref([$enable])
    
    $enabled = $json->get_allow_nonref

allow_unknown

    $json = $json->allow_unknown ([$enable])
    
    $enabled = $json->get_allow_unknown

allow_blessed

    $json = $json->allow_blessed([$enable])
    
    $enabled = $json->get_allow_blessed

convert_blessed

    $json = $json->convert_blessed([$enable])
    
    $enabled = $json->get_convert_blessed

filter_json_object

    $json = $json->filter_json_object([$coderef])

filter_json_single_key_object

    $json = $json->filter_json_single_key_object($key [=> $coderef])

shrink

    $json = $json->shrink([$enable])
    
    $enabled = $json->get_shrink

In JSON::XS, this flag resizes strings generated by either encode or decode to their minimum size possible. It will also try to downgrade any strings to octet-form if possible.

In JSON::PP, it is noop about resizing strings but tries utf8::downgrade to the returned string by encode. See to the utf8 manpage.

See to OBJECT-ORIENTED INTERFACE in the JSON::XS manpage

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.

See SSECURITY CONSIDERATIONS in the JSON::XS manpage for more info on why this is useful.

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.

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 SSECURITY CONSIDERATIONS in the JSON::XS manpage for more info on why this is useful.

encode

    $json_text = $json->encode($perl_scalar)

decode

    $perl_scalar = $json->decode($json_text)

decode_prefix

    ($perl_scalar, $characters) = $json->decode_prefix($json_text)


INCREMENTAL PARSING

In JSON::XS 2.2, incremental parsing feature of JSON texts was experimentally implemented. Please check to INCREMENTAL PARSING in the JSON::XS manpage.

[void, scalar or list context] = $json->incr_parse ([$string])
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.

$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).

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 );

$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.


JSON::PP OWN METHODS

allow_singlequote

    $json = $json->allow_singlequote([$enable])

If $enable is true (or missing), then decode will accept 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 the Math::BigInt manpage object and convert a floating number (any) into a the Math::BigFloat manpage.

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 in the JSON::XS manpage aboout the normal 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 SSECURITY CONSIDERATIONS in the JSON::XS manpage.

escape_slash

    $json = $json->escape_slash([$enable])

According to JSON Grammar, slash (U+002F) is escaped. But default JSON::PP (as same as JSON::XS) encodes strings without escaping slash.

If $enable is true (or missing), then encode will escape slashes.

(OBSOLETED)as_nonblessed

    $json = $json->as_nonblessed

(OBSOLETED) If $enable is true (or missing), then encode will convert a blessed hash reference or a blessed array reference (contains other blessed references) into JSON members and arrays.

This feature is effective only when allow_blessed is enable.

indent_length

    $json = $json->indent_length($length)

JSON::XS indent space length is 3 and cannot be changed. JSON::PP set 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 in encoding JSON objects.

   $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 'JSON::PP::'.

If $integer is set, then the effect is same as canonical on.


INTERNAL

For developers.

PP_encode_box
Returns
        {
            depth        => $depth,
            indent_count => $indent_count,
        }

PP_decode_box
Returns
        {
            text    => $text,
            at      => $at,
            ch      => $ch,
            len     => $len,
            is_utf8 => $is_utf8,
            depth   => $depth,
            encoding      => $encoding,
            is_valid_utf8 => $is_valid_utf8,
        };


MAPPING

See to MAPPING in the JSON::XS manpage.


UNICODE HANDLING ON PERLS

If you do not know about Unicode on Perl well, please check A FEW NOTES ON UNICODE AND PERL in the JSON::XS manpage.

Perl 5.8 and later

Perl can handle Unicode and the JSON::PP de/encode methods also work properly.

    $json->allow_nonref->encode(chr hex 3042);
    $json->allow_nonref->encode(chr hex 12345);

Reuturns "\u3042" and "\ud808\udf45" respectively.

    $json->allow_nonref->decode('"\u3042"');
    $json->allow_nonref->decode('"\ud808\udf45"');

Returns UTF-8 encoded strings with UTF8 flag, regarded as U+3042 and U+12345.

Note that the versions from Perl 5.8.0 to 5.8.2, Perl built-in join was broken, so JSON::PP wraps the join with a subroutine. Thus JSON::PP works slow in the versions.

Perl 5.6

Perl can handle Unicode and the JSON::PP de/encode methods also work.

Perl 5.005

Perl 5.005 is a byte sementics world -- all strings are sequences of bytes. That means the unicode handling is not available.

In encoding,

    $json->allow_nonref->encode(chr hex 3042);  # hex 3042 is 12354.
    $json->allow_nonref->encode(chr hex 12345); # hex 12345 is 74565.

Returns B and E, as chr takes a value more than 255, it treats as $value % 256, so the above codes are equivalent to :

    $json->allow_nonref->encode(chr 66);
    $json->allow_nonref->encode(chr 69);

In decoding,

    $json->decode('"\u00e3\u0081\u0082"');

The returned is a byte sequence 0xE3 0x81 0x82 for UTF-8 encoded japanese character (HIRAGANA LETTER A). And if it is represented in Unicode code point, U+3042.

Next,

    $json->decode('"\u3042"');

We ordinary expect the returned value is a Unicode character U+3042. But here is 5.005 world. This is 0xE3 0x81 0x82.

    $json->decode('"\ud808\udf45"');

This is not a character U+12345 but bytes - 0xf0 0x92 0x8d 0x85.


TODO

speed
memory saving


SEE ALSO

Most of the document are copied and modified from JSON::XS doc.

the JSON::XS manpage

RFC4627 (http://www.ietf.org/rfc/rfc4627.txt)


AUTHOR

Makamaka Hannyaharamitu, <makamaka[at]cpan.org>


COPYRIGHT AND LICENSE

Copyright 2008 by Makamaka Hannyaharamitu

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

 JSON::PP - JSON::XS compatible pure-Perl module.