CPAN::Groonga

Blikistan::MagicEngine::TT2';
use base 'Blikistan::MagicEngine::YamlConfig';
use URI::Escape;
use JSON;

=head1 NAME

Blikistan::MagicEngine::PerlSite

=head1 SYNOPSIS

use Blikistan;
my $b = Blikista

    # Need to get the metadata here
    $r->accept('application/json');
    my $return = _get_page($r, $page);
    my $page_obj = jsonToObj($return);
    my $page_name = $page_obj->{name};
    my $pa

use warnings;
use base 'Blikistan::MagicEngine';
use Template;
use FindBin;
use URI::Escape;
use JSON;

sub render_template {
    my $self = shift;
    my $params = $self->{params} = shift || {};
   

pace_tags} ||= sub {
        my $skip = shift || '';
        $r->accept('application/json');
        my $tags = jsonToObj($r->get_workspace_tags);
        $tags = [ 
            sort { $b->{page_count

};

    my $r    = $self->{rester};
    $r->accept('application/json');
    $r->json_verbose(1);
    my $p = $self->{_page}{$page} = jsonToObj( $r->get_page($page) );
    while ($p->{html} =~ s/<a hre

;
use JSON;

sub print_blog {
    my $self = shift;
    my $r = $self->{rester};
    
    my $params = $self->load_config($r);
    my $json = objToJson($params);
    $json =~ s/'/\\'/g;
    $json =~ s

#<script .+script>##;

    return $self->render_template( { json_data => $json } );
}

1;

 use Carp;
    our $HAVE_JSON_SYCK;
    eval { require JSON::Syck; $HAVE_JSON_SYCK = 1 };
    eval { require JSON } unless $HAVE_JSON_SYCK;
    Carp::croak("JSON::Syck or JSON required to use " . __PA

CKAGE__) if $@;
    *_parse_json =
        $HAVE_JSON_SYCK  ? sub { JSON::Syck::Load($_[1]) }
                         : sub { JSON::jsonToObj($_[1])  };
}

__PACKAGE__->mk_accessors(qw(api_key secret

sub _get_auth_as_json {
    my $self = shift;
    my $cert = shift or croak "You must specify your cert as an argument.";
    my $uri = URI->new('http://auth.hatena.ne.jp/api/auth.json');
    my $requ

lugin::Location;

use strict;
use warnings;

use base qw(MozRepl::Plugin::Base);
use JSON::Any qw(XS DWIW Syck JSON);

=head1 NAME

MozRepl::Plugin::Location - Dump window.location object as possible.

$self->process('execute', $params);
    my $result = $ctx->execute($command);

    return JSON::Any->new->jsonToObj($result);
}

=head1 AUTHOR

Toru Yamaguchi, C<< <zigorou@cpan.org> >>

=head1 BUGS

epl::Plugin::Location

__DATA__
__execute__
(function(all) {

  function getLocationAsJSON(tWindow) {
    var json = {};

    for (var p in tWindow.location) {
      var type;

      try {
        typ

r;

use strict;
use warnings;

use base qw(MozRepl::Plugin::Base);

use Carp::Clan qw(croak);
use JSON;

=head1 NAME

MozRepl::Plugin::LinkExtor - Extract "a" and "link" elements.

=head1 VERSION

ver

Data::Dump qw(dump);

    my $repl = MozRepl->new;
    $repl->setup({ plugins => { plugins => [qw/JSON OpenNewTab LinkExtor/] } });

    $repl->open_new_tab({ url => "http://search.cpan.org/", selecte

cute {
    my ($self, $ctx, $args) = @_;

    croak("Please include MozRepl::Plugin::JSON") unless ($ctx->can("json"));

    my $params = {};

    $params->{repl} = $ctx->repl;
    $params->{all} = ($

1 = $fb->{uid})");

  ## Get results in manageable form:
  use JSON::Syck; # or whatever...
  $fb->format = 'JSON';
  my $arrayref = JSON::Syck::Load $fb->query("...");

=head1 DESCRIPTION

WWW::Faceb

le with SQL, this may be a
more comfortable interface.  Results are currently returned in the raw
JSON or XML format, but more palatable options may be available in the
future.

=cut

use URI::Escape;

{secret} = $self->{private};
    my $resp = $self->_request_nofail('auth.createToken', format => 'JSON');
    $self->{auth_token} = eval $resp->decoded_content;
}

sub _get_session
{
    my $self = sh

e CPAN::WWW::Testers;
use DateTime;
use DBI;
use File::Copy;
use File::stat;
use File::Slurp;
use JSON::Syck;
use LWP::Simple;
use Parse::BACKPAN::Packages;
use Path::Class;
use Template;
use Storable

ile( $directory, 'show', $distribution . ".json" );
        print "Writing $destfile\n";
        overwrite_file( $destfile->stringify,
            _make_json_distribution( $distribution, \@reports ) )

-' . $entry->{version};
        push @yaml, $entry;
    }
    return Dump( \@yaml );
}

sub _make_json_distribution {
    my ( $dist, $data ) = @_;

    my @data;

    foreach my $test (@$data) {
    

Authentication::Credential::AOL;

use strict;
our $VERSION = '0.02';

use UNIVERSAL::require;
use JSON::Any;

sub setup {
    my $c = shift;
    my $config = $c->config->{authentication}->{aol} ||= {}

getInfo");
        $uri->query_form(
            devId => $config->{devId},
            f     => 'json',
            # referer needs to be an actual Referer: header, but since
            # we do redi

ailure: HTTP error " . $res->status_line);
            return;
        }

        my $data = JSON::Any->jsonToObj($res->content);
        unless (($data->{response}->{statusCode} || '') eq '200') {
  

ntent types provided by the base class are:

[]	?format=xml	or	Accept: application/xml
[]	?format=json	or	Accept: text/javascript
[]	?format=html	or	Accept: text/html

HTML will be returned if the req

use XML::Dumper; 		import XML::Dumper; ";		## Conditional Output format: XML
eval "use JSON;        		import JSON; ";			## Conditional Output format: JavaScript Object Notation

our( $VERSION )	= '0.5

if  (-f $INC{"JSON.pm"})
    {
	$this->{mimetype_mapping}->{json} = "text/javascript";		## Support: ?format=json
	$this->format( "text/javascript",
		       \&REST::Resource::format_json,
		       "Re

 use Carp;
    our $HAVE_JSON_SYCK;
    eval { require JSON::Syck; $HAVE_JSON_SYCK = 1 };
    eval { require JSON } unless $HAVE_JSON_SYCK;
    Carp::croak("JSON::Syck or JSON required to use " . __PA

CKAGE__) if $@;
    *_parse_json =
        $HAVE_JSON_SYCK  ? sub { JSON::Syck::Load($_[1]) }
                         : sub { JSON::jsonToObj($_[1])  };
}

sub new {
    my $class = shift;
    my %p 

    my %query = (
        app_key => $self->app_key,
        v => $self->ver,
        format => 'json',
        token => $user->token,
        t => time,
    );
    $query{sig} = $self->calc_sig(\%qu

se strict;
use warnings;
use v5.8.8;

use Moose;
use LWP::UserAgent;
use HTTP::Request;
use JSON::Syck;
$JSON::Syck::ImplicitUnicode = 1;

our $VERSION = '0.0.1';

has url_root => ( is => 'rw', isa =>

lf);
    my $id = shift;
    return _get("@{[$self->url_root]}/=/model/@{[$self->model]}/id/${id}.json");
}

sub update {
    my $self = shift;
    $self = $self->new unless ref($self);
    my $id = s

 %$attributes };

    _ua()->post(
        "@{[$self->url_root]}/=/action/update@{[$self->model]}.json",
        $orig
    );

    return {};
}

sub create {
    my $self = shift;
    my $attributes =

structures.

There are modules or encodings that do support arbitrarily complex
data structures.  JSON, YAML and Data::Dumper all have their own
way of encoding complex structures.  But then to pass t

ty of XForms.

Another benefit is that sparse data can be represented in a more
compact form than JSON or YAML are able to provide.  However, complex data
with long key names will be more verbose as t

e strict;
use warnings;
our $VERSION = '0.01';

use HTTP::Request::Common;
use HTTP::Date ();
use JSON::Any;
use POE qw( Component::Client::HTTP );
use URI;

sub spawn {
    my($class, %args) = @_;

 

0,OBJECT];

    my $req = HTTP::Request::Common::POST(
        $heap->{args}->{apiurl} . '/update.json',
        [ status => $status ],
    );
    $req->authorization_basic($heap->{args}->{username}, 

@_[KERNEL,HEAP,ARG0,OBJECT];

    my $uri = URI->new($heap->{args}->{apiurl} . '/friends_timeline.json');
    $uri->query_form(since => HTTP::Date::time2str($heap->{since})) if $heap->{since};
    $he

ccessor::Fast);

use Carp;
use CGI;
use URI;
use LWP::UserAgent;
use Digest::MD5 qw(md5_hex);
use JSON;

our $VERSION = '0.50';

__PACKAGE__->mk_accessors(qw/
    appid secret userhash appdata timeout

my $WSLOGIN_PREFIX = 'https://api.login.yahoo.com/WSLogin/V1/';
my $JSON_RPC_ENDPOINT = 'http://mail.yahooapis.com/ws/mail/v1.1/jsonrpc';

sub new {
    my ($class, %param) = @_;
    croak('appid and 

e_jsonrpc_call {
    my ($self, $method, $params) = @_;
    if (!$self->_get_access_credentials) {
        return 0;
    }

    my $thecall = { params => $params, method =>  $method  };
    my $jsoncl

:Element::Convert;

  my $tree = HTML::TreeBuilder->new_from_content($html);

  # Search for some JSON-encoded meta-data embedded in the document and extract it:
  my $element = $tree->look_down(...);

arkdown} = \&Text::Markdown::markdown unless $@ };
	1 and			do { eval { require JSON };		$PARSE_FUNC{JSON} = \&JSON::jsonToObj unless $@ };
	1 and			do { eval { require YAML::Syck };	$PARSE_FUNC{YAML}

$EXTRACT_FUNC{YAML} = \&_extract_YAML;

sub _extract_JSON { return $PARSE_FUNC{JSON}->(_as_raw_HTML shift) }
$EXTRACT_FUNC{JSON} = \&_extract_JSON;

sub _extract_markdown { return HTML::TreeBuilder->

port, json) {
    this.each(function(responder) {
      if (typeof responder[callback] == 'function') {
        try {
          responder[callback].apply(responder, [request, transport, json]);
 

 {
    var state = Ajax.Request.Events[readyState];
    var transport = this.transport, json = this.evalJSON();

    if (state == 'Complete') {
      try {
        this._complete = true;
      

'on' + (this.success() ? 'Success' : 'Failure')]
         || Prototype.emptyFunction)(transport, json);
      } catch (e) {
        this.dispatchException(e);
      }

      if ((this.getHeader(

ache2::RequestIO ();
use Apache2::Response ();
use Apache2::Const -compile=>qw(:common);

sub json_popup {
    my $r = shift;
    $r->content_type("text/html");
    $r->set_etag();
    return 

ache2::RequestIO ();
use Apache2::Response ();
use Apache2::Const -compile=>qw(:common);

sub json_css {
    my $r = shift;
    $r->content_type("text/css");
    $r->set_etag();
    return Apa

ript objects to help quickly create
a customized GUI interface for Apache::UploadMeter using the JSON meter type

=head1 DOM, JavaScript and Cascading StyleSheet rules

Although we aim to give ma

you're using
MeterType JSON, this will be embedded in your JavaScript as I<meter_id>.  The
third parameter is the URL of the meter-status URL.  If you're using
MeterType JSON, this will be embedded