CPAN::Groonga

kend::Json 2.155;

use Carp;
use strict;
use warnings;
use Config::Model::Exception;
use File::Path;
use Log::Log4perl qw(get_logger :levels);

use base qw/Config::Model::Backend::Any/;
use JSON;

my 

$logger = get_logger("Backend::Json");

sub read {
    my $self = shift;
    my %args = @_;

    # args is:
    # object     => $obj,         # Config::Model::Node object
    # root       => './my_tes

xists;    # no file to read

    # load Json file
    my $json = $args{file_path}->slurp_utf8;

    # convert to perl data
    my $perl_data = decode_json $json ;
    if ( not defined $perl_data ) {
 

n Williams. 2010 Matt S Trout
  
  =item L<version> Copyright 2004-2010 John Peacock
  
  =item L<JSON::PP> Copyright 2007-2011 by Makamaka Hannyaharamitu
  
  =item L<CPAN::Meta>, L<CPAN::Meta::Requi

code_json {
      my($self, $data) = @_;
      require JSON::PP;
  
      my $json = JSON::PP::encode_json($data);
      $self->uri_escape($json);
  }
  
  sub decode_json {
      my($self, $json) = @

_;
      require JSON::PP;
  
      JSON::PP::decode_json($json);
  }
  
  sub uri_escape {
      my($self, $fragment) = @_;
      $fragment =~ s/([^A-Za-z0-9\-\._~])/uc sprintf("%%%02X", ord($1))/eg;

package Catmandu::Fix::marc_in_json;

use Catmandu::Sane;
use Catmandu::MARC;
use Moo;
use Catmandu::Fix::Has;

with 'Catmandu::Fix::Inlineable';

our $VERSION = '1.33';

has reverse => (fix_opt => 1)

# Transform a raw MARC array into MARC-in-JSON
# See Ross Singer work at:
#  http://dilettantes.code4lib.org/blog/2010/09/a-proposal-to-serialize-marc-in-json/
sub fix {
    my ($self, $data) = @_;

 

MARC->instance->marc_json_to_record($data);
    }
    else {
        return Catmandu::MARC->instance->marc_record_to_json($data);
    }
}

=head1 NAME

Catmandu::Fix::marc_in_json - transform a Catman

package JSON::RPC2::Server;
use 5.010001;
use warnings;
use strict;
use utf8;
use Carp;

our $VERSION = 'v2.1.3';

use JSON::MaybeXS;

use constant ERR_PARSE  => -32700;
use constant ERR_REQ    => -32

elf, $json, $cb) = @_;
    croak 'require 2 params' if 1+2 != @_;
    croak 'second param must be callback' if ref $cb ne 'CODE';

    undef $@;
    my $request = ref $json ? $json : eval { JSON::Mayb

eXS->new(allow_nonref=>0)->decode($json) };
    if ($@) {
        return _error($cb, undef, ERR_PARSE, 'Parse error.');
    }
    if (ref $request eq 'HASH') {
        return $self->_execute($request,

kage JSON::RPC2;
use 5.010001;
use warnings;
use strict;
use utf8;
use Carp;

our $VERSION = 'v2.1.3';


1; # Magic true value required at end of module
__END__

=encoding utf8

=head1 NAME

JSON::RPC

t-independent implementation of JSON-RPC 2.0


=head1 VERSION

This document describes JSON::RPC2 version v2.1.3


=head1 SYNOPSIS

See L<JSON::RPC2::Server> and L<JSON::RPC2::Client> for usage exampl

es.


=head1 DESCRIPTION

This module implement JSON-RPC 2.0 protocol in transport-independent way.
It was very surprising for me to find on CPAN a lot of transport-dependent
implementations of (by na

package JSON::RPC2::Client;
use 5.010001;
use warnings;
use strict;
use utf8;
use Carp;

our $VERSION = 'v2.1.3';

use JSON::MaybeXS;
use Scalar::Util qw( weaken refaddr );


sub new {
    my ($class)

$method, @params) = @_;
    croak 'method required' if !defined $method;
    return encode_json({
        jsonrpc     => '2.0',
        method      => $method,
        (!@params ? () : (
        param

number of elements in %params' if @params % 2;
    my %params = @params;
    return encode_json({
        jsonrpc     => '2.0',
        method      => $method,
        (!@params ? () : (
        param

package JSON::MaybeXS;

use strict;
use warnings FATAL => 'all';
use base qw(Exporter);

our $VERSION = '1.004008';
$VERSION =~ tr/_//d;

sub _choose_json_module {
    return 'Cpanel::JSON::XS' if $IN

C{'Cpanel/JSON/XS.pm'};
    return 'JSON::XS'         if $INC{'JSON/XS.pm'} && eval { JSON::XS->VERSION(3.0); 1 };

    my @err;

    return 'Cpanel::JSON::XS' if eval { require Cpanel::JSON::XS; 1; }

panel::JSON::XS: $@";

    return 'JSON::XS' if eval { require JSON::XS; JSON::XS->VERSION(3.0); 1; };
    push @err, "Error loading JSON::XS: $@";

    return 'JSON::PP' if eval { require JSON::PP; 1

odule::JSON::XS;
use Kelp::Base 'Kelp::Module::Encoder';
use JSON::XS;

our $VERSION = '0.503';

sub encoder_name { 'json' }

sub build_encoder {
    my ($self, $args) = @_;
    my $json = JSON::XS->n

s %{$args}) {
        $json->$key($args->{$key});
    }

    return $json;
}

sub build {
    my ( $self, %args ) = @_;
    $self->SUPER::build(%args);

    $self->register(json => $self->get_encoder)

=head1 NAME

Kelp::Module::JSON::XS - DEPRECATED JSON:XS module for Kelp applications

=head1 DEPRECATED

B<*** This module is now deprecated. ***>

Kelp is now using L<JSON::MaybeXS>, which will auto

package App::Test::DWG::LibreDWG::JSON;

use strict;
use warnings;

use CAD::AutoCAD::Detect qw(detect_dwg_file);
use Capture::Tiny qw(capture);
use File::Copy;
use File::Path qw(mkpath);
use File::Sp

le to JSON.
	my $json_file_first = catfile($tmp_dir, 'first.json');
	my $dwg_to_json_first = "$dwgread $v -o $json_file_first $dwg_file_first";
	if ($self->_exec($dwg_to_json_first, 'dwg_to_json')) {

 JSON to dwg file.
	my $dwg_file_second = catfile($tmp_dir, 'second.dwg');
	my $json_to_dwg_first = "$dwgwrite --as $dwgwrite_version $v -o $dwg_file_second $json_file_first";
	if ($self->_exec($json_

##########
package StorageDisplay::Collect::JSON;

BEGIN {
    # Mark current package as loaded;
    # else, we cannot use 'use StorageDisplay::Collect::JSON;' latter
    my $p = __PACKAGE__;
    $p =

rser` to know if JSON:PP makes all the work alone
#   - `decode_json` to decode a json text with the $json_parser object
# - a public `new` class method that returns
#   - a plain JSON::PP object (if 

t inherit from JSON::PP
# - an overrided `decode` method that
#   - calls SUPER::decode
#   - manually transforms JSON:::PP::Boolean into plain scalar
# $json_parser is
# - either a JSON::PP object (i

package JSON::Path;
$JSON::Path::VERSION = '1.0.6';
use strict;
use warnings;

# VERSION

use Exporter::Shiny qw/ jpath jpath1 jpath_map /;
our $AUTHORITY = 'cpan:POPEFELIX';
our $Safe      = 1;

use 

Carp;
use JSON::MaybeXS qw/decode_json/;
use JSON::Path::Evaluator;
use Scalar::Util qw[blessed];
use LV ();

use overload '""' => \&to_string;

sub jpath {
    my ( $object, $expression ) = @_;
    m

    return $$self;
}

sub paths {
    my ( $self, $object ) = @_;
    my @paths = JSON::Path::Evaluator::evaluate_jsonpath( $object, "$self", want_path => 1);
    return @paths;
}

sub get {
    my ( 

package JSON::Path::Constants;
$JSON::Path::Constants::VERSION = '1.0.6';
use strict;
use warnings;

# ABSTRACT: Constants used in the JSON::Path distribution

# VERSION

use Readonly;

use Exporter::

QUAL_SIGN . $TILDE_SIGN;

1;

__END__

=pod

=encoding UTF-8

=head1 NAME

JSON::Path::Constants - Constants used in the JSON::Path distribution

=head1 VERSION

version 1.0.6

=head1 AUTHOR

Aurelia 

package JSON::Path::Evaluator;
$JSON::Path::Evaluator::VERSION = '1.0.6';
use strict;
use warnings;

# ABSTRACT: A module that recursively evaluates JSONPath expressions with native support for Javasc

ript-style filters

use Carp;
use Carp::Assert qw(assert);
use JSON::MaybeXS;
use JSON::Path::Constants qw(:operators :symbols);
use JSON::Path::Tokenizer qw(tokenize);
use List::Util qw/pairs uniq/;

ssed refaddr/;
use Storable qw/dclone/;
use Try::Tiny;

# VERSION
use Exporter::Shiny qw/evaluate_jsonpath/;
our $AUTHORITY = 'cpan:POPEFELIX';

Readonly my $OPERATOR_IS_TRUE         => 'IS_TRUE';
Rea

package JSON::Path::Tokenizer;
$JSON::Path::Tokenizer::VERSION = '1.0.6';
use strict;
use warnings;

use Carp;
use Readonly;
use JSON::Path::Constants qw(:symbols :operators);
use Exporter::Shiny 'tok

  $TOKEN_QUOTE               => 1,    # "
);

# my $invocation = 0;

# ABSTRACT: Helper class for JSON::Path::Evaluator. Do not call directly.

# Take an expression and break it up into tokens
sub tok

ized/;
    return $token;
}

1;

__END__

=pod

=encoding UTF-8

=head1 NAME

JSON::Path::Tokenizer - Helper class for JSON::Path::Evaluator. Do not call directly.

=head1 VERSION

version 1.0.6

=hea

t;
use warnings FATAL => 'all';

package MarpaX::ESLIF::JSON::Decoder::RecognizerInterface;
use Carp qw/croak/;

# ABSTRACT: MarpaX::ESLIF::JSON Recognizer Interface

our $VERSION = '6.0.35.1'; # VERS

 NAME

MarpaX::ESLIF::JSON::Decoder::RecognizerInterface - MarpaX::ESLIF::JSON Recognizer Interface

=head1 VERSION

version 6.0.35.1

=head1 SYNOPSIS

    use MarpaX::ESLIF::JSON::Decoder::Recognizer

Interface;

    my $recognizerInterface = MarpaX::ESLIF::JSON::Decoder::RecognizerInterface->new();

=head1 DESCRIPTION

MarpaX::ESLIF::JSON's Decoder Recognizer Interface

=head1 SUBROUTINES/METHODS

package JSON::Schema::AsType::Draft3;
our $AUTHORITY = 'cpan:YANICK';
# ABSTRACT: Role processing draft3 JSON Schema 
$JSON::Schema::AsType::Draft3::VERSION = '0.4.4';

use strict;
use warnings;

use 

ils qw/ any all none uniq zip /;

use JSON::Schema::AsType;

use JSON;

use JSON::Schema::AsType::Draft3::Types '-all';
use Types::Standard 'Optional';

with 'JSON::Schema::AsType::Draft4' => {
    -e

dencies
    ];

}

JSON::Schema::AsType->new(
    draft_version => '3',
    uri           => "http${_}://json-schema.org/draft-03/schema",
    schema        => from_json <<'END_JSON' )->type for '', '

=> 'all';

package MarpaX::ESLIF::JSON::Encoder;
use parent qw/MarpaX::ESLIF::Grammar/;

#
# Base required class methods
#
sub _ALLOCATE { return \&MarpaX::ESLIF::JSON::Encoder::allocate }
sub _EQ {
 

T: ESLIF's JSON encoder interface

our $AUTHORITY = 'cpan:JDDPAUSE'; # AUTHORITY

our $VERSION = '6.0.35.1'; # VERSION



1;

__END__

=pod

=encoding UTF-8

=head1 NAME

MarpaX::ESLIF::JSON::Encoder 

PTION

This is JSON's strict and relax encoder writen directly in L<MarpaX::ESLIF> library.

There are two JSON modes:

=over

=item Strict

Encoder is strict, as per L<ECMA-404 The JSON Data Intercha

package JSON::Schema::AsType::Draft3::Types;
our $AUTHORITY = 'cpan:YANICK';
# ABSTRACT: JSON-schema v3 keywords as types
$JSON::Schema::AsType::Draft3::Types::VERSION = '0.4.4';

use strict;
use warn

y zip none /;
use List::Util qw/ pairs pairmap reduce uniq /;

use JSON qw/ to_json from_json /;

use JSON::Schema::AsType;

use JSON::Schema::AsType::Draft4::Types 'Not', 'Integer', 'MultipleOf',
   

ia { 
        my $schema = JSON::Schema::AsType->new( draft_version => 3, schema => $_ );

        if ( $schema->validate_schema ) {
            die "not a valid draft3 json schema\n";
        }

    

e warnings FATAL => 'all';

package MarpaX::ESLIF::JSON;
use MarpaX::ESLIF::JSON::Encoder;
use MarpaX::ESLIF::JSON::Decoder;

# ABSTRACT: ESLIF's JSON interface

our $AUTHORITY = 'cpan:JDDPAUSE'; # AU

w {
    my $class = shift;

    return bless { encoder => MarpaX::ESLIF::JSON::Encoder->new(@_), decoder => MarpaX::ESLIF::JSON::Decoder->new(@_) }, $class
}


sub encode {
    my ($self, $value) = @_

::JSON - ESLIF's JSON interface

=head1 VERSION

version 6.0.35.1

=head1 DESCRIPTION

This is JSON's strict and relax encoder/decoder writen directly in L<MarpaX::ESLIF> library.

There are two JSON 

package JSON::Schema::AsType::Draft6::Types;
our $AUTHORITY = 'cpan:YANICK';
# ABSTRACT: JSON-schema v6 keywords as types
$JSON::Schema::AsType::Draft6::Types::VERSION = '0.4.4';

use strict;
use warn

reUtils qw/ all any zip none /;
use List::Util qw/ pairs pairmap reduce uniq /;

use JSON::Schema::AsType;

use JSON::Schema::AsType::Draft4::Types qw/
    Integer Boolean Number String Null Object Ar

ia { 
        my $schema = JSON::Schema::AsType->new( draft_version => 6, schema => $_ );

        if ( $schema->validate_schema ) {
            die "not a valid draft6 json schema\n";
        }