CPAN::Groonga

;
use Moose;
use MooseX::Storage;

use overload ('""' => 'to_string');

with Storage('format' => 'JSON', 'io' => 'File');

use Forest::Tree;
use Graphics::Primitive::Border;
use Graphics::Primitive::I

age Graphics::Primitive::ComponentList;
use Moose;
use MooseX::Storage;

with Storage (format => 'JSON', io => 'File');

has 'components' => (
    traits => ['Array'],
    is => 'rw',
    isa => 'Arra

itive::Component';

with qw(MooseX::Clone Graphics::Primitive::Aligned);
with Storage (format => 'JSON', io => 'File');

use Graphics::Primitive::Font;

has 'angle' => (
    is => 'rw',
    isa => 'Nu

:Primitive::Path;
use Moose;
use MooseX::Storage;

with 'MooseX::Clone';
with Storage (format => 'JSON', io => 'File');

use Geometry::Primitive::Arc;
use Geometry::Primitive::Bezier;
use Geometry::Pr

orage;

extends 'Graphics::Primitive::Component';

with 'MooseX::Clone';
with Storage (format => 'JSON', io => 'File');

use Graphics::Primitive::Path;

has path => (
    isa => 'Graphics::Primitive::

itive::Component';

with qw(MooseX::Clone Graphics::Primitive::Aligned);
with Storage (format => 'JSON', io => 'File');

has image => (
    is => 'rw',
    isa => 'Str'
);
has scale => (
    is => 'rw

h end devices are connected to which switch ports on which
switches and routers. It also offers a JSON-based client API, for which
this module is an implementation.

In addition to Porttracker, the Po

();

use AnyEvent ();
use AnyEvent::Handle ();

use MIME::Base64 ();
use Digest::HMAC_MD6 ();
use JSON ();

our $VERSION = '1.01';

sub call {
   my ($self, $type, @args) = @_;

   $self->{$type}
    

 => sub {
            while ($_[0]{rbuf} =~ s/^([^\x0a]*)\x0a//) {
               my $msg = JSON::decode_json $1;
               my $id = shift @$msg;

               if (defined $id) {
              

st, 'Compress::unLZMA';
	}

	push @modules_list, qw{
	  Win32::UTCFileTime
	  CPAN::Meta::YAML
	  JSON::PP
	  Parse::CPAN::Meta
	  YAML
	  Net::FTP
	  Digest::MD5
	  Digest::SHA1
	  Digest::SHA
	  Mod

', default => 'JSON::false');
has 'is_fan' => (is => 'ro', isa => 'Maybe[Object]', default => 'JSON::false');
has 'is_following' => (is => 'ro', isa => 'Maybe[Object]', default => 'JSON::false');

no 

y $level = $ENV{'HTML_ZOOM_DEBUG'}) {
  foreach my $mod (qw(Smart::Comments Data::Dumper::Concise JSON)) {
    (my $file_stem = $mod) =~ s/::/\//g;
    die "HTML_ZOOM_DEBUG env var set to ${level} - t

l+2;
  no warnings 'redefine';
  *import = sub { Smart::Comments->import(@smartness) };
  my $j = JSON->new->space_after;
  my $d = \&Data::Dumper::Concise::Dumper;
  *Smart::Comments::Dumper = sub {

Support scope
                      refresh_token =>  $ctx->session->{token} );
        $ctx->res->body( JSON::XS->new->pretty(1)->encode( \%data ) );
        $ctx->detach();
    }

};

=pod
=cut

1;

package Net::Plurk;
use feature ':5.10';
use Moose;
use URI;
use JSON::Any;
use AnyEvent::HTTP;
use Net::Plurk::UserProfile;
use Net::Plurk::OAuth;
use DateTime;
use Data::Dumper;

use namespace::auto

{
            my $plurk = shift;
            # blah
        },
        );
    $p->listen;
    my $json = $p->callAPI( '/api');
    ...

=head1 EXPORT

A list of functions that can be exported.  You ca

file {
    my ($self, $user) = @_;
    my $json_data = $self->callAPI(
        '/Profile/getPublicProfile',
        user_id => $user,
    );
    return $json_data if $self->raw_output;
    $self->publ

' => (is => 'ro', isa => 'Maybe[Object]', default => 'JSON::false');
has 'email_confirmed' => (is => 'ro', isa => 'Maybe[Object]', default => 'JSON::false');

sub _build_display_name {
    my $self = 

;
has _request => (isa => 'Net::OAuth::Request', is => 'rw');
has json_parser => (isa => 'JSON::Any', is => 'ro', default => sub {JSON::Any->new()});

=head1 NAME

Net::Plurk::OAuth 

=head1 SYNOPSIS

er->{Reason});
		$self->_errorcode($header->{Status});
	    }
            $data = $self->json_parser->from_json($data);
            $w->send;
        }
    );
    $w->recv;
    return wantarray ? ($da

:Filters> - Common methods for filtering HTTP request parameters.

L<Apache2::WebApp::Plugin::JSON> - JSON module wrapper.

L<Apache2::WebApp::Plugin::Mail> - Methods for sending template based multi-

f ArrayRef ClassName Object Str /;
use MooseX::Types::Common::String qw/ NonEmptySimpleStr /;
use JSON::XS ();
use CatalystX::OAuth2::Provider::Error;
use namespace::autoclean;

BEGIN { extends 'Catal

rant_type',
                   error_description => 'Invalid grant type');
      $ctx->res->body( JSON::XS->new->pretty(1)->encode( \%data ) );
}

sub handle_grant_type : Private {
    my ( $self, $ct

);
	
	# JSON and local library installation
	$self->install_modules( qw{
		common::sense
		JSON::XS
		JSON
		local::lib
	} );	

	# Now that we have JSON::XS, use it as Parse::CPAN::Meta's JSON backend

.
	$self->add_env('PERL_JSON_BACKEND', 'JSON::XS');
	
	# Graphics module installation.
	$self->install_module( name => 'Imager' );
	$self->install_module( name => 'GD' );
	
	return 1;
}

sub install_s

:NonMoose 0.20;
use CouchDB::Client 0.09 qw ();
use Catalyst::Exception;
use Catalyst::Utils;
use JSON 2.17 qw ();
use Try::Tiny 0.09;


use namespace::autoclean;
extends 'Catalyst::Authentication::Us

for_session {
    my ($self) = @_;

    my $data = $self->_user->contentForSubmit();
    # Return JSON here, because it's fast, it's human readable so we can
    # see what's going on in the session. 

 is mangling it.
    return JSON::encode_json($data);
}

sub from_session {
    my ($self, $frozen_user) = @_;

    $self->_user($self->_user_doc_from_hash(JSON::decode_json($frozen_user)));
    retur

ks for distributing any kind of release distributions and for
providing a lightweight static file JSON REST API.

This module provides a simple PGXN web site. All it needs is a
L<PGXN::API>-powered AP

n Timestamp JSONMap
     JSONBoolean Retvals List Dimension ReferenceType
  NotificationFormat )
];
use MooseX::Types::Moose qw(Int Str ArrayRef HashRef Any);
use DateTimeX::Easy;
use JSON::Any;

subt

'must be a valid date' };

subtype JSONMap,
  as Str,
  where { eval { ref( JSON::Any->new(utf8 => 1)->from_json($_) ) eq 'HASH'} },
  message { 'must be a valid JSON map of key/value pairs' };

subty

{ 'Must be "source", "category", or "location"'};

subtype JSONBoolean,
  as Str,
  where {/^true|false$/ },
  message { 'Must contain a json boolean: "true" or "false"' };

subtype NotificationFormat