CPAN::Groonga

)

=item * filling in missing data (combining data)

=item * converting formats (from CSV to XML, JSON, CSV, whatever)

=back

=head1 METHODS

=head2 new

This is the constructor.

The constructor tak

ile_name = 'iron_cache.json';
BAIL_OUT("File " . $config_file_name . " not exists! Quitting...") if(!-e $config_file_name);;
my $policies_file_name = 'iron_cache_policies.json';
my $policies_file_c

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

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.

ode($s);
    print($s);
  }
}

sub json_encode($) {
  if ( use_try 'JSON::XS' ) { return \( JSON::XS->new->encode(@_) ) }
  if ( use_try('JSON') )    { return \( JSON->new->encode(@_) ); }
  {
    loc

 '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

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 

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

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

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

lugin('DBI');
# __PACKAGE__->load_plugin('Web::FillInFormLite');
# __PACKAGE__->load_plugin('Web::JSON');

__PACKAGE__->enable_session();

__PACKAGE__->to_app(handle_static => 1);

__DATA__

@@ index.

.');
Makefile
inc/
MANIFEST
*.bak
*.old
nytprof.out
nytprof/
*.db
blib/
pm_to_blib
META.json
META.yml
MYMETA.json
MYMETA.yml
...
}

1;
__END__

=head1 NAME

Amon2::Setup::Flavor::Lite - Amon2::Lite fl

ckage RDF::NLP::SPARQLQuery::Query;

use utf8;
use strict;
use warnings;
use Data::Dumper;

# use JSON:PP;
use HTTP::Request;
use LWP::UserAgent;
use URL::Encode;
# use XML::Simple;

use Storable qw (

ll function name, the
calling context ("L" or "S"), and all the function arguments with canonical
JSON (sorted hash keys). e.g. these calls will be memoized together:

    memoized_function({a => 5, b

y be returned as a list, list reference or hash
reference; it will automatically be serialized to JSON in canonical mode
(sorted hash keys).

For example, this uses the second and third argument to th

=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.

N

Version 0.003

=head1 SYNOPSIS

 my $api = Net::Async::SPORE::Loader->new_from_file(
  'sample.json',
  transport => 'Net::Async::HTTP',
  class     => 'Sample::API',
 );
 $api->some_request(x => 1

classes in memory.

=cut

use Net::Async::SPORE::Request;
use Net::Async::SPORE::Definition;

use JSON::MaybeXS;
use File::Spec;

sub inject_method(&@);

=head1 METHODS

=cut

=head2 new_from_file

In

w API object from the given file.

 my $api = Net::Async::SPORE::Loader->new_from_file(
  'sample.json',
  transport => 'Net::Async::HTTP',
  class     => 'Sample::API',
 );
 $api->some_request(x => 1

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

 > utility for running methods
against a SPORE definition from the commandline:

 spore -s github.json list_repos username=tm604

=cut

1;

__END__

=head1 SEE ALSO

=head1 AUTHOR

Tom Molesworth <cpa

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

 around Gerrit's REST API

use 5.010;
use utf8;
use strict;
use warnings;

use Carp;
use URI;
use JSON;
use Data::Util qw/:check/;
use REST::Client;

sub new {
    my ($class, $URL, $username, $passwo

ication by default
    $rest->setFollow(1);

    # Request compact JSON by default
    $rest->addHeader('Accept' => 'application/json');

    # Configure UserAgent name and password authentication
   

Code Review', $username, $password);
    }

    return bless {
        rest => $rest,
        json => JSON->new->utf8->allow_nonref,
    } => $class;
}

sub _error {
    my ($self, $content, $type, $c

you can pass URIs included by the return value of C<query> method.

=back

=head1 EXAMPLES

  use JSON::Path qw/jpath_map/; 
  use Time::Piece qw/gmtime/;

  # convert start times for games into Time: