CPAN::Groonga

package WWW::JSON::Role::Authentication::OAuth1;
use Moo::Role;
use Net::OAuth;
use URI;
$Net::OAuth::PROTOCOL_VERSION = Net::OAuth::PROTOCOL_VERSION_1_0A;
requires 'authentication';
requires 'ua';

s

_OAuth1 {
    my ( $self, $auth, $req) = @_;
    my $q = URI->new;
    # FIXME if we're sending a JSON payload we need to decode instead of this
    $q->query($req->content);
    my $request = Net::OA

package WWW::JSON::Role::Authentication::Basic;
use Moo::Role;
use MIME::Base64;
requires 'authentication';
requires 'ua';


sub _validate_Basic {
    my ( $self, $auth ) = @_;
    for (qw/username pa

package WWW::JSON::Response;
use strict;
use warnings;
use Moo;
use JSON::XS;
use Try::Tiny;

has http_response => (
    is       => 'ro',
    required => 1,

    handles => {
        status_line => '

rl         => 'base',
        content     => 'decoded_content',
    },
);
has json => ( is => 'lazy', default => sub { JSON::XS->new } );
has response            => ( is => 'lazy', builder => '_build_

   return unless ($self->http_response->decoded_content);

    my $decoded = try {
        $self->json->decode( $self->http_response->decoded_content );
    }
    catch {
        $self->_set_error("$_

package WWW::JSON::Role::Authentication::Header;
use Moo::Role;
requires 'authentication';
requires 'ua';

sub _validate_Header {
    my ( $self, $auth ) = @_;
    die "Required header string missing 

package JSON::TinyValidatorV4;
$JSON::TinyValidatorV4::VERSION = '0.003';
use File::ShareDir 'dist_file';
use JavaScript::V8;
use Moo;

use strict;
use warnings;

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

=head1

 NAME

JSON::TinyValidatorV4 - JSON Validator for v4 JSON Schema

=head1 SYNOPSIS

 use JSON::TinyValidatorV4;
 use Data::Dumper;

 my $schema = {
     type       => 'object',
     properties => {
   

 my $data = { longitude => -128.323746, latitude => -24.375870, elevation=> 23.1 };

 my $tv4 = JSON::TinyValidatorV4->new;

 print $tv4->validate( $data, $schema ), "\n";        # prints "1"
 print

ge Jifty::Filter::JSON;
use base qw/ Jifty::DBI::Filter /;
use Jifty::JSON qw(encode_json decode_json);

=head1 NAME

Jifty::Filter::JSON - This filter stores arbitrary Perl via JSON

=head1 SYNOPSIS

hema {
      column my_data =>
          type is 'text',
          filters are qw/ Jifty::Filter::JSON /;
  };

  my $thing = __PACKAGE__->new;
  $thing->create( my_data => { foo => 'bar', baz => [ 1,

rary data structures into a database column using L<JSON>. This is very similar to the L<Jifty::DBI::Filter::Storable> filter except that the L<JSON> format remains human-readable in the database. You

kage Jifty::JSON;

use base 'Exporter';
our @EXPORT_OK = qw/jsonToObj objToJson decode_json encode_json/;

use Carp qw//;
use JSON qw/ -support_by_pp -no_export /;

=head1 NAME

Jifty::JSON -- Wrapper

y::JSON qw/decode_json encode_json/;

  my $obj  = decode_json(q! { "x": "1", "y": "2", "z": "3" } !);
  my $json = encode_json($obj);

=head1 DESCRIPTION

Provides a thin wrapper around the L<JSON> 2

<JSON::XS> and L<JSON::PP>.

This module used to wrap L<JSON::Syck> and L<JSON> 1.xx with special-casing for
outputting JSON with single quoted values.  Single quotes make it easy to
simply plop JSON 

age App::PAIA::JSON;
use strict;
use v5.10;

our $VERSION = '0.30';

use parent 'Exporter';
our @EXPORT = qw(decode_json encode_json);
use JSON::PP qw();

sub decode_json {
    my $json = shift;
    m

y $data = eval { JSON::PP->new->utf8->relaxed->decode($json); };
    if ($@) {
        my $msg = reverse $@;
        $msg =~ s/.+? ta //sm;
        $msg = "JSON error: " . scalar reverse($msg);
      

  return $data;
}

sub encode_json {
    JSON::PP->new->utf8->pretty->encode($_[0]); 
}

1;
__END__

=head1 NAME

App::PAIA::JSON - utility functions to encode/decode JSON

=head1 DESCRIPTION

This mo

::JSON;
$Glib::JSON::VERSION = '0.002';
use strict;
use warnings;
use Carp qw/croak/;
use Exporter;
use Glib;
use Glib::IO;
use Glib::Object::Introspection 0.016;

our @ISA = qw(Exporter);

my $_JSON_

_BASENAME = 'Json';
my $_JSON_GLIB_VERSION = '1.0';
my $_JSON_GLIB_PACKAGE = 'Glib::JSON';

sub import {
  my $class = shift;

  Glib::Object::Introspection->setup (
    basename => $_JSON_GLIB_BASENA

 $_JSON_GLIB_VERSION,
    package => $_JSON_GLIB_PACKAGE,
  );
}

1;

__END__

=head1 NAME

Glib::JSON - Perl interface to the JSON-GLib library

=head1 SYNOPSIS

  use Glib::JSON;

  # build a JSON s

=head1 NAME

JSON::Builder - to build large JSON with temp files when memory limit, and compress optionaly.

=head1 SYNOPSIS

 use JSON::Builder;
 
 my $json = JSON::XS->new()->utf8(1)->ascii(1);
 my 

empfile();
 unlink $filename;
 
 my $builder = JSON::Builder->new(json => $json, fh => $fh);
 or
 my $builder = JSON::Builder::Compress->new(json => $json, fh => $fh); # Compress, Base64
  
 my $fv = 

ek(0,0);
 print <$fh>;

=head1 MOTIVATION

Task: to create JSON while having the memory limitations.

If you have only one large value in JSON, or, large values are created one by one, you can use the

r::JSON;
use strict;
use warnings;
no warnings 'uninitialized';

our $VERSION = '0.8.04';

use parent 'Data::Transit::Reader';

use JSON;

sub _decode {
	my ($self, $data) = @_;
	return decode_json($d

r::JSON;
use strict;
use warnings;
no warnings 'uninitialized';

our $VERSION = '0.8.04';

use parent 'Data::Transit::Writer';

use JSON;

sub _encode {
	my ($self, $data) = @_;
	return encode_json($d

package JSON::XS::Sugar;
use base qw(Exporter);

# ABSTRACT: sugar for using JSON::XS

# right now the XS won't work on anything before this
use 5.014000;

use warnings;
use strict;

use Devel::CallCh

@EXPORT_OK;

use constant JSON_TRUE => Types::Serialiser::true;
push @EXPORT_OK, qw(JSON_TRUE);

use constant JSON_FALSE => Types::Serialiser::false;
push @EXPORT_OK, qw(JSON_FALSE);

## no critic (Su

types)

sub json_truth($) {
    return $_[0] ? JSON_TRUE : JSON_FALSE;
}
push @EXPORT_OK, qw(json_truth);

push @EXPORT_OK, qw(
    json_number
    json_string
);

# load json_number, json_string from

package JSON::WebToken::Crypt::RSA;

use strict;
use warnings;
use parent 'JSON::WebToken::Crypt';

use Crypt::OpenSSL::RSA ();

our $ALGORITHM2SIGNING_METHOD_MAP = {
    RS256  => 'use_sha256_hash',

package JSON::WebToken::Crypt::HMAC;

use strict;
use warnings;
use parent 'JSON::WebToken::Crypt';

use Digest::SHA ();

our $ALGORITHM2SIGNING_METHOD_MAP = {
    HS256 => \&Digest::SHA::hmac_sha256,

package JSON::WebToken::Exception;

use strict;
use warnings;
use overload (
    q|""| => \&to_string,
);

use Carp qw/croak/;

sub throw {
    my ($class, %args) = @_;
    my $self = bless \%args, $c

package JSON::WebToken::Crypt;

use strict;
use warnings;

sub sign {
    my ($class, $algorithm, $message, $key) = @_;
    die 'sign method must be implements!';
}

sub verify {
    my ($class, $algo

package JSON::WebToken;

use strict;
use warnings;
use 5.008_001;

our $VERSION = '0.10';

use parent 'Exporter';

use Carp qw(croak carp);
use JSON qw(encode_json decode_json);
use MIME::Base64 qw(en

code_base64 decode_base64);
use Module::Runtime qw(use_module);

use JSON::WebToken::Constants;
use JSON::WebToken::Exception;

our @EXPORT = qw(encode_jwt decode_jwt);

our $ALGORITHM_MAP = {
    # f

nless (ref $claims eq 'HASH') {
        JSON::WebToken::Exception->throw(
            code    => ERROR_JWT_INVALID_PARAMETER,
            message => 'Usage: JSON::WebToken->encode(\%claims [, $secret,

package JSON::WebToken::Constants;

use strict;
use warnings;
use parent qw/Exporter/;

my @error_code = qw/
    ERROR_JWT_INVALID_PARAMETER
    ERROR_JWT_MISSING_SECRET
    ERROR_JWT_INVALID_SEGMENT_

package Dist::Zilla::Plugin::Test::CPAN::Meta::JSON;
use strict;
use warnings;
# ABSTRACT: release tests for your META.json
our $VERSION = '0.004'; # VERSION

use Moose;
extends 'Dist::Zilla::Plugin::

 Bail if we find META.json
    my $METAjson = 'META.json';
    foreach my $file (@{ $self->zilla->files }) {
        return if $file->name eq $METAjson;
    }

    # If META.json wasn't found, then pr

une out the test
    my $test_filename = 'xt/release/meta-json.t';
    foreach my $file (@{ $self->zilla->files }) {
        next unless $file->name eq $test_filename;

        $self->zilla->prune_fil