CPAN::Groonga

   indexpageids => 1,
                    generator => $generator,
                    format => "json"
                };
                if(defined $namespace_key){
                    $a->{ $namesp

  my $a = {
                            action => "query",
                            format => "json",
                            pageids => $pageid,
                            prop => "revisions"

y, and cannot be overwritten:

action = "query"
indexpageids = 1
generator = <generate>
format = "json"

Additional parameters can be set in the constructor argument 'args'.
Arguments for a generator 

 time details needed for L</"load">).

User is supposed to serialize returned value (for ex. into JSON format),
save it into file/database, and use later with L</"load"> if she wanna
keep information 

*Net::SAMLc::zxid_find_ses;
*ses_to_ldif = *Net::SAMLc::zxid_ses_to_ldif;
*ses_to_json = *Net::SAMLc::zxid_ses_to_json;
*ses_to_qs = *Net::SAMLc::zxid_ses_to_qs;
*ses_to_pool = *Net::SAMLc::zxid_ses_t

~ /(?:<|!=|==)/}sub encode_json {my($self,$data)=@_;require JSON::PP;my$json=JSON::PP::encode_json($data);$json =~ s/([^a-zA-Z0-9_\-.])/uc sprintf("%%%02x",ord($1))/eg;$json}sub version_to_query {my($

atch->{hits}{hits}};$hits[0]->{fields}}sub search_metacpan {my($self,$module,$version)=@_;require JSON::PP;$self->chat("Searching $module ($version) on metacpan ...\n");my$metacpan_uri='http://api.met

ified",query=>{constant_score=>{filter=>{and=>[{term=>{'module.authorized'=>JSON::PP::true()}},{term=>{'module.indexed'=>JSON::PP::true()}},{term=>{'module.name'=>$module }},$self->version_to_query($m

:Target::VERSION = '0.904';
use Moo;
use IO::All;
use IPC::Open3 ();
use Installer::Software;
use JSON_File;
use File::chdir;
use CPAN::Perl::Releases qw[perl_tarballs];
use Installer::cpanm;
use CPAN

o',
  lazy => 1,
  default => sub {
    my ( $self ) = @_;
    tie(my %meta,'JSON_File',file($self->installer_dir,'meta.json')->absolute->stringify, pretty => 1);
    return \%meta;
  },
);

sub insta

onst char* zx_json_extract_raw(const char* hay, const char* key, int* len);
ZXID_DECL char* zx_json_extract_dup(struct zx_ctx* c, const char* hay, const char* key);
ZXID_DECL int zx_json_extract_int(c

#ifndef SRL_COMMON_H_
#define SRL_COMMON_H_

#include "srl_inline.h"

/* inspired by JSON::XS code */
#if __GNUC__ >= 3
# define expect(expr,value) __builtin_expect((expr), (value))
#else
# define exp

ete, wip perl client to the Saucelabs REST API
use Net::HTTP::Knork;
use Carp qw/croak/;
use JSON qw/to_json/;
use Moo;
use namespace::clean;


has user => (
    is => 'ro',
    default => sub {
     

    path => '/info/status',
};

my $spec = {
    name => 'Saucelabs REST API',
    formats => [ 'json' ],
    version => '0.1',
    methods => $methods
};

has _base_url => (
    is => 'ro',
    init

er => sub {
      my ($self) = @_;

      my $knork = Net::HTTP::Knork->new(
          spec => to_json($self->_spec),
          client => $self->_ua,
          default_params => {
              user =

xid_find_ses);
ZEND_NAMED_FUNCTION(_wrap_zxid_ses_to_ldif);
ZEND_NAMED_FUNCTION(_wrap_zxid_ses_to_json);
ZEND_NAMED_FUNCTION(_wrap_zxid_ses_to_qs);
ZEND_NAMED_FUNCTION(_wrap_zxid_ses_to_pool);
ZEND_NA

package Graphite::Enumerator;

use 5.14.1;
use Carp qw/croak/;
use LWP::UserAgent;
use JSON;
use Scalar::Util 'reftype';

our $VERSION = '0.03';

# Recognized constructor options:
# - host (base URL)

   my $completer_answer = eval { decode_json($res->content) };
        if (!$completer_answer) {
            $self->log_warning("URL <$url>: Couldn't decode JSON string: <" . $res->content . ">: $@");

 C<belongs_to()> and maybe C<has_one()>.

=cut

use Mojo::Base -base;
use Mojo::IOLoop;
use Mojo::JSON ();
use Mojo::Loader 'load_class';
use Scalar::Util 'weaken';
use constant DEBUG => $ENV{MAD_DEBU

 ($self, $cb) = @_;
  my @sql = $self->_delete_sql;

  warn "[Mad::Mapper::delete] ", Mojo::JSON::encode_json(\@sql), "\n" if DEBUG;

  if ($cb) {
    weaken $self;
    $self->db->query(
      @sql,
 

per::has_many::$method] %s\n",
        (!$fresh and $self->{cache}{$ck}) ? 'CACHED' : Mojo::JSON::encode_json(\@sql)
        if DEBUG;

      if ($cb) {
        if ($fresh or !$self->{cache}{$ck}) {
 

xt::Xslate>

=head3 L<Yeb::Plugin::JSON> 0.101

JSON responses using L<JSON::MaybeXS>

=head3 L<Yeb::Plugin::GeoJSON> 0.003

Generating GeoJSON output via L<Geo::JSON::Simple> functions

=head1 AUTHOR

plugins(
        ['Git::GatherDir', { exclude_filename => [
                                'META.json',
                                'LICENSE',
                                'README.md',
       

},
        ],
        ['CopyFilesFromBuild', { copy => [
                                   'META.json',
                                   'LICENSE',
                                   $self->build_f

               'dist.ini',
                           'Changes',
                           'META.json',
                           'README.md',
                           'README',
                  

chmatics;
$WebService::Speechmatics::VERSION = '0.02';
use 5.010;
use Moo 1.006;
use JSON           qw/ decode_json /;
use Carp           qw/ croak       /;
use File::Basename qw/ basename    /;
use S

$self = shift;
    my $response = $self->$get('/user/'.$self->user_id);
    my $userdata = decode_json($response->content);

    return WebService::Speechmatics::User->new($userdata->{user});
}

sub b

shift;
    my $response = $self->$get('/user/'.$self->user_id.'/jobs');
    my $jobsdata = decode_json($response->content);

    return map { WebService::Speechmatics::Job->new($_) }
               @{

een written to in the $interval (by default last day).

use 5.14.1;
use Graphite::Enumerator;
use JSON;
use Getopt::Long;

my $interval = '1day';
my $basepath = '';
GetOptions(
    "interval=s" => \$i

t=json&from=-$interval&target=summarize($path,%22$interval%22,%22max%22,true)";
    my $res = $gren->ua->get($last_hour_data_url);
    if ($res->is_success) {
        my $last_hour_data = decode_json(

se64;
use File::Path qw/make_path/;
use LWP::UserAgent;
use HTTP::Request;
use HTTP::Headers;
use JSON::MaybeXS;
use YAML;
use URI::Encode qw/uri_encode/;
use Encode;

our $VERSION = 0.023;

=head1 NA

h = HTTP::Headers->new();
    $h->header( 'Content-Type'	=> "application/json" );
    $h->header( 'Accept'	=> "application/json" );
    $h->header( 'Authorization' => "Basic " . $self->_zendesk_creden

e        => { isa    => 'Int', optional => 1 },
    );
    my $path = '/incremental/ticket_events.json';
    my @results = $self->_paged_get_request_from_api(
        field   => '???', # <--- TODO
   

ions

=head1 VERSION

version 0.104

=head1 SYNOPSIS

  package MyApp::Web;
  use Yeb qw( Session JSON );

  r "/" => sub {
    session test => pa('test');
    text "root";
  };

  r "/blub" => sub {

n '+SomeOther::YebApp';
  };

  1;

  package MyApp::Web::Test;
  use MyApp::Web;

  r "/json" => sub {
    json {
      test => session('test'),
      stash_var => st('stash_var'),
    }
  };

  r "/

ds L<plackup>

Bigger L<Text::Xslate> example:

  package MyApp::WebXslate;

  use Yeb Session => JSON => 'Xslate';

  # because of the root() usage we need to use plugin function call
  plugin Static

arch ) = @_;

    my $s_key;
    if ( $or_self->{cache} ) {
        require JSON::XS;
        $s_key = JSON::XS::encode_json($hr_search);
        if ( my $ar_search_data = $or_self->{cache}->get("sear

arch ) = @_;

    my $s_key;
    if ( $or_self->{cache} ) {
        require JSON::XS;
        $s_key = JSON::XS::encode_json($hr_search);
        if ( my $hr_search_data = $or_self->{cache}->get( "sea

ed_selects{$or_self} = {};

    # deep copy hash
    require JSON::XS;
    $hr_search = JSON::XS::decode_json(
        JSON::XS::encode_json( $hr_search )
    );

    my (
        $s_limit,
        $s

ed_selects{$or_self} = {};

    # deep copy hash
    require JSON::XS;
    $hr_search = JSON::XS::decode_json(
        JSON::XS::encode_json( $hr_search )
    );

    my (
        $s_limit,
        $s