Yet Another CPAN Grep

App-Dazz ( W/WA/WANGQ/App-Dazz-0.1.0.tar.gz, WANGQ, 2020; MetaCPAN )

App-Dazz/lib/App/Dazz/Command/cover.pm ( view source; MetaCPAN )

 $opt->{outfile} ) {
        $opt->{outfile} = Path::Tiny::path( $args->[0] )->absolute . ".cover.json";
    }
}

sub execute {
    my ( $self, $opt, $args ) = @_;

    # make paths absolute before we

       $tempdir->child("meta.cover.json")
            ->spew( JSON::to_json( $meta_of, { pretty => 1, canonical => 1, } ) );
        $tempdir->child("meta.cover.json")->copy( $opt->{outfile} );

App-Dazz ( W/WA/WANGQ/App-Dazz-0.1.0.tar.gz, WANGQ, 2020; MetaCPAN )

App-Dazz/lib/App/Dazz/Common.pm ( view source; MetaCPAN )

ings;
use autodie;

use 5.010001;

use Carp qw();
use Graph;
use IO::Zlib;
use IPC::Cmd qw();
use JSON qw();
use List::Util;
use Path::Tiny qw();
use Statistics::Descriptive qw();
use YAML::Syck qw();

Google-Chat-WebHooks ( I/IG/IGIBBS/Google-Chat-WebHooks-0.3.tar.gz, IGIBBS, 2020; MetaCPAN )

Google-Chat-WebHooks/lib/Google/Chat/WebHooks.pm ( view source; MetaCPAN )

P::UserAgent;
use subs 'timeout';
use Class::Tiny qw(room_webhook_url _ua timeout);
use Carp;
use JSON;
use Try::Tiny;
use Data::Validate::URI qw(is_uri);

BEGIN {
    our $VERSION     = '0.3';
}
my $

ft;

	my $msg_json = "{\"text\": \"$msg\"}";
	my $req = HTTP::Request->new('POST', $self->room_webhook_url);
	$req->header('Content-Type' => 'application/json');
	$req->content($msg_json);
	my $respon


	if($response->is_error)
	{
		my $content = $response->decoded_content();
		my $json;
		try
		{
			$json = decode_json($content);
		};
		my $error_message = $response->code." ".$response->message;

Nuvol ( T/TE/TEKKI/Nuvol-0.03.tar.gz, TEKKI, 2020; MetaCPAN )

Nuvol/lib/Nuvol/Connector.pm ( view source; MetaCPAN )

rm => \%form)->result;
  die color_error $res->message if $res->is_error;

  my $response = $res->json;
  say_ok 'ok';

  return $response;
}

sub _auth_headers ($self, $headers = {}) {
  my $access_t

rm)->result;
  Carp::confess $res->message if $res->is_error;

  $self->_set_token($config, $res->json);

  return $self;
}

1;

=encoding utf8

=head1 NAME

Nuvol::Connector - Base class for Nuvol co

Sentry-Raven ( Q/QR/QRRY/Sentry-Raven-1.14.tar.gz, QRRY, 2020; MetaCPAN )

Sentry-Raven/lib/Sentry/Raven.pm ( view source; MetaCPAN )

e File::Basename 'basename';
use HTTP::Request::Common 'POST';
use HTTP::Status ':constants';
use JSON::XS;
use LWP::UserAgent;
use Sys::Hostname;
use Time::Piece;
use URI;
use UUID::Tiny ':std';
use

(
    is      => 'ro',
    isa     => Int,
    default => 5,
);

has json_obj => (
    is      => 'ro',
    builder => '_build_json_obj',
    lazy    => 1,
);

has ua_obj => (
    is      => 'ro',

nt);

    my ($response, $response_code, $response_content);

    eval {
        my $event_json = $self->json_obj()->encode( $event );

        $self->ua_obj()->timeout($self->timeout());

        my

Zabbix2-API ( S/SU/SUJITSALI/Zabbix2-API-0.014.tar.gz, SUJITSALI, 2020; MetaCPAN )

Zabbix2-API/lib/Zabbix2/API/Macro.pm ( view source; MetaCPAN )

o;

use strict;
use warnings;
use 5.010;
use Carp;
use autodie;
use utf8;

use Moo;
use JSON;
extends qw/Zabbix2::API::CRUDE/;

sub id {
    ## mutator for id
    my ($self, $value) = @

$self->id ],
                                              globalmacro => $self->globalp ? JSON::true : JSON::false,
                                              $self->_extension })->[0];
    cro

lf->id],
                                                  globalmacro => $self->globalp ? JSON::true : JSON::false,
                                                  countOutput => 1 });
    retur

Zabbix2-API ( S/SU/SUJITSALI/Zabbix2-API-0.014.tar.gz, SUJITSALI, 2020; MetaCPAN )

Zabbix2-API/lib/Zabbix2/API.pm ( view source; MetaCPAN )

blessed/;
use Module::Loaded;
use Module::Load;
use Params::Validate qw/validate :types/;
use JSON;
use LWP::UserAgent;
use Log::Any;

our $VERSION = '0.014';

has 'server' => (is => 'ro',

    'Content-Type' => 'application/json-rpc',
                                          Content => encode_json({
                                              jsonrpc => '2.0',

          $error, $response->code, $response->message);
    }

    my $decoded = eval { decode_json($response->decoded_content) };

    if (my $error = $@) {
        # no good either
        cr

Text-Distill ( G/GR/GRIBUSER/Text-Distill-0.5.tar.gz, GRIBUSER, 2020; MetaCPAN )

Text-Distill/script/plagiarism_check.pl ( view source; MetaCPAN )

okFormat TextToGems GemsValidate ExtractSingleZipFile);
use Getopt::Long;
use LWP::UserAgent;
use JSON::XS;
use Data::Dumper;

binmode STDOUT, ":utf8";

my %OPT;
GetOptions(
	'help' => \$OPT{'help'},

ems = TextToGems($Text);

my $Result = GemsValidate($Gems, $Url);

if ($OPT{'fullinfo'}) {
	print JSON::XS->new->pretty(1)->encode($Result);
} else {
	print $Result->{'verdict'}."\n";
}

sub help {

Text-Distill ( G/GR/GRIBUSER/Text-Distill-0.5.tar.gz, GRIBUSER, 2020; MetaCPAN )

Text-Distill/lib/Text/Distill.pm ( view source; MetaCPAN )

ct;
use Encode;
use Archive::Zip qw( :ERROR_CODES :CONSTANTS );
use Carp;
use LWP::UserAgent;
use JSON::XS;
use File::Temp;
use URI::Escape;

Archive::Zip::setErrorHandler(sub{});

our (@ISA, @EXPORT_

(5);
  my $Response = $ua->post( $Url, {gems => join ",",@$Gems});

  my $Result;
  return decode_json( $Response->decoded_content ) if $Response->is_success;
  die $Response->status_line;
}

# EXTRAC

 or later);
 Unicode::Normalize (v1.25 or later);
 Archive::Zip
 Encode;
 Carp;
 LWP::UserAgent;
 JSON::XS;
 File::Temp;

=head1 SCRIPTS

=head2 plagiarism_check.pl - checks your ebook againts known t

Github-Email ( M/MO/MOMOZOR/Github-Email-1.1.0.tar.gz, MOMOZOR, 2020; MetaCPAN )

Github-Email/lib/Github/Email.pm ( view source; MetaCPAN )

ess); 
use JSON;
use LWP::UserAgent;
use List::MoreUtils qw(uniq);
use Email::Valid;


sub get_emails {
    my $username = shift;

    my $user_agent = LWP::UserAgent->new;
    my $get_json =
      $u

name/events/public");

    if ( $get_json->is_success ) {
        my $raw_json    = $get_json->decoded_content;
        my $decoded_json    = decode_json $raw_json;
        my @push_events = grep { $_

->{type} eq 'PushEvent' } @{$decoded_json};
        my @commits     = map { @{$_->{payload}->{commits}} } @push_events;
        my @addresses   = map { $_->{author}->{email} } @commits;
        my @un

Mojo-InfluxDB ( G/GN/GNZL/Mojo-InfluxDB-0.1.tar.gz, GNZL, 2020; MetaCPAN )

Mojo-InfluxDB/lib/Mojo/InfluxDB.pm ( view source; MetaCPAN )

 query_p ( $self, $query ) {
    $self->raw_query_p( $query )->then(sub($tx){
        c($tx->res->json('/results')->@*)->map(sub($src){
            Mojo::InfluxDB::Result->new(
                time_zo