CPAN::Groonga

me eq 'rdfjson') {
                    $self->{formats}{'rdfjson'} = {
                        type => "application/rdf+json",
                        filter => sub { return $_[0]->toRDFJSON; },
     

s} if ($self->{expires});
        $http .= CGI::header( %headers );
        $http .= $response->toJSON($callback);
    } elsif ( $format eq "debug") {
        $http .= CGI::header( -status => $status,

", $self->errors) . "\n" if $self->errors;
        $http .= "*/\n";
        $http .= $response->toJSON($callback) . "\n";
    } else { # other unAPI formats
        # TODO is this properly logged?
   

   return bless $arg, $class;
}

=head2 data

This returns a data structure deserialised from the JSON part of the
response as defined by Flattr's API.

=cut

sub data {
    shift->{data};
}

=head2 h

buckets.. are you running riak 0.14+?"
        unless $response->is_success;
    my $resp = JSON::decode_json($response->content);
    return ref ($resp->{buckets}) eq 'ARRAY' ? @{$resp->{buckets}} : 

new_request('GET', ["stats"]);
    my $response = $self->send_request($request);
    return JSON::decode_json($response->content);
}

1;

__END__

=pod

=head1 NAME

Net::Riak::Role::REST - role for R

le::REST::Object;
{
  $Net::Riak::Role::REST::Object::VERSION = '0.1702';
}

use Moose::Role;
use JSON;

sub store_object {
    my ($self, $w, $dw, $object) = @_;

    my $params = {returnbody => 'tru

    }

    if (ref $object->data && $object->content_type eq 'application/json') {
        $request->content(JSON::encode_json($object->data));
    }
    else {
        $request->content($object->data

      if $http_response->content_type;
        $obj->data(JSON::decode_json($obj->data))
            if $obj->content_type eq 'application/json';
        $obj->vclock($http_response->header('X-Riak-Vc

package AnyEvent::Lingr;
use Mouse;

our $VERSION = '0.07';

use AnyEvent::HTTP;

use Carp;
use JSON;
use Log::Minimal;
use Scalar::Util ();
use Try::Tiny;
use URI;

has ['user', 'password'] => (
    

ms);

    my $cb_wrap = sub {
        my ($body, $hdr) = @_;

        my $json = try { decode_json $body };
        $cb->($json, $hdr);
    };

    if ($http_method eq 'GET') {
        http_get $uri, 

sub {
        my ($body, $hdr) = @_;
        return unless $self;

        my $res = try { decode_json $body };

        if ($res and $res->{status} eq 'ok') {
            if ($res->{counter}) {
     

use base qw(Bot::BasicBot::Pluggable::Module);

use 5.010;
use LWP::Simple qw($ua);
use JSON qw( decode_json );


sub init {
	my $self = shift;

	$self->get( 'user_field_not_set' ) || $self->set( us

LE TESTING_DONE.};
}

sub _get_rb_data {
	my ($self, $rb) = @_;
	$self->ua;
	my $content = decode_json LWP::Simple::get( sprintf( "%s/api/review-requests/%d", $self->get('user_rb_url'), $rb ) );
	my $

Nakanobu;
use strict;
use warnings;
use base qw/Class::Component::Plugin/;
use JSON::RPC::Common::Marshal::HTTP;
use JSON::RPC::Common::Procedure::Call;
use YAML ();
use LWP::UserAgent;
use Text::Trun

 my ($method, $params, $entry_url, $timeout) = @_;

    my $marshal = JSON::RPC::Common::Marshal::HTTP->new();
    my $call = JSON::RPC::Common::Procedure::Call->new(
        method  => $method,
     

lient::VERSION = '0.71';
}
#ABSTRACT: SeeAlso Linkserver Protocol Client

use Carp qw(croak);
use JSON::XS '2.0' ;
use LWP::Simple qw(get);
use URI '1.35';
use Data::Validate::URI qw(is_web_uri);

use

    my $url = $self->queryURL( $identifier );
    my $json = get($url);

    if (defined $json) {
        return SeeAlso::Response->fromJSON( $json ); # may also croak
    } else {
        croak("Fail

1

=head1 SYNOPSIS

  $response = seealso_request ( $baseurl, $identifier );
  print $response->toJSON() . "\n" if ($response);

  $client = SeeAlso::Client->new( $baseurl, ShortName => "myClient" );

e::Role;
use JSON;
use List::Util 'sum';

sub execute_job {
    my ($self, $job, $timeout, $returned_phases) = @_;

    $job->{timeout} = $timeout;

    my $job_request = JSON::encode_json($job);

   

age( MapRedReq => {
            request => $job_request,
            content_type => 'application/json'
        }, sub { push @$results, $self->decode_phase(shift) })
        or
    die "MapReduce que

 $resp) = @_;

    if (defined $resp->response && length($resp->response)) {
        return JSON::decode_json($resp->response);
    }

    return;
}

1;

__END__

=pod

=head1 NAME

Net::Riak::Role::P

nse;
{
  $SeeAlso::Response::VERSION = '0.71';
}
#ABSTRACT: SeeAlso Simple Response

use JSON::XS qw(encode_json);
use Data::Validate::URI qw(is_uri);
use Text::CSV;
use SeeAlso::Identifier;
use Carp;

);
}


sub uris {
    my $self = shift;
    return @{ $self->{uris} };
}


sub toJSON {
    my ($self, $callback, $json) = @_;

    my $response = [
        $self->{query}->as_string,
        $self->{

   return _JSON( $response, $callback, $json );
}


sub as_string {
    return $_[0]->toJSON;
}


sub fromJSON {
    my ($self, $jsonstring) = @_;
    my $json = JSON::XS->new->decode($jsonstring);

 

le::REST::Bucket;
{
  $Net::Riak::Role::REST::Bucket::VERSION = '0.1702';
}

use Moose::Role;
use JSON;

sub get_properties {
    my ($self, $name, $params) = @_;

    # Callbacks require stream mode

urn JSON::decode_json($response->content);
    }

    # In streaming mode, aggregate keys from the multiple returned chunk objects
    else {
        my $json = JSON->new;
        my $props = $json->i

ncr_parse($response->content);
        if ($params->{cb}) {
            while (defined(my $obj = $json->incr_parse)) {
                $params->{cb}->($_) foreach @{$obj->{keys}};
            }
      

ackage Net::Riak::Role::PBC::Object;
{
  $Net::Riak::Role::PBC::Object::VERSION = '0.1702';
}
use JSON;
use Moose::Role;
use List::Util 'first';

sub store_object {
    my ($self, $w, $dw, $object) = 

ey;

    my $value = (ref $object->data && $object->content_type eq 'application/json')
            ? JSON::encode_json($object->data) : $object->data;

    my $content = {
        content_type => $ob

 $content->usermeta);
    }

    my $data = ($object->content_type eq 'application/json')
        ? JSON::decode_json($content->value) : $content->value;

    $object->exists(1);

    $object->data($d

ding. RedOxygen uses custom message formats and response codes and can't just
be used via simple JSON POST calls.

To use this driver you must have a RedOxygen account, either a trial or full accou

EST::MapReduce;
{
  $Net::Riak::Role::REST::MapReduce::VERSION = '0.1702';
}
use Moose::Role;
use JSON;
use Data::Dumper;

sub execute_job {
    my ($self, $job, $timeout) = @_;

    # save existing t

int($timeout/1000));
        }
        $job->{timeout} = $timeout;
    }

    my $content = JSON::encode_json($job);

    my $request = $self->new_request(
        'POST', [$self->mapred_prefix]
    )

success) {
        die "MapReduce query failed: ".$response->status_line;
    }

    return JSON::decode_json($response->content);
}

1;

__END__

=pod

=head1 NAME

Net::Riak::Role::REST::MapReduce

se Device::Hue::UPnP;
use Device::Hue::Light;

use LWP::UserAgent;
use LWP::Protocol::https;

use JSON::XS;

use Data::Dumper;
use Carp;

sub BUILD
{
	my ($self) = @_;

	$self->agent(new LWP::UserAgen

		say $res->status_line
			if $self->debug;

		say Dumper(decode_json($res->decoded_content))
			if $self->debug;

		return decode_json($res->decoded_content);
	}  else {
		say "Request failed: " . $r

ation/json');

	return $self->process($self->agent->request($req));
}

sub put
{
	my ($self, $uri, $data) = @_;

	my $req = HTTP::Request->new('PUT', $uri);

	$req->content_type('application/json');
	

::Light;
{
  $Device::Hue::Light::VERSION = '0.4';
}

use common::sense;
use Class::Accessor;
use JSON::XS;
use Hash::Merge::Simple qw/ merge /;
use Data::Dumper;

use base qw(Class::Accessor);

__PAC

(exists $param->{'on'}) {
		$param->{'on'} = (defined $param->{'on'} && $param->{'on'}) ? JSON::XS::true : JSON::XS::false;
	}

	$self->merge_param($param);

	if ($self->_trx) {
	} else {
#		say Dumpe

s being installed
upon to generate its own list of dependencies (called C<MYMETA.yml> or
C<MYMETA.json>).

This module is a Module::Install plugin that generates C<MYMETA.yml> by simply
passing throug

ms (BINGOS), Ingy döt Net (INGY) and Florian Ragwitz (FLORA)
for explaining the role of C<MYMETA.json>, and helping me figure out why mine
weren't working.

=head1 COPYRIGHT AND LICENCE

This softwar

ION = '0.1702';
}

# ABSTRACT: Allows you to build up and run a map/reduce operation on Riak

use JSON;
use Moose;
use Scalar::Util;

use Data::Dumper;

use Net::Riak::LinkPhase;
use Net::Riak::MapRed

 my ($self, $bucket, $tag, $keep) = @_;
    $bucket ||= '_';
    $tag    ||= '_';
    $keep   ||= JSON::false;

    $self->add_phase(
        Net::Riak::LinkPhase->new(
            bucket => $bucket,

     type     => 'map',
        function => $function,
        keep     => $options{keep} ? JSON::true : JSON::false,
        arg      => $options{arg} || [],
    );
    $self->add_phase($map_reduce);

;
}

use Moose;
use JSON;

has bucket => (is => 'ro', isa => 'Str', required => 1);
has tag    => (is => 'ro', isa => 'Str', required => 1);
has keep   => (is => 'rw', isa => 'JSON::Boolean', required

>setup_indexing('bucket_name');

Does the same as :

    curl -X PUT -H "content-type:application/json" http://localhost:8098/riak/bucket_name -d '{"props":{"precommit":[{"mod":"riak_search_kv_hook","

earch(
        q => 'bucket_name.field:value'
    );

Search the index

=over 4

=item wt => 'XML|JSON'

defines the response format (XML is the default value as for Solr/Lucene)

=item q

the query s