CPAN::Groonga

=item App::cpanoutdated

=item Dist::Milla

=back

=head2 DATA SERIALISER

=over

=item JSON::MaybeXS

=item JSON

=item XML::Twig

=item XML::LibXML

=item XML::Toolkit

=item YAML

=item YAML::Tiny

>agent(
            join "/", __PACKAGE__, $OAuth::Lite2::VERSION);
    }

    $self->{format} = 'json';
    $self->{response_parser} = OIDC::Lite::Client::TokenResponseParser->new;
    $self->{state_

package Test::JsonAPI::Autodoc::Response;
use strict;
use warnings;
use utf8;
use JSON;

sub new {
    my ($class) = @_;

    bless {
    }, $class;
}

sub parse {
    my ($self, $res) = @_;

    my $

my $content_type = $res->content_type;
    if ($content_type =~ m!^application/json!) {
        $body = to_json(from_json($res->decoded_content, { utf8 => 1 }), { pretty => 1, canonical => 1 });
    }

r;

use strict;
use warnings;

our $VERSION = '0.03';

use LWP::UserAgent;
use HTTP::Request;
use JSON;
use Want;
use URI;

use WWW::RabbitMQ::Broker::Shovel;

sub new
{
	my $class  = shift;
	my $self

lication/json; charset=UTF-8');
	$req->authorization_basic($self->{username}, $self->{password});

	my $parser = JSON->new->utf8(1);
	my $json   = $parser->encode($args);
	$req->content($json);

	my $

package Test::JsonAPI::Autodoc;
use 5.008005;
use strict;
use warnings;
use parent qw/Exporter/;
use Carp;
use Test::More ();
use Scope::Guard;
use LWP::UserAgent;
use Test::JsonAPI::Autodoc::Markdown

;
use Test::JsonAPI::Autodoc::Request;
use Test::JsonAPI::Autodoc::Response;

our @EXPORT = qw/
    describe
    http_ok
    plack_ok
    set_documents_path
    set_template
/;

our $VERSION = "0.22";

test($description => $coderef);

    if ($result && $results && $ENV{TEST_JSONAPI_AUTODOC}) {
        my $markdown = Test::JsonAPI::Autodoc::Markdown->new($output_path, $template);
        $markdown->

age metadata:

=over 8

=item * content_type => $ct

This should be a MIME type like "application/json" or "text/plain". This is
exactly like an HTTP Content-Type header.

Note that RabbitMQ doesn't r

EMPLATE_EXTENSION => '.xsl',
    },
    'View::JSON' => {
        allow_callback  => 1,
        callback_param  => 'cb',
        expose_stash    => 'json',
    },
    'Plugin::Session' => { expires =>

e_dir, 'www') ];
}

sub json_reply {
    my ( $c, $json_data ) = @_;

    $c->res->header('X-Ajax-Controller',1);
    $c->stash->{json} = $json_data;
    $c->detach('View::JSON');
}

sub member {
    

username = meon::Web::Util->username_cleanup($username, $c->default_auth_store->folder);

    $c->json_reply({
        username => $username,
    });
}

sub email : Chained('base') PathPart('email') {

ail(
        members_folder => $members_folder,
        email          => $email,
    );

    $c->json_reply({
        registered => ($member ? 1 : 0),
    });
}


__PACKAGE__->meta->make_immutable;

Imager;
use URI::Escape 'uri_escape';
use List::MoreUtils 'none';
use WWW::Mechanize;
use JSON::XS 'decode_json';
use Data::asXML 0.07;

use meon::Web::Form::Login;
use meon::Web::Form::Delete;
use me

                 if ($res->header('Content-Type') =~ m{application/json}) {
                            my $data = eval { decode_json($res->content) };
                            if ($data && $data->

e Test::JsonAPI::Autodoc::Markdown;
use strict;
use warnings;
use utf8;
use Data::Section::Simple;
use Time::Piece;
use Text::Xslate qw(mark_raw);
use Text::Xslate::Bridge::Star;
use Test::JsonAPI::Au

nerate {
    my ($self, $description, $results, $first_time) = @_;

    my $document_path = Test::JsonAPI::Autodoc::Path->document_path($self->{output_path});

    my $vpath = Data::Section::Simple->n

                                : $tx->render('document.json.tx', $vars);
    print $fh $rendered;
    close $fh;
}
1;

__DATA__
@@ document.json.tx
: if $generated_at {
generated at: <: $generated_at

s;
use base 'Class::Accessor::Fast';

use MIME::Base64 qw/encode_base64url decode_base64url/;
use JSON::WebToken qw/encode_jwt decode_jwt/;
use Params::Validate;
use Digest::SHA qw/sha256 sha384 sha51

package Test::JsonAPI::Autodoc::Request;
use strict;
use warnings;
use utf8;
use Carp;
use JSON;
use URL::Encode qw/url_params_flat/;

sub new {
    my ($class) = @_;

    bless {
    }, $class;
}

su

ontent_type;

    my $is_json = 0;
    if ($content_type =~ m!^application/json!) {
        $body = to_json(from_json($req->decoded_content), { pretty => 1 });
        $is_json = 1;
    }

    my $tar

method       => $req->method,
        parameters   => $self->_parse_request_parameters($body, $is_json, $param_description),
        path         => $req->uri->path,
        query        => $req->uri-

se strict;

our $VERSION = '0.05';

use Moose;
use CPAN::Patches::SPc;
use Carp;
use IO::Any;
use JSON::Util;
use YAML::Syck;
use File::chdir;
use Scalar::Util 'blessed';
use Module::Pluggable require

pec->catfile($path, 'META.yml');
    my $json = File::Spec->catfile($path, 'META.json');
    if (-f $json) {
        my $meta = eval { JSON::Util->decode([$json]) };
        return $meta
            i

ile($yml) };
        return $meta
            if $meta;
    }
    croak 'failed to read META.(yml|json)';
}

sub read_meta_intrusive {
    my $self = shift;
    my $path = shift || '.';

    my $build

package WWW::Marvel::Client;
use strict;
use warnings;
use Carp;
use Digest::MD5;
use JSON;
use LWP::UserAgent;
use URI;

sub new {
	my ($class, $args) = @_;
	my $self = bless {}, $class;
	for my $k (

i({ path => 'characters', params => \%p });
	my $http_res = $self->get($uri);
	return $self->_get_json_content($http_res);
}

sub get {
	my ($self, $uri) = @_;
	my $attempts_limit = 3;
	my $http_res;

gest;
}

sub _get_json_content {
	my ($self, $http_res) = @_;
	my $content = $self->json->decode( $http_res->decoded_content );
	return $content;
}

sub json { $_[0]->{_json} //= JSON->new()->allow_no

package HAL::Tiny;
use 5.008001;
use strict;
use warnings;

use JSON qw/encode_json/;

our $VERSION = "0.03";

sub new {
    my ($class, %args) = @_;

    my ($state, $links, $embedded)
        = @arg

d} = $v;
    }

    return %hash;
}

sub as_hashref {
    +{ $_[0]->as_hash };
}

sub as_json {
    encode_json($_[0]->as_hashref);
}


1;
__END__

=encoding utf-8

=head1 NAME

HAL::Tiny - Hypertext 

,
            find => {
                href      => '/orders{?id}',
                templated => JSON::true,
            },
        },
        embedded => +{
            orders => [
                H

en> simpler INI files).
For XML, JSON, and YAML, there are many modules available,
some examples are:
L<YAML::XS|YAML::XS>,
L<XML::Simple|XML::Simple>,
and L<JSON|JSON>.

=back

=head1 Author, Copyrig

use Data::Dumper;
use Mojo::UserAgent;
use Time::HiRes 'gettimeofday';
use POSIX 'strftime';
use JSON::XS;
use MIME::Base64;
use XML::Simple;

use feature 'say';

=head1 VERSION

Version 0.02

=cut
 

pping::MRW;

    my $MRW = Business::Shipping::MRW->new();

    my $Info = $E->TransmEnvio('envio.json');

    my $PDF = $E->EtiquetaEnvio($Info->{NumeroEnvio});


=head1 EXPORT

A list of functions t

=cut
sub new {
    my $class = shift;
    my $file  = shift;
    my $self;

    my $config = OpenJSON($file);
    
    map { $self->{mrw}->{$_} = $config->{$_} } keys %{ $config };

    $self->{error

on 0.2.0

=head1 SYNOPSIS

    use strict;
    use warnings;

    use Test::More;

    use JSON qw/ from_json /;

    use Test::TCP;
    use WWW::Mechanize::PhantomJS;
    use Dancer::Plugin::Test::Ja

;

            $mech->get("http://localhost:$port?test=hello");

            jasmine_results from_json
                $mech->eval_in_page('jasmine.getJSReportAsString()'; 
        },
        server =

 as you might expect if normally C<use>d.

=item B<include>

  [ReportVersions::Tiny]
  include = JSON:PP 2.27103
  include = Path::Class
  include = Some::Thing = 1.1

Include extra modules in versio

META files:

=over 4

=item L<Test-CPAN-Meta|Test::CPAN::Meta>

=item L<Test-CPAN-Meta-JSON|Test::CPAN::Meta::JSON>

=item L<Test-CPAN-Meta-YAML|Test::CPAN::Meta::YAML>

=back

All three have slightly

eta-JSON|Test::CPAN::Meta::JSON> is the most recent addition to the family, and is specifically
aimed at those distributions that use a F<META.json> Meta file. The distribution
requires the L<JSON> mo

E ALSO

=over 4

=item L<Test::YAML::Valid>

=item L<Test::CPAN::Meta>

=item L<Test::CPAN::Meta::JSON>

=item L<Test::CPAN::Meta::YAML>

=back

=head1 AUTHOR

Barbie, <barbie@cpan.org>
for Miss Barbe