CPAN::Groonga

b opt_spec
{
	(
		[verbatim => 'show the Changes file verbatim'],
	);
}

sub _metacpan
{
	require JSON;
	require LWP::UserAgent;
	my ($self, @path) = @_;
	state $ua = LWP::UserAgent->new(
		agent => s

/$path");
	$r->is_success or die("HTTP request failed");
	if ($r->content_type =~ /json/i)
	{
		return JSON::from_json( $r->decoded_content );
	}
	else
	{
		return $r->decoded_content;
	}
}

my $DATE 

 strict;
use warnings;

use JSON 'decode_json';
use Path::Class 'file';

use Exporter 'import';
our @EXPORT_OK = qw(get_un);


sub get_un {
  my $fn = sprintf "%s/%04d.json", data_dir(), shift;
  retu

rn unless -e $fn;
  open my $fh, '<', $fn;
  my $text = <$fh>;
  my $hashref = decode_json $text or return;
  return %$hashref;
}

sub data_dir {
  file(__FILE__)->parent()->subdir('UN-data');  
}

1;

ut performance
(because App::Cmd or P5U has already loaded them). These include
L<Class::Load>, L<JSON> and L<Path::Tiny>.

If you need OO, then use L<Moo> (but do it in a workhorse module that's
load

 FATAL => 'all';
use Moo;
use Getopt::Long qw(GetOptionsFromArray);
use Redis;
use Try::Tiny;
use JSON;

=head1 NAME

App::Unicheck::Modules::Redis - App::Unicheck module to check redis servers.

=hea

	my ($self, $status, $value, $format) = @_;

	return JSON->new->encode(
		{
			message => $value,
			status  => $status,
		}
	) if $format eq 'json';
	# default last in case some non supported format 

'Default: num',
				},
				formats => {
					'num'  => 'Returns the status code',
					'json' => 'Returns a JSON structure',
				},
			},
			size => {
				description => 'Check redis RAM consumption',

leaned up.

In addition, an entry will be made into C<provides> for the C<.pm> file of the
C<META.json/yml> files. This will assist PAUSE, search.cpan.org and metacpan.org
in properly indexing the dis

two different conventions; named arguments:

	p5u reprove --release=JSON --version=2.53

Or positional arguments:

	p5u reprove JSON 2.53

The first argument is the distribution name or module name; t

::" is used to disambiguate between distribution
and module names; in the case of something like "JSON" which is ambiguous,
use a trailing "::" to force it to be interpreted as a module name.

When gi

'all';
use Moo;
use Getopt::Long qw(GetOptionsFromArray);
use Mojo::UserAgent;
use Try::Tiny;
use JSON;
use Time::HiRes;

=head1 NAME

App::Unicheck::Modules::HTTP - App::Unicheck module to check web 

, $value, $format) = @_;

    return JSON->new->encode(
        {
            message => $value,
            status  => $status,
        }
    ) if $format eq 'json';
    # default last in case some n

mats => {
                    'num'  => 'Returns the status code',
                    'json' => 'Returns a JSON structure',
                },
                default_format => 'num',
            },

= '0.100';
};

use Moo;
use IO::Uncompress::Gunzip qw< gunzip $GunzipError >;
use JSON             2.00  qw< from_json >;
use LWP::Simple      0     qw< get >;
use match::smart     0     qw< M >;
use 

;
use Type::Utils      0     qw< class_type >;
use Types::Standard  0.004 qw< HashRef >;

my $json   = JSON::->new->allow_nonref;

sub dist2deb
{
	my ($dist) = @_;
	"lib".lc($dist)."-perl";
}

use nam

elease/_search?q=author:".
		uc($author)."%20AND%20status:latest&fields=name&size=1000";
	$res = $json->decode($res);
	die "MetaCPAN timed out" if $res->{timed_out};

	my $pkgs = $self->debian;

	my %

0';
};

use Moo; no warnings;
use Types::Standard qw< ArrayRef HashRef Maybe Num Str >;
use JSON qw(from_json);
use LWP::Simple qw(get);
use Object::AUTHORITY;

use constant {
	template_website       

pan_data => (
	is         => 'lazy',
	isa        => HashRef,
);

sub _build_metacpan_data
{
	from_json get sprintf __PACKAGE__->template_metacpan_data, uc shift->cpanid
}

has [qw(metacpan_releases me

_json get sprintf __PACKAGE__->template_metacpan_releases, uc shift->cpanid)
				->{hits}{hits}
		}
	]
}

sub _build_metacpan_popular
{
	my @plusplus = map $_->{fields}{distribution}, @{
		(from_json 

ib::Version::AUTHORITY = 'cpan:TOBYINK';
	$P5U::Lib::Version::VERSION   = '0.100';
};

use JSON qw< from_json >;
use LWP::Simple qw< get >;
use Module::Info;
use Module::Runtime qw< module_notional_fi

_installed(@_);
}

sub cpan_module_info
{
	my $self = shift;
	my $mod  = shift;

	my $data = from_json get(
		sprintf
			'http://api.metacpan.org/v0/module/_search?q=status:cpan+AND+path:lib/%s&fields

n => $data);
}

sub backpan_module_info
{
	my $self = shift;
	my $mod  = shift;

	my $data = from_json get(
		sprintf
			'http://api.metacpan.org/v0/module/_search?q=status:backpan+AND+path:lib/%s&fie

e Getopt::Long qw(GetOptionsFromArray);
use Try::Tiny;
use MongoDB;
use MongoDB::MongoClient;
use JSON;

=head1 NAME

App::Unicheck::Modules::MongoDB - App::Unicheck module to check mongodb servers.

, $value, $format) = @_;

    return JSON->new->encode(
        {
            message => $value,
            status  => $status,
        }
    ) if $format eq 'json';
    # default last in case some n

mats => {
                    'num'  => 'Returns the status code',
                    'json' => 'Returns a JSON structure',
                },
            },
        },
    }
}

=head1 AUTHOR

Matthi

e;

use Moo;
use App::Prove qw//;
use Class::Load qw/load_class/;
use Carp qw/confess/;
use JSON qw/from_json/;
use File::pushd qw/pushd/;
use File::Temp qw//;
use Module::Info qw//;
use Path::Tiny qw

 = $1;
			}
		}
	}
	
	if (defined $args{module} and not defined $args{release})
	{
		my $d = from_json(get(sprintf('http://api.metacpan.org/v0/module/%s', $args{module})));
		$args{release}  = $d->{di

= $d->{author};
	}
	
	if (defined $args{release} and not defined $args{author})
	{
		my $d = from_json(get(sprintf('http://api.metacpan.org/v0/release/%s', $args{release})));
		$args{author} //= $d->{

ead1 EXPORT


=cut

use strict;
use warnings;

use HTTP::Request::Common;
use LWP::UserAgent;
use JSON;
use MIME::Base64 'encode_base64';
use Time::HiRes (qw(gettimeofday));
use DateTime;
use Sys::Hos

       'extra'       => $params->{'extra'} || {}
    };

    my $json = JSON->new->utf8(1)->pretty(1)->allow_nonref(1);
    return $json->encode( $data );
}

1;

=head1 LICENSE AND COPYRIGHT

Copyrigh

::Lib::Testers::VERSION   = '0.100';
};

use Moo;
use File::Spec       0 qw< >;
use JSON             0 qw< from_json >;
use LWP::Simple      0 qw< mirror is_success >;
use List::Util       0 qw< maxst

ttp://www.cpantesters.org/distro/%s/%s.json',
		substr($self->distro, 0, 1),
		$self->distro,
	);
	my $results_file = path(
		$self->cache_dir,
		sprintf('%s.json', $self->distro),
	);
	
	is_success m

unlink $results_file;
			die "Failed to retrieve URI $results_uri\n";
		};
		
	my $results = from_json scalar $results_file->slurp;
	die "Unexpected non-ARRAY content from $results_uri\n"
		unless ref

5.010;
use strict;
use App::Cmd::Setup-command;

use File::HomeDir qw<>;
use File::Temp qw<>;
use JSON qw<>;
use Path::Tiny qw<>;
use Object::AUTHORITY;

my %config;

sub get_tempdir
{
	Path::Tiny::->

d_names)[0]),
		'config.json',
	);
}

sub get_config
{
	my $proto = shift;
	my $class = ref($proto) || $proto;
	
	unless ($config{$class})
	{
		$config{$class} =
			eval { JSON::->new->decode(scalar $

'all';
use Moo;
use Getopt::Long qw(GetOptionsFromArray);
use Mojo::UserAgent;
use Try::Tiny;
use JSON;
use Time::HiRes;

=head1 NAME

Uninets::Check::Modules::HTTP - Uninets::Check module to check we

, $value, $format) = @_;

    return JSON->new->encode(
        {
            message => $value,
            status  => $status,
        }
    ) if $format eq 'json';
    # default last in case some n

mats => {
                    'num'  => 'Returns the status code',
                    'json' => 'Returns a JSON structure',
                },
                default_format => 'num',
            },

=item *

L<autobox|autobox>

=item *

L<autobox::Core|autobox::Core>

=item *

L<autobox::JSON|autobox::JSON>

=item *

L<MIME::Base64|MIME::Base64>

=back

=head1 SOURCE

The development version is 

ATAL => 'all';
use Moo;
use Getopt::Long qw(GetOptionsFromArray);
use Try::Tiny;
use MongoDB;
use JSON;

=head1 NAME

Uninets::Check::Modules::MongoDB - Uninets::Check module to check mongodb servers.

	my ($self, $status, $value, $format) = @_;

	return JSON->new->encode(
		{
			message => $value,
			status  => $status,
		}
	) if $format eq 'json';
	# default last in case some non supported format 

 'Default: num'
				},
				formats => {
					'num'  => 'Returns the status code',
					'json' => 'Returns a JSON structure',
				},
			},
		},
	}
}

=head1 AUTHOR

Matthias Krull, C<< <<m.krull at uni

I::Command::Settings::VERSION = '0.751';
}
use Any::Moose;
use Params::Validate qw/validate/;
use JSON;

extends 'Prophet::CLI::Command';
with 'Prophet::CLI::TextEditorCommand';

sub ARG_TRANSLATIONS 

ngs edit
       ${cmd}settings set -- setting "new value"

Note that setting values must be valid JSON.
END_USAGE
}

sub run {
    my $self = shift;

    $self->print_usage if $self->has_arg('h');

  

ue to $new_value.\n";
            if ( $old_value ne $new_value ) {
                $s->set( from_json( $new_value, { utf8 => 1 } ) );
                print " -> Changed.\n";
            } else {
    

 FATAL => 'all';
use Moo;
use Getopt::Long qw(GetOptionsFromArray);
use Redis;
use Try::Tiny;
use JSON;

=head1 NAME

Uninets::Check::Modules::Redis - Uninets::Check module to check redis servers.

=h

	my ($self, $status, $value, $format) = @_;

	return JSON->new->encode(
		{
			message => $value,
			status  => $status,
		}
	) if $format eq 'json';
	# default last in case some non supported format 

'Default: num',
				},
				formats => {
					'num'  => 'Returns the status code',
					'json' => 'Returns a JSON structure',
				},
			},
			size => {
				description => 'Check redis RAM consumption',