CPAN::Groonga

racter> strings.

As of now thrown exceptions are simple character strings
that include, where relevant, a
L<JSON pointer|https://tools.ietf.org/html/rfc6901> to the problematic
data point.

=cut

1;

sv_undef;
    }

    PUTBACK;
    FREETMPS;
    LEAVE;

    return ret;
}

static inline SV* _get_json_pointer_sv (pTHX_ SV** stack, unsigned stack_idx) {
    AV* pointer = newAV();

    for (unsigned

ointer_ar = newRV_noinc( (SV*) pointer );

    return _call_pv_scalar_1_1(aTHX_ "TOML::XS::_BUILD_JSON_POINTER", pointer_ar);
}

toml_table_t* _get_toml_table_from_sv(pTHX_ SV *self_sv) {
    SV *refe

len-1) {

        SV* jsonpointer = _get_json_pointer_sv(aTHX_ stack, stack_idx);

        SV* errsv = newSVpvf("Cannot descend into non-container! (JSON pointer: %" SVf ")", jsonpointer);
        cro

DB;

use 5.010001;
use strict;
use warnings;
use Carp;

use URI;
use JSON; # imports encode_json, decode_json, to_json and from_json.
use IPC::Cmd qw[ run ];

require Exporter;

our @ISA = qw(Exporter

@_;
    unshift @args, '-H', "Key: $this->{v2Key}";
    unshift @args, '-H', 'Accept: application/json';
    unshift @args, '/usr/bin/curl';
    my @result = run( command => \@args, verbose => $this->

_string );  }
    }

    my $json = $this->curlv2('-s', $url);
    if ($this->{Debug})
    {
        print STDERR "JSON:  $json\n";
    }

    my $result = from_json( $json );
    if( $this->{Debug})

.

=back

=head1 NOTE ON CHARACTER DECODING

This library mimics the default behaviour of popular JSON modules:
the TOML input to the parser is expected to be a byte string, while the
strings that the

ointer {
    my ($msg, $path_ar) = @_;

    die sprintf( "%s (JSON pointer: %s)", $msg, _BUILD_JSON_POINTER($path_ar) );
}

sub _BUILD_JSON_POINTER {
    my $pieces_ar = shift;

    my @pieces =  @$pi

; # VERSION

1;
# ABSTRACT: CSVJF (CSV with JSON Fields) file format specification

__END__

=pod

=encoding UTF-8

=head1 NAME

CSVJF - CSVJF (CSV with JSON Fields) file format specification

=head1 

 Healthchecks API
use Mojo::Base -base, -signatures;

use Mojo::UserAgent;
use Mojo::JSON qw(decode_json encode_json);
use Carp qw(carp);
use Data::Dumper;

our $VERSION = "0.02";

has 'url';
has 'api

(defined $args->{data}) {
        $res = $c->ua->$method($url => { 'X-Api-Key' => $c->apikey } => json => $args->{data})->result;
    } else {
        $res = $c->ua->$method($url => { 'X-Api-Key' => $

json when json is too large
        my $json = decode_json($res->body);
        my $data;
        if (defined $args->{key}) {
            $data = (ref($json) eq 'HASH') ? $json->{$args->{key}} : $json

# ABSTRACT: CSVJF (CSV with JSON Fields) file format specification
#PODNAME: CSVJF

__END__

=pod

=encoding UTF-8

=head1 NAME

CSVJF - CSVJF (CSV with JSON Fields) file format specification

=head1

stable in 1.0.

=head1 ABSTRACT

CSVJF (short for "CSV with JSON field") is an extension to the CSV format to
allow fields that contain JSON string, arrays, or hashes (objects).

=head1 NOTATION

The 

 comma-separated list of fields.

A field is either an unquoted string, a JSON-encoded string, a JSON-encoded
array, or a JSON-encoded hash (object).

An unquoted string must not contain the record se

SION

use 5.010001;
use strict;
use warnings;
use Log::ger;

use Data::Clean::FromJSON;
use Data::Clean::JSON;
use JSON::MaybeXS;
use Perinci::AccessUtil qw(insert_riap_stuffs_to_res decode_args_in_ri

eless->new();
    });

my $json       = JSON::MaybeXS->new->allow_nonref->canonical;
my $cleanser   = Data::Clean::JSON->get_cleanser;
my $cleanserfj = Data::Clean::FromJSON->get_cleanser;

$|++;

# d

insert_riap_stuffs_to_res($res, $v);
    $res = $cleanser->clone_and_clean($res);
    print "j", $json->encode($res), "\015\012";
}

sub run {
    my $self = shift;
    my $last;

    log_trace("Start

# VERSION

use 5.010001;
use strict;
use warnings;
use Log::ger;

use Data::Clean::FromJSON;
use Data::Clean::JSON;
use File::HomeDir;
use IO::Handle::Record; # to get peercred() in IO::Socket::UNIX
u

se IO::Select;
use IO::Socket qw(:crlf);
use IO::Socket::INET;
use IO::Socket::UNIX;
use JSON::MaybeXS;
use Perinci::Access;
use Perinci::AccessUtil qw(insert_riap_stuffs_to_res decode_args_in_riap_re

es qw(time);
use URI::Escape;

use Moo;

my $cleanser   = Data::Clean::JSON->get_cleanser;
my $cleanserfj = Data::Clean::FromJSON->get_cleanser;

has name                   => (
    is => 'rw',
    de

e strict;
use warnings;
use IO::Socket::SSL;
use Scalar::Util ();
use Furl;
use JSON::MaybeXS qw( decode_json encode_json );

sub new {
    my ($class, $parent) = @_;
    my $token = \$parent->{token}

n   => ${$self->{parent_token}},
        formato => 'json',
        %$params,
    });

    if ($res->is_success) {
        my $content = decode_json($res->decoded_content);
        return $content->{r

n $self->_post( 'https://api.tiny.com.br/api2/nota.servico.incluir.php', {
        nota => encode_json({ nota_servico => $params }),
    });
}


sub emitir {
    my ($self, $params) = @_;
    if (!ref

eMetaJSON;

our $AUTHORITY = 'cpan:TOBYINK';
our $VERSION   = '0.026';

use Moose::Role;
use namespace::autoclean;

after BUILD => sub {
	my $self = shift;
	unshift @{ $self->targets }, 'MetaJSON';
};

sub Build_MetaJSON
{
	my $self = shift;
	my $file = $self->targetfile('META.json');
	$file->exists and return $self->log('Skipping %s; it already exists', $file);
	$self->log('Writing %s', $file);
	

$self->rights_for_generated_files->{'META.json'} ||= [
		$self->_inherited_rights
	];
	$self->metadata->save($file, { version => '2' });
}

1;

::Controller::Run;
use Mojo::Base 'Mojolicious::Controller', -signatures;
use Mojo::JSON qw( decode_json encode_json );
use Mojo::Loader qw( data_section );
use Time::Piece;
use Zapp::Task;
use Zapp::

app_runs => $run_id ) || {};
    my $input = decode_json( $run->{input} );
    my %context = (
        (
            map { $_->{name} => decode_json( $_->{output} ) }
            grep { $_->{state} eq

$task ( @tasks ) {
        $task->{input} = decode_json( $task->{input} );
        if ( $task->{output} ) {
            $task->{output} = decode_json( $task->{output} );
        }

        if ( $task-

rigger management

use Mojo::Base 'Mojolicious::Controller', -signatures;
use Mojo::JSON qw( decode_json encode_json );
use Zapp::Util qw( build_data_from_params );

#pod =method edit
#pod
#pod Create

aram( 'plan_id' ),
            };
        }

        # XXX: Auto-decode JSON in Yancy
        $trigger->{config} &&= decode_json( $trigger->{config} );
        my $plan = $self->app->get_plan( $trigge

       );
    }

    my $trigger = build_data_from_params( $self );
    $trigger->{$_} &&= encode_json( $trigger->{$_} ) for qw( config input );
    my $trigger_id = $self->param( 'trigger_id' );
    

             - The HTTP message (like "OK" or "Not Found")
#pod     json                - If the response was JSON, the decoded JSON structure
#pod     file                - If the response was a file

 =head1 SEE ALSO
#pod
#pod =cut

use Mojo::Base 'Zapp::Task', -signatures;
use Mojo::JSON qw( false true encode_json );

sub schema( $class ) {
    return {
        input => {
            type => 'obj

      type => 'string',
                    enum => ['', qw( application/octet-stream application/json )],
                    default => '',
                },
                # XXX: Query params / F

e strict;
use warnings;
use IO::Socket::SSL;
use Scalar::Util ();
use Furl;
use JSON::MaybeXS qw( decode_json encode_json );

sub new {
    my ($class, $parent) = @_;
    my $token = \$parent->{token}

n   => ${$self->{parent_token}},
        formato => 'json',
        %$params,
    });

    if ($res->is_success) {
        my $content = decode_json($res->decoded_content);
        return $content->{r

rn $self->_post( 'https://api.tiny.com.br/api2/nota.fiscal.incluir.php', {
        nota => encode_json({ nota_fiscal => $params }),
    });
}

sub emitir {
    my ($self, $params) = @_;
    if (ref $p

ken
#pod
#pod =head1 SEE ALSO
#pod
#pod =cut

use Mojo::Base 'Zapp::Task', -signatures;
use Mojo::JSON qw( false true );
use Mojo::Util qw( b64_encode );

sub schema( $class ) {
    return {
        i

 response will be a JSON document. On success (200 OK) it will contain
    # the token. On failure (400 Bad Request) it will describe the
    # error.
    my $json = $tx->res->json;
    my %output = (

    if ( $output{is_success} ) {
        return $self->finish({
            %output,
            $json->%{qw( access_token token_type expires_in refresh_token )},
            # If scope is omitted, it

:Controller::Plan;
use Mojo::Base 'Mojolicious::Controller', -signatures;
use Mojo::JSON qw( decode_json encode_json );
use List::Util qw( uniqstr );
use Zapp::Util qw( build_data_from_params );

# Za

     # XXX: Auto-encode/-decode JSON fields in Yancy schema
        for my $json_field ( qw( input ) ) {
            $task->{ $json_field } = encode_json( $task->{ $json_field } );
        }

        

: Auto-encode/-decode JSON fields in Yancy schema
        for my $json_field ( qw( value config ) ) {
            $form_input->{ $json_field } = encode_json( $form_input->{ $json_field } );
        }

package Test::Zapp;

use Mojo::Base 'Test::Mojo';
use Mojo::JSON qw( encode_json );
use Mojo::File qw( tempdir );
use Mojo::Home;
use Zapp;
use Scalar::Util qw( blessed );
use Test::More;

sub new {
 

       name => $task_class,
                class => $task_class,
                input => encode_json( $input ),
            },
        ],
        inputs => $context,
    });
    my $run = $self->{za

sort, you can manually install it. Download the tarball and unpack it.",
		"Consult the file META.json for a list of pre-requisites. Install these first.",
		sprintf("To build %s:", $self->name),
		"\

FALSE()
#pod
#pod Returns a false value.
#pod
#pod =cut

sub _func_false( $f ) {
    return Mojo::JSON->false;
}

#pod =head3 IF
#pod
#pod     =IF( <expression>, <true_result>, <false_result> )
#pod
#

  =TRUE()
#pod
#pod Returns a true value.
#pod
#pod =cut

sub _func_true( $f ) {
    return Mojo::JSON->true;
}

#pod =head3 XOR
#pod
#pod     =XOR( <expression>... )
#pod
#pod Returns C<TRUE> if one