CPAN::Groonga

deps_relationship = requires

=begin MetaPOD::JSON v1.1.0

{
    "namespace":"Dist::Zilla::Role::BundleDeps",
    "interface":"role"
}


=end MetaPOD::JSON

=head1 LIMITATIONS

=head2 Self References 

problem.

=begin MetaPOD::JSON v1.1.0

{
    "namespace":"Dist::Zilla::Role::Bootstrap",
    "interface":"role",
    "does":"Dist::Zilla::Role::Plugin"
}


=end MetaPOD::JSON

=head1 AUTHOR

Kent Fred

s is a L<< C<Dist::Zilla>|Dist::Zilla >> Plugin that populates the C<provides>
property of C<META.json> and C<META.yml> by absorbing it from your shipped modules,
in a manner similar to how C<PAUSE> i

k

This parameter may be specified multiple times to aggregate a list of finders

=begin MetaPOD::JSON v1.1.0

{
    "namespace":"Dist::Zilla::Plugin::MetaProvides::Package",
    "interface":"class",

herits":"Moose::Object",
    "does":"Dist::Zilla::Role::MetaProvider::Provider"
}


=end MetaPOD::JSON

=head1 OPTIONS INHERITED FROM L<Dist::Zilla::Role::MetaProvider::Provider>

=head2 L<< C<inherit

mpdir>

=begin MetaPOD::JSON v1.1.0

{
    "namespace":"Test::File::ShareDir::Object::Inc",
    "interface":"class",
    "inherits":"Class::Tiny::Object"
}


=end MetaPOD::JSON

=head1 AUTHOR

Kent Fr

use Try::Tiny;
use Carp;
use LWP;
use HTTP::Request::Common;
use Encode qw();
use Data::Dump;
use JSON::PP;


=head1 NAME

Business::Tax::Avalara - An interface to Avalara's REST webservice

=head1 SY

EST-based sales tax webservice.
It takes in a perl hash of data to send to Avalara, generates the JSON, fetches a response,
and converts that back into a perl hash structure.

This module only support

nd 'unique_key' in the get_tax() call.

If debug is set to a true value, it will dump out the raw json messages being sent to
and coming back from Avalara.

Returns a Business::Tax::Avalara object.

=

001
   1000.001001

Etc.

=begin MetaPOD::JSON v1.1.0

{
    "namespace":"Dist::Zilla::Role::Version::Sanitize",
    "interface":"role"
}


=end MetaPOD::JSON

=head1 NORMAL FORMS

=head2 C<normal>

N

_build_use_external_file {
  return;
}

sub _build_external_file_name {
  return 'misc/built_with.json';
}





sub metadata {
  my ($self) = @_;
  return {} unless 'only' eq ( $self->use_external_fil

urn unless $self->use_external_file;

  my $type =
      $self->external_file_name =~ /[.]json\z/msix  ? 'JSON'
    : $self->external_file_name =~ /[.]ya?ml\z/msix ? 'YAML'
    :                      

;

  if ( 'JSON' eq $type ) {
    require JSON::MaybeXS;
    require Dist::Zilla::File::FromCode;
    my $json = JSON::MaybeXS->new;
    $json->pretty(1);
    $json->canonical(1);
    $json->convert_b

lt
  version  = 1.4      ; default

=head1 DESCRIPTION

Generally, if you're creating both C<META.json> and C<META.yml>, then you're doing so purely for compatibility reasons.

In such circumstances, 

on is for such circumstances.

However, if you are I<only> shipping C<META.yml> and B<NOT> C<META.json>, then using this extension
would be harmful and cause loss of information.

Presently, this exte

_prereqs => CPAN::Meta->load_file('Dist-Foo-1.01/META.json')->effective_prereqs,
    old_prereqs => CPAN::Meta->load_file('Dist-Foo-1.00/META.json')->effective_prereqs,
  );

  # Currently slightly co

ance, this L<diff|https://metacpan.org/diff/file?target=ETHER/Moose-2.1210/META.json&source=ETHER/Moose-2.1005/META.json> would display as:

  [ Dependencies::Stats ]
    - configure: +2
    - develop

Bootstrap> >>|Dist::Zilla::Role::Bootstrap >>>

=head1 ATTRIBUTES

=head2 C<dir>

=begin MetaPOD::JSON v1.1.0

{
    "namespace":"Dist::Zilla::Plugin::Bootstrap::ShareDir::Dist",
    "interface":"clas

w_prereqs => CPAN::Meta->load_file('Dist-Foo-1.01/META.json')->effective_prereqs
    old_prereqs => CPAN::Meta->load_file('Dist-Foo-1.00/META.json')->effective_prereqs
  );
  my @changes = $diff->diff

WW::XKCD::AsText::VERSION = '0.006';
use namespace::autoclean;
use Moose;

use Carp;
use URI;
use JSON;
use LWP::UserAgent;

has 'timeout' => (
  is  => 'ro',
  isa => 'Maybe[Int]',
  required => 1,
 

.com/$id/"));
  my $json_uri = URI->new("https://xkcd.com/$id/info.0.json");
  my $response = $self->ua->get($json_uri);

  if ($response->is_success){
    my $decoded = decode_json($response->content

    }
  )->recv;

  # Send job, data created by encoding @args with JSON
  use JSON::XS;
  $client->encoder(\&JSON::XS::encode_json);
  my $job2 = $client->put(
    { priority => 100,
      ttr      

:Fitbit::Response;
$WebService::Fitbit::Response::VERSION = '0.000001';
use Moo;

use JSON::MaybeXS qw( decode_json );
use Types::Standard qw( Bool InstanceOf Maybe HashRef );

has content => (
    is

my $self    = shift;
    my $content = $self->raw->decoded_content;

    return $content ? decode_json($content) : undef;
}

sub _build_success {
    my $self = shift;
    return $self->raw->is_succes

item raw

An L<HTTP::Response> object.

=back

=head1 METHODS

=head2 content

This is the parsed JSON body of the response.  Generally this will be a C<HashRef>.

=head2 raw

Returns the raw L<HTTP::

ode';
has user_info        => 1;
has user_info_url    => 'https://api.fitbit.com/1/user/-/profile.json';

sub moniker { 'fitbit' }

1;

=pod

=encoding UTF-8

=head1 NAME

Mojolicious::Plugin::Web::Au

rmation from the CPAN Index.

The information is provided in a number of different formats: YAML, JSON, XML and HTML.

Information is requested by using a special URL

  http://name.of.website/<prefix

he purposes of this documentation.

=over

=item C<<format>>

The format may be one of C<yaml>, C<json>, C<xml> or C<html>.

=item C<<cmd>>

The command may be one of the following:

=over

=item C<mo

package PubNub::PubSub;

use strict;
use warnings;
use v5.10;

use Carp;
use Mojo::JSON qw/encode_json/;
use Mojo::UserAgent;
use Mojo::Util qw/url_escape/;

use PubNub::PubSub::Message;

our $VERSION

";

    return map {
        my $json = $_->json;
        my $uri  = Mojo::URL->new($self->{web_host} . qq~/publish/$pub_key/$sub_key/0/$channel/0/~ . url_escape($json));
        $uri->query($_->query

  my $json = $tx->res->json;
    my @cb_args = $params{raw_msg} ? ($json) : (@{$json->[0]});

    my $rtn = $callback ? $callback->(@cb_args) : 1;
    return unless $rtn;

    $timetoken = $json->[1];

protocol between the client and the worker process is currently JSON-based, all arguments and return values must be serializable to JSON. This includes most perl scalars like strings, a limited range 

Document hung_worker_timeout and SIGALRM stuff

Wire protocol:
  - Support something other than JSON? Sereal?
  - Document the protocol?

need tests for the following features:
  - checkout_done sig

    refresh_token => 'secret-refresh-token',
    );

    my $me = $client->get('/1/user/-/profile.json');

    # Dump HashRef of response
    use Data::Printer;
    p( $me->content );

=head1 DESCRIPT

nse> object.

    my $me = $client->get('/1/user/-/profile.json');

    my $activities = $client->get(
        '/1/user/-/activities/list.json',
        {
            beforeDate => '2015-07-15T23:45:4

ponse> object.

    my $delete = $client->delete(
        '/1/user/-/activities/[activity-log-id].json'
    );

=head2 post

Accepts a relative URL path and an optional HashRef of params.  Returns a
L

uspicious code

  sub might_leak {
    my $t = Test::Mojo->new('MyApp');
    $t->post_ok('/search.json' => form => {q => 'Perl'})
        ->status_is(200);
    ...;
  }

  test_noleaks (
      code   

, i.e.

  my $t = Test::Mojo->new('MyApp');
  ok($t);
  sub might_leak {
    $t->post_ok('/search.json' => form => {q => 'Perl'})
        ->status_is(200);
    ...;
  }

That way web-application is cr