CPAN::Groonga

/
Build
!Build/
Build.bat
.last_cover_stats
/Makefile
/Makefile.old
/MANIFEST.bak
/META.yml
/META.json
/MYMETA.*
nytprof.out
/pm_to_blib
*.o
*.bs
*.swp
END_OF_BODY
    },
    travis_yml => {
        f

he SMS::Matrix API

use warnings;
use strict;

use LWP::UserAgent;
use HTTP::Request::Common;
use JSON();
## use Data::Dumper;

our $VERSION = '1.01';

################################################

blank');
   $self->status (1001);
   return;
  }

 my $json_txt = JSON::to_json ($rqp);
 if ($json_txt eq '')
  {
   $self->errstr ('JSON::to_json() returned NULL');
   $self->status (1000);
   return

;
 my $res = $ua->request
  (
   POST $rqp->{url},
   Content_Type  => 'application/json',
   Content       => $json_txt
  );

 ## print Dumper($rqp) . "\n\n";
 ## print Dumper($res) . "\n\n";

 if ($

 $VERSION = '0.12'; # VERSION: generated by DZP::OurPkgVersion



use Log::Any  qw{$log};
require JSON::MaybeXS;
use Data::UUID ();
use Hash::Util 0.06 qw{lock_keys lock_keys_plus unlock_keys legal_ke

->fatalf("Missing config item \'project_id\'. Please check that Iron.io config is accessible (by .json file or environmental variables).");
        $log->tracef('Exiting check_for_iron_io_config():%d'

ard characters can be used in
cache names, item keys, etc.

For example, if F<iron_cache_policies.json>:

    {
        "definition":{
            "character_group":{
                "[:lim_uchar:]":"

      }
    }

then

    ironcache list items .* --cache cache_A01 --policies iron_cache_policies.json

would print out:

    Cache                         Item                expires
    cache_A01   

g. B<ironcache get item item.02_A.{2} --cache cache_A01 --config iron_cache.json --policies iron_cache_policies_test_01.json --warn>

=back

=item increment: Increment an item/items in cache/caches.

mentation of partial responses using the C<fields>
parameter, and it is based on the node module "json-mask".

=head1 RULES

=head2 Properties

Select one or more properties from an object by sepratin

://developers.google.com/discovery/v1/performance#partial-response>

=item *

json-mask: L<https://github.com/nemtsov/json-mask>

=back

=head1 AUTHOR

Andrew Rodland <arodland@cpan.org>

=head1 COPYR

er:

  The MIT (X11) License

=head1 ADDITIONAL LICENSE

This module contains code and tests from json-mask,
Copyright (c) 2013 Yuriy Nemtsov.

=head1 CREDIT

Development of this module is supported b

strict;
use warnings;

our $VERSION = 0.14;

use base qw(CohortExplorer::Datasource);
use JSON qw( decode_json );

#-------
sub authenticate {
 my ( $self, %opts ) = @_;
 my $ds_name = $self->name;
 r

 Accept => "application/json"
 );
 my $res  = $ua->request($req);
 my $code = $res->code;
 if ( $code == 200 ) {
  my $json = decode_json( $res->decoded_content );
  if ( $json->{type} ne 'mongodb' ) 

w = map { $_ => 1 } @{ $json->{view} || [] };
   my @tables = @{ $json->{table} || [] };

   # Get all base tables ( i.e. exclude views )
   my @base_tables =
     defined $json->{view} ? grep { not $

er:

  The MIT (X11) License

=head1 ADDITIONAL LICENSE

This module contains code and tests from json-mask,
Copyright (c) 2013 Yuriy Nemtsov.

=head1 CREDIT

Development of this module is supported b

er:

  The MIT (X11) License

=head1 ADDITIONAL LICENSE

This module contains code and tests from json-mask,
Copyright (c) 2013 Yuriy Nemtsov.

=head1 CREDIT

Development of this module is supported b

arnings;
use LWP::UserAgent;
use HTTP::Response;
use HTTP::Request::Common;
use MIME::Base64;
use JSON;
use Data::Dumper;

sub new {
    my $class = shift;
    my $self = {};
    bless ($self,$class);

s = $self->_do_request(GET $url);
        my $content = $res->content;
        my $values = JSON::decode_json($content);
        @entries = @$values;
    };
    my @ret = ();
    foreach my $entry (@e

s to try to JSON decode it.  If that works,
        #return the JSON decoded value.  Otherwise, return it un-decoded
        my $value;
        eval {
            $value = JSON::decode_json($entry->{V

 'MooX::Singleton';

use Carp;
use strict;
use warnings;
use Digest::MD5 'md5_hex';

use URI;
use JSON;
use Furl;

use API::Instagram::User;
use API::Instagram::Location;
use API::Instagram::Tag;
use 

ields };
	my $json = $self->_request( 'post', $self->_access_token_url, $data, { token_not_required => 1 } );

	wantarray ? ( $json->{access_token}, $self->user( $json->{user} ) ) : $json->{access_tok

poses
	print "Requesting: $url$/" if $self->_debug;

	# Treats response content
	my $res = decode_json $self->_ua->$method( $url, [], $params )->decoded_content;

	# Verifies meta node
	my $meta = $re

=back

Conditions:

=over 4

=item * siam.device.set_components

The value of this condition is a JSON array of hashes, and each has
represents a Device Component object and its attributes. The driver

the driver to reset the contents and add
new items to the report. The value of the condition is a JSON-encoded
array consisted of hashes. Each hash must have a mandatory item with the
key C<siam.repor

d be
documented in the reporting program.

=back

The computable C<siam.report.content> returns a JSON array that is
comprised of the report items as specified in C<siam.report.set_items>
condition.

nder --template=template.html --values=values.json --output=output.html [--config=config.json] 
 
 # Render template tmpl.html with values from values.json into webpage.html
 # You can use single-lett

ues.json -o webpage.html
 
 # Same as above, but configure the template object using values from 
 # the config.json file
 ht_render -t tmpl.html -V values.json -o webpage.html --config=config.json
  

:Template file.

=head2 --values

The path to the values file.  The values file should describe a JSON object, 
which will be parsed into a Perl hash.  The keys of the hash should correspond 
to varia

package SIAM::Report;

use warnings;
use strict;

use base 'SIAM::Object';
use JSON;

=head1 NAME

SIAM::Report - Report object class

=head1 SYNOPSIS

   my $sorted_items = $report->get_items();
   m

= $self->attr('siam.report.object_class');
    my $content_json = $self->computable('siam.report.content');
    if( not defined($content_json) )
    {
        $self->error('Computable siam.report.cont

 return $ret;
    }
    
    my $content = eval { decode_json($content_json) };
    if( $@ )
    {
        $self->error('Failed to process JSON in ' .
                     'siam.report.contents comput

qxjkh
  Writing profile to 'metabase_id.json'

  $ mkdir ~/.cpanreporter
  $ cp metabase_id.json ~/.cpanreporter/
  $ chmod 400 ~/.cpanreporter/metabase_id.json
  $ vi ~/.cpanreporter/config.ini

  em

sport = Metabase uri https://metabase.cpantesters.org/api/v1/ id_file ~/.cpanreporter/metabase_id.json

=head1 CONTENTS

Params::Util		1.07

HTML::Parser            3.71

Data::UUID		1.219

Data::GUID

rse::CPAN::Meta	1.4414

Test::Reporter		1.60

Config::Perl::V		0.20

common::sense		3.72

JSON::XS		3.01

JSON			2.90

CPAN::DistnameInfo	0.12

Metabase::Fact		0.024

Metabase::Client::Simple 0.009

C

SION = '1.04';

=head1 NAME

Config::Merge - load a configuration directory tree containing
YAML, JSON, XML, Perl, INI or Config::General files

=head1 SYNOPSIS

   OO style
   -----------------------

als:

=over

=item * Flexible storage

Store all configuration in your format(s) of choice (YAML, JSON, INI, XML, Perl,
Config::General / Apache-style config) broken down into individual files in
a co

to decide what type of data the file contains, so:

    YAML            : .yaml .yml
    JSON            : .json .jsn
    XML             : .xml
    INI             : .ini
    Perl            : .perl 

Normally the calling
application would load the driver configuration from some data file
(YAML or JSON), and optionally supply its own logger object.

The following entries are supported in the config

}

sub psgi {
    my ($self, $result) = @_;
    my $json = JSON->new->encode( $result );
    return [ 200, [ "Content-Type" => $self->type ], [ $json ] ];
}

1;

__END__

=pod

=encoding UTF-8

=head1

erver

use warnings;
use strict;

use Carp;
use JSON;
use Net::WebSocket::Server;

our $VERSION = "2.000000";
$VERSION = eval $VERSION;

my $json = JSON->new->convert_blessed;

=head1 NAME
 
McBain::W

:WebSocket::Server>.

The created server will be a JSON-in JSON-out service. When a client sends a message to
the server, it is expected to be a JSON string, which will be converted into a hash-ref
an

to JSON as well and sent back to the client.

Note that if an API method does not return a hash-ref, this runner module will automatically
turn it into a hash-ref to ensure that conversion into JSON w

use warnings;
use strict;

use Carp;
use Gearman::XS qw(:constants);
use Gearman::XS::Worker;
use JSON;

our $VERSION = "2.000000";
$VERSION = eval $VERSION;

=head1 NAME
 
McBain::WithGearmanXS - Loa

orkers created receive payloads in JSON format, and convert them into the hash-refs your
API's methods expect to receive. Results are sent back to the clients in JSON as well. Note
that if an API meth

ref, this runner module will automatically
turn it into a hash-ref to ensure that conversion into JSON will be possible. The created
hash-ref will have one key - holding the method's name, with whatev

Curses::UI;
use LWP::UserAgent;
use LWP::Protocol::https;
use HTTP::Request;
use URI::Escape;
use JSON::XS;
use YAML::XS;

our $SELF;
sub PPP {
    my $self = $SELF;
    my $text = YAML::XS::Dump(@_);

rized. Maybe you need to login as an admin user?";
        } else {
            my $data = decode_json($response->content);
            for (0 .. $#{$data}) {
                my $user = $data->[$_];
 

      $self->error("Couldn't login.");
        return $self->logout;
    }
    my $token = decode_json($response->content)->{token};
    $self->current_target->{user} = $username;
    $self->current_t