CPAN::Groonga

eate.pl model ModelName Riak http:/192.168.0.1:8089 900
	
	
	# In you controller use
	my $coder = JSON::XS->new->utf8->pretty->allow_nonref;
	
	#
	# Set bucket
	#
	$c->model("ModelName")->bucket('Buck

eate

Creates a new key/value pair

	$c->model("ModelName")->create({ key => 'keyname', value => $json_data });
	

=head2 delete

Deletes a key/value pair

=head2 get

Get a key/value pair from the ri

head2 update

Update a key/value pair

	$c->model('ModelName')->update( { key => 'key', value => $json_data } );

=head2 dw

Get or set the number of partitions to wait for write confirmation

=head2 

ead1 EXPORT


=cut

use strict;
use warnings;

use HTTP::Request::Common;
use LWP::UserAgent;
use JSON;
use MIME::Base64 'encode_base64';
use Time::HiRes (qw(gettimeofday));
use DateTime;
use Sys::Hos

       'extra'       => $params->{'extra'} || {}
    };

    my $json = JSON->new->utf8(1)->pretty(1)->allow_nonref(1);
    return $json->encode( $data );
}

1;

=head1 LICENSE AND COPYRIGHT

Copyrigh

I::Command::Settings::VERSION = '0.751';
}
use Any::Moose;
use Params::Validate qw/validate/;
use JSON;

extends 'Prophet::CLI::Command';
with 'Prophet::CLI::TextEditorCommand';

sub ARG_TRANSLATIONS 

ngs edit
       ${cmd}settings set -- setting "new value"

Note that setting values must be valid JSON.
END_USAGE
}

sub run {
    my $self = shift;

    $self->print_usage if $self->has_arg('h');

  

ue to $new_value.\n";
            if ( $old_value ne $new_value ) {
                $s->set( from_json( $new_value, { utf8 => 1 } ) );
                print " -> Changed.\n";
            } else {
    

package NG;
use strict;
use warnings;
use Try::Tiny;
use autodie;
use YAML::XS ();
use JSON::XS ();
use XML::Simple;
use Spreadsheet::ParseExcel;
use NG::Autobox;
use NG::Array;
use NG::DB;
use NG::Ex

RT = qw(
  local_run
  remote_run
  fork_run
  taskset

  web_get

  mail_send
  mail_get

  from_json
  from_yaml
  mkdir_p
  rm_r
  cp_r
  read_file
  read_dir
  file_stat

  process_log
  geo_ip

 

Hashtable->new($ref)
      : NG::Array->new($ref);
}

sub from_json {
    my $data = &read_file(@_);
    my $ref  = JSON::XS::decode_json($data);
    return ref($ref) eq 'HASH'
      ? NG::Hashtable->

two different conventions; named arguments:

	p5u reprove --release=JSON --version=2.53

Or positional arguments:

	p5u reprove JSON 2.53

The first argument is the distribution name or module name; t

::" is used to disambiguate between distribution
and module names; in the case of something like "JSON" which is ambiguous,
use a trailing "::" to force it to be interpreted as a module name.

When gi

olutionDB::VERSION = '0.751';
}
use Any::Moose;
use Prophet::Change;
use Prophet::Collection;
use JSON;
use Digest::SHA 'sha1_hex';
extends 'Prophet::Resolver';

sub run {
    my $self               =

y %answer_count;

    for my $answer ( $res->items ) {
        my $key = sha1_hex(
            to_json(
                $answer->get_props, { utf8 => 1, pretty => 1, canonical => 1 }
            )
   

'all';
use Moo;
use Getopt::Long qw(GetOptionsFromArray);
use Mojo::UserAgent;
use Try::Tiny;
use JSON;
use Time::HiRes;

=head1 NAME

App::Unicheck::Modules::HTTP - App::Unicheck module to check web 

, $value, $format) = @_;

    return JSON->new->encode(
        {
            message => $value,
            status  => $status,
        }
    ) if $format eq 'json';
    # default last in case some n

mats => {
                    'num'  => 'Returns the status code',
                    'json' => 'Returns a JSON structure',
                },
                default_format => 'num',
            },

e Getopt::Long qw(GetOptionsFromArray);
use Try::Tiny;
use MongoDB;
use MongoDB::MongoClient;
use JSON;

=head1 NAME

App::Unicheck::Modules::MongoDB - App::Unicheck module to check mongodb servers.

, $value, $format) = @_;

    return JSON->new->encode(
        {
            message => $value,
            status  => $status,
        }
    ) if $format eq 'json';
    # default last in case some n

mats => {
                    'num'  => 'Returns the status code',
                    'json' => 'Returns a JSON structure',
                },
            },
        },
    }
}

=head1 AUTHOR

Matthi

ib::Version::AUTHORITY = 'cpan:TOBYINK';
	$P5U::Lib::Version::VERSION   = '0.100';
};

use JSON qw< from_json >;
use LWP::Simple qw< get >;
use Module::Info;
use Module::Runtime qw< module_notional_fi

_installed(@_);
}

sub cpan_module_info
{
	my $self = shift;
	my $mod  = shift;

	my $data = from_json get(
		sprintf
			'http://api.metacpan.org/v0/module/_search?q=status:cpan+AND+path:lib/%s&fields

n => $data);
}

sub backpan_module_info
{
	my $self = shift;
	my $mod  = shift;

	my $data = from_json get(
		sprintf
			'http://api.metacpan.org/v0/module/_search?q=status:backpan+AND+path:lib/%s&fie

5.010;
use strict;
use App::Cmd::Setup-command;

use File::HomeDir qw<>;
use File::Temp qw<>;
use JSON qw<>;
use Path::Tiny qw<>;
use Object::AUTHORITY;

my %config;

sub get_tempdir
{
	Path::Tiny::->

d_names)[0]),
		'config.json',
	);
}

sub get_config
{
	my $proto = shift;
	my $class = ref($proto) || $proto;
	
	unless ($config{$class})
	{
		$config{$class} =
			eval { JSON::->new->decode(scalar $

e;

use Moo;
use App::Prove qw//;
use Class::Load qw/load_class/;
use Carp qw/confess/;
use JSON qw/from_json/;
use File::pushd qw/pushd/;
use File::Temp qw//;
use Module::Info qw//;
use Path::Tiny qw

 = $1;
			}
		}
	}
	
	if (defined $args{module} and not defined $args{release})
	{
		my $d = from_json(get(sprintf('http://api.metacpan.org/v0/module/%s', $args{module})));
		$args{release}  = $d->{di

= $d->{author};
	}
	
	if (defined $args{release} and not defined $args{author})
	{
		my $d = from_json(get(sprintf('http://api.metacpan.org/v0/release/%s', $args{release})));
		$args{author} //= $d->{

ut performance
(because App::Cmd or P5U has already loaded them). These include
L<Class::Load>, L<JSON> and L<Path::Tiny>.

If you need OO, then use L<Moo> (but do it in a workhorse module that's
load

= '0.100';
};

use Moo;
use IO::Uncompress::Gunzip qw< gunzip $GunzipError >;
use JSON             2.00  qw< from_json >;
use LWP::Simple      0     qw< get >;
use match::smart     0     qw< M >;
use 

;
use Type::Utils      0     qw< class_type >;
use Types::Standard  0.004 qw< HashRef >;

my $json   = JSON::->new->allow_nonref;

sub dist2deb
{
	my ($dist) = @_;
	"lib".lc($dist)."-perl";
}

use nam

elease/_search?q=author:".
		uc($author)."%20AND%20status:latest&fields=name&size=1000";
	$res = $json->decode($res);
	die "MetaCPAN timed out" if $res->{timed_out};

	my $pkgs = $self->debian;

	my %

0';
};

use Moo; no warnings;
use Types::Standard qw< ArrayRef HashRef Maybe Num Str >;
use JSON qw(from_json);
use LWP::Simple qw(get);
use Object::AUTHORITY;

use constant {
	template_website       

pan_data => (
	is         => 'lazy',
	isa        => HashRef,
);

sub _build_metacpan_data
{
	from_json get sprintf __PACKAGE__->template_metacpan_data, uc shift->cpanid
}

has [qw(metacpan_releases me

_json get sprintf __PACKAGE__->template_metacpan_releases, uc shift->cpanid)
				->{hits}{hits}
		}
	]
}

sub _build_metacpan_popular
{
	my @plusplus = map $_->{fields}{distribution}, @{
		(from_json 

::Lib::Testers::VERSION   = '0.100';
};

use Moo;
use File::Spec       0 qw< >;
use JSON             0 qw< from_json >;
use LWP::Simple      0 qw< mirror is_success >;
use List::Util       0 qw< maxst

ttp://www.cpantesters.org/distro/%s/%s.json',
		substr($self->distro, 0, 1),
		$self->distro,
	);
	my $results_file = path(
		$self->cache_dir,
		sprintf('%s.json', $self->distro),
	);
	
	is_success m

unlink $results_file;
			die "Failed to retrieve URI $results_uri\n";
		};
		
	my $results = from_json scalar $results_file->slurp;
	die "Unexpected non-ARRAY content from $results_uri\n"
		unless ref

 FATAL => 'all';
use Moo;
use Getopt::Long qw(GetOptionsFromArray);
use Redis;
use Try::Tiny;
use JSON;

=head1 NAME

App::Unicheck::Modules::Redis - App::Unicheck module to check redis servers.

=hea

	my ($self, $status, $value, $format) = @_;

	return JSON->new->encode(
		{
			message => $value,
			status  => $status,
		}
	) if $format eq 'json';
	# default last in case some non supported format 

'Default: num',
				},
				formats => {
					'num'  => 'Returns the status code',
					'json' => 'Returns a JSON structure',
				},
			},
			size => {
				description => 'Check redis RAM consumption',

tmp/file');
    say $f->fstat;

=head1 METHODS

=head2 from_json/yaml

Return Hashtable or Array:

    my $object = NG::File->from_yaml/json($file);

=head2 read_file

    my $filepath = '/home/chenry

}
use Any::Moose;
extends 'Prophet::Replica';
use File::Spec;
use Params::Validate qw(:all);
use JSON;
use Prophet::Util;


sub replica_exists {
    my $self = shift;
    return $self->uuid ? 1 : 0;

_no          => 1
        }
    );

    require Prophet::ChangeSet;
    my $content_struct = from_json( $args{content}, { utf8 => 1 } );
    my $changeset = Prophet::ChangeSet->new_from_hashref($conte

 strict;
use warnings;

use JSON 'decode_json';
use Path::Class 'file';

use Exporter 'import';
our @EXPORT_OK = qw(get_un);


sub get_un {
  my $fn = sprintf "%s/%04d.json", data_dir(), shift;
  retu

rn unless -e $fn;
  open my $fh, '<', $fn;
  my $text = <$fh>;
  my $hashref = decode_json $text or return;
  return %$hashref;
}

sub data_dir {
  file(__FILE__)->parent()->subdir('UN-data');  
}

1;

entAddressedStore;
{
  $Prophet::ContentAddressedStore::VERSION = '0.751';
}
use Any::Moose;

use JSON;
use Digest::SHA qw(sha1_hex);

has fs_root => ( is => 'rw', );

has root => (
    isa => 'Str',

$content ) = @_;

    $content = $$content
      if ref($content) eq 'SCALAR';

    $content = to_json( $content, { canonical => 1, pretty => 0, utf8 => 1 } )
      if ref($content);
    my $fingerpri