CPAN::Groonga

ervice::Jandi::WebHook::VERSION = 'v0.0.1';
use strict;
use warnings;

use HTTP::Tiny;
use JSON qw/encode_json/;

=encoding utf8

=head1 NAME

WebService::Jandi::WebHook - Perl interface to Jandi Serv

',
                accept         => 'application/vnd.tosslab.jandi-v2+json',
                'content-type' => 'application/json',
            }
        ),
    };

    bless $self, $class;
    return

ge } unless ref $message;
    my $json = encode_json($message);
    my $res  = $self->{http}->request(
        'POST',
        $self->{url},
        { content => $json }
    );

    return $res;
}

=h

e' => 'sort-select',
        'action' => 'sort',
        'inStorage' => bless( do{\(my $o = 1)}, 'JSON::PP::Boolean' ),
        'data' => {
                    'order' => '',
                    'type

        'ignore' => ''
                  },
        'isAnimateToTop' => bless( do{\(my $o = 0)}, 'JSON::PP::Boolean' ),
        'inDeepLinking' => $VAR1->[0]{'inStorage'},
        'name' => 'sort',
  

package SMS::Send::Twilio;

use strict;
use warnings;

use 5.008_005;

use Carp;
use JSON::PP;
use WWW::Twilio::API;

use parent qw(SMS::Send::Driver);

our $VERSION = '0.20';

=encoding utf-8

=head1

       'Messages.json',
        From => $self->{_from},
        To   => $recipient,
        Body => $message,
    );

    if ( $response->{code} == '201' ) {
        my $result = JSON::PP->new->utf8->

n $result->{sid};
        }
    }
    elsif ( $response->{code} == '400' ) {
        my $result = JSON::PP->new->utf8->decode( $response->{content} );
        if ( $result->{message} ) {
            c

est params.

=back

=head1 SEE ALSO

=over 4

=item * L<Moose>

=item * L<URI::Escape>

=item * L<JSON>

=back

=head1 REPOSITORY

L<https://github.com/sheeju/JPList>

=head1 ACKNOWLEDGEMENTS

Develop

==================================== #

package JPList::Request;

use Moose;
use URI::Escape;
use JSON;

with 'JPList::Controls::Filter';
with 'JPList::Controls::Sort';

# ============================

c   : decode params

=cut

sub _decode_request_params
{

    my $self = shift;

    return decode_json(uri_unescape($self->request_params));
}

# ======================================================

use Mojo::Base -base;

our $VERSION = '0.4';

=for comment

We want JSON
WANT_JSON

=cut

use Mojo::JSON qw/decode_json encode_json/;
use Mojo::File qw/path/;
use POSIX qw/locale_h/;
use Carp qw/croa

0])->slurp;
  my $json = decode_json($args);
  return $json if defined $json;
  my $params = {};
  for my $arg (split $args) {
    my ($k, $v) = split '=', $arg;
    $self->fail_json(
      {msg => 'T

his module requires key=value style argument: ' . $arg})
      unless defined $v;
    $self->fail_json({msg => "Duplicate parameter: $k"})
      if exists $params->{$k};
    $params->{$k} = $v;
  }
  

default_headers => {
            'Fastly-Key' => $token,
            'Accept'     => 'application/json'
        },
    );
    return $http_requester;
}


=head1 Net::Fastly

Methods below return objec

package Test::AnsibleModule;

use Mojo::Base -base;
use Test::More;
use Mojo::JSON qw/decode_json encode_json/;
use Mojo::Asset::File;
use Carp qw/croak/;
use Data::Dumper qw/Dumper/;
$Data::Dumper::S

rgs   = ref $_[0] ? $_[0] : {@_};

  my $file = Mojo::Asset::File->new;
  $file->add_chunk(encode_json($args));
  my $p;

  open($p, "-|", join(" ", $module, $file->path))
    // croak "Could not run 

  my $response = "";

  while (my $line = <$p>) {
    $response .= $line;
  }
  my $res = decode_json($response);
  $self->last_response($res);
  close $p;
  return $? >> 8;
}

sub _test {
  my ($sel

use Moo;
use WWW::Mechanize;
use Method::Signatures 20121201;
use WebService::HabitRPG::Task;
use JSON::MaybeXS;
use Data::Dumper;
use Carp qw(croak);

our $DEBUG = $ENV{HRPG_DEBUG} || 0;
our $TAG_PRE

);
has 'api_base'   => (is => 'ro', default => sub { 'https://habitica.com/api/v3' });
has '_last_json' => (is => 'rw'); # For debugging
has 'tags'       => (is => 'rw');
has 'tag_prefix' => (is => 'r

= 1,
    :$down = 1,
    :$extend = {},
) {

    # Magical boolification for JSONification.
    # TODO: These work with JSON::XS. Do they work with other backends?

    $up   = $up   ? \1 : \0;
    $d

package WebService::HabitRPG::Task;
use v5.010;
use strict;
use warnings;
use autodie;
use JSON::MaybeXS qw(is_bool);
use Moo;
use Scalar::Util qw(looks_like_number);
use POSIX qw(strftime);
use Carp 

($self, $args) = @_;

    # Since we're usually being called directly with the results of
    # a JSON parse, we want to record that original structure here.

    $self->_raw($args);
}


sub active_to

0.04';
# ABSTRACT: Airbrake Notifier API V2 Client

use Net::Airbrake 0.02;
use JSON::MaybeXS qw(encode_json decode_json);
use XML::Simple   qw(xml_in xml_out);

our @ISA = 'Net::Airbrake';

# Net::Ai

sub convert_request {
  my ($self, $req, $opts) = @_;

  my $string = !ref $req;
  $req = decode_json($req) if $string;

  $opts ||= {};

  my $mod     = $opts->{mod} || ref($self) || $self;
  my $ap

  SuppressEmpty => 1,
    XMLDecl  => q[<?xml version="1.0" encoding="utf-8"?>],
  );

  # decode_json should return a structure with character strings,
  # and XML::Simple doesn't encode until writin

ctor>
#include <algorithm>
#include <utility>
#include <iostream>
#include "./base.h"
#include "./json.h"
#include "./logging.h"
#include "./type_traits.h"
#include "./optional.h"

namespace dmlc {
//

d());
  }
  /*!
   * \brief Write the parameters in JSON format.
   * \param writer JSONWriter used for writing.
   */
  inline void Save(dmlc::JSONWriter *writer) const {
    writer->Write(this->__DI

\brief Load the parameters from JSON.
   * \param reader JSONReader used for loading.
   * \throw ParamError when something go wrong.
   */
  inline void Load(dmlc::JSONReader *reader) {
    std::map<

 m/$CORE_PAIR_RE/) {
    $self->parse_symbol($1, &_decode_JSON_string($2), &_decode_colour($3), $4);
    $self->parse_symbol($4, &_decode_JSON_string($5), &_decode_colour($6), $1);
  } elsif ($line =~

/) {
    $self->parse_symbol($1, &_decode_JSON_string($2), &_decode_colour($3));
  } elsif ($line =~ m/$AMBIG_RE/) {
    $self->parse_symbol($1, &_decode_JSON_string($2), &_decode_colour($3), undef, $

$sym) = @_;
  my $name_info = '';
  if (defined($sym->{name})) {
    $name_info = ' "' . &_encode_JSON_string($sym->{name}) . '"';
  }
  my $colour_info = '';
  if (defined($sym->{colour})) {
    $col

rvice, either as a file or as a variable in the call to
Geo::OGC::Service->new.

The file must be JSON and either have top level key WMTS, WMS, or TMS
if more than one service is defined. The value of

10000; # say // and //=
use feature "switch";
use Carp;
use File::Basename;
use Modern::Perl;
use JSON;
use Geo::GDAL;
use Cwd;
use Math::Trig;
use HTTP::Date;

use Data::Dumper;
use XML::LibXML::Pret

ndef;
    } else {
        my $json = JSON->new;
        $json->allow_blessed([1]);
        my $writer = $self->{responder}->([200, [ 'Content-Type' => 'application/json',
                            

etc/service.conf

(make sure this file is not served by your httpd)

The configuration must be in JSON format. I.e., something like

  {
    Common: {
        "CORS": {
                "Allow-Origin" 

Carp;
use Modern::Perl;
use Encode qw(decode encode);
use Plack::Request;
use Plack::Builder;
use JSON;
use XML::LibXML;
use Clone 'clone';
use XML::LibXML::PrettyPrint;

use parent qw/Plack::Componen

ion for the services. The top
level keys are service names. If it is a file, it is expected to be
JSON. A configuration in a file may use top level Common hash and
references. A reference is a key,val

rs
 * \file json.h
 * \brief Lightweight JSON Reader/Writer that read save into C++ data structs.
 *  This includes STL composites and structures.
 */
#ifndef DMLC_JSON_H_
#define DMLC_JSON_H_

// Thi

namespace dmlc {
/*!
 * \brief Lightweight JSON Reader to read any STL compositions and structs.
 *  The user need to know the schema of the
 *
 */
class JSONReader {
 public:
  /*!
   * \brief Constr

he input stream.
   */
  explicit JSONReader(std::istream *is)
      : is_(is),
        line_count_r_(0),
        line_count_n_(0) {}
  /*!
   * \brief Parse next JSON string.
   * \param out_str the 

package Net::PMP::Profile;
use Moose;
use Data::Dump qw( dump );
use Data::Clean::JSON;
use Net::PMP::Profile::TypeConstraints;
use Net::PMP::CollectionDoc;
use Net::PMP::CollectionDoc::Link;

our $VE

les/base'}
sub get_profile_title { ref(shift) }

# singleton for class
my $cleaner = Data::Clean::JSON->new(
    DateTime                              => [ call_method => 'stringify' ],
    'Net::PMP:

 Ttl  => 'Turtle',
    N3   => 'Notation3',
    Xml  => 'RDFXML',
    XML  => 'RDFXML',
    Json => 'RDFJSON',
);

has type => (
    is => 'ro',
    coerce => sub { my $t = ucfirst($_[0]); $TYPE_ALIAS

porter::RDF>

Serialize RDF data (as RDF/XML, RDF/JSON, Turtle, NTriples, RDFa...)

=item L<Catmandu::Importer::RDF>

Parse RDF data (RDF/XML, RDF/JSON, Turtle, NTriples...) or import from a SPARQL
en

package DR::TarantoolQueue::Task;
use utf8;
use strict;
use warnings;
use Mouse;
use JSON::XS ();
use Carp;

has space   => (is => 'ro', isa => 'Str', required => 1);
has status  => (
    is          

ss::Zlib;
use MIME::Base64;

use JSON::XS;
        
has jsp =>
    is      => 'ro',
    isa     => 'Object',
    lazy    => 1,
    builder => sub {
        return JSON::XS
                -> new