CPAN::Groonga

ta_candidates  = map File::Spec->catfile($abs_extract_path, $_),
                         qw<META.json META.yml>;
 my $meta_file;
 for my $file (@meta_candidates) {
  if ($files->{$file}) {
   $meta_f

rialized
document.

=item L<Sereal::Path> - a query language for Sereal. It's similar to XPath or
JSONPath.

=back

The result of this documentation describes Sereal::Path module. For others
please us

('$[*][foo]');

=head2 Description

Sereal::Path for Sereal is the same as XPath for XML or JSONPath for JSON.
Sereal::Path can directly work with encoded Sereal document. In other words,
there is no 

ax from JSONPath. Its documentation can be
found at L<http://goessner.net/articles/JsonPath/>.

However, Sereal::Path supports a subset of JSONPath. Below is the comparasion
between XPath, JSONPath an

$jsonxs, $msgpack, $dd_noindent, $dd_indent, $cbor
);
my $storable_tag= "strbl";
my $sereal_tag= "srl";
my %meta = (
    jxs => {
        enc  => '$::jsonxs->encode($data);',
        dec  => '$::jsonx

);',
        name => 'JSON::XS OO',
        init => sub {
            $jsonxs = JSON::XS->new()->allow_nonref();
        },
        use => 'use JSON::XS qw(decode_json encode_json);',
    },
    ddl =

. $x;
                },
            }
        );
    }

    my %names = (
        "JSON::XS"                => 'json xs',
        "Data::Dumper::Limited"   => 'ddl',
        "Data::MessagePack"      

tachment::VERSION = '0.991006';use v5.24;
use utf8;
use Moo;

with 'Yukki::Web::Controller';

use JSON;
use Yukki::Error qw( http_throw );

use namespace::clean;

# ABSTRACT: Controller for uploading,

$upload->filename,
    });

    $ctx->response->content_type('application/json');
    $ctx->response->body(
        encode_json({
            viewable        => 1,
            repository_path => join(

        "Content-Type" => "application/json",
        "X-Requested-With" => "YAHC",
    ]

Will produce these request headers:

    Content-Type: application/json
    X-Requested-With: YAHC

=head3 ho

#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

ently

=cut

use Params::Validate qw(:all);
use LWP::UserAgent;
use Encode;
use MIME::Base64;
use JSON::XS;
use File::Slurp;

use Pootle::Logger;
my $l = bless({}, 'Pootle::Logger'); #Lazy load packag

nd error handling

 @RETURNS List of 0 - HTTP::Response
                  1 - HASHRef of response JSON payload
 @THROWS Pootle::Exception::HTTP::MethodNotAllowed endpoint doesn't support the given met

ponse, $contentHash)) if $l->is_trace();
  } catch {
    if ($_ =~ /^malformed JSON string/) { #Presumably this is a JSON::XS issue
      my $errorStr = $s->_httpResponseToLoggableFromFail($response);

#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

 $file_text.=$row }
    if ( $file_text =~ /^\s*\{/s ){
        require_module('JSON');
        return JSON::decode_json( $file_text )
    } elsif ( $file_text =~ /^\s*\-/s ){
        require_module('

oseX::ConfigCascade::Util->path(      # set the path to the config file

        '/path/to/config.json' 

    );  


    MooseX::ConfigCascade::Util->conf(      # set the config hash directly

       

ntation for L<MooseX::ConfigCascade>.

    MooseX::ConfigCascade::Util->path( '/path/to/my_config.json' );

When L<path> is changed it reads the specified file and overwrites L<conf> with the new valu

#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

', '#'],
    ['number', '=' ],
    ['object', '{'],
    ['list', '[' ],
    ['data', 'c' ],
    ['json', 'D' ],
    ['special', '^' ],
    ['boolean', '?' ],
    ['null', '~' ],
    #this is a pseudo-

/**
 * JSON Simple/Stacked/Stateful Lexer.
 * - Does not buffer data
 * - Maintains state
 * - Callback oriented
 * - Lightweight and fast. One source file and one header file
 *
 * Copyright (C) 2012

-2015 Mark Nunberg
 * See included LICENSE file for license details.
 */

#ifndef JSONSL_H_
#define JSONSL_H_

#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <

s */

#ifdef JSONSL_USE_WCHAR
typedef jsonsl_char_t wchar_t;
typedef jsonsl_uchar_t unsigned wchar_t;
#else
typedef char jsonsl_char_t;
typedef unsigned char jsonsl_uchar_t;
#endif /* JSONSL_USE_WCHAR

s' JSON::XS, particularly because it's fast,
 * doesn't seem to rely on any external structures, and because
 * numeric conversions aren't my ideas of fun.
 */

#ifndef JSONXS_INLINE_H_
#define JSONXS

_INLINE_H_

#include "perl-jsonsl.h"
#if __GNUC__ >= 3
# define expect(expr,value)         __builtin_expect ((expr), (value))
# define INLINE                     static inline
#else
# define expect(ex

fine expect_true(expr)  expect ((expr) != 0, 1)

#define jsonxs__atof_scan1(s,a,e,p,m) jsonxs__atof_scan1_THX(aTHX_ s,a,e,p,m)
INLINE void
jsonxs__atof_scan1_THX(pTHX_ const char *s,
                 

mon 'options' field:

my @options = (
    ["PLTUBA", "JSON::SL::Tuba", [qw(utf8 no_cache_mro cb_unified allow_unhandled)]],
    ["PLJSONSL", "JSON::SL", [qw(utf8 nopath noqstr max_size object_drip)]]

ters
EOC

foreach (@options) {
    my ($ctype,$pkgname,$opts) = @$_;
    print <<"EOC";

MODULE = JSON::SL PACKAGE = $pkgname PREFIX = $ctype\_

PROTOTYPES: DISABLED

EOC

    my $ix_counter = 1;
    

#ifndef PERL_JSONSL_H_
#define PERL_JSONSL_H_
#define PERL_NO_GET_CONTEXT

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "ppport.h"
#include <limits.h>
/**
 * Default depth limit to

e PLJSONSL_MAX_DEFAULT 512

/**
 * Key names for the information returned by
 * JSONpointer results
 */
#define PLJSONSL_INFO_KEY_PATH "Path"
#define PLJSONSL_INFO_KEY_VALUE "Value"
#define PLJSONSL_I

EY_QUERY "JSONPointer"

/**
 * Names of various perl globs
 */
#define PLJSONSL_CLASS_NAME "JSON::SL"
#define PLJSONSL_BOOLEAN_NAME "JSON::SL::Boolean"
#define PLJSONSL_PLACEHOLDER_NAME "JSON::SL::Pla

e;

use JSON;
use XML::Struct qw(readXML);

has items => (is => 'ro', required => 1);
has lang  => (is => 'ro', default => 'nl-NL');

sub json {
    my ($self) = @_;
    my $tree = decode_json($self->

ha;

use strict;
use 5.008_005;
our $VERSION = '0.02';

use Carp 'croak';
use LWP::UserAgent;
use JSON;
use Try::Tiny;

use vars qw/$errstr/;
sub errstr { $errstr }

sub new {
    my $class = shift;
 

n";
    $args{ua} ||= LWP::UserAgent->new;
    $args{ua}->default_header('Accept' => 'application/json');
    $args{url} ||= 'http://api.dbcapi.me/api/captcha';
    $args{sleep} ||= 3;

    return ble

urn $self->request(
        __method => 'POST',
        type => 4,
        token_params => encode_json(\%params)
    );
}

sub get {
    my ($self, $id) = @_;

    return $self->request(
        url =

#include "perl-jsonsl.h"
#include "jsonxs_inline.h"

/*
 * JSON::SL, JSON::SL::Boolean
 */
#define MY_CXT_KEY "JSON::SL::_guts" XS_VERSION

typedef struct {
    PLJSONSL* quick;
    HV *stash_obj;
   

static int PLJSONSL_Escape_Table_dfl[0x80];
#define ESCTBL PLJSONSL_Escape_Table_dfl

#define PLJSONSL_CROAK_USAGE(m) \
    die("JSON::SL: %s %s", GvNAME(CvGV(cv)), m)


#ifdef PLJSONSL_HAVE_HV_COMM

e delete_he(pjsn,hv,he) delete_he_THX(aTHX_ pjsn, hv, he)
static void
delete_he_THX(pTHX_ const PLJSONSL *dummy, HV* hv, HE* he)
{
    char *kbuf;
    STRLEN klen;
    int is_utf8;

    kbuf = HePV(he

   GV* on_key;
    GV* on_number;
    GV* on_object;
    GV* on_list;
    GV* on_data;
    GV* on_json;
    GV* on_special;
    GV* on_boolean;
    GV* on_null;
    GV* on_any;
    GV* start_string;
 

    GV* start_number;
    GV* start_object;
    GV* start_list;
    GV* start_data;
    GV* start_json;
    GV* start_special;
    GV* start_boolean;
    GV* start_null;
    GV* start_any;
    GV* end

 end_key;
    GV* end_number;
    GV* end_object;
    GV* end_list;
    GV* end_data;
    GV* end_json;
    GV* end_special;
    GV* end_boolean;
    GV* end_null;
    GV* end_any;
} methgv;

#endif /

util/accessors.pl' and is meant to generate easy boolean
# getters and setters

MODULE = JSON::SL PACKAGE = JSON::SL::Tuba PREFIX = PLTUBA_

PROTOTYPES: DISABLED

#define PLTUBA_OPTION_IX_utf8 1
#defi

LE = JSON::SL PACKAGE = JSON::SL PREFIX = PLJSONSL_

PROTOTYPES: DISABLED

#define PLJSONSL_OPTION_IX_utf8 1
#define PLJSONSL_OPTION_IX_nopath 2
#define PLJSONSL_OPTION_IX_noqstr 3
#define PLJSONSL_OP

max_size 4
#define PLJSONSL_OPTION_IX_object_drip 5

int
PLJSONSL__options(PLJSONSL* obj, ...)
    ALIAS:
    utf8            = PLJSONSL_OPTION_IX_utf8
    nopath          = PLJSONSL_OPTION_IX_nopath