CPAN::Groonga

        $ts = ($ts * 256) + hex(substr($self->value, $i*2, 2));
    }
    return $ts;
}


sub TO_JSON {
    my ($self) = @_;
    return {'$oid' => $self->value};
}

use overload
    '""' => \&to_stri

s the timestamp.  

=head2 TO_JSON

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

    $json->encode(MongoDB::OID->new);

Returns a JSON string for this OID.  This is

t;

use HTML::Entities::Interpolate; # For %Entitize.
use HTML::Template;

use IPC::Capture;

use JSON::XS;

use Path::Class; # For dir() and cleanup().

our $VERSION = '1.03';

# --------------------

quotes to satisfy Path::Class.
	# Encode HTML entities with HTML::Entities::Interpolate.

	return JSON::XS -> new() -> encode
		({
			response =>
			{
				left    => "$left_name",
				message => $mess

se IRC::Formatting::HTML qw/html_to_irc/;

use App::Alice::Stream;
use App::Alice::Commands;

use JSON;
use Encode;
use utf8;
use Any::Moose;
use Try::Tiny;

has 'app' => (
  is  => 'ro',
  isa => 'Ap

ender('range', $after, 'after');
        my $res = $req->new_response(200);
        $res->body(to_json [$before, $after]);
        $respond->($res->finalize);
      }
    ); 
  }
}

sub send_config {

f->app->render('server_listitem', $name);
  
  my $res = $req->new_response(200);
  $res->body(to_json({config => $config, listitem => $listitem}));
  $res->header("Cache-control" => "no-cache");
  re

package App::Alice::Stream;

use JSON;
use Time::HiRes qw/time/;
use Try::Tiny;
use Any::Moose;

use strict;
use warnings;

has queue => (
  is  => 'rw',
  isa => 'ArrayRef[HashRef]',
  default => sub

started) {
    $output .= "--".$self->seperator."\n";
    $self->started(1);
  }

  $output .= to_json({
    queue => $self->queue,
    time  => time - $self->offset,
  }, {utf8 => 1});

  $output .= 

package App::Alice::MessageStore::Redis;

use Any::Moose;
use AnyEvent::Redis;
use JSON;

my $redis = AnyEvent::Redis->new;

has id => (
  is => 'ro',
  required => 1
);

has buffersize => (
  is => '

ub add {
  my ($self, $message) = @_;
  return unless $message;
  $redis->rpush($self->id, encode_json $message);
  $redis->llen($self->id, sub {
    $redis->lpop($self->id) if $_[0] > $self->buffersi

_[0] eq 'ARRAY' ? $_[0] : [];
      $cb->(
        grep {$_}
        map  {my $msg = eval {decode_json $_ }; $@ ? undef : $msg}
        @$msgs
      );
      if ($end == $self->buffersize or @$msgs !=

use Data::GUID;
use DateTime;
use DateTime::Format::ISO8601;
use File::Slurp qw/write_file/;
use JSON;
use Metabase::Librarian 0.013; # bug fixes on extraction
use XML::Feed;

use namespace::autoclea

ersion = "1.0";

  my $mb = $self->ct_metabase;
  my $librarian = $mb->public_librarian;
  my $json = JSON->new->pretty;
  my $since = $self->since;
  $since =~ s/Z?$/Z/;

  my $guids = $librarian->se

ntry->title($msg);
      $entry->author($fn);
      $entry->summary($msg);
      $entry->content($json->encode( $data ));
      $entry->issued(DateTime::Format::ISO8601->parse_datetime( $ts ));
      

on
process could find it (C</usr/local/etc/genreport/daily.yml> or
C</opt/p5-genreport/etc/weekly.json>).

Use C<< genreport commands >> to figure out, which reports can be run.

=head1 FUNCTIONS/METH

 with other Event loops.

=item * Log4perl

This is the logging backend of ControlFreak.

=item * JSON::XS

=item * Object::Tiny

=item * Try::Tiny

=item * Params::Util

=back

=head2 cpanm

Other in

vent::Util();
use AnyEvent::Handle();
use Carp;
use ControlFreak::Util();
use Data::Dumper();
use JSON::XS;
use Params::Util qw{ _NUMBER _STRING _IDENTIFIER _ARRAY _POSINT };
use POSIX qw{ SIGTERM SIG

lue =~ /^\[/) {
        $value = try { decode_json($value) }
        catch {
            my $error = $_;
            $svc->{ctrl}->log->error("Invalid JSON: $error");
            return;
        };
  

package ControlFreak::Proxy::Process;

use strict;
use warnings;

use JSON::XS;
use Try::Tiny;
use POSIX 'SIGTERM';
use IO::Select;

$SIG{PIPE} = 'IGNORE';

=head1 NAME

ControlFreak::Proxy::Process -

s_command {
    my $proxy = shift;
    my $command = shift;

    my $param = try {
        decode_json($command)
    } catch {
        $proxy->log('err', "parse error in command $command: $_");
      

me, $pid, $es) = @_;
    my $fh = $proxy->{status_fh}
        or return;

    my $string = encode_json({
        status => $cmd,
        name => $name,
        pid => $pid,
        exit_status => $es,

AnyEvent::Util();
use Carp;
use ControlFreak::Util;
use Fcntl qw(F_GETFD F_SETFD FD_CLOEXEC);
use JSON::XS;
use Object::Tiny qw{ name cmd pid is_running env auto };
use Params::Util qw{ _ARRAY _STRING

svc->tie_stdin_to,
        no_new_session => $svc->no_new_session,
    };
    my $string = encode_json($descr);
    $hdl->push_write("$string\n");
}

sub stop_service {
    my $proxy = shift;
    my %

escr = {
        command => 'stop',
        name    => $svc->name,
    };
    my $string = encode_json($descr);
    $hdl->push_write("$string\n");
}

sub unset {
    my $proxy = shift;
    my $attr = 

::Functions qw(catdir catfile);
use File::Basename qw(dirname);

use Path::Class;
use Config;
use JSON;


__PACKAGE__->add_property('task_name' => 'Core');
__PACKAGE__->add_property('static_dir' => 's

om most outer {} brackets
	$components =~ m/(\{.*\})/s;
	$components = $1;

	my $deploys = decode_json $components;
	
	$self->concatenate_for_task($deploys, $self->task_name);
}


#===================

>make_tarball($dist_dir);
    $self->delete_filetree($dist_dir);

    $self->add_to_cleanup('META.json');
#    $self->add_to_cleanup('*.gz');
}



#====================================================

ML::Simple;
use JSON;

require Exporter;
our @ISA = qw(Exporter);
our @EXPORT_OK = qw(getSWIFT new);
our $VERSION = '0.04';

my $format;		#response return format i.e. xml json csv
my $swiftbi

	}
}

sub validateFormat{
        #Validate response format must match json, xml, or, csv
        if ($format !~ /^json$|^xml$|^csv$/){
                $error .= "INVALID - Result Format";
   

ess4></address4><location></location><country></country></swiftbic>";
        }elsif($format eq "json"){
         	$responseString = "{\"result\":\"" . $responseString . "\",\"bic\":\"\",\"name1\":\

bInfo {
	my $self = shift;
	my $res = $self->{client}->req('GET', $self->uriName);
	return $res->{json} if $res->{success};
	confess("Connection error: $res->{msg}");
}

sub create {
	my $self = shift

y $res = $self->{client}->req('PUT', $self->uriName);
	return $self if $res->{success} and $res->{json}->{ok};
	confess("Database '$self->{name}' exists: $res->{msg}") if $res->{status} == 409;
	confe

my $res = $self->{client}->req('DELETE', $self->uriName);
	return 1 if $res->{success} and $res->{json}->{ok};
	confess("Database '$self->{name}' not found: $res->{msg}") if $res->{status} == 404;
	co

::Simple;
use JSON;

require Exporter;
our @ISA = qw(Exporter);
our @EXPORT_OK = qw(ibanValidate new);
our $VERSION = '0.05';

my $format;		#response return format i.e. xml json csv
my $iban;

	}
}

sub validateFormat{
        #Validate response format must match json, xml, or, csv
        if ($format !~ /^json$|^xml$|^csv$/){
                $error .= "INVALID - Result Format";
   

ng=\"UTF-8\"?><iban><result>" . $responseString . "</result></iban>";
        }elsif($format eq "json"){
         	$responseString = "{\"result\":\"" . $responseString . "\"}";
        }
}

1;

package CouchDB::Client;

use strict;
use warnings;

our $VERSION = '0.09';

use JSON::Any       qw(XS JSON DWIW);
use LWP::UserAgent  qw();
use HTTP::Request   qw();
use Encode          qw(encode);

host}   || 'localhost') . ':'   .
					 ($opt{port}   || '5984')      . '/';
	}
	$self{json} = ($opt{json} || JSON::Any->new(utf8 => 1, allow_blessed => 1));
	$self{ua}   = ($opt{ua}   || LWP::UserAge

@;
	return 1;
}

sub serverInfo {
	my $self = shift;
	my $res = $self->req('GET');
	return $res->{json} if $res->{success};
	confess("Connection error: $res->{msg}");
}

sub newDB {
	my $self = shift;

me . $vp . $qs);
	confess("Connection error: $res->{msg}") unless $res->{success};
	return $res->{json};
}

1;

=pod

=head1 NAME

CouchDB::Client::DesignDoc - CouchDB::Client design documents (views)

ss("Storage error: $res->{msg}") unless $res->{success};
	$self->{rev} = $res->{json}->{rev};
	$self->{id} = $res->{json}->{id} unless $self->{id};
	return $self;
}

sub contentForSubmit {
	my $self =

tus} == 404;
	confess("Connection error: $res->{msg}") unless $res->{success};
	my $data = $res->{json};
	my %private;
	my @keys = keys %$data; # need to two-step this due to delete()
	for my $k (@key

tus} == 404;
	confess("Connection error: $res->{msg}") unless $res->{success};
	my $data = $res->{json};
	my %private;
	my @keys = keys %$data; # need to two-step this due to delete()
	for my $k (@key

ntation is very XML/XPath-centric, but there's certainly room to incorporate other formats (YAML, JSON, etc)

=item  *

Figure out how to make friendly with Test::Harness and whatnot

=item *

Allow e

package WWW::Notifo;

use warnings;
use strict;

use Carp;
use JSON;
use Data::Dumper;
use LWP::UserAgent;
use MIME::Base64;

use base qw( Exporter );

our @EXPORT_OK = qw( notifo );

=head1 NAME

WWW

elf->_ua->post( join( '/', API, $method ), Content => \%args );
  my $rd = $self->{last} = eval { JSON->new->decode( $resp->content ) };
  my $err = $@;
  if ( $resp->is_error ) {
    croak join ' ', 

 'error';
    croak $resp->status_line;
  }
  croak $err if $err;    # Only report errors parsing JSON we have a 200
  return $rd;
}

sub api {
  my ( $self, $method, @args ) = @_;
  return $self->_ap