CPAN::Groonga

ervice::SSLLabs::Simulation();

our $VERSION = '0.33';

sub new {
    my ( $class, $json ) = @_;
    my $self = $json;
    bless $self, $class;
    my @simulations = @{ $self->{results} };
    $self->

esponse;

use Mojo::Base 'Mojo::Message::Response';
use Mojo::JSON qw(decode_json encode_json);

use MIME::Base64;
use Try::Tiny;
use JSON::Types;
use Encode;

sub output {
    my $self = shift;

    

ingleValueHeaders->{'content-type'};
    my $isBase64Encoded = $type !~ m(^text/.*|application/(:?json|javascript|xml))i;
    if ($isBase64Encoded) {
        $body = encode_base64 $body, '';
    } 
  

 WebService::SSLLabs::Suite();

our $VERSION = '0.33';

sub new {
    my ( $class, $json ) = @_;
    my $self = $json;
    bless $self, $class;
    return $self;
}

sub cipher_strength {
    my ($self

rt;

use strict;
use warnings;

our $VERSION = '0.33';

sub new {
    my ( $class, $json ) = @_;
    my $self = $json;
    bless $self, $class;
    return $self;
}

sub subject {
    my ($self) = @_;

nt;

use strict;
use warnings;

our $VERSION = '0.33';

sub new {
    my ( $class, $json ) = @_;
    my $self = $json;
    bless $self, $class;
    return $self;
}

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

package WebService::SSLLabs;

use strict;
use warnings;
use JSON();
use URI::Escape();
use LWP::UserAgent();
use WebService::SSLLabs::Info();
use WebService::SSLLabs::Host();
use WebService::SSLLabs::

self->_parse_success($response);
        return WebService::SSLLabs::Info->new(
            JSON::decode_json( $response->decoded_content() ) );
    }
    else {
        Carp::croak( "Failed to retrie

->_parse_success($response);
        my $host = WebService::SSLLabs::Host->new(
            JSON::decode_json( $response->decoded_content() ) );
        $self->{_previous_host} = $host;
        return

{ $_[0] } : @_;

    # Break out the JSON::XS::Boolean values into 1/0
    for my $field (keys %args) {
        if (ref($args{$field}) =~ /^(JSON::XS::Boolean|JSON::PP::Boolean)$/) {
            $args

/GET POST DELETE/;
use MIME::Base64 qw/encode_base64/;
use URI::Escape qw/uri_escape/;
use JSON qw/decode_json/;
use URI qw//;
use DateTime qw//;
use Net::Stripe::TypeConstraints;
use Net::Stripe::Con

tus_line . " - " . $resp->content,
        );
    }

    my $e = eval {
        my $hash = decode_json($resp->content);
        Net::Stripe::Error->new($hash->{error})
    };
    if ($@) {
        Net

st $req!) {
    my $resp = $self->_get_response(
        req => $req,
    );
    my $ref = decode_json( $resp->content );
    if ( ref( $ref ) eq 'ARRAY' ) {
        # some list-type data structures a

view_date'))
        ->worker_waittime_metrics($self->param('worker'));

    return $self->render(json => $waittime);
}

=head2 throughput

Show throughput metrics for a worker

=cut

sub throughput {

inished' });
    my $failed = $throughput->grep(sub { $_->{ state } eq 'failed' });

    return $self->render(json => {
        finished    => $finished,
        failed      => $failed,
    });
}

1;

 indexes the lists
themselves? To be safer, an Acme::CPANLists module could export the lists to a
JSON, so lcpan does not have to load the module.

The indexing part could be modularized, so we can ha

});
    my $failed = $runtime->grep(sub { $_->{ state } eq 'failed' });

    return $self->render(json => {
        finished    => $finished,
        failed      => $failed,
    });
}

=head2 throughp

inished' });
    my $failed = $throughput->grep(sub { $_->{ state } eq 'failed' });

    return $self->render(json => {
        finished    => $finished,
        failed      => $failed,
    });
}

1;

ackend::mysql;
use Mojo::Base 'Mojolicious::Plugin::Minion::Overview::Backend';

use Mojo::JSON qw(decode_json);


=head2 failed_jobs

Search failed jobs

=cut

sub failed_jobs {
    return shift->whe

   $collection->each(sub {
        my $object = shift;

        $object->{ tags } = eval { decode_json($object->{ notes })->{ tags } || [$object->{ task }] };
    });

    my $response = {
        res

 $collection->each(sub {
        my $object = shift;

        $object->{ status } = eval { decode_json($object->{ status }) };
        $object->{ jobs_stats } = $self->db->query($stats_sql, $object->{

> 1,
    #keywords         => undef,
);



__PACKAGE__->set(
    # Objectify options
    json_method => 'TO_JSON',
    object      => '$data',
    #object      => '{$class_str : $data}',
    overloads

ct => $tag_method );
}
sub _objectify_via_json {
    my $self   = shift;
    my $object = shift;

    return $self->_objectify_via( $object => $self->get('json_method') );
}



# Override Datify::obje

a = $self->arrayify( $object->$tag('JSON') );
    } elsif ( my $to_json = $self->_objectify_via_json($object) ) {
        $data = $self->scalarify( $object->$to_json() );
    } elsif ( my $method = $s

('integer_unsigned');

  $self->stash(%args) if %args;

  return $self;
}

method json(Any %args) {
  $self->type('json');

  $self->stash(%args) if %args;

  return $self;
}

method null(Any %args) {

=back

=cut

=head2 json

  json(Any %args) : Column

Configures a JSON column and returns itself.

=over 4

=item json example #1

  # given: synopsis

  my $json = $self->json;

=back

=cut

=head

ary('id');
  $table->uuid('arid');
  $table->column('name');
  $table->string('email');
  $table->json('metadata');

  my $command = $table->create;
  my $grammar = $self->grammar('sqlite');
  my $sta

umn type string

  return $self->type_integer($col);
}

method type_json(Column $col) {
  # return column type string

  return 'json';
}

method type_string(Column $col) {
  # return column type stri

mn);

  # integer

=back

=cut

=head2 type_json

  type_json(Column $column) : Str

Returns the type expression for a json column.

=over 4

=item type_json example #1

  # given: synopsis

  use Doo

dle;

  my $ddl = Doodle->new;
  my $column = $ddl->table('users')->column('json');

  $self->type_json($column);

  # json

=back

=cut

=head2 type_string

  type_string(Column $column) : Str

Retur

integer_unsigned(Column $col) {
  # return column type string

  return 'integer';
}

method type_json(Column $col) {
  # return column type string

  return 'text';
}

method type_string(Column $col)

mn);

  # integer

=back

=cut

=head2 type_json

  type_json(Column $column) : Str

Returns the type expression for a json column.

=over 4

=item type_json example #1

  # given: synopsis

  use Doo

dle;

  my $ddl = Doodle->new;
  my $column = $ddl->table('users')->column('json');

  $self->type_json($column);

  # text

=back

=cut

=head2 type_string

  type_string(Column $column) : Str

Retur

(Column $col) {
  # return column type string

  return $self->type_integer($col);
}

method type_json(Column $col) {
  # return column type string

  return 'nvarchar(max)';
}

method type_string(Col

column);

  # int

=back

=cut

=head2 type_json

  type_json(Column $column) : Str

Returns the type expression for a json column.

=over 4

=item type_json example #1

  # given: synopsis

  use Doo

dle;

  my $ddl = Doodle->new;
  my $column = $ddl->table('users')->column('json');

  $self->type_json($column);

  # nvarchar(max)

=back

=cut

=head2 type_string

  type_string(Column $column) : S

attern::Git (dist=Regexp-Pattern-Git)
    prove-mods: Found module: Regexp::Pattern::JSON (dist=Regexp-Pattern-JSON)
    prove-mods: Found module: Regexp::Pattern::License (dist=Regexp-Pattern-License

rn-CPAN
    prove-mods: Found dist: Regexp-Pattern-Git
    prove-mods: Found dist: Regexp-Pattern-JSON
    prove-mods: Found dist: Regexp-Pattern-License
    prove-mods: Found dist: Regexp-Pattern-Net

  prove-mods: [DRY] [4/12] Running prove for distribution Regexp-Pattern-JSON (directory /home/u1/repos/perl-Regexp-Pattern-JSON) ...
    prove-mods: [DRY] [5/12] Running prove for distribution Regexp

  require JSON::MaybeXS;

    if($opt->{'history'}) {
        $self->show_history;
    }
    else {
        $self->cover;
    }
}

sub show_history {
    my $self = shift;
    my $json = JSON::MaybeXS

->new(pretty => 1);

    my $history_file = path('.coverhistory.json');
    exit if !$history_file->exists;

    my $history = $json->decode($history_file->slurp);
    exit if !scalar @$history;

    

my $self = shift;

    my $json = JSON::MaybeXS->new(pretty => 1);
    local $ENV{'HARNESS_PERL_SWITCHES'} = '-MDevel::Cover';

    my @cover_command = qw/cover -report json/;
    my $zilla = $self->z