CPAN::Groonga

:LogicBoxes::Contact::Factory->construct_from_response( $response );

Given a HashRef that is the JSON response from LogicBoxes when retrieving contact details, returns an instance of L<WWW::LogicBoxe

}

sub json_json2 {
    <<'...';
[% INCLUDE "js/json-json2.js" %]
...
}

sub json_json2_internal {
    <<'...';
;(function(){

var JSON;

[% INCLUDE "js/json2.js" %]

[% INCLUDE "js/json-json2-intern

al.js" %]

}());
...
}

sub json_yui {
    <<'...';
[% INCLUDE "js/json-yui.js" %]
...
}

sub json2 {
    <<'...';
[% INCLUDE "js/json2.js" %]
...
}

sub xhr_gregory {
    <<'...';
[% INCLUDE "js/xhr-

 METHODS

head2 kernel

head2 ajax_jquery

head2 ajax_xhr

head2 ajax_yui

head2 json_json2

head2 json_yui

head2 json2

head2 xhr_gregory

head2 xhr_ilinsky

head2 xxx

=head1 COPYRIGHT

Copyright (

urp;
    if ($mode eq 'perl') {
        require JSON;
        my $json = JSON->new(); #pretty => 1, delimiter => 1);
        $context = $json->objToJson(eval $content );
    } else {
        #assume i

with "WWW::LogicBoxes::Role::Commands";

# Supported Response Types:
my @response_types = qw(xml json xml_simple);
subtype "LogicBoxesResponseType"
	=> as "Str",
	=> where {
		my $type = $ARG;
		{ $t

s' API will be in.  The default is XML, all supported protocols are:

=over

=item * xml

=item * json

=item * xml_simple

=back

=head2 Suggest Domains (and many others)

	my $response = $logic_boxe

he sample URI for this request would then be:

https://test.httpapi.com/api/domains/suggest-names.json?auth-userid=0&auth-password=password&keyword=domain&tlds=com&tlds=net&no-of-results=0&hyphen-allo

-json=json2
    --runtime=standard

    --runtime=lite      Same as --ajax=none --json=none
    --runtime=jquery    Same as --ajax=jquery --json=none
    --runtime=yui       Same as --ajax=yui --json=

ajax=gregory --json=json2

    --json              By itself, equivalent to --json=json2
    --json=json2        Include http://www.json.org/json2.js for parsing/stringifying
    --json=yui          U

se YUI: YAHOO.lang.JSON (requires external YUI)
    --json=none         Doesn't provide any JSON functionality except a warning
    
    --ajax              By itself, equivalent to --ajax=xhr
    --a

File::ShareDir;
use JSON;
use FindBin qw/$Bin/;

Net::AMQP::Protocol->load_xml_spec(File::ShareDir::dist_dir("AnyEvent-RabbitMQ") . '/fixed_amqp0-8.xml');

my $data = JSON::to_json(\%Net::AMQP::Protoc

21 C31 C32 )];
enum NexusPurpose,       [qw( P1 P2 P3 P4 P5 )];
enum ResponseType,       [qw( xml json xml_simple )];
enum VerificationStatus, [qw( Verified Pending Suspended NA )];

class_type Contac

est suite to blow up if you require a module not listed as a
requirement in C<META.yml> or C<META.json>.

    perl Build.PL
    HARNESS_PERL_SWITCHES=-MModule::Mask::Deps ./Build test

Or use directly

rse::CPAN::Meta;

# Need to load these early in case we mask them later
use CPAN::Meta::YAML;
use JSON::PP;

use File::Spec::Functions qw(
    file_name_is_absolute
    updir
    splitdir
    abs2rel

et_deps

    @deps = $class->get_deps()

Returns current dependencies as defined in either C<META.json> or C<META.yml>,
checked in that order.  This is used internally by import and new, so there's
no

Temp;
use File::Basename qw(dirname);
use IO::Uncompress::Unzip 2.030 qw($UnzipError);
use JSON qw(decode_json);
use MIME::Base64;
use Scalar::Util qw(blessed looks_like_number);
use XML::Simple;



s

keys %prefs ) {
        my $value       = $prefs{$_};
        my $clean_value = '';

        if ( JSON::is_bool($value) ) {
            $self->set_boolean_preference( $_, $value );
            next;
 

ou can set
multiple preferences at once. If you need to set a boolean preference,
either use JSON::true/JSON::false, or see C<set_boolean_preference()>.

    $profile->set_preference("quoted.integer.p

 for the duration of the session.
    Proxy configuration:              "proxy"                   JSON    Defines the current session’s proxy configuration.

New Stuff:

    Page load strategy:     

Resizing and Positioning Windows.
    Session timeouts configuration:   "timeouts"                JSON    Describes the timeouts imposed on certain session operations.
    Unhandled prompt behavior:  

=head2 Remote Driver Response

Selenium::Remote::Driver uses the L<JsonWireProtocol|http://code.google.com/p/selenium/wiki/JsonWireProtocol> to communicate with the
Selenium Server. If an error oc

rver
sends back an HTTP error code with a JSON encoded reponse that indicates the
precise L<Response Error Code|http://code.google.com/p/selenium/wiki/JsonWireProtocol#Response_Status_Codes>. The mo

  $self->{javascript} = JSON::true;
        }
        else {
            $self->{javascript} = JSON::false;
        }
    }
    else {
        $self->{javascript} = JSON::true;
    }
    
  

he sample URI for this request would then be:

https://test.httpapi.com/api/domains/suggest-names.json?auth-userid=0&auth-password=password&keyword=domain&tlds=com&tlds=net&no-of-results=0&hyphen-allo

check that accept the same I<key> multiple times:

https://test.httpapi.com/api/domains/available.json?auth-userid=0&auth-password=password&domain-name=domain1&domain-name=domain2&tlds=com&tlds=net

T

imes except an incrementing digit is appended:

https://test.httpapi.com/api/contacts/set-details.json?auth-userid=0&auth-password=password&contact-id=0&attr-name1=sponsor1&attr-value1=0&product-key=d

LWP::UserAgent;
use HTTP::Headers;
use HTTP::Request;
use Net::Ping;
use Carp qw(croak);
use JSON;
use Data::Dumper;

use Selenium::Remote::ErrorHandler;

sub new {
    my ($class, $remote_

ub/$url";
    }

    if ((defined $params) && $params ne '') {
        my $json = new JSON;
        $content = $json->allow_nonref->utf8->encode($params);
    }

    # HTTP request
    my $ua

header =
      HTTP::Headers->new(Content_Type => 'application/json; charset=utf-8');
    $header->header('Accept' => 'application/json');
    my $request = HTTP::Request->new($method, $fullurl, $h

 ShipIt::Step::JenkinsCheck;

use strict;
use warnings;

use base qw/ ShipIt::Step /;
use JSON qw/ decode_json /;
use LWP::UserAgent;
use Try::Tiny;
use ShipIt::Util qw/ $term /;

our $VERSION = '0.01

nt->new();
    my $response = $ua->get("$jenkins/api/json");
    die $response->status_line unless $response->is_success;

    my $obj = decode_json($response->decoded_content);

    my %jobs = map { 

package Net::AMQP::PP;
use strict;
use warnings;
use JSON ();

our $VERSION = '0.01';

my $data = JSON::from_json(
q[{"domain":{"delivery tag":{"type":"longlong"},"exchange name":{"type":"shortstr"},"

::Role;
use MooseX::Params::Validate;

use WWW::LogicBoxes::Types qw( HashRef Str );

use JSON qw( decode_json );

use Try::Tiny;
use Carp;

requires 'response_type';
with 'WWW::LogicBoxes::Role::Comm

our $VERSION = '1.11.0'; # VERSION
# ABSTRACT: Submission of LogicBoxes Commands

# Used to force json as the response_type and restore the existing type afterwards
around submit => sub {
    my $orig

e_type;

    my $response;
    try {
        if( $current_response_type ne 'json' ) {
            $self->response_type('json');
        }

        $response = $self->$orig( $args );
    }
    catch {

else if (typeof data == 'string') {
//        Jemplate.Ajax.get(data, function(r) { proc(Jemplate.JSON.parse(r)) });
        var url = data;
        Jemplate.Ajax.processGet(url, function(data) { proc

e.JSON = {

    parse: function(decodeValue) {
        throw("This is a Jemplate.JSON.parse " + stubExplanation);
    },

    stringify: function(encodeValue) {
        throw("This is a Jemplate.JSON.

ry.get(url, null, callback);
    },

    processGet: function(url, processor) {
        jQuery.getJSON(url, null, processor);
    },

    post: function(url, data, callback) {
        jQuery.post(url,

x.get('url/data.json');
    var elem = document.getElementById('some-div');
    elem.innerHTML = Jemplate.process('my-template.html', data);

or:

    var data = Ajax.get('url/data.json');
    var ele

r simply:

    Jemplate.process('my-template.html', 'url/data.json', '#some-div');

or, with jQuery.js:

    jQuery.getJSON("url/data.json", function(data) {
        Jemplate.process('my-template.html

g
the template code. Presto, we have full featured JavaScript
templating language!

Combined with JSON and xmlHttpRequest, Jemplate provides a really simple
and powerful way to do Ajax stuff.

=head1 

ellowBot::API::Response;
{
  $YellowBot::API::Response::VERSION = '0.96';
}
use Moose;
use JSON qw(decode_json);
use namespace::clean -except => 'meta';

has http => (
   is  => 'ro',
   isa => 'HTTP:

ine,
                };
    }
    my $data = decode_json($self->http->content);
    if ($ENV{API_DEBUG} and $ENV{API_DEBUG} > 2) {
        warn "JSON response:\n" . $self->http->content . "\n";
    }

%REQ_CLASS = (
    'post' => 'YellowBot::API::Request',
    'j-post' => 'YellowBot::API::Request::JSON',
);

sub _request {
    my ($self, $method, %args) = @_;

    my $request_class = $REQ_CLASS{$se