CPAN::Groonga

package Mojo::JSON::Pointer;
use Mojo::Base -base;

has 'data';

sub contains { shift->_pointer(0, @_) }
sub get      { shift->_pointer(1, @_) }

sub new { @_ > 1 ? shift->SUPER::new(data => shift) : 

a : 1;
}

1;

=encoding utf8

=head1 NAME

Mojo::JSON::Pointer - JSON Pointers

=head1 SYNOPSIS

  use Mojo::JSON::Pointer;

  my $pointer = Mojo::JSON::Pointer->new({foo => [23, 'bar']});
  say $poin

s('/foo');

=head1 DESCRIPTION

L<Mojo::JSON::Pointer> is an implementation of L<RFC 6901|https://tools.ietf.org/html/rfc6901>.

=head1 ATTRIBUTES

L<Mojo::JSON::Pointer> implements the following attr

use Object::Pad;
use utf8;

package JSON::Relaxed::Parser;

our $VERSION = "0.098";

class JSON::Relaxed::Parser;

# Instance data.
field $data    :mutator;	# RJSON string being parser
field @pretoks;

tandard.
# Strict true -> RJSON conformant.
# Strict false (default) -> RRJSON. Everything goes :).
field $strict		   :mutator :param = 0;

# Allow extra stuff after the JSON structure.
# Strict mode 

 input

    if ( $booleans ) {
	if ( ref($booleans) ne 'ARRAY' ) {
	    $booleans = [ $JSON::Boolean::false, $JSON::Boolean::true ];
	}
    }
    else {
	$booleans = [ 0, 1 ];
    }

    my $glue = 0;

ckage Kelp::Module::JSON;

use Kelp::Base 'Kelp::Module::Encoder';

use JSON::MaybeXS;

sub encoder_name { 'json' }

sub build_encoder
{
    my ($self, $args) = @_;
    return JSON::MaybeXS->new(%$arg

;
    $self->SUPER::build(%args);

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

1;

__END__

=head1 NAME

Kelp::Module::JSON - Simple JSON module for a Kelp application

=head1 SYNOPSIS

    pa

 json configured to UTF-8
        $self->res->set_charset('UTF-8');
        $self->res->render_binary(
            $self->json->encode({ yes => 1 })
        );
    }

=head1 DESCRIPTION

Standard JSON

package JSON::Lines;
use 5.006; use strict; use warnings; our $VERSION = '1.09';
use Cpanel::JSON::XS; use base 'Import::Export';

our ($JSON, $LINES, %EX);
BEGIN {
	$JSON = Cpanel::JSON::XS->new;
	$L

ES = qr{ ([\[\{] (?: (?> [^\[\]\{\}]+ ) | (??{ $LINES }) )* [\]\}]) }x;
	%EX = (
		jsonl => [qw/all/]
	);
}

sub jsonl {
	my %args = (scalar @_ == 1 ? %{$_[0]} : @_);
	my $self = __PACKAGE__->new(%arg

scalar @_ == 1 ? %{$_[0]} : @_);
	my $self = bless { headers => [] }, $pkg;
	exists $args{$_} && $JSON->$_($args{$_}) for qw/pretty canonical utf8/;
	$self->{$_} = $args{$_} for qw/parse_headers error

::JSON.pm
## Author: Bryan Jurish <moocow@cpan.org>
## Description: collocation db, source document, JSON

package DiaColloDB::Document::JSON;
use DiaColloDB::Document;
use DiaColloDB::Utils qw(:json)

$ext = $doc->extension()
##  + default extension, for Corpus::Compiled
sub extension {
  return '.json';
}

##--------------------------------------------------------------
## API: I/O: parse

## $boo

  $doc->{label} = ref($file) ? "$file" : $file;
  my $data = loadJsonFile($file);
  $doc->logconfess("fromFile(): failed to load JSON object from '$file'")
    if (!UNIVERSAL::isa($data,'HASH'));
  @

NAME

MooX::JSON_LD - Extend Moo to provide JSON-LD mark-up for your objects.

=head1 SYNOPSIS

    # Your Moo (or Moose) Class
    package My::Moo::Class;

    use Moo;

    use MooX::JSON_LD 'Person

',
      # various other properties...
      json_ld => 1,
    );

    has last_name  => (
      is => 'ro',
      # various other properties...
      json_ld => 1,
    );

    has birth_date => (
   

   is => 'ro',
      # various other properties...
      json_ld => 'birthDate',
      json_ld_serializer => sub { shift->birth_date },
    );

    # Then, in a program somewhere...
    use My::Moo::C

MooX::Role::JSON_LD - Easily provide JSON-LD mark-up for your objects.

=head1 SYNOPSIS

    # Your Moo (or Moose) Class
    package My::Moo::Class;

    use Moo;
    with 'MooX::Role::JSON_LD';

    

      # Various other properties
    );

    # Add two required methods
    sub json_ld_type { 'Person' };

    sub json_ld_fields { [ qw[ first_name last_name birth_date ] ] };

    # Then, in a prog

int a text representation of the JSON-LD
    print $obj->json_ld;

    # print the raw data structure for the JSON-LD
    use Data::Dumper;
    print Dumper $obj->json_ld_data;

=head1 DESCRIPTION

Th

package Test2::Harness::Util::JSON;
use strict;
use warnings;

use Carp qw/confess longmess croak/;
use Cpanel::JSON::XS();
use Importer Importer => 'import';
use File::Temp qw/ tempfile /;

our $VERS

ode_json
    encode_json
    encode_pretty_json
    stream_json_l
    stream_json_l_url
    stream_json_l_file

    json_true
    json_false

    encode_json_file
    decode_json_file
};

my $json   =

 Cpanel::JSON::XS->new->utf8(1)->convert_blessed(1)->allow_nonref(1);
my $ascii  = Cpanel::JSON::XS->new->ascii(1)->convert_blessed(1)->allow_nonref(1);
my $pretty = Cpanel::JSON::XS->new->ascii(1)->p

ness::Util::File::JSON;
use strict;
use warnings;

our $VERSION = '2.000004';

use Carp qw/croak confess/;
use Test2::Harness::Util::JSON qw/encode_json decode_json encode_pretty_json/;

use parent 'T

y/;

sub decode { shift; decode_json(@_) }
sub encode { shift->pretty ? encode_pretty_json(@_) : encode_json(@_) }

sub reset { croak "line reading is disabled for json files" }
sub read_line  { croak

t2::Harness::Util::File::JSON - Utility class for a JSON file.

=head1 DESCRIPTION

Subclass of L<Test2::Harness::Util::File> which automatically handles
encoding/decoding JSON data.

=head1 SYNOPSIS

:JSON;
use strict;
use warnings;

use Carp qw/croak/;

our $VERSION = '1.000161';

BEGIN {
    local $@ = undef;
    my $ok = eval {
        require JSON::MaybeXS;
        JSON::MaybeXS->import('JSON'

   1;

        if (JSON() eq 'JSON::PP') {
            *JSON_IS_PP = sub() { 1 };
            *JSON_IS_XS = sub() { 0 };
            *JSON_IS_CPANEL = sub() { 0 };
            *JSON_IS_CPANEL_OR_XS = 

  }
        elsif (JSON() eq 'JSON::XS') {
            *JSON_IS_PP = sub() { 0 };
            *JSON_IS_XS = sub() { 1 };
            *JSON_IS_CPANEL = sub() { 0 };
            *JSON_IS_CPANEL_OR_XS = 

ness::Util::File::JSON;
use strict;
use warnings;

our $VERSION = '1.000161';

use Carp qw/croak confess/;
use Test2::Harness::Util::JSON qw/encode_json decode_json encode_pretty_json/;

use parent 'T

y/;

sub decode { shift; decode_json(@_) }
sub encode { shift->pretty ? encode_pretty_json(@_) : encode_json(@_) }

sub reset { croak "line reading is disabled for json files" }
sub read_line  { croak

t2::Harness::Util::File::JSON - Utility class for a JSON file.

=head1 DESCRIPTION

Subclass of L<Test2::Harness::Util::File> which automatically handles
encoding/decoding JSON data.

=head1 SYNOPSIS

package Web::ComposableRequest::Role::JSON;

use Encode                            qw( decode );
use JSON::MaybeXS                     qw( );
use Web::ComposableRequest::Constants qw( FALSE TRUE );
us

nfig _decode_body );

add_config_role __PACKAGE__.'::Config';

has '_json' => is => 'lazy', isa => Object,
   builder  => sub { JSON::MaybeXS->new( allow_nonref => TRUE, utf8 => FALSE )};

around '_de

body, $content)
      unless $self->content_type eq 'application/json';

   $body->{$self->_config->json_body_attribute} = $self->_json->decode(
      decode($self->_config->encoding, $content)
   );

14;
use warnings;

package Test::BDD::Cucumber::Harness::JSON 0.87;

=head1 NAME

Test::BDD::Cucumber::Harness::JSON - Generate results to JSON file

=head1 VERSION

version 0.87

=head1 DESCRIPTION

A L<Test::BDD::Cucumber::Harness> subclass that generates JSON output file.

So that it is possible use tools like
L<"Publish pretty cucumber reports"|https://github.com/masterthought/cucumber-reporti

ng>.

=cut

use Moo;
use Types::Standard qw( Num HashRef ArrayRef FileHandle );
use JSON::MaybeXS;
use Time::HiRes qw ( time );

extends 'Test::BDD::Cucumber::Harness::Data';

=head1 CONFIGURABLE ATTR

use warnings;
package Test::JSON::Schema; # git description: db019d2
# vim: set ts=8 sts=2 sw=2 tw=100 et :
# ABSTRACT: Test your data against a JSON Schema
# KEYWORDS: JSON Schema test structured dat

sub json_schema ($schema) {
  die 'not yet implemented';
}

sub load_json_schema ($schema_or_filename) {
  die 'not yet implemented';
}

1;

__END__

=pod

=encoding UTF-8

=head1 NAME

Test::JSON::Sc

hema - Test your data against a JSON Schema

=head1 VERSION

version 0.001

=head1 SYNOPSIS

  use Test2::V0l
  use Test::JSON::Schema;

  # something in your application that generates a data structu

Solr::JSON;{
our $VERSION = '1.11';
}

use base 'Apache::Solr';

use warnings;
use strict;

use Log::Report          qw(solr);

use Apache::Solr::Result ();
use HTTP::Request        ();
use JSON      

;
	$args->{format}   ||= 'JSON';
	$self->SUPER::init($args);

	$self->{ASJ_json} = $args->{json} || JSON->new->utf8;
	$self;
}

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

sub json() {shift->{ASJ_json}}

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

point, core => $self);
	$self->request($endpoint, $result);

	if(my $dec = $result->decoded)
	{	# JSON uses different names!
		my $r = $dec->{result} = delete $dec->{response};
		$r->{doc} = delete $r

# Connector::Proxy::JSON
#
# Proxy class for reading a JSON file

package Connector::Proxy::JSON;

use strict;
use warnings;
use English;
use JSON;
use Data::Dumper;

use Moose;

extends 'Connector::B

      eval {
            $config = decode_json($content);
        };
        if ($@ || !$config || !ref $config) {
            $self->log()->error('Proxy::JSON error parsing content from file '.$file)

e );
        }
        $self->log()->debug('Proxy::JSON loading configuration from file '.$file);
    } else {
        $self->log()->warn('Proxy::JSON configuration file '.$file.' not found ');
    }

STRACT: A JSON encoder for the OTLP exporter

package OpenTelemetry::Exporter::OTLP::Encoder::JSON;

our $VERSION = '0.021';

class OpenTelemetry::Exporter::OTLP::Encoder::JSON {
    use JSON::MaybeXS

lemetry::SDK::Logs::LogRecord';

    method content_type () { 'application/json' }

    method serialise ($data) { encode_json $data }

    method encode_arraylist ($v) {
        [ map $self->encode_a

ata::Record::Serialize::Encode::json;

# ABSTRACT: encoded a record as JSON

use v5.12;
use strict;
use warnings;

use Data::Record::Serialize::Error { errors => ['json_backend'] }, -all;

use Moo::Ro

= '2.02';


BEGIN {
    my $Cpanel_JSON_XS_VERSION = 3.0236;

    # Module::Version doesn't load the code, so avoids loading
    # Cpanel::JSON::XS's version of JSON::PP::Boolean which prevents
    # 

loading the version provided by JSON::PP if Cpanel::JSON::XS is
    # too old. Symbol::delete_package could be used to remove
    # Cpanel::JSON::XS's version, but it's better not to load it in
    # 

tha::Role::JSON;
our $AUTHORITY = 'cpan:GETTY';
# ABSTRACT: Role for JSON
$Langertha::Role::JSON::VERSION = '0.008';
use Moose::Role;
use JSON::MaybeXS;

sub json { shift->_json }
has _json => (
  is 

_build => 1,
);
sub _build__json { JSON::MaybeXS->new( utf8 => 1, canonical => 1 ) }

1;

__END__

=pod

=encoding UTF-8

=head1 NAME

Langertha::Role::JSON - Role for JSON

=head1 VERSION

version 0.

package JSON::Schema::Generate;
use 5.006; use strict; use warnings; our $VERSION = '0.15';
use Tie::IxHash; use Types::Standard qw/Str HashRef Bool/;
use Compiled::Params::OO qw/cpo/; use JSON; use B

lessed::Merge;

our ($validate, $JSON);
BEGIN {
	$validate = cpo(
		new => {
			id => {
				type => Str,
				default => sub {
					'http://example.com/root.json'
				}
			},
			title => {
				type => 

oot schema is the schema that comprises the entire JSON document.'
				}
			},
			schema => {
				type => Str,
				default => sub {
					'http://json-schema.org/draft-07/schema#'
				}
			},
			spec =