CPAN::Groonga

n release

=item *

L<Dist::Zilla::Plugin::Bitbucket::Meta>

Add Bitbucket repo info to META.{yml,json}

=back

=head2 Configuration

Configure git with your Bitbucket credentials:

	$ git config --gl

rangoDB2::HTTP
);

use Data::Dumper;
use HTTP::Response;
use JSON::XS;
use Scalar::Util qw(weaken);
use WWW::Curl::Easy;



my $JSON = JSON::XS->new->utf8;



sub new
{
    my($class, $arango) = @_;

;
        return;
    }
    # decode response, assuming JSON
    my $res = eval { $JSON->decode($$response) };
    # if content is not valid JSON then return entire content
    return $$response unles

:ClickSend;

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

use Carp;
use LWP::UserAgent;
use JSON;
use MIME::Base64;
use HTTP::Request;
use vars qw/$errstr/;

sub errstr { $errstr }

sub new {
  

($self, $url, $method, $params) = @_;

    $url = 'https://api.clicksend.com/rest/v2/' . $url . '.json';

    $params ||= {};
    $params->{method} = 'rest'; # we prefer rest

    my $uri = URI->new($

st($req);
    if (not $res->header('Content-Type') =~ /json/) {
        $errstr = $res->status_line;
        return;
    }

    return decode_json($res->decoded_content);
}

1;
__END__

=encoding utf-

# version
#
# GET /_api/version
#
# Returns the server name and version number. The response is a JSON object with the following attributes:
#
# server: will always contain arango
# version: the serve

 minor will be numeric, and sub may contain a number or a textual version.
# details: an optional JSON object with additional details. This is returned only if the details URL parameter is set to true

rs.  The only validation that takes place is to
insure that bool parameters have properly encoded JSON true and false values.

=head1 METHODS

=over 4

=item new

=item admin

=item database

=item da

se warnings;

use base qw(
    ArangoDB2::Base
);

use Data::Dumper;
use JSON::XS;

use ArangoDB2::Graph::Edge;

my $JSON = JSON::XS->new->utf8;



# create
#
# POST /_api/gharial/graph-name/edge
sub 

tp->post(
        $self->api_path('gharial', $self->graph->name, 'edge'),
        undef,
        $JSON->encode($args),
    ) or return;
    # set name
    $self->name($name);
    # update parent graph

     $self->api_path('gharial', $self->graph->name, 'edge', $self->name),
        undef,
        $JSON->encode($args),
    ) or return;
    # set name
    $self->name($name);
    # update parent graph

use strict;
use warnings;

use base qw(
    ArangoDB2::Base
);

use Data::Dumper;
use JSON::XS;

my $JSON = JSON::XS->new->utf8;



# create
#
# POST /_api/gharial/graph-name/vertex/collection-name
s

h('gharial', $self->graph->name, $self->_class, $self->collection->name),
        $args,
        $JSON->encode($data),
    ) or return;
    # get response data
    $res = $res->{$self->_class}
       

aph->name, $self->_class, $self->collection->name, delete $args->{name}),
        $args,
        $JSON->encode($data),
    ) or return;
    # get response data
    $res = $res->{$self->_class}
       

use strict;
use warnings;

use base qw(
    ArangoDB2::Base
);

use Data::Dumper;
use JSON::XS;

my $JSON = JSON::XS->new->utf8;



###############
# API METHODS #
###############

# applierConfig
#

uild our own response
    my $ret = {};
    # response is newline separated JSON log entries
    $ret->{log} = [ map { $JSON->decode($_) } split(/\n/, $res->content) ];

    # get response header valu

the collection to dump.  Accepts string or L<ArangoDB2::COllection> object.

=item configuration

JSON representation of the configuration

=item from

Lower bound tick value for results.

=item inclu

use strict;
use warnings;

use base qw(
    ArangoDB2::Base
);

use Data::Dumper;
use JSON::XS;

my $JSON = JSON::XS->new->utf8;

my @PARAMS = qw(
    direction edgeCollection expander filter graphNa

  return $self->arango->http->post(
        $self->api_path('traversal'),
        undef,
        $JSON->encode($args),
    );
}

# expander
#
# get/ set expander
sub expander { shift->_get_set('expand

rator function with this attribute. Note that the value here has to be a string to conform to the JSON standard, which in turn is parsed as function body on the server side. Furthermore note that this

 

=head1 DESCRIPTION

It is often desirable to create an object from a database row or a decoded
JSON object. However, it is quite likely that you might have declared some
attributes with C<< init_ar

use strict;
use warnings;

use base qw(
    ArangoDB2::Base
);

use Data::Dumper;
use JSON::XS;

my $JSON = JSON::XS->new->utf8;



# action
#
# get/set action
sub action { shift->_get_set('action', 

return $self->arango->http->post(
        $self->api_path('transaction'),
        undef,
        $JSON->encode($args),
    );
}

# lockTimeout
#
# get/set lockTimeout
sub lockTimeout { shift->_get_set

 warnings;

use base qw(
    ArangoDB2::Base
);

use Data::Dumper;
use JSON::XS;
use URI::Escape qw(uri_escape);

my $JSON = JSON::XS->new->utf8;



###############
# API METHODS #
###############

# 

equest
    my $res = $self->arango->http->post(
        '/_api/endpoint',
        undef,
        $JSON->encode($args),
    ) or return;
    # if request was success copy args to self
    $self->_build

 JSON::XS;
use Scalar::Util qw(reftype);

use ArangoDB2::Collection;
use ArangoDB2::Graph;
use ArangoDB2::Query;
use ArangoDB2::Replication;
use ArangoDB2::Transaction;
use ArangoDB2::User;

my $JSON 

= JSON::XS->new->utf8;



# collection
#
# get/create ArangoDB2::Collection object
sub collection
{
    my($self, $name) = @_;

    if (defined $name) {
        # only create one ArangoDB2::Collection

equest
    my $res = $self->arango->http->post(
        '/_api/database',
        undef,
        $JSON->encode($args),
    ) or return;

    return $self;
}

# current
#
# GET /_api/database/current
s

 Data::Dumper;
use JSON::XS;

# parameters that can be set when creating index or
# are returned when creating/getting index
our @PARAMS = qw(
    byteSize constraint fields geoJson id ignoreNull
    

isNewlyCreated minLength size type unique
);

my $JSON = JSON::XS->new->utf8;



# byteSize
#
# get/set byteSize
sub byteSize { shift->_get_set('byteSize', @_) }

# constraint
#
# get/set constraint v

   my $res = $self->arango->http->post(
        $self->api_path('index'),
        $args,
        $JSON->encode($index),
    ) or return;
    # get name from id
    my($name) = $res->{id} =~ m{/(\d+)$}

ints;
use HTTP::Tiny 0.050;
use Try::Tiny 0.22;
use MIME::Base64 3.14;
use JSON::MaybeXS 1.002006 qw( encode_json decode_json );
use Git::Wrapper 0.037;
use File::pushd 1.009;

extends 'Dist::Zilla::P

c " . MIME::Base64::encode_base64("$login:$pass", '');
	$headers->{'content-type'} = "application/json";

	# We use the v2.0 API to create
	my $url = 'https://api.bitbucket.org/2.0/repositories/' . $l

ository '%s'", $repo_name ]);
	my $response = $http->request( 'POST', $url, {
		content => encode_json( $params ),
		headers => $headers
	});

	if ( ! $response->{'success'} ) {
		$self->log( ["Error:

: localhost
    Content-Type: application/json

    {
     "method":"create"
    }

    ## response
    HTTP/1.1 201 Created
    Content-Type: application/json;charset=UTF-8
    Cache-Control: no-stor

Type: application/json

    {
     "method":"read",
     "id":"81c8feb9b54f632823fafea71966b5f89ad5cc92"
    }

    ## response
    HTTP/1.1 200 OK
    Content-Type: application/json;charset=UTF-8
   

cation/json

    {
     "method":"update",
     "id":"81c8feb9b54f632823fafea71966b5f89ad5cc92",
     "type":"hotp"
    }

    ## response
    HTTP/1.1 200 OK
    Content-Type: application/json;charse

erver::Ident> 1.16

=head3 L<POE::Component::Server::Inet> 0.06

=head3 L<POE::Component::Server::JSONRPC> 0.05

=head3 L<POE::Component::Server::MySQL> 0.02

=head3 L<POE::Component::Server::NNTP> 1.

Filter::IRCD> 2.44

=head3 L<POE::Filter::IRCv3> 1.001001

=head3 L<POE::Filter::JSON> 0.04

=head3 L<POE::Filter::JSON::Incr> 0.03

=head3 L<POE::Filter::KennySpeak> 1.02

=head3 L<POE::Filter::LOLCA

ArangoDB2::Admin;

use strict;
use warnings;

use base qw(
    ArangoDB2::Base
);

use JSON::XS;

my $JSON = JSON::XS->new->utf8;



###############
# API METHODS #
###############

# echo
#
# GET /_a

($self, $args) = @_;
    # process args
    $args = $self->_build_args($args, ['program','returnAsJSON']);
    my $program = delete $args->{program};
    # make request
    return $self->arango->http-

roperties';
    # make request
    return $args
        ? $self->arango->http->put($path, undef, $JSON->encode($args))
        : $self->arango->http->get($path);
}

####################
# PROPERTY MET

use strict;
use warnings;

use base qw(
    ArangoDB2::Base
);

use Data::Dumper;
use JSON::XS;

my $JSON = JSON::XS->new->utf8;



# create
#
# POST /_api/document
#
# Query Parameters
#
# collectio

$res = $self->arango->http->post(
        $self->api_path($self->_class),
        $args,
        $JSON->encode($data),
    ) or return;
    # copy response data to instance
    $self->_build_self($res

    $self->api_path($self->_class, $self->collection->name, $self->name),
        $args,
        $JSON->encode($data),
    ) or return;
    # copy response data to instance
    $self->_build_self($res

se qw(
    ArangoDB2::Base
);

use Data::Dumper;
use JSON::XS;

use ArangoDB2::Document;
use ArangoDB2::Edge;
use ArangoDB2::Index;

my $JSON = JSON::XS->new->utf8;

# params that can be set when crea

 $res = $self->arango->http->post(
        $self->api_path('collection'),
        undef,
        $JSON->encode($args),
    ) or return;
    # copy response data to instance
    $self->_build_self($res

        # if args are passed then set with PUT
        ? $self->arango->http->put($path, undef, $JSON->encode($args))
        # otherwise get properties
        : $self->arango->http->get($path);
   

use strict;
use warnings;

use base qw(
    ArangoDB2::Base
);

use Data::Dumper;
use JSON::XS;

my $JSON = JSON::XS->new->utf8;

my @PARAMS = qw(
    active changePassword extra name passwd
);



##

    my $res = $self->arango->http->post(
        $self->api_path('user'),
        undef,
        $JSON->encode($args),
    ) or return;
    # if request was success copy args to self
    $self->_build

ango->http->patch(
        $self->api_path('user', delete $args->{name}),
        undef,
        $JSON->encode($args),
    ) or return;
    # if request was success copy args to self
    $self->_build