CPAN::Groonga

ay be broken!

package OODoc::Export::JSON;{
our $VERSION = '3.04';
}

use parent 'OODoc::Export';

use strict;
use warnings;

use Log::Report  'oodoc';

use JSON   ();

#--------------------

sub new

 $class->SUPER::new(serializer => 'json', @_) }

#--------------------

# Bleh: JSON has real true and false booleans :-(
sub boolean($) { $_[1] ? $JSON::true : $JSON::false }


sub write($$%)
{	my ($

fault __x"cannot write output to {file}", file => $output;
	}

	my $json = JSON->new->pretty($args{pretty_print});
	$fh->print($json->encode($data));

	$output eq '-' || $fh->close
		or fault __x"writ

e::Session::Serialize::JSON;

use strict;
use JSON qw(to_json from_json);

our $VERSION = '1.2.6';

sub serialize {
    my $session = shift;

    $session->{serialized} = to_json( $session->{data}, { 

ta;
}

sub _unserialize {
    my ( $serialized, $next ) = @_;
    my $tmp;
    eval { $tmp = from_json( $serialized, { allow_nonref => 1 } ) };
    if ($@) {
        require Storable;
        $next ||

ize::JSON - Use JSON to zip up data

=head1 SYNOPSIS

 use Apache::Session::Serialize::JSON;

 $zipped = Apache::Session::Serialize::JSON::serialize($ref);
 $ref = Apache::Session::Serialize::JSON::un

use strict;
use warnings;

package JSON::Pointer::Marpa::Semantics;

use subs qw( _index_exists _member_exists );

use constant { ## no critic (ProhibitConstantPragma)
  EMPTY => '',
  SLASH => '/',
 

rv, $index ) )
  } else {
    Marpa::R2::Context::bail(
"Currently referenced type '$crt' isn't a JSON structured type (array or object)!"
    )
  }

  undef
}

sub next_array_index_dereferencing {
  

rrently referenced type
  Marpa::R2::Context::bail(
    "Currently referenced type '$crt' isn't a JSON object!" )
    unless $crt eq 'HASH';
  $self->set_crv( _member_exists( $crv, $member ) );

  und

---------------------------
# File:         JSON.pm
#
# Description:  Read JSON files
#
# Notes:        Set ExifTool MissingTagValue to "null" to ignore JSON nulls
#
# Revisions:    2017/03/13 - P. Ha

package Image::ExifTool::JSON;
use strict;
use vars qw($VERSION);
use Image::ExifTool qw(:DataAccess :Utils);
use Image::ExifTool::Import;

$VERSION = '1.10';

sub ProcessJSON($$);
sub ProcessTag($$$$

OUPS => { 0 => 'JSON', 1 => 'JSON', 2 => 'Other' },
    VARS => { NO_ID => 1 },
    PROCESS_PROC => \&ProcessJSON,
    NOTES => q{
        Other than a few tags in the table below, JSON tags have not 

se strict;
use warnings;

package JSON::Pointer::Marpa;

$JSON::Pointer::Marpa::VERSION = 'v1.0.3';

use Marpa::R2   ();
use URI::Escape qw( uri_unescape );

use JSON::Pointer::Marpa::Semantics ();

m

get {
  my ( undef, $json_document, $json_pointer ) = @_;

  # FIXME: properly differentiate between the 2 different representations
  # (RFC6901 section 5 and section 6) of a JSON pointer. uri_unesca

. Backslash unescaping has to be done for the JSON string
  # representation (section 5) type.
  $json_pointer = uri_unescape( $json_pointer )
    if $json_pointer =~ s/\A#//; ## no critic (RequireExt

:JSON::XS::Type;

=pod

=head1 NAME

Cpanel::JSON::XS::Type - Type support for JSON encode

=head1 SYNOPSIS

 use Cpanel::JSON::XS;
 use Cpanel::JSON::XS::Type;


 encode_json([10, "10", 10.25], [JSON

_TYPE_INT, JSON_TYPE_INT, JSON_TYPE_STRING]);
 # '[10,10,"10.25"]'

 encode_json([10, "10", 10.25], json_type_arrayof(JSON_TYPE_INT));
 # '[10,10,10]'

 encode_json(1, JSON_TYPE_BOOL);
 # 'true'

 my 

ey2 => "2", key3 => 1 };
 my $type_spec = { key1 => JSON_TYPE_STRING, key2 => JSON_TYPE_INT, key3 => JSON_TYPE_BOOL };
 my $json_string = encode_json($perl_struct, $type_spec);
 # '{"key1":"1","key2":

package Cpanel::JSON::XS;
our $VERSION = '4.40';
our $XS_VERSION = $VERSION;
# $VERSION = eval $VERSION;

=pod

=head1 NAME

Cpanel::JSON::XS - cPanel fork of JSON::XS, fast and correct serializing

=

Cpanel::JSON::XS;

 # 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_

d_json_text;

 # OO-interface

 $coder = Cpanel::JSON::XS->new->ascii->pretty->allow_nonref;
 $pretty_printed_unencoded = $coder->encode ($perl_scalar);
 $perl_scalar = $coder->decode ($unicode_json_t

=head1 NAME

JSON::XS - JSON serialising/deserialising, done correctly and fast

=encoding utf-8

JSON::XS - 正しくて高速な JSON シリアライザ/デシリアライザ
           (http://fleu

o.jp/perldoc/mix/lib/JSON/XS.html)

=head1 SYNOPSIS

 use JSON::XS;

 # exported functions, they croak on error
 # and expect/generate UTF-8

 $utf8_encoded_json_text = encode_json $perl_hash_or_array

ref;
 $perl_hash_or_arrayref  = decode_json $utf8_encoded_json_text;

 # OO-interface

 $coder = JSON::XS->new->ascii->pretty->allow_nonref;
 $pretty_printed_unencoded = $coder->encode ($perl_scalar);

JSON::SIMD - JSON serialising/deserialising, done correctly and faster

=head1 SYNOPSIS

 use JSON::SIMD;

 # 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::SIMD->new->ascii->pretty->allow_nonref;
 $pretty_printed_u

->decode ($unicode_json_text);

 $coder = JSON::SIMD->new->use_simdjson;
 $perl_scalar = $coder->decode ($unicode_json_text);
 $perl_scalar = $coder->decode_at_pointer ($unicode_json_text, '/just/a/pa

S::JSON;

use strict;
use warnings;

use Exporter qw(import);

my $package;

BEGIN
{
    if ($INC{'Cpanel/JSON/XS.pm'} or eval { require Cpanel::JSON::XS; 1 })
    {
        $package = 'Cpanel::JSON::

C{'JSON/XS.pm'} or eval { require JSON::XS; 1 }) and eval { JSON::XS->VERSION(3.0); 1 })
    {
        $package = 'JSON::XS';
    }
    else
    {
        require JSON::PP;
        $package = 'JSON::P

ort(qw(encode_json decode_json));

    *PLS::JSON::true  = $package->can('true');
    *PLS::JSON::false = $package->can('false');
} ## end BEGIN

our @EXPORT = qw(encode_json decode_json);    ## no cr

ckORM::Conflator::JSON::ASCII;
use strict;
use warnings;

our $VERSION = '0.000005';

use parent 'DBIx::QuickORM::Conflator::JSON';

use Cpanel::JSON::XS();

my $ASCII = Cpanel::JSON::XS->new->ascii(1

)->convert_blessed(1)->allow_nonref(1);
sub JSON { $ASCII }

1;

r::JSON;
use strict;
use warnings;

our $VERSION = '0.000005';

use Cpanel::JSON::XS qw/decode_json/;

use Role::Tiny::With qw/with/;
with 'DBIx::QuickORM::Role::Conflator';

my $JSON = Cpanel::JSON::

->allow_nonref(1);
sub JSON { $JSON }

sub qorm_sql_type {
    my $class = shift;
    my %params = @_;

    my $con = $params{connection};

    if (my $type = $con->supports_json) {
        return $ty

n decode_json($val);
}

sub qorm_deflate {
    my $class = shift;
    my %params = @_;

    my $val = $params{value} or return undef;
    return $val unless ref($val);
    return $class->JSON->encode(

 warnings;
package JSON::Schema::Types; # git description: f55a51a
# vim: set ts=8 sts=2 sw=2 tw=100 et :
# ABSTRACT: Create Type::Tiny types defined by JSON Schemas
# KEYWORDS: JSON Schema types

our

t yet implemented';
}

sub json_schema_type ($class) {
  die 'not yet implemented';
}

1;

__END__

=pod

=encoding UTF-8

=for stopwords schema subschema

=head1 NAME

JSON::Schema::Types - Create Ty

ined by JSON Schemas

=head1 VERSION

version 0.001

=head1 SYNOPSIS

  use JSON::Schema::Types ':all';

  my $my_type = json_schema_type({
    type => 'object',
    properties => {
      foo => { typ

r::JSON;
use strict;
use warnings;

our $VERSION = '0.000004';

use Cpanel::JSON::XS qw/decode_json/;

use Role::Tiny::With qw/with/;
with 'DBIx::QuickORM::Role::Conflator';

my $JSON = Cpanel::JSON::

->allow_nonref(1);
sub JSON { $JSON }

sub qorm_sql_type {
    my $class = shift;
    my %params = @_;

    my $con = $params{connection};

    if (my $type = $con->supports_json) {
        return $ty

n decode_json($val);
}

sub qorm_deflate {
    my $class = shift;
    my %params = @_;

    my $val = $params{value} or return undef;
    return $val unless ref($val);
    return $class->JSON->encode(

package DBIx::QuickORM::Type::JSON;
use strict;
use warnings;

our $VERSION = '0.000019';

use DBIx::QuickORM::Util qw/parse_conflate_args/;

use Carp qw/croak/;
use Scalar::Util qw/reftype blessed/;

ole::Type';

use Cpanel::JSON::XS qw/decode_json/;

my $JSON = Cpanel::JSON::XS->new->utf8(1)->convert_blessed(1)->allow_nonref(1);
sub JSON { $JSON }

my $CJSON = Cpanel::JSON::XS->new->utf8(1)->conv

ert_blessed(1)->allow_nonref(1)->canonical(1);
sub CJSON { $CJSON }

sub qorm_inflate {
    my $params = parse_conflate_args(@_);
    my $val    = $params->{value} or return undef;
    my $class  = $p

ckORM::Conflator::JSON::ASCII;
use strict;
use warnings;

our $VERSION = '0.000004';

use parent 'DBIx::QuickORM::Conflator::JSON';

use Cpanel::JSON::XS();

my $ASCII = Cpanel::JSON::XS->new->ascii(1

)->convert_blessed(1)->allow_nonref(1);
sub JSON { $ASCII }

1;

package Wiki::JSON::Contributing;

use v5.16.3;
use strict;
use warnings;

1;
=encoding utf8

=head1 WAYS TO CONTRIBUTE

=head2 REPORTING BUGS

If you think some behavior is undesired you can use the 

Github repository L<https://github.com/sergiotarxz/Perl-Wiki-JSON> to report it
in the issues tab.

This should be enough, but if you really want to ensure I understand you ideally you could write in 

se strict;
 use warnings;
 
 use lib 'lib';
 
 use Test::Most;
 
 use_ok 'Wiki::JSON';
 
 {
     my $parsed = Wiki::JSON->new->parse(
         q(= This is a wiki title =
 '''This is bold'''
 ''This is

package Wiki::JSON::HTML;

use v5.16.3;

use strict;
use warnings;

use Moo;
use Mojo::Util qw/xml_escape/;
use Mojo::URL;

has _wiki_json => ( is => 'lazy' );

sub pre_html_json {
    my ( $self, $wi

 );
    my $json =
      $self->_wiki_json->parse( $wiki_text, { track_lines_for_errors => 1 } );

    #    print Data::Dumper::Dumper $json;

    push @dom, @{ $self->_parse_output( $json, $template_

html_element('article');
    return \@dom;
}

sub _build__wiki_json {
    my $self = shift;
    require Wiki::JSON;
    return Wiki::JSON->new;
}

sub _open_html_element {
    if ( @_ < 2 ) {
        

package Sisimai::Data::JSON;
use feature ':5.10';
use strict;
use warnings;
use JSON;

sub dump {
    # Data dumper(JSON)
    # @param    [Sisimai::Data] argvs   Object
    # @return   [String, Undef]

my $jsonstring = '';
    eval { $jsonstring = JSON->new->space_after(1)->encode($argvs->damn) };
    warn sprintf(" ***warning: Something is wrong in JSON encoding: %s", $@) if $@;
    return $jsonstr

ing;
}

1;
__END__

=encoding utf-8

=head1 NAME

Sisimai::Data::JSON - Dumps parsed data object as a JSON format

=head1 SYNOPSIS

    use Sisimai::Data;
    my $data = Sisimai::Data->make('data' => 

package Sisimai::Fact::JSON;
use v5.26;
use strict;
use warnings;
use JSON;

sub dump {
    # Data dumper(JSON)
    # @param    [Sisimai::Fact] argvs   Object
    # @return   [String]                D

my $jsonstring = "";
    eval { $jsonstring = JSON->new->space_after(1)->encode($argvs->damn) };
    warn sprintf(" ***warning: Something is wrong in JSON encoding: %s", $@) if $@;
    return $jsonstr

ing;
}

1;
__END__

=encoding utf-8

=head1 NAME

Sisimai::Fact::JSON - Dumps decoded data object as a JSON format

=head1 SYNOPSIS

    use Sisimai::Fact;
    my $fact = Sisimai::Fact->rise('data' =>