Result:
found more than 290 distributions - search limited to the first 2001 files matching your query
( run in 0.427 )
AMF-Connection
view release on metacpan or search on metacpan
lib/AMF/Connection.pm view on Meta::CPAN
package AMF::Connection;
use AMF::Connection::Message;
use AMF::Connection::MessageBody;
use AMF::Connection::OutputStream;
use AMF::Connection::InputStream;
use LWP::UserAgent;
use HTTP::Cookies;
#use Data::Dumper; #for debug
use Carp;
use strict;
our $VERSION = '0.32';
our $HASMD5 = 0;
{
local $@;
eval { require Digest::MD5; };
$HASMD5 = ($@) ? 0 : 1 ;
};
our $HASUUID;
{
local $@;
eval { require Data::UUID; };
$HASUUID = ($@) ? 0 : 1 ;
}
our $HAS_LWP_PROTOCOL_SOCKS;
{
local $@;
eval { require LWP::Protocol::socks };
$HAS_LWP_PROTOCOL_SOCKS = ($@) ? 0 : 1 ;
}
sub new {
my ($proto, $endpoint) = @_;
my $class = ref($proto) || $proto;
my $self = {
'endpoint' => $endpoint,
'headers' => [],
'http_headers' => {},
'http_cookie_jar' => new HTTP::Cookies(),
'response_counter' => 0,
'encoding' => 0, # default is AMF0 encoding
'ua' => new LWP::UserAgent(),
'append_to_endpoint' => ''
};
$self->{'ua'}->cookie_jar( $self->{'http_cookie_jar'} );
return bless($self, $class);
};
# plus add paramters, referer, user agent, authentication/credentials ( see also SecureAMFChannel stuff ),
# plus timezone on retunred dates to pass to de-serializer - see AMF3 spec saying "it is suggested that time zone be queried independnetly as needed" - unelss local DateTime default to right locale!
# we pass the string, and let Storable::AMF to parse the options into a scalar - see Input/OutputStream and Storable::AMF0 documentation
sub setInputAMFOptions {
my ($class, $options) = @_;
$class->{'input_amf_options'} = $options;
};
sub setOutputAMFOptions {
my ($class, $options) = @_;
$class->{'output_amf_options'} = $options;
};
# useful when input and output options are the same
sub setAMFOptions {
my ($class, $options) = @_;
$class->setInputAMFOptions ($options);
$class->setOutputAMFOptions ($options);
};
sub getInputAMFOptions {
my ($class) = @_;
return $class->{'input_amf_options'};
};
sub getOutputAMFOptions {
my ($class) = @_;
return $class->{'output_amf_options'};
};
sub setEndpoint {
my ($class, $endpoint) = @_;
$class->{'endpoint'} = $endpoint;
};
sub getEndpoint {
my ($class) = @_;
return $class->{'endpoint'};
};
sub setHTTPProxy {
my ($class, $proxy) = @_;
if( ($proxy =~ m!^socks://(.*?):(\d+)!) &&
(!$HAS_LWP_PROTOCOL_SOCKS) ) {
croak "LWP::Protocol::socks is required for SOCKS support";
};
$class->{'http_proxy'} = $proxy;
$class->{'ua'}->proxy( [qw(http https)] => $class->{'http_proxy'} );
};
API-Assembla
view release on metacpan or search on metacpan
lib/API/Assembla.pm view on Meta::CPAN
package API::Assembla;
BEGIN {
$API::Assembla::VERSION = '0.03';
}
use Moose;
use DateTime::Format::ISO8601;
use LWP::UserAgent;
use URI;
use XML::XPath;
use API::Assembla::Space;
use API::Assembla::Ticket;
# ABSTRACT: Access to Assembla API via Perl.
has '_client' => (
is => 'ro',
isa => 'LWP::UserAgent',
lazy => 1,
default => sub {
my $self = shift;
return LWP::UserAgent->new;
}
);
has 'password' => (
is => 'ro',
isa => 'Str',
required => 1
);
has 'url' => (
is => 'ro',
isa => 'URI',
lazy => 1,
default => sub {
my $self = shift;
return URI->new('https://www.assembla.com/');
}
);
has 'username' => (
is => 'ro',
isa => 'Str',
required => 1
);
sub get_space {
my ($self, $id) = @_;
my $req = $self->make_req('/spaces/'.$id);
my $resp = $self->_client->request($req);
# print STDERR $resp->decoded_content;
my $xp = XML::XPath->new(xml => $resp->decoded_content);
my $space = $xp->find('/space')->pop;
my $name = $space->findvalue('name')."";
return API::Assembla::Space->new(
id => $space->findvalue('id').'',
created_at => DateTime::Format::ISO8601->parse_datetime($space->findvalue('created-at').''),
name => $name,
description => $space->findvalue('description').'',
);
}
sub get_spaces {
my ($self) = @_;
my $req = $self->make_req('/spaces/my_spaces');
my $resp = $self->_client->request($req);
# print STDERR $resp->decoded_content;
my $xp = XML::XPath->new(xml => $resp->decoded_content);
my $spaces = $xp->find('/spaces/space');
my %objects = ();
foreach my $space ($spaces->get_nodelist) {
my $name = $space->findvalue('name')."";
$objects{$name} = API::Assembla::Space->new(
id => $space->findvalue('id').'',
created_at => DateTime::Format::ISO8601->parse_datetime($space->findvalue('created-at').''),
name => $name,
description => $space->findvalue('description').'',
);
}
return \%objects;
}
sub get_ticket {
my ($self, $id, $number) = @_;
my $req = $self->make_req('/spaces/'.$id.'/tickets/'.$number);
my $resp = $self->_client->request($req);
# print STDERR $resp->decoded_content;
my $xp = XML::XPath->new(xml => $resp->decoded_content);
my $ticket = $xp->find('/ticket')->pop;
return API::Assembla::Ticket->new(
id => $ticket->findvalue('id').'',
created_on => DateTime::Format::ISO8601->parse_datetime($ticket->findvalue('created-on').''),
description => $ticket->findvalue('description').'',
number => $ticket->findvalue('number').'',
priority => $ticket->findvalue('priority').'',
status_name => $ticket->findvalue('status-name').'',
summary => $ticket->findvalue('summary').''
);
}
sub get_tickets {
my ($self, $id) = @_;
my $req = $self->make_req('/spaces/'.$id.'/tickets');
my $resp = $self->_client->request($req);
# print STDERR $resp->decoded_content;
my $xp = XML::XPath->new(xml => $resp->decoded_content);
my $tickets = $xp->find('/tickets/ticket');
my %objects = ();
foreach my $ticket ($tickets->get_nodelist) {
my $id = $ticket->findvalue('id').'';
$objects{$id} = API::Assembla::Ticket->new(
id => $id,
created_on => DateTime::Format::ISO8601->parse_datetime($ticket->findvalue('created-on').''),
description => $ticket->findvalue('description').'',
number => $ticket->findvalue('number').'',
priority => $ticket->findvalue('priority').'',
status_name => $ticket->findvalue('status-name').'',
summary => $ticket->findvalue('summary').''
);
}
return \%objects;
}
sub make_req {
my ($self, $path) = @_;
my $req = HTTP::Request->new(GET => $self->url.$path);
$req->header(Accept => 'application/xml');
$req->authorization_basic($self->username, $self->password);
return $req;
}
__PACKAGE__->meta->make_immutable;
1;
=pod
=head1 NAME
API::Assembla - Access to Assembla API via Perl.
=head1 VERSION
version 0.03
=head1 UNDER CONSTRUCTION
API::Assembla is not feature-complete. It's a starting point. The Assembla
API has LOTS of stuff that this module does not yet contain. These features
will be added as needed by the author or as gifted by thoughtful folks who
write patches! ;)
=head1 SYNOPSIS
use API::Assembla;
my $api = API::Asembla->new(
username => $username,
password => $password
);
my $href_of_spaces = $api->get_spaces;
# Got an href of API::Assembla::Space objects keyed by space id
my $space = $api->get_space($space_id);
# Got an API::Assembla::Space object
my $href_of_tickets = $api->get_tickets;
# Got an href of API::Assembla::Space objects keyed by ticket id
my $ticket = $api->get_ticket($space_id, $ticket_number);
API-Google
view release on metacpan or search on metacpan
lib/API/Google/GCal.pm view on Meta::CPAN
sub busy_time_ranges {
my ($self, $params) = @_;
$self->api_query({
method => 'post',
route => $self->{api_base}.'/freeBusy',
user => $params->{user}
}, {
timeMin => $params->{dt_start},
timeMax => $params->{dt_end},
timeZone => $params->{timeZone},
items => [{ 'id' => $params->{calendarId} }]
});
};
sub events_list {
my ($self, $params) = @_;
if (!defined $params->{calendarId}) { die "No calendarId provided as parameter"}
if (!defined $params->{user}) { die "No user provided as parameter"}
my $res = $self->api_query({
method => 'get',
route => $self->{api_base}.'/calendars/'.$params->{calendarId}.'/events',
user => $params->{user}
});
if (defined $res->{items}) { return $res->{items} };
if (defined $res->{error}) { return $res };
};
1;
__END__
=pod
=encoding UTF-8
=head1 NAME
API::Google::GCal - Google Calendar API client
=head1 VERSION
version 0.12
=head1 SYNOPSIS
use API::Google::GCal;
my $gapi = API::Google::GCal->new({ tokensfile => 'config.json' });
my $user = 'someuser@gmail.com';
my $calendar_id = 'ooqfhagr1a91u1510ffdf7vfpk@group.calendar.google.com';
my $timeZone = 'Europe/Moscow';
my $event_start = DateTime->now->set_time_zone($timeZone);
my $event_end = DateTime->now->add_duration( DateTime::Duration->new( hours => 2) );
$gapi->refresh_access_token_silent($user); # inherits from API::Google
$gapi->get_calendars($user);
$gapi->get_calendars($user, ['id', 'summary']); # return only specified fields
$gapi->get_calendar_id_by_name($user, 'Contacts');
my $event_data = {};
$event_data->{summary} = 'Exibition';
$event_data->{description} = 'Amazing cats exibition';
$event_data->{location} = 'Angels av. 13';
$event_data->{start}{dateTime} = DateTime::Format::RFC3339->format_datetime($event_start); # '2016-11-11T09:00:00+03:00' format
$event_data->{end}{dateTime} = DateTime::Format::RFC3339->format_datetime($event_end);
$event_data->{start}{timeZone} = $event_data->{end}{timeZone} = $timeZone; # not obligatory
$gapi->add_event($user, $calendar_id, $event_data);
my $freebusy_data = {
user => $user,
calendarId => $calendar_id,
dt_start => DateTime::Format::RFC3339->format_datetime($event_start),
dt_end => DateTime::Format::RFC3339->format_datetime($event_end),
timeZone => 'Europe/Moscow'
};
$gapi->busy_time_ranges($freebusy_data);
$gapi->events_list($freebusy_data);
=head2 get_calendars
Get all calendars of particular Google account
=head2 get_calendar_id_by_name
$gapi->get_calendar_id_by_name($user, $name)
Get calendar id by its name. Name = "summary" parameter
=head2 add_event
$gapi->add_event($user, $calendar_id, $event_data)
# https://developers.google.com/google-apps/calendar/v3/reference/events/insert
=head2 busy_time_ranges
Return List of time ranges during which this calendar should be regarded as busy.
=head2 events_list
Return list of events in particular calendar
L<https://developers.google.com/google-apps/calendar/v3/reference/events/list>
Usage:
$gapi->events_list({
calendarId => 'ooqfhagr1a91u1510ffdf7vfpk@group.calendar.google.com',
user => 'someuser@gmail.com'
});
=head1 AUTHOR
Pavel Serikov <pavelsr@cpan.org>
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2016 by Pavel Serikov.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
ASNMTAP
view release on metacpan or search on metacpan
applications/collector-test.pl view on Meta::CPAN
} else {
$action = 'Failed';
$dumphttpRename = 'UNKNOWN';
printDebugAll (" call_system --- : $system_action: <$exit_value><$signal_num><$dumped_core><$stderr>");
printDebugNOK (" call_system --- : $system_action: <$exit_value><$signal_num><$dumped_core><$stderr>");
if ( $exit_value == -1 ) {
$returnStatus = "$dumphttpRename - $title: PLUGIN '$msgCommand.pl' doesn't exist - contact administrators";
} elsif ( $boolean_signal_kill ) {
$returnStatus = "$dumphttpRename - $title: TIMING OUT SLOW PLUGIN";
my $httpdumpFilenameTmpKnownError = $httpdumpFilenameTmp .'-KnownError';
unlink ($httpdumpFilenameTmpKnownError) if (-e "$httpdumpFilenameTmpKnownError");
unlink ($httpdumpFilenameTmp) if (-e "$httpdumpFilenameTmp");
} else {
$returnStatus = "$dumphttpRename - $title: ERROR NOT DEFINED - contact server administrators";
}
}
$endDate = get_csvfiledate();
$endTime = get_csvfiletime();
unless ( $CAPTUREOUTPUT ) {
$loggedStatus = ( $dumphttp ne 'N' ) ? $httpdumpFilenameTmp : $logging;
$loggedStatus .= '-status.txt';
$returnStatus = "<NIHIL> - $title: $loggedStatus";
if (-e "$loggedStatus") {
unless ( $boolean_signal_kill ) {
$rvOpen = open(DEBUG, "$loggedStatus");
if ($rvOpen) {
while (<DEBUG>) {
chomp;
$returnStatus = $_;
}
close(DEBUG);
} else {
$dumphttpRename = 'UNKNOWN';
$returnStatus = "$dumphttpRename - $title: Cannot open $loggedStatus to retrieve debug information - contact server administrators";
}
}
unlink ($loggedStatus);
} else {
$dumphttpRename = 'UNKNOWN';
$returnStatus = "$dumphttpRename - $title: $loggedStatus doesn't exist - contact server administrators";
}
}
my ($duration) = $returnStatus =~ m/Trendline=([0-9.]+)s;[0-9.]+;;;$/i;
if (defined $duration) {
my ($thour, $tmin, $tsec);
$thour = int ($duration / 3600);
$tmin = int (int ($duration % 3600) / 60);
$tsec = int ($duration % 60);
$duration = sprintf("%02d:%02d:%02d", $thour, $tmin, $tsec);
} else {
my ($tyear, $tmonth, $tday, $thour, $tmin, $tsec, @startDateTime, @endDateTime, @diffDateTime);
($tyear, $tmonth, $tday) = split(/\//, $startDate);
($thour, $tmin, $tsec) = split(/\:/, $startTime);
@startDateTime = ($tyear, $tmonth, $tday, $thour, $tmin, $tsec);
($tyear, $tmonth, $tday) = split(/\//, $endDate);
($thour, $tmin, $tsec) = split(/\:/, $endTime);
@endDateTime = ($tyear, $tmonth, $tday, $thour, $tmin, $tsec);
@diffDateTime = Delta_DHMS(@startDateTime, @endDateTime);
$duration = sprintf("%02d:%02d:%02d", $diffDateTime[1], $diffDateTime[2], $diffDateTime[3]);
}
# my ($outputData, $performanceData) = split(/\|/, $returnStatus, 2);
my $_returnStatus = reverse $returnStatus;
my ($_outputData, $_performanceData) = reverse split(/\|/, $_returnStatus, 2);
my $outputData = reverse $_outputData;
my $performanceData = reverse $_performanceData;
$rvOpen = open(CSV,">>$logging-$msgCommand-$catalogID_uniqueKey-csv.txt");
if ($rvOpen) {
print CSV '"', $catalogID, '","","', $uniqueKey, '","I","', $system_action, '","', $title, '","', $dumphttpRename, '","', $startDate, '","', $startTime, '","', $endDate, '","', $endTime, '","', $duration, '","', $outputData, '","', $performanceDa...
close(CSV);
} else {
print "Cannot open $logging-$msgCommand-$catalogID_uniqueKey-csv.txt to print debug information\n";
}
if ( $boolean_perfParseInstalled ) {
if (defined $performanceData) {
my $perfParseTimeslot = get_timeslot ($currentDate);
my $perfParseCommand;
my $environment = (($system_action =~ /\-\-environment=([PASTDL])/) ? $1 : 'P');
my $eTitle = $title .' ('. $ENVIRONMENT{$environment} .')' if (defined $environment);
$eTitle .= ' from '. $catalogID;
if ( $perfParseMethode eq 'PULP' ) {
$perfParseCommand = "$APPLICATIONPATH/sbin/perfparse_asnmtap_pulp_command.pl $PREFIXPATH/log/perfdata-asnmtap.log \"$perfParseTimeslot\t$eTitle\t$catalogID_uniqueKey\t$outputData\t$dumphttpRename\t$performanceData\"";
} else {
$perfParseCommand = "printf \"%b\" \"$perfParseTimeslot\t$eTitle\t$catalogID_uniqueKey\t$outputData\t$dumphttpRename\t$performanceData\n\" | $PERFPARSEBIN/perfparse-log2mysql -c $PERFPARSEETC/$PERFPARSECONFIG";
}
if ($CAPTUREOUTPUT) {
use IO::CaptureOutput qw(capture_exec);
($stdout, $stderr) = capture_exec("$perfParseCommand");
} else {
system ("$perfParseCommand"); $stdout = $stderr = '';
}
$exit_value = $? >> 8;
$signal_num = $? & 127;
$dumped_core = $? & 128;
printDebugNOK (" perfParse ----- : $perfParseCommand: <$exit_value><$signal_num><$dumped_core><$stderr>") unless ( $exit_value == 0 && $signal_num == 0 && $dumped_core == 0 && $stderr eq '' );
}
}
insertEntryDBI ($currentDate, $catalogID_uniqueKey, $catalogID, $uniqueKey, $title, $dbiFilename.$msgCommand.'-'.$catalogID_uniqueKey.'-sql', $system_action, $interval, $dumphttpRename, $logging, $debug, $startDate, $startTime, $endDate, $endTime, ...
return $action;
}
# - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
sub printDebugAll {
my ($l_text) = @_;
if ($boolean_screenDebug or $boolean_debug_all) {
chomp ($l_text);
my $date = scalar(localtime());
my $tlogging = $logging . get_logfiledate();
AWS-Networks
view release on metacpan or search on metacpan
lib/AWS/Networks.pm view on Meta::CPAN
package AWS::Networks;
use Moose;
use JSON;
use HTTP::Tiny;
use DateTime;
our $VERSION = '0.01';
has url => (
is => 'ro',
isa => 'Str|Undef',
default => 'https://ip-ranges.amazonaws.com/ip-ranges.json'
);
has netinfo => (
is => 'ro',
isa => 'HashRef',
default => sub {
my $self = shift;
die "Can't get some properties from derived results" if (not $self->url);
my $response = HTTP::Tiny->new->get($self->url);
die "Error downloading URL" unless ($response->{ success });
return decode_json($response->{ content });
},
lazy => 1,
);
has sync_token => (
is => 'ro',
isa => 'DateTime',
default => sub {
return DateTime->from_epoch( epoch => shift->netinfo->{ syncToken } );
},
lazy => 1,
);
has networks => (
is => 'ro',
isa => 'ArrayRef',
default => sub {
return shift->netinfo->{ prefixes };
},
lazy => 1,
);
has regions => (
is => 'ro',
isa => 'ArrayRef',
default => sub {
my ($self) = @_;
my $regions = {};
map { $regions->{ $_->{ region } } = 1 } @{ $self->networks };
return [ keys %$regions ];
},
lazy => 1,
);
sub by_region {
my ($self, $region) = @_;
return AWS::Networks->new(
url => undef,
sync_token => $self->sync_token,
networks => [ grep { $_->{ region } eq $region } @{ $self->networks } ]
);
}
has services => (
is => 'ro',
isa => 'ArrayRef',
default => sub {
my ($self) = @_;
my $services = {};
map { $services->{ $_->{ service } } = 1 } @{ $self->networks };
return [ keys %$services ];
},
lazy => 1,
);
sub by_service {
my ($self, $service) = @_;
return AWS::Networks->new(
url => undef,
sync_token => $self->sync_token,
networks => [ grep { $_->{ service } eq $service } @{ $self->networks } ]
);
}
has cidrs => (
is => 'ro',
isa => 'ArrayRef',
default => sub {
my ($self) = @_;
return [ map { $_->{ ip_prefix } } @{ $self->networks } ];
},
lazy => 1,
);
1;
#################### main pod documentation begin ###################
=head1 NAME
AWS::Networks - Parse and query official AWS network ranges
=head1 SYNOPSIS
use AWS::Networks;
my $nets = AWS::Networks->new();
say $nets->sync_token->iso8601;
foreach my $cidr (@{ $nets->cidrs }){
say $cidr
}
=head1 DESCRIPTION
This module parses the official public IP network information published by Amazon Web Services at https://ip-ranges.amazonaws.com/ip-ranges.json
Please read and understand the information can be found at http://docs.aws.amazon.com/general/latest/gr/aws-ip-ranges.html to make sense of the data retured by this module.
=head1 USAGE
Instance an object, and use it to filter information of interest to you with the attributes and methods provided.
=head1 METHODS
=head2 new([ url => 'http....' ])
Standard Moose constructor. Can specify a custom URL to download a document that follows the same schema
=head2 url
Returns the URL from which the information was retrieved. Returns undef on filtered datasets
=head2 sync_token
Returns a DateTime object created from the current timestamp of the syncToken reported from the service
=head2 networks
Returns an ArrayRef with HashRefs following the following structure:
{ ip_prefix => '0.0.0.0/0', region => '...', service => '...' }
The keys and values in the HashRefs are the ones returned by the Network service
service can be one of: AMAZON | EC2 | CLOUDFRONT | ROUTE53 | ROUTE53_HEALTHCHECKS, but expect
new values to appear
region can be one of: ap-northeast-1 | ap-southeast-1 | ap-southeast-2 | cn-north-1 | eu-central-1 | eu-west-1 | sa-east-1 | us-east-1 | us-gov-west-1 | us-west-1 | us-west-2 | GLOBAL, but expect new values to appear
=head2 services
Returns an ArrayRef of the different services present in the current dataset
=head2 regions
Returns an ArrayRef of the different regions present in the current dataset
=head2 cidrs
Returns an ArrayRef with the CIDR blocks in the dataset
=head2 by_region($region)
Returns a new AWS::Networks object with the data filtered to only the objects in the
specified region
=head2 by_service($service)
Returns a new AWS::Networks object with the data filtered to only the services specified
=cut
=head1 CONTRIBUTE
The source code is located here: https://github.com/pplu/aws-networks
=head2 SEE ALSO
The dist is bundled with a couple of sample scripts in bin that play around with
the information returned by this module, these scripts try to determine the number
of IP addresses that AWS has, and given an IP address, if it pertains to AWS, and
what service.
=head1 AUTHOR
Jose Luis Martinez
CPAN ID: JLMARTIN
CAPSiDE
jlmartinez@capside.com
http://www.pplusdomain.net
=head1 COPYRIGHT
Copyright (c) 2014 by Jose Luis Martinez Torres
AXL-Client-Simple
view release on metacpan or search on metacpan
share/AXLSoap.xsd view on Meta::CPAN
</xsd:annotation>
</xsd:element>
<xsd:element name="failedLogon" type="xsd:nonNegativeInteger" nillable="false">
<xsd:annotation>
<xsd:documentation>Failed logon must be a number in the range 0 to 100.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="resetFailedLogonAttempts" type="xsd:nonNegativeInteger" nillable="false">
<xsd:annotation>
<xsd:documentation>Reset Failed logon attempts must be a number in the range 1 to 120.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="administratorMustUnlock" type="xsd:boolean" nillable="true" minOccurs="0">
<xsd:annotation>
<xsd:documentation>If this tag is set to true, zero is inserted into the database for lockoutDuration.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="lockoutDuration" type="xsd:nonNegativeInteger" nillable="false">
<xsd:annotation>
<xsd:documentation>Lockout duration must be a number in the range 0 to 1440.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="credChangeDuration" type="xsd:nonNegativeInteger" nillable="false">
<xsd:annotation>
<xsd:documentation>Credential change duration must be a number in the range 0 to 129600.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="neverExpires" type="xsd:boolean" nillable="true" minOccurs="0">
<xsd:annotation>
<xsd:documentation>If this tag is set to true, zero is inserted into the database for credExpiresAfter.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="credExpiresAfter" type="xsd:nonNegativeInteger" nillable="false">
<xsd:annotation>
<xsd:documentation>Credential expires after must be a number in the range 0 to 365.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="minCredLength" type="xsd:nonNegativeInteger" nillable="false">
<xsd:annotation>
<xsd:documentation>Minimum credential length must be a number in the range 0 to 64.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="prevCredStoredNum" type="xsd:nonNegativeInteger" nillable="false">
<xsd:annotation>
<xsd:documentation>Stored number of previous credentials must be a number in the range 0 to 25.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="inactiveDaysAllowed" type="xsd:nonNegativeInteger" nillable="false">
<xsd:annotation>
<xsd:documentation>Inactive days allowed must be a number in the range 0 to 5000.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="expiryWarningDays" type="xsd:nonNegativeInteger" nillable="false">
<xsd:annotation>
<xsd:documentation>Expiry warning days must be a number in the range 0 to 90.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="trivialCredCheck" type="xsd:boolean" nillable="false"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="XDateTimeSetting">
<xsd:sequence minOccurs="0">
<xsd:element name="name" type="axlapi:String50"/>
<xsd:element name="dateTemplate" type="axlapi:String50"/>
<xsd:element name="timeZone" type="xsd:string"/><!--This field is of the type axl:XTimeZone in AXLEnums.xsd-->
</xsd:sequence>
<xsd:attribute name="uuid" type="axlapi:XUUID"/>
</xsd:complexType>
<xsd:complexType name="XDevicePool">
<xsd:sequence minOccurs="0">
<xsd:element name="name" type="axlapi:UniqueString50">
<xsd:annotation>
<xsd:documentation>Not nullable.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:choice minOccurs="0">
<xsd:element name="autoSearchSpace" type="axlapi:XCallingSearchSpace">
<xsd:annotation>
<xsd:documentation>Only the uuid attribute is read by the AXL API. Nullable.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="autoSearchSpaceName" type="axlapi:String50"/>
</xsd:choice>
<xsd:choice>
<xsd:element name="dateTimeSetting" type="axlapi:XDateTimeSetting">
<xsd:annotation>
<xsd:documentation>Only the uuid attribute is read by the AXL API. Not Nullable.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="dateTimeSettingName" type="axlapi:String50"/>
</xsd:choice>
<xsd:choice>
<xsd:element name="callManagerGroup" type="axlapi:XCallManagerGroup">
<xsd:annotation>
<xsd:documentation>Only the uuid attribute is read by the AXL API. Not nullable.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="callManagerGroupName" type="axlapi:String50"/>
</xsd:choice>
<xsd:choice minOccurs="0">
<xsd:annotation>
<xsd:documentation>uuid will be returned in get Response.</xsd:documentation>
</xsd:annotation>
<xsd:element name="mediaResourceList" type="axlapi:XMediaResourceList">
<xsd:annotation>
<xsd:documentation>Only the uuid attribute is read by the AXL API. Nullable.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="mediaResourceListName" type="axlapi:String50"/>
</xsd:choice>
<xsd:choice>
<xsd:element name="region" type="axlapi:XRegion">
<xsd:annotation>
<xsd:documentation>Only the uuid attribute is read by the AXL API. Nullable.</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="regionName" type="axlapi:String50"/>
</xsd:choice>
<xsd:element name="networkLocale" type="xsd:string" minOccurs="0">
<xsd:annotation>
<xsd:documentation>Nullable. The value accepted and retrieved from the database for this field will be of type XCountry in AXLEnums.xsd</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:choice>
<xsd:element name="srstInfo" type="axlapi:XSRSTInfo"/>
<xsd:element name="srstName" type="axlapi:String50"/>
</xsd:choice>
<xsd:element name="connectionMonitorDuration" type="xsd:int" nillable="false" minOccurs="0">
<xsd:annotation>
<xsd:documentation>-1 means using system default</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:choice minOccurs="0">
<xsd:element name="automatedAlternateRoutingCSS" type="axlapi:XCallingSearchSpace" nillable="true">
<xsd:annotation>
<xsd:documentation>The calling search space used by Automated Alternate Routing. Nullable. Only the uuid attribute is read by the AXL API</xsd:documentation>
</xsd:annotation>
</xsd:element>
<xsd:element name="automatedAlternateRoutingCSSName" type="axlapi:String50" nillable="true">
<xsd:annotation>
<xsd:documentation>name of the calling search space used by Automated Alternate Routing. Nullable.</xsd:documentation>
</xsd:annotation>
</xsd:element>
</xsd:choice>
<xsd:choice minOccurs="0">
Acme-2zicon
view release on metacpan or search on metacpan
lib/Acme/2zicon.pm view on Meta::CPAN
package Acme::2zicon;
use 5.008001;
use strict;
use warnings;
use Carp qw(croak);
use DateTime;
our $VERSION = "0.7";
my @members = qw(
MatobaKarin
NakamuraAkari
NemotoNagi
OkumuraNonoka
ShigematsuYuka
SuyamaEmiri
TsurumiMoe
OtsukaMiyu
YamatoAo
);
sub new {
my $class = shift;
my $self = bless {members => []}, $class;
$self->_initialize;
return $self;
}
sub members {
my ($self, $type, @members) = @_;
@members = @{$self->{members}} unless @members;
return @members unless $type;
}
sub sort {
my ($self, $type, $order, @members) = @_;
@members = $self->members unless @members;
# order by desc if $order is true
if ($order) {
return sort {$b->$type <=> $a->$type} @members;
}
else {
return sort {$a->$type <=> $b->$type} @members;
}
}
sub select {
my ($self, $type, $number, $operator, @members) = @_;
$self->_die('invalid operator was passed in')
unless grep {$operator eq $_} qw(== >= <= > <);
@members = $self->members unless @members;
my $compare = eval "(sub { \$number $operator \$_[0] })";
return grep { $compare->($_->$type) } @members;
}
sub _initialize {
my $self = shift;
for my $member (@members) {
Acme-BABYMETAL
view release on metacpan or search on metacpan
lib/Acme/BABYMETAL/Base.pm view on Meta::CPAN
package Acme::BABYMETAL::Base;
use strict;
use warnings;
use DateTime;
use base qw(Class::Accessor);
our $VERSION = '0.03';
__PACKAGE__->mk_accessors(qw(
metal_name
name_ja
first_name_ja
family_name_ja
name_en
first_name_en
family_name_en
birthday
age
blood_type
hometown
));
sub new {
my $class = shift;
my $self = bless {}, $class;
$self->_initialize;
return $self;
}
sub _initialize {
my $self = shift;
my %info = $self->info;
$self->{$_} = $info{$_} for keys %info;
$self->{name_ja} = $self->family_name_ja . $self->first_name_ja;
$self->{name_en} = $self->first_name_en . ' ' . $self->family_name_en;
my ($year, $month, $day) = ($self->{birthday} =~ /^(\d{4})-(\d{2})-(\d{2})$/);
$self->{age} = (DateTime->now - DateTime->new(
year => $year,
month => $month,
day => $day,
))->years;
return 1;
}
sub shout {
my $self = shift;
print $self->metal_name . " DEATH!!\n";
}
1;
Acme-CPANAuthors-BackPAN-OneHundred
view release on metacpan or search on metacpan
examples/update100.pl view on Meta::CPAN
#!/usr/bin/perl
use warnings;
use strict;
$|++;
my $VERSION = '1.05';
#----------------------------------------------------------------------------
=head1 NAME
update100.pl - preps the OneHundred module for release, if required.
=head1 SYNOPSIS
perl update100.pl
=head1 DESCRIPTION
Downloads the latest copy of the backpan100.csv file from CPAN Testers
Statistics site. Compares with the previous download, and if there is a change,
takes the module template and inserts the appropriate data ready for the next
release.
=cut
# -------------------------------------
# Library Modules
use CPAN::Changes;
#use Data::Dumper;
use DateTime;
use File::Basename;
use Getopt::Long;
use IO::File;
use Template;
use WWW::Mechanize;
# -------------------------------------
# Variables
my (%options,%old,%new,%tvars,%pause,%changes);
my $changed = 0;
my $max = 4;
my @files = qw(
lib/Acme/CPANAuthors/BackPAN/OneHundred.pm
LICENSE
META.json
META.yml
README
t/10cpanauthor.t
);
my %config = ( # default config info
RELATIVE => 1,
ABSOLUTE => 1,
INTERPOLATE => 0,
POST_CHOMP => 1,
TRIM => 0,
INCLUDE_PATH => 'templates',
OUTPUT_PATH => '..'
);
my %groups = (
'insert' => 'New Authors',
'update' => 'Updated Counts',
'delete' => 'See You Again?',
);
# -------------------------------------
# Program
GetOptions(\%options, 'local', 'build', 'release') or die "Usage: $0 [--local] [--build] [--release]\n";
my $base = dirname($0);
chdir($base);
#print "dir=$base\n";
unless($options{local}) {
my $mech = WWW::Mechanize->new();
my $source = 'http://stats.cpantesters.org/stats/backpan100.csv';
my $target = basename($source);
$mech->mirror($source,$target);
}
# read old file
my $inx = 0;
my $file = 'data/backpan100.csv';
if(my $fh = IO::File->new($file,'r')) {
while(<$fh>) {
s/\s+$//;
examples/update100.pl view on Meta::CPAN
if($inx == 1) {
$tvars{TOPDOG} = $pause;
$tvars{TOPCAT} = $name;
}
# check whether anything has changed
if(!$pause{$pause}) {
push @{$changes{insert}}, $pause;
$changed = 1;
} elsif($pause{$pause} != $cnt) {
push @{$changes{update}}, $pause;
delete $pause{$pause};
$changed = 1;
} elsif($old{$inx} && ($old{$inx}{name} ne $name || $old{$inx}{pause} ne $pause)) {
delete $pause{$pause};
$changed = 1;
} else {
delete $pause{$pause};
}
$max = length $new{$inx}{pause} if($max < length $new{$inx}{pause});
}
$fh->close;
$tvars{COUNT} = scalar(keys %new);
#print "new=" . Dumper(\%new);
#print "pause=" . Dumper(\%pause);
# counts can go down as well as up
if(scalar(keys %pause)) {
$changed = 1;
push @{$changes{delete}}, $_
for(keys %pause);
}
#print "max=$max, changed=$changed\n";
# bail if nothing has changed
unless($changed) {
print "Nothing has changed, bailing\n";
exit 0;
}
$max = (int($max/4) + 1) * 4 if($max % 4);
$max+=2;
# create lists
for my $inx (sort {$new{$a}{pause} cmp $new{$b}{pause}} keys %new) {
my $pad = $max - length $new{$inx}{pause};
push @{$tvars{LIST1}}, sprintf " '%s'%s=> '%s',", $new{$inx}{pause}, (' ' x $pad), $new{$inx}{name};
}
my $cnt = 1;
for my $inx (sort {$new{$b}{count} <=> $new{$a}{count} || $new{$a}{pause} cmp $new{$b}{pause}} keys %new) {
my $pad = $max - length $new{$inx}{pause};
push @{$tvars{LIST2}}, sprintf " %2d. %3d %s%s%s", $cnt++, $new{$inx}{count}, $new{$inx}{pause}, (' ' x $pad), $new{$inx}{name};
}
# calculate copyright
$tvars{COPYRIGHT} = '2014';
my $year = DateTime->now->year;
$tvars{COPYRIGHT} .= "-$year" if($year > 2014);
# calculate version
$file = '../Changes';
my $changes = CPAN::Changes->load( $file );
my @releases = $changes->releases();
my $version = $releases[-1]->{version};
$version += 0.01;
$tvars{VERSION} = sprintf "%.2f", $version;
# update Changes file
my $release = CPAN::Changes::Release->new( version => $tvars{VERSION}, date => DateTime->now->ymd );
for my $group (qw(insert update delete)) {
next unless($changes{$group});
$release->add_changes(
{ group => $groups{$group} },
join(', ',@{$changes{$group}})
);
push @releases, $release;
}
$changes->releases( @releases );
$fh = IO::File->new($file,'w+') or die "Cannot open file [$file]: $!\n";
my $content = $changes->serialize;
my @content = split(/\n/,$content);
$content = '';
for my $line (@content) {
$line =~ s/^([\d.]+)\s+(.*?)$/$1 $2/;
$line =~ s/^\s+(.*?)/ $1/;
$line =~ s/^\s+(.*?)/ - $1/ unless($line =~ /^\s+[\[\-]/);
$content .= "$line\n";
}
print $fh $content;
$fh->close;
# update other files
my $parser = Template->new(\%config); # initialise parser
for my $template (@files) {
eval {
# parse to text
$parser->process($template,\%tvars,$template) or die $parser->error();
};
die "TT PARSER ERROR: eval=$@, error=" . $parser->error if($@);
}
# now store new data
system("cp data/backpan100.csv data/backpan100.old.csv ");
system("mv backpan100.csv data");
if($options{build}) {
# build tarball
system("perl Makfile.PL");
system("make dist");
if($options{release}) {
# submit tarball
system("cpan-upload Acme-CPANAuthors-BackPAN-OneHundred-$tvars{VERSION}.tar.gz");
}
}
print "Done!\n";
__END__
=head1 BUGS, PATCHES & FIXES
There are no known bugs at the time of this release. However, if you spot a
bug or are experiencing difficulties, that is not explained within the POD
Acme-CPANAuthors-CPAN-OneHundred
view release on metacpan or search on metacpan
examples/update100.pl view on Meta::CPAN
#!/usr/bin/perl
use warnings;
use strict;
$|++;
my $VERSION = '1.06';
#----------------------------------------------------------------------------
=head1 NAME
update100.pl - preps the OneHundred module for release, if required.
=head1 SYNOPSIS
perl update100.pl
=head1 DESCRIPTION
Downloads the latest copy of the cpan100.csv file from CPAN Testers Statistics
site. Compares with the previous download, and if there is a change, takes the
module template and inserts the appropriate data ready for the next release.
=cut
# -------------------------------------
# Library Modules
use CPAN::Changes;
#use Data::Dumper;
use DateTime;
use File::Basename;
use Getopt::Long;
use IO::File;
use Template;
use WWW::Mechanize;
# -------------------------------------
# Variables
my (%options,%old,%new,%tvars,%pause,%changes);
my $changed = 0;
my $max = 4;
my @files = qw(
lib/Acme/CPANAuthors/CPAN/OneHundred.pm
LICENSE
META.json
META.yml
README
t/10cpanauthor.t
);
my %config = ( # default config info
RELATIVE => 1,
ABSOLUTE => 1,
INTERPOLATE => 0,
POST_CHOMP => 1,
TRIM => 0,
INCLUDE_PATH => 'templates',
OUTPUT_PATH => '..'
);
my %groups = (
'insert' => 'New Authors',
'update' => 'Updated Counts',
'delete' => 'See You Again?',
);
# -------------------------------------
# Program
GetOptions(\%options, 'local', 'build', 'release') or die "Usage: $0 [--local] [--build] [--release]\n";
my $base = dirname($0);
chdir($base);
#print "dir=$base\n";
unless($options{local}) {
my $mech = WWW::Mechanize->new();
my $source = 'http://stats.cpantesters.org/stats/cpan100.csv';
my $target = basename($source);
$mech->mirror($source,$target);
}
# read old file
my $inx = 0;
my $file = 'data/cpan100.csv';
if(my $fh = IO::File->new($file,'r')) {
while(<$fh>) {
s/\s+$//;
examples/update100.pl view on Meta::CPAN
if($inx == 1) {
$tvars{TOPDOG} = $pause;
$tvars{TOPCAT} = $name;
}
# check whether anything has changed
if(!$pause{$pause}) {
push @{$changes{insert}}, $pause;
$changed = 1;
} elsif($pause{$pause} != $cnt) {
push @{$changes{update}}, $pause;
delete $pause{$pause};
$changed = 1;
} elsif($old{$inx} && ($old{$inx}{name} ne $name || $old{$inx}{pause} ne $pause)) {
delete $pause{$pause};
$changed = 1;
} else {
delete $pause{$pause};
}
$max = length $new{$inx}{pause} if($max < length $new{$inx}{pause});
}
$fh->close;
$tvars{COUNT} = scalar(keys %new);
#print "new=" . Dumper(\%new);
#print "pause=" . Dumper(\%pause);
# counts can go down as well as up
if(scalar(keys %pause)) {
$changed = 1;
push @{$changes{delete}}, $_
for(keys %pause);
}
#print "max=$max, changed=$changed\n";
# bail if nothing has changed
unless($changed) {
print "Nothing has changed, bailing\n";
exit 0;
}
$max = (int($max/4) + 1) * 4 if($max % 4);
$max+=2;
# create lists
for my $inx (sort {$new{$a}{pause} cmp $new{$b}{pause}} keys %new) {
my $pad = $max - length $new{$inx}{pause};
push @{$tvars{LIST1}}, sprintf " '%s'%s=> '%s',", $new{$inx}{pause}, (' ' x $pad), $new{$inx}{name};
}
my $cnt = 1;
for my $inx (sort {$new{$b}{count} <=> $new{$a}{count} || $new{$a}{pause} cmp $new{$b}{pause}} keys %new) {
my $pad = $max - length $new{$inx}{pause};
push @{$tvars{LIST2}}, sprintf " %2d. %3d %s%s%s", $cnt++, $new{$inx}{count}, $new{$inx}{pause}, (' ' x $pad), $new{$inx}{name};
}
# calculate copyright
$tvars{COPYRIGHT} = '2014';
my $year = DateTime->now->year;
$tvars{COPYRIGHT} .= "-$year" if($year > 2014);
# calculate version
$file = '../Changes';
my $changes = CPAN::Changes->load( $file );
my @releases = $changes->releases();
my $version = $releases[-1]->{version};
$version += 0.01;
$tvars{VERSION} = sprintf "%.2f", $version;
# update Changes file
my $release = CPAN::Changes::Release->new( version => $tvars{VERSION}, date => DateTime->now->ymd );
for my $group (qw(insert update delete)) {
next unless($changes{$group});
$release->add_changes(
{ group => $groups{$group} },
join(', ',@{$changes{$group}})
);
push @releases, $release;
}
$changes->releases( @releases );
$fh = IO::File->new($file,'w+') or die "Cannot open file [$file]: $!\n";
my $content = $changes->serialize;
my @content = split(/\n/,$content);
$content = '';
for my $line (@content) {
$line =~ s/^([\d.]+)\s+(.*?)$/$1 $2/;
$line =~ s/^\s+(.*?)/ $1/;
$line =~ s/^\s+(.*?)/ - $1/ unless($line =~ /^\s+[\[\-]/);
$content .= "$line\n";
}
print $fh $content;
$fh->close;
# update other files
my $parser = Template->new(\%config); # initialise parser
for my $template (@files) {
eval {
# parse to text
$parser->process($template,\%tvars,$template) or die $parser->error();
};
die "TT PARSER ERROR: eval=$@, error=" . $parser->error if($@);
}
# now store new data
system("cp data/cpan100.csv data/cpan100.old.csv ");
system("mv cpan100.csv data");
if($options{build}) {
# build tarball
system("perl Makfile.PL");
system("make dist");
if($options{release}) {
# submit tarball
system("cpan-upload Acme-CPANAuthors-CPAN-OneHundred-$tvars{VERSION}.tar.gz");
}
}
print "Done!\n";
__END__
=head1 BUGS, PATCHES & FIXES
There are no known bugs at the time of this release. However, if you spot a
bug or are experiencing difficulties, that is not explained within the POD
Acme-CPANLists-Import-BKB
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/BKB/Japanese.pm view on Meta::CPAN
package Acme::CPANLists::Import::BKB::Japanese;
our $DATE = '2017-03-27'; # DATE
our $VERSION = '0.001'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [https://www.lemoda.net/perl/cpan-japanese-language/index.html] (retrieved on 2017-03-27). Visit the URL for the full contents.",entries=>[{module=>"Da...
1;
# ABSTRACT: CPAN modules for dealing with the Japanese language (2012)
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::BKB::Japanese - CPAN modules for dealing with the Japanese language (2012)
=head1 VERSION
This document describes version 0.001 of Acme::CPANLists::Import::BKB::Japanese (from Perl distribution Acme-CPANLists-Import-BKB), released on 2017-03-27.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in L<https://www.lemoda.net/perl/cpan-japanese-language/index.html> (retrieved on 2017-03-27). Visit the URL for the full contents.
=head1 MODULE LISTS
=head2 CPAN modules for dealing with the Japanese language (2012)
This list is generated by extracting module names mentioned in [https://www.lemoda.net/perl/cpan-japanese-language/index.html] (retrieved on 2017-03-27). Visit the URL for the full contents.
=over
=item * L<DateTime::Calendar::Japanese::Era>
=item * L<Lingua::JA::FindDates>
=item * L<Lingua::JA::Moji>
=item * L<Lingua::JA::Numbers>
=item * L<Lingua::JA::Yomi>
=item * L<Text::MeCab>
=back
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/Acme-CPANLists-Import-BKB>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-Acme-CPANLists-Import-BKB>.
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=Acme-CPANLists-Import-BKB>
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
=head1 SEE ALSO
L<Acme::CPANLists> - about the Acme::CPANLists namespace
L<acme-cpanlists> - CLI tool to let you browse/view the lists
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2017 by perlancar@cpan.org.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
Acme-CPANLists-Import-PERLANCAR-GetoptModules
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/PERLANCAR/GetoptModules.pm view on Meta::CPAN
package Acme::CPANLists::Import::PERLANCAR::GetoptModules;
our $DATE = '2016-12-26'; # DATE
our $VERSION = '0.001'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [https://perlancar.wordpress.com/2016/12/02/getopt-modules-02-getoptstd/] (retrieved on 2016-12-26). Visit the URL for the full contents.",entries=>[{m...
1;
# ABSTRACT: Modules mentioned in PERLANCAR's mini-article series on Getopt modules (2016)
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::PERLANCAR::GetoptModules - Modules mentioned in PERLANCAR's mini-article series on Getopt modules (2016)
=head1 VERSION
This document describes version 0.001 of Acme::CPANLists::Import::PERLANCAR::GetoptModules (from Perl distribution Acme-CPANLists-Import-PERLANCAR-GetoptModules), released on 2016-12-26.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in L<https://perlancar.wordpress.com/2016/12/02/getopt-modules-02-getoptstd/> (retrieved on 2016-12-26). Visit the URL for the full contents.
=head1 MODULE LISTS
=head2 Modules mentioned in PERLANCAR's mini-article series on Getopt modules (2016)
This list is generated by extracting module names mentioned in [https://perlancar.wordpress.com/2016/12/02/getopt-modules-02-getoptstd/] (retrieved on 2016-12-26). Visit the URL for the full contents.
=over
=item * L<Getopt::Long>
=item * L<Getopt::Long::Complete>
=item * L<Getopt::Long::Descriptive>
=item * L<Getopt::Std>
=item * L<Getopt::Compact>
=item * L<Docopt>
=item * L<Getopt::Euclid>
=item * L<Opt::Imistic>
=item * L<overload>
=item * L<Getopt::Lucid>
=item * L<Getopt::Std::Strict>
=item * L<Getopt::Declare>
=item * L<Getopt::Long::More>
=item * L<Getopt::Simple>
=item * L<Getopt::Tiny>
=item * L<App::Options>
=item * L<Getopt::Auto>
=item * L<MooX::Options>
=item * L<MooseX::Getopt>
=item * L<Smart::Options>
=item * L<Getopt::ArgvFile>
=item * L<Perinci::CmdLine>
=item * L<App::Cmd>
=item * L<Config::Any>
=item * L<DateTime>
=item * L<Moose>
=item * L<MooseX::App::Cmd>
=item * L<MooseX::ConfigFromFile>
=item * L<MooseX::Getopt::Strict>
=item * L<MooseX::SimpleConfig>
=item * L<MooX::ConfigFromFile>
=item * L<Getopt::Attribute>
=item * L<Getopt::Awesome>
=item * L<Getopt::Modular>
=item * L<Dist::Zilla>
=item * L<App::Spec>
=item * L<Getopt::Long::Subcommand>
=item * L<Smart::Options::Declare>
=item * L<opts>
=item * L<Getopt::ArgParse>
=item * L<Moo>
=item * L<Getopt::Kingpin>
=item * L<Complete::Util>
=item * L<Shell::Completer>
=item * L<Getopt::Alt>
=item * L<Getopt::Chain>
=item * L<Getopt::Fancy>
=item * L<Getopt::Flex>
=item * L<Getopt::Helpful>
=item * L<Getopt::Long::EvenLess>
=item * L<Getopt::Long::Less>
=item * L<Getopt::Panjang>
=item * L<Perinci::CmdLine::Lite>
=back
=head1 HOMEPAGE
Acme-CPANLists-Import-PerlAdvent-2004
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/PerlAdvent/2004.pm view on Meta::CPAN
package Acme::CPANLists::Import::PerlAdvent::2004;
our $DATE = '2016-11-07'; # DATE
our $VERSION = '0.001'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [http://perladvent.org/2004/] (retrieved on 2016-11-07). Visit the URL for the full contents.",entries=>[{module=>"DateTime"},{module=>"DateTime::Durat...
1;
# ABSTRACT: Modules mentioned in Perl Advent Calendar 2004
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::PerlAdvent::2004 - Modules mentioned in Perl Advent Calendar 2004
=head1 VERSION
This document describes version 0.001 of Acme::CPANLists::Import::PerlAdvent::2004 (from Perl distribution Acme-CPANLists-Import-PerlAdvent-2004), released on 2016-11-07.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in L<http://perladvent.org/2004/> (retrieved on 2016-11-07). Visit the URL for the full contents.
=head1 MODULE LISTS
=head2 Modules mentioned in Perl Advent Calendar 2004
This list is generated by extracting module names mentioned in [http://perladvent.org/2004/] (retrieved on 2016-11-07). Visit the URL for the full contents.
=over
=item * L<DateTime>
=item * L<DateTime::Duration>
=item * L<DateTime::Format::Duration>
=item * L<DateTime::Format::HTTP>
=item * L<Acme::Colour>
=item * L<Term::ANSIColor>
=item * L<Term::Cap>
=item * L<Class::Accessor>
=item * L<Class::Accessor::Chained>
=item * L<String::ShellQuote>
=item * L<CPAN::Mini>
=item * L<Imager>
=item * L<Module::Pluggable>
=item * L<Module::Pluggable::Ordered>
=item * L<LWP::Parallel>
=item * L<LWP::Simple>
=item * L<Term::ProgressBar>
=item * L<Data::Dumper>
=item * L<Data::Dumper::Simple>
=item * L<Email::Address>
=item * L<Email::Simple>
=item * L<File::Copy>
=item * L<Proc::Daemon>
=item * L<Proc::PID::File>
=item * L<Data::UUID>
=item * L<Tie::DataUUID>
=item * L<Encode>
=item * L<Text::Unidecode>
=item * L<Devel::Trace>
=item * L<Class::DBI>
=item * L<DBI>
=item * L<SQL::Abstract>
=item * L<Archive::Extract>
=item * L<File::Temp>
Acme-CPANLists-Import-PerlAdvent-2005
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/PerlAdvent/2005.pm view on Meta::CPAN
package Acme::CPANLists::Import::PerlAdvent::2005;
our $DATE = '2016-11-07'; # DATE
our $VERSION = '0.001'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [http://perladvent.org/2005/] (retrieved on 2016-11-07). Visit the URL for the full contents.",entries=>[{module=>"Acme::Code::FreedomFighter"},{module...
1;
# ABSTRACT: Modules mentioned in Perl Advent Calendar 2005
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::PerlAdvent::2005 - Modules mentioned in Perl Advent Calendar 2005
=head1 VERSION
This document describes version 0.001 of Acme::CPANLists::Import::PerlAdvent::2005 (from Perl distribution Acme-CPANLists-Import-PerlAdvent-2005), released on 2016-11-07.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in L<http://perladvent.org/2005/> (retrieved on 2016-11-07). Visit the URL for the full contents.
=head1 MODULE LISTS
=head2 Modules mentioned in Perl Advent Calendar 2005
This list is generated by extracting module names mentioned in [http://perladvent.org/2005/] (retrieved on 2016-11-07). Visit the URL for the full contents.
=over
=item * L<Acme::Code::FreedomFighter>
=item * L<Acme::Drunk>
=item * L<Acme::Intraweb>
=item * L<Acme::Pony>
=item * L<Archive::Extract>
=item * L<Attribute::Handlers>
=item * L<Attribute::Overload>
=item * L<Attribute::TieClasses>
=item * L<Benchmark>
=item * L<CGI::Application>
=item * L<CGI::Untaint>
=item * L<CPAN::Mini>
=item * L<CPANPLUS>
=item * L<Cache::Cache>
=item * L<Class::Accessor::Chained>
=item * L<Class::DBI>
=item * L<Class::Data::Inheritable>
=item * L<Class::ISA>
=item * L<Class::MethodMaker>
=item * L<Class::Multimethods>
=item * L<Class::Virtual>
=item * L<Crypt::RC4>
=item * L<Crypt::Solitaire>
=item * L<DBD::SQLite>
=item * L<DBI>
=item * L<Data::Dimensions>
=item * L<Data::Dumper>
=item * L<Data::Dumper::Simple>
=item * L<Data::Structure::Util>
=item * L<Data::UUID>
=item * L<Date::Christmas>
=item * L<Date::Parse>
=item * L<DateTime>
=item * L<Devel::DProf>
=item * L<Devel::Size>
=item * L<Devel::Trace>
=item * L<Encode>
=item * L<Exporter>
=item * L<Exporter::Simple>
=item * L<ExtUtils::ModuleMaker>
=item * L<File::Find>
=item * L<File::Find::Rule>
=item * L<File::MMagic>
=item * L<File::Remote>
=item * L<File::Spec>
=item * L<File::chdir>
=item * L<Filesys::Virtual>
=item * L<GD>
=item * L<Getopt::Long>
=item * L<GraphViz>
=item * L<HTML::Entities>
=item * L<Hook::LexWrap>
=item * L<IO::AtomicFile>
=item * L<Image::Imlib2>
=item * L<Image::Size>
=item * L<Inline>
=item * L<Inline::Files>
=item * L<Inline::TT>
=item * L<LWP::Simple>
=item * L<Lingua::EN::Numbers::Ordinate>
=item * L<Lingua::PT::Nums2Ords>
=item * L<List::Util>
=item * L<Mac::Glue>
Acme-CPANLists-Import-PerlAdvent-2006
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/PerlAdvent/2006.pm view on Meta::CPAN
package Acme::CPANLists::Import::PerlAdvent::2006;
our $DATE = '2016-11-07'; # DATE
our $VERSION = '0.001'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [http://perladvent.org/2006/] (retrieved on 2016-11-07). Visit the URL for the full contents.",entries=>[{module=>"Devel::FastProf"},{module=>"Devel::S...
1;
# ABSTRACT: Modules mentioned in Perl Advent Calendar 2006
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::PerlAdvent::2006 - Modules mentioned in Perl Advent Calendar 2006
=head1 VERSION
This document describes version 0.001 of Acme::CPANLists::Import::PerlAdvent::2006 (from Perl distribution Acme-CPANLists-Import-PerlAdvent-2006), released on 2016-11-07.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in L<http://perladvent.org/2006/> (retrieved on 2016-11-07). Visit the URL for the full contents.
=head1 MODULE LISTS
=head2 Modules mentioned in Perl Advent Calendar 2006
This list is generated by extracting module names mentioned in [http://perladvent.org/2006/] (retrieved on 2016-11-07). Visit the URL for the full contents.
=over
=item * L<Devel::FastProf>
=item * L<Devel::SmallProf>
=item * L<File::Find::Iterator>
=item * L<File::Find::Object>
=item * L<File::Find::Rule>
=item * L<File::Finder>
=item * L<Text::CSV>
=item * L<Treemap>
=item * L<XML::Simple>
=item * L<CGI::Minimal>
=item * L<CGI::Simple>
=item * L<HTML::Template>
=item * L<File::Next>
=item * L<Module::Starter>
=item * L<Acme::Don::t>
lib/Acme/CPANLists/Import/PerlAdvent/2006.pm view on Meta::CPAN
=item * L<Devel::ptkdb>
=item * L<Fatal>
=item * L<Graphics::ColorNames>
=item * L<Shell>
=item * L<Shell::Autobox>
=item * L<IPC::Run3>
=item * L<File::HomeDir>
=item * L<Math::ErrorPropagation>
=item * L<Math::Symbolic>
=item * L<Math::Symbolic::Custom::Contains>
=item * L<Math::SymbolicX::Inline>
=item * L<Number::Uncertainty>
=item * L<Number::WithError>
=item * L<Params::Util>
=item * L<Test::LectroTest>
=item * L<prefork>
=item * L<Log::Dispatch::FileRotate>
=item * L<Logfile::Rotate>
=item * L<Algorithm::Diff>
=item * L<Text::Diff>
=item * L<XML::Feed>
=item * L<Date::Calc>
=item * L<Devel::Cover>
=item * L<Pod::Coverage>
=item * L<Apache::PAR>
=item * L<PAR::Dist>
=item * L<PAR::Dist::FromCPAN>
=item * L<PAR::Dist::InstallPPD>
=item * L<criticism>
=item * L<DBD::AnyData>
=item * L<DateTime::Calendar::Discordian>
=back
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/Acme-CPANLists-Import-PerlAdvent-2006>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-Acme-CPANLists-Import-PerlAdvent-2006>.
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=Acme-CPANLists-Import-PerlAdvent-2006>
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
=head1 SEE ALSO
L<Acme::CPANLists> - about the Acme::CPANLists namespace
L<acme-cpanlists> - CLI tool to let you browse/view the lists
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2016 by perlancar@cpan.org.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
Acme-CPANLists-Import-PerlAdvent-2007
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/PerlAdvent/2007_12_16.pm view on Meta::CPAN
package Acme::CPANLists::Import::PerlAdvent::2007_12_16;
our $DATE = '2016-11-07'; # DATE
our $VERSION = '0.001'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [http://perladvent.org/2007/16/] (retrieved on 2016-11-07). Visit the URL for the full contents.",entries=>[{module=>"DateTime::TimeZone"}],summary=>"M...
1;
# ABSTRACT: Modules mentioned in Perl Advent Calendar 2007 (day 16)
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::PerlAdvent::2007_12_16 - Modules mentioned in Perl Advent Calendar 2007 (day 16)
=head1 VERSION
This document describes version 0.001 of Acme::CPANLists::Import::PerlAdvent::2007_12_16 (from Perl distribution Acme-CPANLists-Import-PerlAdvent-2007), released on 2016-11-07.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in L<http://perladvent.org/2007/16/> (retrieved on 2016-11-07). Visit the URL for the full contents.
=head1 MODULE LISTS
=head2 Modules mentioned in Perl Advent Calendar 2007 (day 16)
This list is generated by extracting module names mentioned in [http://perladvent.org/2007/16/] (retrieved on 2016-11-07). Visit the URL for the full contents.
=over
=item * L<DateTime::TimeZone>
=back
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/Acme-CPANLists-Import-PerlAdvent-2007>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-Acme-CPANLists-Import-PerlAdvent-2007>.
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=Acme-CPANLists-Import-PerlAdvent-2007>
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
=head1 SEE ALSO
L<Acme::CPANLists> - about the Acme::CPANLists namespace
L<acme-cpanlists> - CLI tool to let you browse/view the lists
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2016 by perlancar@cpan.org.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
Acme-CPANLists-Import-PerlAdvent-2012
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/PerlAdvent/2012.pm view on Meta::CPAN
package Acme::CPANLists::Import::PerlAdvent::2012;
our $DATE = '2016-11-06'; # DATE
our $VERSION = '0.001'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [http://perladvent.org/2012/] (retrieved on 2016-11-06). Visit the URL for the full contents.",entries=>[{module=>"File::Path"},{module=>"File::Spec"},...
1;
# ABSTRACT: Modules mentioned in Perl Advent Calendar 2012
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::PerlAdvent::2012 - Modules mentioned in Perl Advent Calendar 2012
=head1 VERSION
This document describes version 0.001 of Acme::CPANLists::Import::PerlAdvent::2012 (from Perl distribution Acme-CPANLists-Import-PerlAdvent-2012), released on 2016-11-06.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in L<http://perladvent.org/2012/> (retrieved on 2016-11-06). Visit the URL for the full contents.
=head1 MODULE LISTS
=head2 Modules mentioned in Perl Advent Calendar 2012
This list is generated by extracting module names mentioned in [http://perladvent.org/2012/] (retrieved on 2016-11-06). Visit the URL for the full contents.
=over
=item * L<File::Path>
=item * L<File::Spec>
=item * L<Moose>
=item * L<MooseX::Types::Path::Class>
=item * L<Path::Class>
=item * L<Scope::Upper>
=item * L<Dist::Zilla>
=item * L<Dist::Zilla::Plugin::ReportVersions::Tiny>
=item * L<Dist::Zilla::Plugin::Test::ReportPrereqs>
=item * L<Dancer>
=item * L<DBI>
=item * L<DDP>
=item * L<Data::Printer>
=item * L<DateTime>
=item * L<Digest>
=item * L<Digest::MD5>
=item * L<Safe>
=item * L<File::AtomicWrite>
=item * L<Dist::Zilla::Plugin::ShareDir::Tarball>
=item * L<ExtUtils::MakeMaker>
=item * L<File::ShareDir>
=item * L<File::ShareDir::Tarball>
=item * L<Module::Build>
=item * L<Module::Build::CleanInstall>
=item * L<Module::Build::Cookbook>
=item * L<Module::Pluggable>
=item * L<IO::Prompt::Hooked>
=item * L<IO::Prompt::Tiny>
=item * L<IO::Prompter>
=item * L<LWP>
=item * L<LWP::UserAgent>
=item * L<PSGI>
=item * L<Test::LWP::UserAgent>
=item * L<Test::Mock::LWP::Dispatch>
=item * L<Term::ExtendedColor>
=item * L<Web::Machine>
=item * L<pp>
=item * L<App::FatPacker>
=item * L<Carp>
=item * L<Carp::Heavy>
=item * L<HTTP::Tiny>
=item * L<local::lib>
=item * L<Fcntl>
=item * L<File::Flock::Tiny>
Acme-CPANLists-Import-PerlAdvent-2013
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/PerlAdvent/2013.pm view on Meta::CPAN
package Acme::CPANLists::Import::PerlAdvent::2013;
our $DATE = '2016-11-06'; # DATE
our $VERSION = '0.002'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [http://perladvent.org/2013/] (retrieved on 2016-11-06). Visit the URL for the full contents.",entries=>[{module=>"RDF::Query"},{module=>"RDF::Query::C...
1;
# ABSTRACT: Modules mentioned in Perl Advent Calendar 2013
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::PerlAdvent::2013 - Modules mentioned in Perl Advent Calendar 2013
=head1 VERSION
This document describes version 0.002 of Acme::CPANLists::Import::PerlAdvent::2013 (from Perl distribution Acme-CPANLists-Import-PerlAdvent-2013), released on 2016-11-06.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in L<http://perladvent.org/2013/> (retrieved on 2016-11-06). Visit the URL for the full contents.
=head1 MODULE LISTS
=head2 Modules mentioned in Perl Advent Calendar 2013
This list is generated by extracting module names mentioned in [http://perladvent.org/2013/] (retrieved on 2016-11-06). Visit the URL for the full contents.
=over
=item * L<RDF::Query>
=item * L<RDF::Query::Client>
=item * L<RDF::Trine>
=item * L<Catalyst>
=item * L<Dancer>
=item * L<DBIx::Class>
=item * L<Object::Remote>
=item * L<Graph::Easy>
=item * L<Graph::Easy::As_svg>
=item * L<Exception::Class>
=item * L<Safe::Isa>
=item * L<Scalar::Util>
=item * L<Throwable>
=item * L<Try::Tiny>
=item * L<UNIVERSAL>
lib/Acme/CPANLists/Import/PerlAdvent/2013.pm view on Meta::CPAN
=item * L<Twiggy>
=item * L<Web::Simple>
=item * L<App::PAUSE::CheckPerms>
=item * L<App::PAUSE::Comaint>
=item * L<PAUSE::Permissions>
=item * L<enum>
=item * L<Dist::Zilla::App::Command::msg_compile>
=item * L<Dist::Zilla::App::Command::msg_init>
=item * L<Dist::Zilla::App::Command::msg_merge>
=item * L<Dist::Zilla::LocaleTextDomain>
=item * L<ExtUtils::MakeMaker>
=item * L<Locale::Maketext>
=item * L<Locale::TextDomain>
=item * L<Module::Build>
=item * L<App::cpanminus>
=item * L<Carton>
=item * L<App::jt>
=item * L<GitStore>
=item * L<MooseX::Storage>
=item * L<Devel::CompiledCalls>
=item * L<DBD::ODBC>
=item * L<DBD::Pg>
=item * L<DBD::SQLite>
=item * L<DBD::mysql>
=item * L<DBIx::Connector>
=item * L<DBIx::Introspector>
=item * L<App::AYCABTU>
=item * L<App::GitGot>
=item * L<Beam::Emitter>
=item * L<Moo>
=item * L<DateTime::Duration>
=item * L<Time::Duration>
=item * L<Time::Duration::Object>
=item * L<Time::Duration::Parse>
=item * L<File::Basename>
=item * L<File::Copy>
=item * L<File::Find>
=item * L<File::Path>
=item * L<File::Spec>
=item * L<File::Temp>
=item * L<File::stat>
=item * L<Path::Class>
=item * L<Path::Iterator::Rule>
=item * L<Path::Tiny>
=item * L<Moose>
=item * L<MooseX::StrictConstructor>
=item * L<fields>
=item * L<PPI>
=item * L<PPI::HTML>
=item * L<Pod::Elemental::Transformer::PPIHTML>
=item * L<Pod::Elemental::Transformer::VimHTML>
=item * L<Text::VimColor>
=item * L<WWW::AdventCalendar>
=item * L<Role::HasPayload::Merged>
=item * L<String::Errf>
=item * L<DateTime>
=item * L<DateTime::Moonpig>
=item * L<Acme::Boom>
=item * L<Devel::cst>
=back
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/Acme-CPANLists-Import-PerlAdvent-2013>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-Acme-CPANLists-Import-PerlAdvent-2013>.
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=Acme-CPANLists-Import-PerlAdvent-2013>
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
=head1 SEE ALSO
L<Acme::CPANLists> - about the Acme::CPANLists namespace
L<acme-cpanlists> - CLI tool to let you browse/view the lists
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2016 by perlancar@cpan.org.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
Acme-CPANLists-Import-PerlAdvent-2014
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/PerlAdvent/2014.pm view on Meta::CPAN
package Acme::CPANLists::Import::PerlAdvent::2014;
our $DATE = '2016-11-06'; # DATE
our $VERSION = '0.001'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in [http://perladvent.org/2014/] (retrieved on 2016-11-06). Visit the URL for the full contents.",entries=>[{module=>"File::Temp"},{module=>"Test::TempDir...
1;
# ABSTRACT: Modules mentioned in Perl Advent Calendar 2014
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::PerlAdvent::2014 - Modules mentioned in Perl Advent Calendar 2014
=head1 VERSION
This document describes version 0.001 of Acme::CPANLists::Import::PerlAdvent::2014 (from Perl distribution Acme-CPANLists-Import-PerlAdvent-2014), released on 2016-11-06.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in L<http://perladvent.org/2014/> (retrieved on 2016-11-06). Visit the URL for the full contents.
=head1 MODULE LISTS
=head2 Modules mentioned in Perl Advent Calendar 2014
This list is generated by extracting module names mentioned in [http://perladvent.org/2014/] (retrieved on 2016-11-06). Visit the URL for the full contents.
=over
=item * L<File::Temp>
=item * L<Test::TempDir::Tiny>
=item * L<DBIx::Class>
=item * L<DBIx::Class::Schema::Loader>
=item * L<Mac::Safari::JavaScript>
=item * L<HTTP::Tiny>
=item * L<PSGI>
=item * L<Plack>
=item * L<Plack::Builder>
=item * L<Plack::Middleware>
=item * L<Plack::Util>
=item * L<List::UtilsBy>
=item * L<Sub::Name>
=item * L<Sub::Util>
=item * L<DBI>
lib/Acme/CPANLists/Import/PerlAdvent/2014.pm view on Meta::CPAN
=item * L<Code::TidyAll::Plugin::MasonTidy>
=item * L<Code::TidyAll::Plugin::PHPCodeSniffer>
=item * L<Code::TidyAll::Plugin::PerlCritic>
=item * L<Code::TidyAll::Plugin::PerlTidy>
=item * L<Code::TidyAll::Plugin::PodChecker>
=item * L<Code::TidyAll::Plugin::PodSpell>
=item * L<Code::TidyAll::Plugin::SVG>
=item * L<Code::TidyAll::Plugin::SortLines>
=item * L<Code::TidyAll::Plugin::SortLines::Naturally>
=item * L<Code::TidyAll::Plugin::UniqueLines>
=item * L<File::Zglob>
=item * L<Perl::Tidy>
=item * L<BPM::Engine>
=item * L<DBD::SQLite>
=item * L<Devel::Monitor>
=item * L<IO::Socket::SSL>
=item * L<Kavorka>
=item * L<LWP>
=item * L<Sereal>
=item * L<Storable>
=item * L<Test::LeakTrace>
=item * L<Test::Requires>
=item * L<Test::Requires::Env>
=item * L<Test::RequiresInternet>
=item * L<Text::Xslate>
=item * L<Tiffany>
=item * L<WWW::Mechanize>
=item * L<ZeroMQ>
=item * L<namespace::autoclean>
=item * L<Data::ICal>
=item * L<Data::ICal::DateTime>
=item * L<DateTime>
=item * L<DateTime::Format::ICal>
=item * L<Capture::Tiny>
=item * L<Devel::Size>
=item * L<Struct::Dumb>
=item * L<Path::Router>
=item * L<Plack::App::Path::Router>
=item * L<Plack::App::Path::Router::Custom>
=item * L<CLDR::Number>
=item * L<DateTime::Locale>
=item * L<Geo::Region>
=item * L<Locale::CLDR>
=item * L<Locales>
=item * L<AnyEvent>
=item * L<AnyEvent::HTTP>
=item * L<AnyEvent::RabbitMQ>
=item * L<Future>
=item * L<Promises>
=back
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/Acme-CPANLists-Import-PerlAdvent-2014>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-Acme-CPANLists-Import-PerlAdvent-2014>.
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=Acme-CPANLists-Import-PerlAdvent-2014>
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
=head1 SEE ALSO
L<Acme::CPANLists> - about the Acme::CPANLists namespace
L<acme-cpanlists> - CLI tool to let you browse/view the lists
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2016 by perlancar@cpan.org.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
Acme-CPANLists-Import
view release on metacpan or search on metacpan
lib/Acme/CPANLists/Import/DatesPart1.pm view on Meta::CPAN
package Acme::CPANLists::Import::DatesPart1;
our $DATE = '2016-12-28'; # DATE
our $VERSION = '0.03'; # VERSION
our @Module_Lists = ({description=>"This list is generated by extracting module names mentioned in the article [http://blogs.perl.org/users/buddy_burden/2015/09/a-date-with-cpan-part-1-state-of-the-union.html] (retrieved on 2016-07-19). For the full ...
1;
# ABSTRACT: CPAN modules for processing dates - Part 1 (2015)
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANLists::Import::DatesPart1 - CPAN modules for processing dates - Part 1 (2015)
=head1 VERSION
This document describes version 0.03 of Acme::CPANLists::Import::DatesPart1 (from Perl distribution Acme-CPANLists-Import), released on 2016-12-28.
=head1 DESCRIPTION
This module is generated by extracting module names mentioned in the article L<http://blogs.perl.org/users/buddy_burden/2015/09/a-date-with-cpan-part-1-state-of-the-union.html> (retrieved on 2016-07-19). For the full article, visit the URL.
=head1 MODULE LISTS
=head2 CPAN modules for processing dates - Part 1 (2015)
This list is generated by extracting module names mentioned in the article [http://blogs.perl.org/users/buddy_burden/2015/09/a-date-with-cpan-part-1-state-of-the-union.html] (retrieved on 2016-07-19). For the full article, visit the URL.
=over
=item * L<Class::Date>
=item * L<DBIx::Class>
=item * L<DBIx::Class::InflateColumn::DateTimeX::Immutable>
=item * L<Date::Calc>
=item * L<Date::Format>
=item * L<Date::Handler>
=item * L<Date::Manip>
=item * L<Date::Manip::Date>
=item * L<Date::Parse>
=item * L<Date::Piece>
=item * L<Date::Simple>
=item * L<DateTime>
=item * L<DateTime::Format::DateManip>
=item * L<DateTime::Moonpig>
=item * L<DateTimeX::Immutable>
=item * L<Panda::Date>
=item * L<Time::Local>
=item * L<Time::Moment>
=item * L<Time::Object>
=item * L<Time::ParseDate>
=item * L<Time::Piece>
=back
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/Acme-CPANLists-Import>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-Acme-CPANLists-Import>.
=head1 BUGS
Please report any bugs or feature requests on the bugtracker website L<https://rt.cpan.org/Public/Dist/Display.html?Name=Acme-CPANLists-Import>
When submitting a bug or request, please include a test-file or a
patch to an existing test-file that illustrates the bug or desired
feature.
=head1 SEE ALSO
L<Acme::CPANLists> - about the Acme::CPANLists namespace
L<acme-cpanlists> - CLI tool to let you browse/view the lists
=head1 AUTHOR
perlancar <perlancar@cpan.org>
=head1 COPYRIGHT AND LICENSE
This software is copyright (c) 2016 by perlancar@cpan.org.
This is free software; you can redistribute it and/or modify it under
the same terms as the Perl 5 programming language system itself.
=cut
Acme-CPANModules-CalculatingDayOfWeek
view release on metacpan or search on metacpan
lib/Acme/CPANModules/CalculatingDayOfWeek.pm view on Meta::CPAN
package Acme::CPANModules::CalculatingDayOfWeek;
use 5.010001;
use strict;
use warnings;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2023-08-06'; # DATE
our $DIST = 'Acme-CPANModules-CalculatingDayOfWeek'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {
summary => 'List of modules to calculate day of week',
entries => [
{
module => 'Date::DayOfWeek',
bench_fcall_template => 'Date::DayOfWeek::dayofweek(<day>, <month>, <year>)',
description => <<'_',
Both <pm:Date::DayOfWeek> and <pm:Time::DayOfWeek> are lightweight modules.
_
},
{
module => 'Time::DayOfWeek',
bench_fcall_template => 'Time::DayOfWeek::DoW(<year>, <month>, <day>)',
description => <<'_',
Both <pm:Date::DayOfWeek> and <pm:Time::DayOfWeek> are lightweight modules.
This module offers cryptic and confusing function names: `DoW` returns 0-6,
`Dow` returns 3-letter abbrev.
_
},
{
module => 'DateTime',
bench_code_template => 'DateTime->new(year=><year>, month=><month>, day=><day>)->day_of_week',
description => <<'_',
Compared to <pm:Date::DayOfWeek> and <pm:Time::DayOfWeek>, <pm:DateTime> is a
behemoth. But it provides a bunch of other functionalities as well.
_
},
{
module => 'Date::Calc',
bench_fcall_template => 'Date::Calc::Day_of_Week(<year>, <month>, <day>)',
description => <<'_',
<pm:Date::Calc> is a nice compromise when you want something that is more
lightweight and does not need to be as accurate as <pm:DateTime>.
_
},
{
module => 'Time::Moment',
bench_code_template => 'Time::Moment->new(year => <year>, month => <month>, day => <day>)->day_of_week',
description => <<'_',
<pm:Time::Moment> is also a nice alternative to <pm:DateTime>. Although it's not
as featureful as DateTime, it is significantly more lightweight. Compared to
<pm:Date::Calc>, Time::Moment's API is closer to DateTime's. Being an XS module,
it's also faster.
_
},
],
bench_datasets => [
{name=>'date1', args => {day=>20, month=>11, year=>2019}},
],
};
1;
# ABSTRACT: List of modules to calculate day of week
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::CalculatingDayOfWeek - List of modules to calculate day of week
=head1 VERSION
This document describes version 0.002 of Acme::CPANModules::CalculatingDayOfWeek (from Perl distribution Acme-CPANModules-CalculatingDayOfWeek), released on 2023-08-06.
=head1 SYNOPSIS
To run benchmark with default option:
% bencher --cpanmodules-module CalculatingDayOfWeek
To run module startup overhead benchmark:
% bencher --module-startup --cpanmodules-module CalculatingDayOfWeek
For more options (dump scenario, list/include/exclude/add participants, list/include/exclude/add datasets, etc), see L<bencher> or run C<bencher --help>.
=head1 ACME::CPANMODULES ENTRIES
=over
=item L<Date::DayOfWeek>
Author: L<RBOW|https://metacpan.org/author/RBOW>
Both L<Date::DayOfWeek> and L<Time::DayOfWeek> are lightweight modules.
=item L<Time::DayOfWeek>
Author: L<PIP|https://metacpan.org/author/PIP>
Both L<Date::DayOfWeek> and L<Time::DayOfWeek> are lightweight modules.
This module offers cryptic and confusing function names: C<DoW> returns 0-6,
C<Dow> returns 3-letter abbrev.
=item L<DateTime>
Author: L<DROLSKY|https://metacpan.org/author/DROLSKY>
Compared to L<Date::DayOfWeek> and L<Time::DayOfWeek>, L<DateTime> is a
behemoth. But it provides a bunch of other functionalities as well.
=item L<Date::Calc>
Author: L<STBEY|https://metacpan.org/author/STBEY>
L<Date::Calc> is a nice compromise when you want something that is more
lightweight and does not need to be as accurate as L<DateTime>.
=item L<Time::Moment>
Author: L<CHANSEN|https://metacpan.org/author/CHANSEN>
L<Time::Moment> is also a nice alternative to L<DateTime>. Although it's not
as featureful as DateTime, it is significantly more lightweight. Compared to
L<Date::Calc>, Time::Moment's API is closer to DateTime's. Being an XS module,
it's also faster.
=back
=head1 BENCHMARKED MODULES
Version numbers shown below are the versions used when running the sample benchmark.
L<Date::DayOfWeek> 1.22
L<Time::DayOfWeek> 1.8
L<DateTime> 1.59
L<Date::Calc> 6.4
L<Time::Moment> 0.44
=head1 BENCHMARK PARTICIPANTS
=over
=item * Date::DayOfWeek::dayofweek (perl_code)
Function call template:
Date::DayOfWeek::dayofweek(<day>, <month>, <year>)
=item * Time::DayOfWeek::DoW (perl_code)
Function call template:
Time::DayOfWeek::DoW(<year>, <month>, <day>)
=item * DateTime (perl_code)
Code template:
DateTime->new(year=><year>, month=><month>, day=><day>)->day_of_week
=item * Date::Calc::Day_of_Week (perl_code)
Function call template:
Date::Calc::Day_of_Week(<year>, <month>, <day>)
=item * Time::Moment (perl_code)
Code template:
Time::Moment->new(year => <year>, month => <month>, day => <day>)->day_of_week
=back
=head1 BENCHMARK DATASETS
=over
=item * date1
=back
=head1 BENCHMARK SAMPLE RESULTS
=head2 Sample benchmark #1
Run on: perl: I<< v5.38.0 >>, CPU: I<< Intel(R) Core(TM) i5-7200U CPU @ 2.50GHz (2 cores) >>, OS: I<< GNU/Linux Ubuntu version 20.04 >>, OS kernel: I<< Linux version 5.4.0-91-generic >>.
Benchmark command (default options):
% bencher --cpanmodules-module CalculatingDayOfWeek
Result formatted as table:
#table1#
{dataset=>"date1"}
+----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| participant | rate (/s) | time (μs) | pct_faster_vs_slowest | pct_slower_vs_fastest | errors | samples |
+----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
| DateTime | 37000 | 27 | 0.00% | 8030.29% | 3.8e-08 | 24 |
| Date::DayOfWeek::dayofweek | 562000 | 1.78 | 1415.39% | 436.51% | 3.8e-10 | 20 |
| Date::Calc::Day_of_Week | 650000 | 1.54 | 1650.85% | 364.36% | 9.3e-10 | 20 |
| Time::DayOfWeek::DoW | 1030000 | 0.97 | 2677.36% | 192.73% | 6.3e-10 | 20 |
| Time::Moment | 3020000 | 0.331 | 8030.29% | 0.00% | 1.7e-10 | 20 |
+----------------------------+-----------+-----------+-----------------------+-----------------------+---------+---------+
The above result formatted in L<Benchmark.pm|Benchmark> style:
Rate D DD:d DC:D_o_W TD:D T:M
D 37000/s -- -93% -94% -96% -98%
DD:d 562000/s 1416% -- -13% -45% -81%
DC:D_o_W 650000/s 1653% 15% -- -37% -78%
TD:D 1030000/s 2683% 83% 58% -- -65%
T:M 3020000/s 8057% 437% 365% 193% --
Legends:
D: participant=DateTime
DC:D_o_W: participant=Date::Calc::Day_of_Week
DD:d: participant=Date::DayOfWeek::dayofweek
T:M: participant=Time::Moment
TD:D: participant=Time::DayOfWeek::DoW
=head2 Sample benchmark #2
Benchmark command (benchmarking module startup overhead):
% bencher --cpanmodules-module CalculatingDayOfWeek --module-startup
Result formatted as table:
#table2#
+---------------------+-----------+-------------------+-----------------------+-----------------------+---------+---------+
| participant | time (ms) | mod_overhead_time | pct_faster_vs_slowest | pct_slower_vs_fastest | errors | samples |
+---------------------+-----------+-------------------+-----------------------+-----------------------+---------+---------+
| DateTime | 145 | 139.2 | 0.00% | 2398.83% | 3.7e-05 | 20 |
| Date::Calc | 24.9 | 19.1 | 483.22% | 328.45% | 1.2e-05 | 21 |
| Time::Moment | 12.2 | 6.4 | 1086.86% | 110.54% | 8.3e-06 | 20 |
| Time::DayOfWeek | 9.8 | 4 | 1380.99% | 68.73% | 5.7e-06 | 20 |
| Date::DayOfWeek | 9.34 | 3.54 | 1453.50% | 60.85% | 5e-06 | 20 |
| perl -e1 (baseline) | 5.8 | 0 | 2398.83% | 0.00% | 6.4e-06 | 20 |
+---------------------+-----------+-------------------+-----------------------+-----------------------+---------+---------+
The above result formatted in L<Benchmark.pm|Benchmark> style:
Rate D D:C T:M T:D D:D perl -e1 (baseline)
D 6.9/s -- -82% -91% -93% -93% -96%
D:C 40.2/s 482% -- -51% -60% -62% -76%
T:M 82.0/s 1088% 104% -- -19% -23% -52%
T:D 102.0/s 1379% 154% 24% -- -4% -40%
D:D 107.1/s 1452% 166% 30% 4% -- -37%
perl -e1 (baseline) 172.4/s 2400% 329% 110% 68% 61% --
Legends:
D: mod_overhead_time=139.2 participant=DateTime
D:C: mod_overhead_time=19.1 participant=Date::Calc
D:D: mod_overhead_time=3.54 participant=Date::DayOfWeek
T:D: mod_overhead_time=4 participant=Time::DayOfWeek
T:M: mod_overhead_time=6.4 participant=Time::Moment
perl -e1 (baseline): mod_overhead_time=0 participant=perl -e1 (baseline)
To display as an interactive HTML table on a browser, you can add option C<--format html+datatables>.
=head1 FAQ
=head2 What is an Acme::CPANModules::* module?
An Acme::CPANModules::* module, like this module, contains just a list of module
names that share a common characteristics. It is a way to categorize modules and
document CPAN. See L<Acme::CPANModules> for more details.
=head2 What are ways to use this Acme::CPANModules module?
Aside from reading this Acme::CPANModules module's POD documentation, you can
install all the listed modules (entries) using L<cpanm-cpanmodules> script (from
L<App::cpanm::cpanmodules> distribution):
% cpanm-cpanmodules -n CalculatingDayOfWeek
Alternatively you can use the L<cpanmodules> CLI (from L<App::cpanmodules>
distribution):
% cpanmodules ls-entries CalculatingDayOfWeek | cpanm -n
or L<Acme::CM::Get>:
% perl -MAcme::CM::Get=CalculatingDayOfWeek -E'say $_->{module} for @{ $LIST->{entries} }' | cpanm -n
or directly:
% perl -MAcme::CPANModules::CalculatingDayOfWeek -E'say $_->{module} for @{ $Acme::CPANModules::CalculatingDayOfWeek::LIST->{entries} }' | cpanm -n
This Acme::CPANModules module contains benchmark instructions. You can run a
benchmark for some/all the modules listed in this Acme::CPANModules module using
the L<bencher> CLI (from L<Bencher> distribution):
% bencher --cpanmodules-module CalculatingDayOfWeek
This Acme::CPANModules module also helps L<lcpan> produce a more meaningful
result for C<lcpan related-mods> command when it comes to finding related
modules for the modules listed in this Acme::CPANModules module.
See L<App::lcpan::Cmd::related_mods> for more details on how "related modules"
are found.
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/Acme-CPANModules-CalculatingDayOfWeek>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-Acme-CPANModules-CalculatingDayOfWeek>.
=head1 SEE ALSO
L<Acme::CPANModules> - about the Acme::CPANModules namespace
Acme-CPANModules-FormattingDate
view release on metacpan or search on metacpan
lib/Acme/CPANModules/FormattingDate.pm view on Meta::CPAN
package Acme::CPANModules::FormattingDate;
use strict;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2023-10-29'; # DATE
our $DIST = 'Acme-CPANModules-FormattingDate'; # DIST
our $VERSION = '0.002'; # VERSION
my $text = <<'_';
**Overview**
Date formatting modules can be categorized by their expected input format and
the formatting styles.
Input format: Some modules accept date in the form of Unix epoch (an integer),
or a list of integer produced by running the epoch through the builtin gmtime()
or localtime() function. Some others might expect the date as <pm:DateTime>
object. For formatting style: there's strftime in the <pm:POSIX> core module,
and then there's the others.
This list is organized using the latter criteria (formatting style).
**strftime (and variants)**
The <pm:POSIX> module provides the `strftime()` routine which lets you format
using a template string containing sprintf-style conversions like `%Y` (for
4-digit year), `%m` (2-digit month number from 1-12), and so on. There's also
<pm:Date::strftimeq> which provides an extension to this.
You can actually add some modifiers for the conversions to set
width/zero-padding/alignment, like you can do with sprintf (e.g. `%03d`
supposing you want 3-digit day of month numbers). But this feature is
platform-dependent.
**yyyy-mm-dd template**
This "yyyy-mm-dd" (for lack of a better term) format is much more commonly used
in the general computing world, from spreadsheets to desktop environment clocks.
And this format is probably older than strftime. The template is more intuitive
to use for people as it gives a clear picture of how wide each component (and
the whole string) will be.
There are some modules you can use to format dates using this style. First of
all there's <pm:Date::Formatter>. I find its API a little bit annoying, from the
verbose date component key names and inconsistent usage of plurals, to having to
use a separate method to "create the formatter" first.
**PHP**
PHP decided to invent its own date template format. Its `date()` function
accepts template string in which you specify single letter conversions like `Y'
(for 4-digit year), `y` (2-digit year), and so on. Some of the letters mean the
same like their counterpart in strftime, but some are different (examples: `i`,
`a`, `M`, and so on). The use of single letter means it's more concise, but the
format becomes unsuitable if you want to put other stuffs (like some string
alphabetical literals) in addition to date components.
In Perl, you can use the <pm:PHP::DateTime> to format dates using PHP `date()`
format.
_
our $LIST = {
summary => 'List of various methods to format dates',
description => $text,
tags => ['task'],
entries => [
map { +{module=>$_} }
do { my %seen; grep { !$seen{$_}++ }
($text =~ /<pm:(\w+(?:::\w+)+)>/g)
}
],
};
1;
# ABSTRACT: List of various methods to format dates
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::FormattingDate - List of various methods to format dates
=head1 VERSION
This document describes version 0.002 of Acme::CPANModules::FormattingDate (from Perl distribution Acme-CPANModules-FormattingDate), released on 2023-10-29.
=head1 DESCRIPTION
B<Overview>
Date formatting modules can be categorized by their expected input format and
the formatting styles.
Input format: Some modules accept date in the form of Unix epoch (an integer),
or a list of integer produced by running the epoch through the builtin gmtime()
or localtime() function. Some others might expect the date as L<DateTime>
object. For formatting style: there's strftime in the L<POSIX> core module,
and then there's the others.
This list is organized using the latter criteria (formatting style).
B<strftime (and variants)>
The L<POSIX> module provides the C<strftime()> routine which lets you format
using a template string containing sprintf-style conversions like C<%Y> (for
4-digit year), C<%m> (2-digit month number from 1-12), and so on. There's also
L<Date::strftimeq> which provides an extension to this.
You can actually add some modifiers for the conversions to set
width/zero-padding/alignment, like you can do with sprintf (e.g. C<%03d>
supposing you want 3-digit day of month numbers). But this feature is
platform-dependent.
B<yyyy-mm-dd template>
This "yyyy-mm-dd" (for lack of a better term) format is much more commonly used
in the general computing world, from spreadsheets to desktop environment clocks.
And this format is probably older than strftime. The template is more intuitive
to use for people as it gives a clear picture of how wide each component (and
the whole string) will be.
There are some modules you can use to format dates using this style. First of
all there's L<Date::Formatter>. I find its API a little bit annoying, from the
verbose date component key names and inconsistent usage of plurals, to having to
use a separate method to "create the formatter" first.
B<PHP>
PHP decided to invent its own date template format. Its C<date()> function
accepts template string in which you specify single letter conversions like C<Y'
(for 4-digit year),>yC<(2-digit year), and so on. Some of the letters mean the
same like their counterpart in strftime, but some are different (examples:>iC<,
>aC<,>M`, and so on). The use of single letter means it's more concise, but the
format becomes unsuitable if you want to put other stuffs (like some string
alphabetical literals) in addition to date components.
In Perl, you can use the L<PHP::DateTime> to format dates using PHP C<date()>
format.
=head1 ACME::CPANMODULES ENTRIES
=over
=item L<Date::strftimeq>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<Date::Formatter>
Author: L<BIANCHINI|https://metacpan.org/author/BIANCHINI>
=item L<PHP::DateTime>
Author: L<BLUEFEET|https://metacpan.org/author/BLUEFEET>
=back
=head1 FAQ
=head2 What is an Acme::CPANModules::* module?
An Acme::CPANModules::* module, like this module, contains just a list of module
names that share a common characteristics. It is a way to categorize modules and
document CPAN. See L<Acme::CPANModules> for more details.
=head2 What are ways to use this Acme::CPANModules module?
Aside from reading this Acme::CPANModules module's POD documentation, you can
install all the listed modules (entries) using L<cpanm-cpanmodules> script (from
L<App::cpanm::cpanmodules> distribution):
% cpanm-cpanmodules -n FormattingDate
Alternatively you can use the L<cpanmodules> CLI (from L<App::cpanmodules>
distribution):
% cpanmodules ls-entries FormattingDate | cpanm -n
or L<Acme::CM::Get>:
% perl -MAcme::CM::Get=FormattingDate -E'say $_->{module} for @{ $LIST->{entries} }' | cpanm -n
or directly:
% perl -MAcme::CPANModules::FormattingDate -E'say $_->{module} for @{ $Acme::CPANModules::FormattingDate::LIST->{entries} }' | cpanm -n
This Acme::CPANModules module also helps L<lcpan> produce a more meaningful
result for C<lcpan related-mods> command when it comes to finding related
modules for the modules listed in this Acme::CPANModules module.
See L<App::lcpan::Cmd::related_mods> for more details on how "related modules"
are found.
=head1 HOMEPAGE
Please visit the project's homepage at L<https://metacpan.org/release/Acme-CPANModules-FormattingDate>.
=head1 SOURCE
Source repository is at L<https://github.com/perlancar/perl-Acme-CPANModules-FormattingDate>.
=head1 SEE ALSO
L<Bencher::Scenario::FormattingDate>
L<Acme::CPANModules> - about the Acme::CPANModules namespace
L<cpanmodules> - CLI tool to let you browse/view the lists
=head1 AUTHOR
perlancar <perlancar@cpan.org>
Acme-CPANModules-Frameworks
view release on metacpan or search on metacpan
lib/Acme/CPANModules/Frameworks.pm view on Meta::CPAN
package Acme::CPANModules::Frameworks;
use strict;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2022-11-29'; # DATE
our $DIST = 'Acme-CPANModules-Frameworks'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {
summary => "List of frameworks on CPAN",
description => <<'_',
What qualifies as a framewor to be listed here is the existence of ecosystem of
CPAN modules/distributions (plugins, extensions, even application distributions,
etc) pertaining to it.
This list is used in building a list of framework classifiers in
<pm:Module::Features::PerlTrove>.
_
entries => [
# acme
{module=>'Acme::CPANAuthors', tags=>['category:acme']},
{module=>'Acme::CPANModules', tags=>['category:acme']},
# app
{module=>'Jifty', tags=>['category:app']},
# async
{module=>'AnyEvent', tags=>['category:async']},
{module=>'IO::Async', tags=>['category:async']},
{module=>'POE', tags=>['category:async']},
# benchmark
{module=>'Bencher', tags=>['category:benchmark']},
# caching
{module=>'CHI', tags=>['category:caching']},
# cli
{module=>'App::Cmd', tags=>['category:cli']},
{module=>'Perinci::CmdLine', tags=>['category:cli']},
{module=>'ScriptX', tags=>['category:cli','category:web']},
# data modules
{module=>'ArrayData', tags=>['category:data']},
{module=>'HashData', tags=>['category:data']},
{module=>'Games::Word::Phraselist', tags=>['category:data']},
{module=>'Games::Word::Wordlist', tags=>['category:data']},
{module=>'TableData', tags=>['category:data']},
{module=>'WordList', tags=>['category:data']},
# database
{module=>'DBI', tags=>['category:database']},
# data-dumping
{module=>'Data::Printer', tags=>['category:data-dumping']},
# date
{module=>'DateTime', tags=>['category:date']},
# distribution-authoring
{module=>'Dist::Zilla', tags=>['category:distribution-authoring']},
{module=>'Minilla', tags=>['category:distribution-authoring']},
{module=>'ShipIt', tags=>['category:distribution-authoring']},
# e-commerce
{module=>'Interchange', tags=>['category:e-commerce']},
# logging
{module=>'Log::Any', tags=>['category:logging']},
{module=>'Log::Contextual', tags=>['category:logging']},
{module=>'Log::Dispatch', tags=>['category:logging']},
{module=>'Log::ger', tags=>['category:logging']},
{module=>'Log::Log4perl', tags=>['category:logging']},
# numeric
{module=>'PDL', tags=>['category:numeric']},
# oo
{module=>'Moose', tags=>['category:oo']},
{module=>'Moo', tags=>['category:oo']},
# orm
{module=>'DBIx::Class', tags=>['category:orm']},
# regexp
{module=>'Regexp::Common', tags=>['category:regexp']},
{module=>'Regexp::Pattern', tags=>['category:regexp']},
# template
{module=>'Template::Toolkit', tags=>['category:template']},
# testing
{module=>'Test2', tags=>['category:testing']},
# type
{module=>'Specio', tags=>['category:type','category:validation']},
{module=>'Type::Tiny', tags=>['category:type', 'category:validation']},
# validation
{module=>'Data::Sah', tags=>['category:validation']},
{module=>'Params::Validate', tags=>['category:validation']},
# Params::ValidationCompiler?
# Specio*
# Type::Tiny*
# web
{module=>'Catalyst', tags=>['category:web']},
{module=>'CGI::Application', tags=>['category:web']},
{module=>'Dancer', tags=>['category:web']},
{module=>'Dancer2', tags=>['category:web']},
{module=>'Gantry', tags=>['category:web']},
{module=>'Mason', tags=>['category:web']},
{module=>'Maypole', tags=>['category:web']},
{module=>'Mojolicious', tags=>['category:web']},
# Plack?
# web-form
{module=>'HTML::FormFu', tags=>['category:web-form']},
lib/Acme/CPANModules/Frameworks.pm view on Meta::CPAN
=item L<IO::Async>
Author: L<PEVANS|https://metacpan.org/author/PEVANS>
=item L<POE>
Author: L<BINGOS|https://metacpan.org/author/BINGOS>
=item L<Bencher>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<CHI>
Author: L<ASB|https://metacpan.org/author/ASB>
=item L<App::Cmd>
Author: L<RJBS|https://metacpan.org/author/RJBS>
=item L<Perinci::CmdLine>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<ScriptX>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<ArrayData>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<HashData>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<Games::Word::Phraselist>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<Games::Word::Wordlist>
Author: L<DOY|https://metacpan.org/author/DOY>
=item L<TableData>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<WordList>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<DBI>
Author: L<TIMB|https://metacpan.org/author/TIMB>
=item L<Data::Printer>
Author: L<GARU|https://metacpan.org/author/GARU>
=item L<DateTime>
Author: L<DROLSKY|https://metacpan.org/author/DROLSKY>
=item L<Dist::Zilla>
Author: L<RJBS|https://metacpan.org/author/RJBS>
=item L<Minilla>
Author: L<SYOHEX|https://metacpan.org/author/SYOHEX>
=item L<ShipIt>
Author: L<MIYAGAWA|https://metacpan.org/author/MIYAGAWA>
=item L<Interchange>
=item L<Log::Any>
Author: L<PREACTION|https://metacpan.org/author/PREACTION>
=item L<Log::Contextual>
Author: L<FREW|https://metacpan.org/author/FREW>
=item L<Log::Dispatch>
Author: L<DROLSKY|https://metacpan.org/author/DROLSKY>
=item L<Log::ger>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
=item L<Log::Log4perl>
Author: L<ETJ|https://metacpan.org/author/ETJ>
=item L<PDL>
Author: L<ETJ|https://metacpan.org/author/ETJ>
=item L<Moose>
Author: L<ETHER|https://metacpan.org/author/ETHER>
=item L<Moo>
Author: L<HAARG|https://metacpan.org/author/HAARG>
=item L<DBIx::Class>
Author: L<RIBASUSHI|https://metacpan.org/author/RIBASUSHI>
=item L<Regexp::Common>
Author: L<ABIGAIL|https://metacpan.org/author/ABIGAIL>
=item L<Regexp::Pattern>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
Acme-CPANModules-Import-CPANRatings-User-davidgaramond
view release on metacpan or search on metacpan
lib/Acme/CPANModules/Import/CPANRatings/User/davidgaramond.pm view on Meta::CPAN
package Acme::CPANModules::Import::CPANRatings::User::davidgaramond;
use strict;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2023-10-29'; # DATE
our $DIST = 'Acme-CPANModules-Import-CPANRatings-User-davidgaramond'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {description=>"This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.",entries=>[{description=>"\nOk, it's not 2004 anymore, I suggest we retire or start to deprecate this module? This module now requires Perl 5....
1;
# ABSTRACT: List of modules mentioned by CPANRatings user davidgaramond
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::Import::CPANRatings::User::davidgaramond - List of modules mentioned by CPANRatings user davidgaramond
=head1 VERSION
This document describes version 0.002 of Acme::CPANModules::Import::CPANRatings::User::davidgaramond (from Perl distribution Acme-CPANModules-Import-CPANRatings-User-davidgaramond), released on 2023-10-29.
=head1 DESCRIPTION
This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.
This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.
=head1 ACME::CPANMODULES ENTRIES
=over
=item L<Perl6::Say>
Author: L<CHORNY|https://metacpan.org/author/CHORNY>
Ok, it's not 2004 anymore, I suggest we retire or start to deprecate this module? This module now requires Perl 5.8, and Perl 5.10+ has "say" built in, so basically this is a module specifically for 5.8 I<only>.
Rating: 4/10
=item L<Data::Rmap>
Author: L<BOWMANBS|https://metacpan.org/author/BOWMANBS>
I was looking for a simple way to transform all DateTime objects in my data structure into string (e.g. "2010-07-06"). After failed experiment with Data::Walk and dumping Data::Transformer due to unsightly interface, I found Data::Rmap. It'...
<br><br>My only complaint would be the name: it's not immediately searchable (I was searching for 'data modify', 'data walk', 'data traverse', 'modify data inplace', and the like). Also, the name "map" suggests that the function will return...
=item L<Data::Walk>
Author: L<GUIDO|https://metacpan.org/author/GUIDO>
Nice interface (the analogy to File::Find certainly helps) and very straightforward to use, but one thing I can't do is modify the data inplace. I spent about an of hours trying to make Data::Walk do inplace modification, but finally gave up and use ...
Rating: 8/10
=item L<Data::Transformer>
Author: L<BALDUR|https://metacpan.org/author/BALDUR>
Frankly, I don't like the interface. I suspect most people would like to just specify one callback function instead of one for each type. Also I don't like having to work with $$_ ($_ should perhaps be aliased to the real data). As the Data::Transfor...
<br>
Rating: 4/10
=item L<Data::Traverse>
Author: L<FRIEDO|https://metacpan.org/author/FRIEDO>
I find the interface rather unintuitive, because I expect data to be in $_ (instead of type). For those looking for alternatives, see also Data::Walk (which provides breadth-first as well as depth-first) and Data::Rmap (which provides inplace modific...
<br>
Rating: 4/10
=item L<Regexp::Grammars>
Author: L<DCONWAY|https://metacpan.org/author/DCONWAY>
Parse::RecDescent is dead. Long live Regexp::Grammars!
<br><br>As Damian himself has said/presented, RG is the successor for the popular PRD.
<br><br>The docs of RG is not as complete (yet) as PRD's.
<br><br>The PRD grammar syntax is also nicer/cleaner (due to RG having some restrictions because you are writing your grammar inside a regex).
<br><br>RG doesn't (yet) have some of the features of PRD, like <leftop> and <rightop>. But it does have most of the features, and add a few of its own.
<br><br>RG performs significantly faster than PRD.
<br><br>In general, whenever you consider PRD to be a good candidate of tool to solve your problem, consider using RG.
<br><br>But you need Perl 5.10+ to use RG, as it depends on regex features not found in older Perl.
<br>
Rating: 8/10
=item L<Parse::RecDescent>
Author: L<JTBRAUN|https://metacpan.org/author/JTBRAUN>
Responding to previous comment from MB: "Have you the time to do this Damian?" The answer is yes, in the form of Regexp::Grammars, which Damian said himself is the successor of Parse::RecDescent.
<br><br>To give credit to this module, PRD is very featureful and easy to use, it's very convenient to generate parsers, and the docs is quite complete. The only problem with it is, as many have pointed out, speed.
<br><br>It is I<seriously> slow, with parser generation can take up to half a second on my laptop with a moderate grammar (200-400 lines) and parsing can take seconds even minutes for a moderately long string. It is orders of magnitude slower than ot...
<br><br>For alternatives, try Regexp::Grammars. (Or Parse::Yapp or Parse::EYapp, as other reviewers have written.)
Rating: 6/10
=item L<Test::Seperate>
Sorry, just commenting the name, shouldn't it be Separate?
=item L<File::Size>
Author: L<OFER|https://metacpan.org/author/OFER>
Frankly I prefer the name and interface of Filesys::DiskUsage. Sadly, despite the docs mentioning "blocks", this module doesn't really count block usage like the Unix "du" command, because it doesn't take multiple hard links into ...
<br><br>Even more sadly, Filesys::DiskUsage doesn't either.
<br><br>I guess I'll have to do with 'system "du $file"' command for now.
<br>
Rating: 4/10
=item L<DateTime>
Author: L<DROLSKY|https://metacpan.org/author/DROLSKY>
I<THE> definitive date/time handling module in Perl (and even maybe in all major programming languages). Can't believe I went through all the pain of reinventing the wheel, and using various date/time modules of various quality & interface. If on...
<br><br>Look no more, DateTime it is.
<br>
=item L<Data::Rx>
Author: L<RJBS|https://metacpan.org/author/RJBS>
I've been mulling over writing this kind of module (planning to call it Schema::Nested or something), but never got around to do it. Thankfully somebody stepped up and did it! Keep up the good work, will be looking forward to future releases (especia...
<br>
=item L<DBI::Mysqlsimple>
I agree with the previous reviewer. IMO, overall this module is not necessary. Plain DBI is actually simple enough for simple cases. Maybe the author of Mysqlsimple did not realize this. Let's compare:
<br><br>* Retrieving a single row:
<br>
Mysqlsimple: my ($v1,$v2) = $db->get_row("select v1,v2 from table");
<br>
DBI: my ($v1, $v2) = $dbh->selectrow_array("select v1,v2 from table");
<br><br>* Retrieving a single row (with params):
<br>
Mysqlsimple: my ($v1,$v2) = $db->get_row("select v1,v2 from table where cond1=? and cond2=?", [$cond1,$cond2]);
<br>
DBI: my ($v1,$v2) = $db->selectrow_array("select v1,v2 from table where cond1=? and cond2=?", {}, $cond1,$cond2);
<br><br>* Retrieving all rows with params:
<br>
Mysqlsimple: my $rows = $db->get_rows(..., [$param1, $param2]);
<br>
DBI: my $rows = $dbh->selectall_arrayref(..., {}, $param1, $param2);
<br><br>* do() with params:
<br>
Mysqlsimple: my $rows = $db->do(..., [$param1, $param2]);
<br>
DBI: my $rows = $dbh->do(..., {}, $param1, $param2);
<br><br>As you can see, the differences are minimal.
<br>
Rating: 2/10
=item L<Carp::Always>
Author: L<FERREIRA|https://metacpan.org/author/FERREIRA>
Modules like this deserve to be more well-known and should perhaps included in core Perl (or even become a command-line switch). I'm never comfortable with Carp and all the "complexity" of using it. What I wanted is simple, when debugging I...
<br><br>Call me inflicted with Ruby- or Python-envy, but it's been so ridiculous wanting to print out stack traces in Perl. I don't want to have to change/rewrite all my die()'s to croak() or confess()! And what about library codes which use die()?
<br><br>Thank God somebody wrote Carp::Always.
=item L<Data::Dump>
Author: L<GARU|https://metacpan.org/author/GARU>
I've envied Ruby users which can use just "p" to print out data structures instead of us which used to have to do 'use Data::Dumper; print Dumper(...);'. And even then there's this '$VAR1 = ' garbage which 99% of the time is not wanted. Whi...
<br><br>With Data::Dump we're still a bit behind but closer. One rant is the with the doc: the pp() function should perhaps be advertised more prominently, since I suspect that's what most users want most of the time.
=item L<V>
Author: L<ABELTJE|https://metacpan.org/author/ABELTJE>
Acme-CPANModules-Import-CPANRatings-User-perlancar
view release on metacpan or search on metacpan
lib/Acme/CPANModules/Import/CPANRatings/User/perlancar.pm view on Meta::CPAN
package Acme::CPANModules::Import::CPANRatings::User::perlancar;
use strict;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2023-10-29'; # DATE
our $DIST = 'Acme-CPANModules-Import-CPANRatings-User-perlancar'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {description=>"This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.",entries=>[{description=>"\nI'm not sure this really "befits a ::Tiny distribution" just because it's a thin wrapper of something. P...
1;
# ABSTRACT: List of modules mentioned by CPANRatings user perlancar
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::Import::CPANRatings::User::perlancar - List of modules mentioned by CPANRatings user perlancar
=head1 VERSION
This document describes version 0.002 of Acme::CPANModules::Import::CPANRatings::User::perlancar (from Perl distribution Acme-CPANModules-Import-CPANRatings-User-perlancar), released on 2023-10-29.
=head1 DESCRIPTION
This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.
This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.
=head1 ACME::CPANMODULES ENTRIES
=over
=item L<LWP::JSON::Tiny>
Author: L<SKINGTON|https://metacpan.org/author/SKINGTON>
I'm not sure this really "befits a ::Tiny distribution" just because it's a thin wrapper of something. Please read: <a href="http://blogs.perl.org/users/dan_muey/2014/08/please-dont-use-tiny-unless-it-meets-the-tiny-criteria-thanks.html" re...
=item L<Acme::CPANRatings>
Author: L<PERLANCAR|https://metacpan.org/author/PERLANCAR>
After the last template change of the website which is one year ago, "Was this review helpful" links no longer works. <a href="https://github.com/perlorg/perlweb/issues/232" rel="nofollow">github.com/perlorg/perlweb/issues/232</a>
<br>
Rating: 2/10
=item L<Finance::Currency::Convert::WebserviceX>
Author: L<CLACO|https://metacpan.org/author/CLACO>
No longer works. Sigh, looks like there is currently NO working generic currency converter module on CPAN anymore. Every converter module is either: 1) dead; 2) specific for some currencies only.
<br>
Rating: 2/10
=item L<Finance::Currency::Convert>
Author: L<JANW|https://metacpan.org/author/JANW>
Uses hard-coded rates in the source code. Does not seem to work anymore: convert() returns zero even after updateRates().
lib/Acme/CPANModules/Import/CPANRatings/User/perlancar.pm view on Meta::CPAN
Has some problems, e.g. it uses InstallTool phase so it conflicts with DZP:StaticInstall when wanting to produce a static install distro. Use alternatives like the simpler DZP:Pod2Readme or the more complex DZP:ReadmeAnyFromPod.
<br>
Rating: 2/10
=item L<Dist::Zilla::Plugin::Hook>
Author: L<VDB|https://metacpan.org/author/VDB>
Great for debugging. Just whip up some code in dist.ini to e.g. dump & print some stuffs, etc.
=item L<File::Tail::Dir>
Author: L<JJSCHUTZ|https://metacpan.org/author/JJSCHUTZ>
Interesting features, but mooseware.
Rating: 6/10
=item L<Algorithm::Dependency>
Author: L<ETHER|https://metacpan.org/author/ETHER>
Happily returns result when graph is cyclic (and thus proper topological sorting cannot be done). See also Data::Graph::Util for a simpler alternative.
<br>
Rating: 6/10
=item L<Data::Match>
Author: L<KSTEPHENS|https://metacpan.org/author/KSTEPHENS>
(Reviewing Sort::Topological, which is included in Data-Match distribution at the time of this review).
<br><br>Hangs when given a dependency like: a => ["a"]. Happily returns result when graph is cyclic (and thus proper topological sorting cannot be done). See also Data::Graph::Util for alternative.
<br>
Rating: 4/10
=item L<File::Find::Wanted>
Author: L<PETDANCE|https://metacpan.org/author/PETDANCE>
File::Find lacks the "making easy things easy" part, so modules like this are great. A further step would be an option to omit $wanted for even simpler cases, but that would probably break the interface. Another alternative is File::Finder,...
<br>
Rating: 8/10
=item L<Hash::MD5>
Author: L<MZIESCHA|https://metacpan.org/author/MZIESCHA>
Since this is essentially md5(dump($data)), why restrict yourself to hash? This works also for any kind of Perl data structure.
=item L<DateTime::Format::Docker>
Author: L<MZIESCHA|https://metacpan.org/author/MZIESCHA>
Isn't this basically ISO8601 (see DateTime::Format::ISO8601)?
=item L<WWW::CPANRatings>
Author: L<CORNELIUS|https://metacpan.org/author/CORNELIUS>
To get the ratings for a single distribution, this client library needs to download /csv/all_ratings.csv (~80KB at the time of this writing) first. This is not the fault of the client because the website indeed does not provide the necessary ratings ...
Rating: 8/10
=item L<Parse::CPAN::Ratings>
Author: L<LBROCARD|https://metacpan.org/author/LBROCARD>
Not as useful as the name implies. It requires you to download the CSV of all ratings first, which BTW does not seem to be advertised on the CPAN Ratings website. The CSV file only contains numeric ratings and does not include any reviews. So basical...
<br><br>One might want to look at WWW::CPANRatings instead.
Rating: 6/10
=item L<Acme::Curse>
Author: L<MORITZ|https://metacpan.org/author/MORITZ>
This pure-perl module creates a shallow copy of the object instead of directly removing blessing from the same object (which requires XS). Acme::Damn is the more direct counterpart of bless().
<br>
=item L<Digest::SHA1>
Author: L<GAAS|https://metacpan.org/author/GAAS>
Use Digest::SHA instead. In general, there is no reason in using Digest::SHA1 over Digest::SHA. The latter is a core Perl module, more updated, and implements the other algorithms while the former only implements SHA-1 which is now deprecated.
<br><br>
=item L<File::Checksum>
Author: L<KNORR|https://metacpan.org/author/KNORR>
The "checksum" (basically just adding 16-bit words) is too simplistic to be a real checksum or to be practically useful. Even MD5 or CRC32 is infinitely better.
<br>
=item L<WordPress::XMLRPC>
Author: L<IGIBBS|https://metacpan.org/author/IGIBBS>
Still works, partially, but in general out of date. For example, to get post the deprecated metaWeblog.getPost API method is still used instead of the newer wp.getPost call (which understandably is only introduced in WordPress 3.4, while this module ...
<br><br>Luckily, performing XMLRPC request directly is easy enough. Just use XMLRPC::Lite and peruse the Wordpress documentation here: <a href="https://codex.wordpress.org/XML-RPC_WordPress_API" rel="nofollow">codex.wordpress.org/XML-RPC_WordPress......
=item L<Text::Levenshtein::Flexible>
Author: L<MBETHKE|https://metacpan.org/author/MBETHKE>
My new favorite Levenshtein distance module. It's as fast (if not faster) than Text::Levenshtein::XS and can provide a speed boost if you don't care about distances above a certain limit. Which I think in many cases is true.
Acme-CPANModules-Import-CPANRatings-User-stevenharyanto
view release on metacpan or search on metacpan
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
package Acme::CPANModules::Import::CPANRatings::User::stevenharyanto;
use strict;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2023-10-29'; # DATE
our $DIST = 'Acme-CPANModules-Import-CPANRatings-User-stevenharyanto'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {description=>"This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.",entries=>[{description=>"\n(REMOVED)\n",module=>"Log::Any",rating=>undef},{description=>"\nProvides a thin/lightweight OO interface for \$?, ...
1;
# ABSTRACT: List of modules mentioned by CPANRatings user stevenharyanto
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::Import::CPANRatings::User::stevenharyanto - List of modules mentioned by CPANRatings user stevenharyanto
=head1 VERSION
This document describes version 0.002 of Acme::CPANModules::Import::CPANRatings::User::stevenharyanto (from Perl distribution Acme-CPANModules-Import-CPANRatings-User-stevenharyanto), released on 2023-10-29.
=head1 DESCRIPTION
This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.
This list is generated by scraping CPANRatings (cpanratings.perl.org) user page.
=head1 ACME::CPANMODULES ENTRIES
=over
=item L<Log::Any>
Author: L<PREACTION|https://metacpan.org/author/PREACTION>
(REMOVED)
=item L<Process::Status>
Author: L<RJBS|https://metacpan.org/author/RJBS>
Provides a thin/lightweight OO interface for $?, much like what Time::Piece does for localtime()/gmtime() or File::Stat for stat(). Of course, Real(TM) programmers shift and fiddle bits by themselves, but for the rest of us this module is a nice conv...
=item L<Archive::Any>
Author: L<OALDERS|https://metacpan.org/author/OALDERS>
Nice idea, but the API needs to richer to be more useful (otherwise one will still need to go to individual Archive::Tar, Archive::Zip, etc). Currently the API provided are: listing files and extracting all files. We can't: create archive, add more f...
Rating: 8/10
=item L<Devel::Confess>
Author: L<HAARG|https://metacpan.org/author/HAARG>
Very nifty, it's like Carp::Always but with much more options/features (so you don't need a separate Carp::Always::Color, Carp::Always::Dump, and so on).
=item L<SQL::Statement>
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
=item L<Text::CharWidth>
Author: L<KUBOTA|https://metacpan.org/author/KUBOTA>
It's faster than Unicode::GCString->new($str)->columns, but it gives wrong answers to lots of characters, e.g. control characters like "\n", "\t", etc are currently assumed to have width of -1 character. You're better off wi...
Rating: 2/10
=item L<App::Options>
Author: L<SPADKINS|https://metacpan.org/author/SPADKINS>
2010-10-13:
<br><br>I admit, this is not the most flexible configuration framework out there as it enforces some convention. And I don't/can't use it on every project. But it's certainly one of the easiest. You can slap a few lines of options declaration in your...
<br><br>There are still a few annoyances (I submitted them in the RT), but in general, this is a very handy module to use for lazy coders who just want to accept configuration/options from outside the code.
<br><br><shameless plug>I'm trying to do somewhat the same with Config::Tree, but as of now the module is not really done yet.</shameless plug>
<br><br>UPDATE 2013-08-15:
<br><br>I'm reducing the ratings from 5 to 2. I've now avoided using this module due to two lingering issue since 2010: 1) App::Options does not accept '--opt val', only '--opt=val' which is incompatible with how most command-line programs work, caus...
<br><br>I'm now using Perinci::CmdLine as replacement, but I cannot recommend it in general, as the two modules are not equivalent.
Rating: 4/10
=item L<Filesys::Notify::Simple>
Author: L<MIYAGAWA|https://metacpan.org/author/MIYAGAWA>
It's rather unfortunate that currently the choice for general purpose cross-platform filesystem notification modules on CPAN falls between this module (FNS) or File::ChangeNotify (F::CN). The other CPAN modules are either OS-/framework-specific.
<br><br>FNS has a simple API but is perhaps too simple for some uses, while F::CN uses Moose and has a big startup overhead.
<br><br>If you simply want to check from time to time whether a change has occured, you need to wrap the wait() method with alarm(). And I found on my Linux PC that I need a timeout of at least 3 seconds for this to work reliably.
Rating: 8/10
=item L<experimental>
Author: L<LEONT|https://metacpan.org/author/LEONT>
Vote +1 to add this to core. Please make coding in Perl 5 relatively painless.
=item L<MIME::Lite::HTML>
Author: L<ALIAN|https://metacpan.org/author/ALIAN>
Very straightforward to use (I needed to send a URL/webpage as HTML email with embedded images/objects). With this module I can finish my job with only a few lines of Perl in 3-5 minutes (searching for this module in CPAN takes more than that! search...
<br><br>Blackberry is having trouble displaying the resulting email though. No problem with Gmail or Thunderbird/Icedove.
=item L<Term::Size>
Author: L<FERREIRA|https://metacpan.org/author/FERREIRA>
5-year old bug like RT#38594 still present. Use one of the alternate implementations like Term::Size::{Unix,Win32,ReadKey}.
<br>
Rating: 2/10
=item L<DateTime::Format::Flexible>
Author: L<THINC|https://metacpan.org/author/THINC>
While it doesn't cover as much phrases as DateTime::Format::Natural, at least it's simpler to translate (and the dist already includes a couple of translations). BTW, I think like in the POD of DateTime::Format::Natural, it needs to list which phrase...
<br><br>
Rating: 8/10
=item L<DateTime::Format::Natural>
Author: L<SCHUBIGER|https://metacpan.org/author/SCHUBIGER>
I'm giving DateTime::Format::Natural 3 stars because while it's great for English (it covers more phrases than DateTime::Format::Flexible), it's also hard to translate. Look at the source code for DateTime::Format::Natural::Lang::EN: lots of Englishi...
<br>
Rating: 6/10
=item L<App::sourcepan>
Author: L<PEVANS|https://metacpan.org/author/PEVANS>
Thanks, just what I needed. (I was hoping cpanm would accept my --download patch, but this is just as well).
<br><br>It still uses CPAN.pm and thus downloads the relatively big 01mailrc.txt.gz and 02packages.details.txt.gz file, thus slowing the first use. If you use cpanm exclusively, this is rather annoying especially if you're on a slow link.
Rating: 8/10
=item L<Text::ASCIITable::TW>
The method of determining visual width of Chinese characters is rather hackish. Text::ASCIITable should perhaps use Text::CharWidth (which can be used to determine visual width of text in other languages e.g. Japanese, etc) thus rendering this module...
<br>
=item L<Text::VisualWidth>
Author: L<NANZOU|https://metacpan.org/author/NANZOU>
Also look at Text::CharWidth for an alternative that can be used with text in other languages (Chinese, etc).
<br>
=item L<Text::VisualWidth::PP>
Author: L<TOKUHIROM|https://metacpan.org/author/TOKUHIROM>
Also look at Text::CharWidth for an alternative that can be used with text in other languages (Chinese, etc).
<br>
=item L<Taint::Runtime>
Author: L<RHANDOM|https://metacpan.org/author/RHANDOM>
Nice idea. Perl should really have included something like this (analogous to warnings.pm for -w).
<br><br>However, for something as security-related as tainting, I personally think the interface is a bit too complex and not robust enough. There are too many pitfalls where one can fail to turn on tainting properly.
<br><br>* First, user must remember to import $TAINT, or doing '$TAINT = 1' has no effect. There's no error/warning for this mistake.
<br><br>* Then, if one also forgets to import taint_start or taint_start, then doing 'taint_start' or 'taint_env' (without parentheses) will do nothing. Also does not produce an error/warning except under strict mode.
<br><br>* One must remember to 'taint_env' I<after> 'taint_start'. There's no warning/error if one does the opposite.
<br><br>I'd rather have something like this:
<br><br>{
<br><br>use tainting;
<br><br>... code is running in taint mode ...
<br>
}
<br><br>use tainting;
<br>
{
<br><br>no tainting;
<br><br>... code is running without taint mode ...
<br>
}
<br><br>No functions, no variables to set, no exports. Tainting of %ENV etc should be done automatically just like -T.
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
=item L<Switch>
Author: L<CHORNY|https://metacpan.org/author/CHORNY>
With all due respect to the author, Switch is no longer necessary in 5.10+ as 5.10+ already introduced smart matching and given(). given() is superior because it doesn't introduce compile-time overhead, doesn't mess line numbers, and should be faster...
<br><br>You have been using 5.10+, right? (Since 5.8 is no longer officially supported)
<br>
=item L<Moo>
Author: L<HAARG|https://metacpan.org/author/HAARG>
Last week I ported an application from Mouse (Any::Moose) to Moo. Went without a hitch (well I did replace "with 'X', 'Y', 'Z';" to "with 'X'; with 'Y'; with 'Z';" as instructed in the Moo documentation). Startup time decreased si...
<br>
=item L<Sub::StopCalls>
Author: L<RUZ|https://metacpan.org/author/RUZ>
Cool idea, if a bit extreme.
<br><br>If computing a value is expensive, there's Memoize for the caller. On the callee side, you can cache the result (there's state variable in 5.10+ so it's dead simple to use).
<br><br>So I believe Sub::StopCalls is only necessary if you find the overhead of the sub call itself to be a bottleneck. And if that is the case, perhaps you should refactor the calling code anyway.
Rating: 8/10
=item L<Log::Log4perl::Tiny>
Author: L<POLETTIX|https://metacpan.org/author/POLETTIX>
5 stars solely for the idea (I'm beginning to love the ::Tiny movement more and more these days). Haven't actually tried it though, but I bet many Log4perl users, me included, mostly only use easy_init. As much as Log4perl is mature and fairly optimi...
=item L<SHARYANTO::YAML::Any>
Re: Blue. I guess I shouldn't release this. I need something quick to fix our application, so this is not really something meant for public use. Will be purging this from PAUSE.
<br>
=item L<SQL::Easy>
Author: L<BESSARABV|https://metacpan.org/author/BESSARABV>
IIRC, there has also previous similar attempt like this. Modules like these are not necessary, as DBI already has something equivalent (and even better): selectrow_{array,hashref,arrayref} and selectall_{array,hash}ref.
<br>
Rating: 2/10
=item L<CGI::Struct>
Author: L<FULLERMD|https://metacpan.org/author/FULLERMD>
Cool, will definitely try this out the next time I write another form processing CGI script. Although the module is named CGI::, there's nothing CGI-specific about it, and that's good. So this module is basically a "path-expander" for hash ...
<br><br>Btw, one thing I use rather often in PHP is naming parameter as "foo[]" which will automatically add elements to the $_REQUEST['foo'] array. Perhaps this feature can be considered too.
=item L<DateTime::BusinessHours>
Author: L<BRICAS|https://metacpan.org/author/BRICAS>
Just tried it. It works, but the module/dist is not in the best shape:
<br><br>* Test fails (pod-coverage, error in POD)
<br><br>* dependency on Class::MethodMaker not yet specified
<br><br>* Documentation: Synopsis contains mistake (class name is DateTime::BusinessHours not BusinessHours), the name '$testing' is not very suitable, there are typos.
<br><br>* Style-wise, method naming is "joinedwords", while in DateTime families it's "separated_words" (not a big deal though).
<br><br>
Rating: 6/10
=item L<Bundle::Dpchrist>
Every once in a while everyone of us encounters a programmer that disregards existing reusable code and creates his/her own "standard library" for everything, from trimming string to creating random number to cleaning the kitchen sink. We a...
<br><br>A commendable effort, David. But there really are a lot of wheels being reinvented here.
=item L<Net::BitTorrent::File>
Author: L<ORCLEV|https://metacpan.org/author/ORCLEV>
I mass download stuffs by putting a bunch of torrent files in a directory on the server and let rtorrent takes care of them. With this module I can quickly whip up a short script to calculate the total size of the downloadable files so I can be prett...
<br>
=item L<Module::CoreList>
Author: L<BINGOS|https://metacpan.org/author/BINGOS>
Wow, I was thinking the same exact "godsend" too and turns out some other reviewer already said so. Very very helpful to assist deployment and pick modules to use. I personally made a couple of command-line scripts like pm-in-core or core-s...
<br>
=item L<WWW::Mechanize>
Author: L<SIMBABQUE|https://metacpan.org/author/SIMBABQUE>
WWW::Mechanize is of course one of the indispensable tools for any web programmer or admin. The current problem is the proliferation of 3rd party subclasses, the functionalities of which cannot be used together. So you want a polite Mechanize which d...
<br>
=item L<Mail::Sendmail>
Author: L<NEILB|https://metacpan.org/author/NEILB>
I used Mail::Sendmail and a few others "older" modules back from the days when it didn't support setting envelope sender different from RFC From, and when the test hung on some dead host.
<br><br>If it's still working for you, great. I personally have moved on to other modules like Email::Sender::Simple, which abstracts sending mechanism (transport) and support SMTP auth, for two. Also, many of the guide/documentation for Mail::Sendma...
Rating: 6/10
=item L<autodie>
Author: L<TODDR|https://metacpan.org/author/TODDR>
I started using autodie in almost all of my applications a few months ago. It's somewhat of a mixed blessing. For existing applications, it can break things and making things less robust, solely because old code are not built with autodie in mind.
<br><br>But the best thing about it is that it's lexically scoped, so for sections of code that you're not sure about, just sprinkle 'no autodie' to get the old behaviour.
<br><br>It should be used on probably 95% of code out there. For the rest of the cases, where you need to report the status of each I/O operation, it's obviously more convenient to check $? instead of trapping exception everytime.
<br><br>+1 for getting it into core.
<br>
=item L<App::FileTools::BulkRename>
Disclaimer: I maintain a "competitor" module, App::perlmv. Apparently a lot of people, like me, likes to rename files using Perl. And the examples in the documentation are about renaming movie files too, something which I do a lot :)
<br><br>I applaud Stirling Westrup for taking a legacy script and improving it. May we have a lot of ideas to borrow from each other.
lib/Acme/CPANModules/Import/CPANRatings/User/stevenharyanto.pm view on Meta::CPAN
<br>
=item L<Log::Handler>
Author: L<BLOONIX|https://metacpan.org/author/BLOONIX>
This review mostly compares Log::Handler with Log4perl, which is a mature and one of the most popular logging frameworks.
<br><br>I think Log::Handler's interface is much simpler, nicer, more Perlish than Log4perl. It's a bit similar to Log::Any::App, which I created just because I hate Log4perl configuration.
<br><br>There is a unique concept of maxlevel not normally found in other frameworks, though it can be emulated in other frameworks using filters.
<br><br>At a quick glance, the speed is around twice that of Log::Log4perl, so I'll say it's on the low-end side (there are other much faster logging modules, but anyway speed is not an issue to most people).
<br><br>It currently lacks sublogger (hierarchical categorization and adjustable/automatic appending of subcategory to its parent), so it cannot be used to replace Log4perl in most cases as that's one of the main feature of Log4perl. Which is a pity ...
Rating: 8/10
=item L<Log::Fast>
Author: L<POWERMAN|https://metacpan.org/author/POWERMAN>
This logging framework is also minimalistic: no categories/hierarchiecal loggers, no custom levels, no config file, or other whistles and bells. And the interface & default levels are rather syslog-oriented. But it's fast alright. The POD doesn't...
<br><br>So this module will certainly come handy if you have a performance critical application.
<br><br>Btw, note that the benchmarks are done for actual logging to output. For log statements that do not actually get logged (e.g. because the level is below the desired output level), I don't find that extreme differences in overhead between log...
=item L<Log::Minimal>
Author: L<KAZEBURO|https://metacpan.org/author/KAZEBURO>
Log::Minimal's slogan is "minimal but customizable". It's minimal alright, probably only suitable for simple scripts as the moment you organize your application/library into separate modules, you'll want/need categories instead of just leve...
<br><br>Also, only formats is customizable, there is currently no way to customize level. And the levels are "not standard" (not that there is an official authoritative standard, but the popular convention is TRACE/DEBUG/INFO/WARN/ERROR/FAT...
<br>
DEBUG/INFO/WARN/CRITICAL and NONE). Surely most people would expect another level between WARN and CRITICAL, for non-critical errors? But that is actually just a matter of taste.
<br>
Rating: 4/10
=item L<Log::Fine>
Author: L<CFUHRMAN|https://metacpan.org/author/CFUHRMAN>
Log::Fine is touted as a framework for those who "need a fine-grained logging mechanism in their program(s)". But apart from the emphasis on custom levels, to me there is nothing extra fine-grained about it. The other thing it provides is c...
<br><br>Btw regarding custom levels, this practice is long deprecated by log4j (and thus also by Log4perl, although Log4perl can do custom levels). I can understand this decision as I sometimes already have trouble managing the popular convention of ...
Rating: 6/10
=item L<Config::IniFiles>
Author: L<SHLOMIF|https://metacpan.org/author/SHLOMIF>
This module has been developed for more than a decade and seen different maintainers over the years. The codebase is indeed showing these, with different capitalization and indentation styles, among other things.
<br><br>However, among more than a dozen or so of INI modules in CPAN, ironically there seems to be few other choices if you go beyond the most basic feature set. Some INI modules can only simplistically rewrite/dump the whole INI structure and thus ...
<br><br>Config::IniFiles by far offers the most options and features, like dealing with line continuation, case sensitivity, default section, multiline/array, deltas, etc. So for now, despite all of its quirks, this module is still hard to beat.
<br><br>There's another nice little INI module that can do read/set/delete/unset (instead of just read/dump): Prima::IniFile, but it is included in a totally unrelated distribution.
Rating: 8/10
=item L<DateTime>
Author: L<DROLSKY|https://metacpan.org/author/DROLSKY>
Amidst all the glowing reviews may I add a reminder that, as with everything, there's a catch: runtime performance. On my PC, the speed of creating a DateTime object is just around 6000/sec. If you use DateTime intensively, it can quickly add up.
<br><br>Imagine serving a web page that fetches 50 rows from database, where for convenience you convert each date column to a DateTime object, and you have 120 requests/sec coming in... That's already 6000 objects (an extra second!).
<br><br>Which is unfortunate because DateTime is so wonderful, convenient, correct, complete and all that. So one approach you can use might be to delay converting to DateTime object until necessary.
=item L<Date::Manip>
Author: L<SBECK|https://metacpan.org/author/SBECK>
Wow, there are surely a lot of negative reviews ...
<br><br>First of all, Date::Manip has a long history. I used this module back in 2001-2002, IIRC. Back then it was I<the> swiss army of date/time manipulation, something you use when you want the most flexible/complete thing in Perl. True, it's slow,...
<br><br>But then things change. DateTime project was started, and now it is somewhat the de facto standard. It's more modern and far more modular than the monolithic Date::Manip (every timezone and language support and parsing/formatting modules ship...
<br><br>And then there's the 5.x -> 6.x debacle. As someone who also sprinkle Perl 5.10 requirements to his CPAN modules, I can feel for the author. But the difference is, most of my modules are not that widely used/known, and also many start its ...
<br><br>All in all, you are free to use or not use Date::Manip. There are other alternatives. Pick wisely.
<br>
Rating: 6/10
=item L<App::pmuninstall>
Author: L<XAICRON|https://metacpan.org/author/XAICRON>
One would wonder why CPAN clients still don't have this crucial feature Though you see Miyagawa listed in the Credits so maybe cpanminus or its sister will end up having this functionality? One can only hope. At 0.06, some things are not working flaw...
<br><br>
=item L<App::lntree>
Author: L<ROKR|https://metacpan.org/author/ROKR>
I guess this app is still useful, since "cp -sR" still doesn't work as many would expect, and there are Windows users out there (yes, newer NTFS does support symlinks; though I don't know whether this module supports creating symlinks on NT...
<br><br>A minor comment would be on the name, maybe lnstree can be considered instead (since "ln" indicates hardlink, at least for me). Btw, there's also a free software called "lns" to do the exact same thing.
<br><br>
=item L<Data::Clone>
Author: L<GFUJI|https://metacpan.org/author/GFUJI>
I've never encountered difficulty in cloning data structures in Perl, usually I just use Clone or sometimes Storable's freeze + thaw (the later does not yet support cloning Regexp objects out of the box).
<br><br>However, I like Data::Clone for its speed! It's several times faster than Clone or freeze+thaw. So hats up. Planning to use Data::Clone in future projects.
<br><br>Now if we can convince Goro to write a fast serializer/deserializer with compact output (essentially, a faster version of Storable), that would be even nicer :-)
<br><br>
=item L<Data::Pond>
Author: L<ZEFRAM|https://metacpan.org/author/ZEFRAM>
With due respect to the author, I fail to see the practical point of Pond. Pond (Perl-based open notation for data) is the Perl counterpart of JSON, except that implementation is currently only available in Perl (CMIIW), and "Pond represents few...
<br><br>Pond is pitched against Data::Dumper + eval, which is dangerous, but Data::Dumper + eval is by far not the only method available for serialization. Perl can do Storable, JSON, YAML, even PHP serialization format.
<br><br>The documentation does not show what Pond looks like.
<br><br>One cute thing about Pond is that you can check Pond syntax using a single regex. But apart from that, there's nothing compelling in using Pond to serialize data.
Rating: 4/10
=item L<File::Which>
Author: L<PLICEASE|https://metacpan.org/author/PLICEASE>
You can always count on CPAN to have prewritten modules for various things, including this one. I've never bothered before about portability and just rely on the "which" command, but for one reason there's a time when I just couldn't do tha...
<br><br>Btw, there's also File::Which::Cached.
=item L<String::ShellQuote>
Author: L<ROSCH|https://metacpan.org/author/ROSCH>
I admit it. Ever since I know about escapeshellarg() and escapeshellcmd() in PHP, I've been reimplementing this function in Perl literally a million of times (mostly because of laziness and because it only takes a couple of lines in Perl). Only a fe...
<br><br>The only problem for this module is lack of visibility. Before I've never read articles or blog posts mentioning this module, ever. Yes, we have system() that can bypass the shell, but qx() can't. So yes, this module needs to be marketed more...
Acme-CPANModules-NewDistributions-202001
view release on metacpan or search on metacpan
lib/Acme/CPANModules/NewDistributions/202001.pm view on Meta::CPAN
description => "Distribution Bencher-Scenarios-ModuleInstalledTiny first released by PERLANCAR at 2020-01-13T01:01:35Z.",
module => "Bencher::Scenarios::ModuleInstalledTiny",
summary => "Scenarios to benchmark Module::Installed::Tiny",
},
{
description => "Distribution BettingStrategy-MonteCarlo first released by NQOUNET at 2020-01-16T18:55:33Z.",
module => "BettingStrategy::MonteCarlo",
summary => "Monte Carlo method for gambling.",
},
{
description => "Distribution Bio-WGS2NCBI first released by RVOSA at 2020-01-23T15:54:29Z.",
module => "Bio::WGS2NCBI",
summary => "module to assist in submitting whole genome sequencing projects to NCBI",
},
{
description => "Distribution CGI-Application-Plugin-OpenTracing first released by VANHOESEL at 2020-01-16T13:57:56Z.",
module => "CGI::Application::Plugin::OpenTracing",
summary => "Use OpenTracing in CGI Applications",
},
{
description => "Distribution Calendar-Dates-UnitedNations-InternationalDays first released by PERLANCAR at 2020-01-01T11:35:05Z.",
module => "Calendar::Dates::UnitedNations::InternationalDays",
summary => "United Nations' International Days",
},
{
description => "Distribution Catalyst-Authentication-Credential-RedmineCookie first released by BOKUTIN at 2020-01-09T06:00:28Z.",
module => "Catalyst::Authentication::Credential::RedmineCookie",
summary => "Decode the redmine cookie _redmine_session",
},
{
description => "Distribution Catalyst-Authentication-RedmineCookie first released by BOKUTIN at 2020-01-17T07:22:36Z.",
module => "Catalyst::Authentication::RedmineCookie",
summary => "Decode the redmine cookie _redmine_session",
},
{
description => "Distribution Chart-Colors first released by CDRAKE at 2020-01-20T10:56:51Z.",
module => "Chart::Colors",
summary => "Perl extension to return an endless stream of new distinct RGB colours codes (good for coloring any number of chart lines)",
},
{
description => "Distribution Config-Registry first released by BLUEFEET at 2020-01-19T15:54:32Z.",
module => "Config::Registry",
summary => "Settings bundler.",
},
{
description => "Distribution Crypto-NanoRPC first released by HACKTOR at 2020-01-16T15:17:14Z.",
module => "Crypto::NanoRPC",
summary => "Perl module for interacting with Nano node",
},
{
description => "Distribution Data-Validate-Chemistry first released by MERKYS at 2020-01-29T14:38:32Z.",
module => "Data::Validate::Chemistry",
summary => "Validate common chemical identifiers",
},
{
description => "Distribution Date-strftimeq first released by PERLANCAR at 2020-01-19T01:57:48Z.",
module => "Date::strftimeq",
summary => "POSIX::strftime() with support for embedded perl code in %(...)q",
},
{
description => "Distribution DateTime-Format-Strftimeq first released by PERLANCAR at 2020-01-12T00:05:08Z.",
module => "DateTime::Format::Strftimeq",
summary => "Format DateTime object using DateTimeX::strftimeq",
},
{
description => "Distribution DateTimeX-strftimeq first released by PERLANCAR at 2020-01-05T00:05:58Z.",
module => "DateTimeX::strftimeq",
summary => "POSIX::strftime() with support for embedded perl code in %(...)q",
},
{
description => "Distribution Dist-Zilla-Plugin-Test-ProveDeps first released by PERLANCAR at 2020-01-29T09:03:54Z.",
module => "Dist::Zilla::Plugin::Test::ProveDeps",
summary => "Add release test to run 'prove' on dependent distributions",
},
{
description => "Distribution Dist-Zilla-Plugin-Test-ProveRdeps first released by PERLANCAR at 2020-01-30T11:45:24Z.",
module => "Dist::Zilla::Plugin::Test::ProveRdeps",
summary => "Add release test to run 'prove' on distributions that depend on us",
},
{
description => "Distribution Duadua first released by BAYASHI at 2020-01-31T05:07:25Z.",
module => "Duadua",
summary => "Detect User-Agent",
},
{
description => "Distribution Eircode first released by DRAXIL at 2020-01-20T11:11:18Z.",
module => "Eircode",
summary => "Validation and utilities for Eircodes / Irish postcodes",
},
{
description => "Distribution FTN-Crypt first released by PIETRO at 2020-01-15T20:49:51Z.",
module => "FTN::Crypt",
summary => "Encryption of the FTN messages.",
},
{
description => "Distribution File-BackupCopy first released by SGRAY at 2020-01-20T07:48:10Z.",
module => "File::BackupCopy",
summary => "create a backup copy of the file.",
},
{
description => "Distribution Font-Fontconfig first released by VANHOESEL at 2020-01-20T16:38:30Z.",
module => "Font::Fontconfig",
summary => "An Object Oriented interface to fontconfig",
},
{
description => "Distribution Font-Selector first released by VANHOESEL at 2020-01-21T08:20:21Z.",
module => "Font::Selector",
summary => "select the right font for rendering",
},
{
description => "Distribution Geo-Coder-DAMS first released by BOKUTIN at 2020-01-04T19:00:11Z.",
module => "Geo::Coder::DAMS",
summary => "Perl bindings for Japanese Geocoder DAMS",
},
{
description => "Distribution HarfBuzz-Shaper first released by JV at 2020-01-25T20:50:26Z.",
module => "HarfBuzz::Shaper",
summary => "Use HarfBuzz for text shaping",
},
{
description => "Distribution Huawei-Info-Ipaddr first released by PINGAN at 2020-01-08T15:01:58Z.",
module => "Huawei::Info::Ipaddr",
summary => undef,
},
{
description => "Distribution IO-EPP first released by VADIML at 2020-01-12T12:01:15Z.",
module => "IO::EPP",
lib/Acme/CPANModules/NewDistributions/202001.pm view on Meta::CPAN
=item * L<Bencher::Scenarios::ModuleInstalledTiny> - Scenarios to benchmark Module::Installed::Tiny
Distribution Bencher-Scenarios-ModuleInstalledTiny first released by PERLANCAR at 2020-01-13T01:01:35Z.
=item * L<BettingStrategy::MonteCarlo> - Monte Carlo method for gambling.
Distribution BettingStrategy-MonteCarlo first released by NQOUNET at 2020-01-16T18:55:33Z.
=item * L<Bio::WGS2NCBI> - module to assist in submitting whole genome sequencing projects to NCBI
Distribution Bio-WGS2NCBI first released by RVOSA at 2020-01-23T15:54:29Z.
=item * L<CGI::Application::Plugin::OpenTracing> - Use OpenTracing in CGI Applications
Distribution CGI-Application-Plugin-OpenTracing first released by VANHOESEL at 2020-01-16T13:57:56Z.
=item * L<Calendar::Dates::UnitedNations::InternationalDays> - United Nations' International Days
Distribution Calendar-Dates-UnitedNations-InternationalDays first released by PERLANCAR at 2020-01-01T11:35:05Z.
=item * L<Catalyst::Authentication::Credential::RedmineCookie> - Decode the redmine cookie _redmine_session
Distribution Catalyst-Authentication-Credential-RedmineCookie first released by BOKUTIN at 2020-01-09T06:00:28Z.
=item * L<Catalyst::Authentication::RedmineCookie> - Decode the redmine cookie _redmine_session
Distribution Catalyst-Authentication-RedmineCookie first released by BOKUTIN at 2020-01-17T07:22:36Z.
=item * L<Chart::Colors> - Perl extension to return an endless stream of new distinct RGB colours codes (good for coloring any number of chart lines)
Distribution Chart-Colors first released by CDRAKE at 2020-01-20T10:56:51Z.
=item * L<Config::Registry> - Settings bundler.
Distribution Config-Registry first released by BLUEFEET at 2020-01-19T15:54:32Z.
=item * L<Crypto::NanoRPC> - Perl module for interacting with Nano node
Distribution Crypto-NanoRPC first released by HACKTOR at 2020-01-16T15:17:14Z.
=item * L<Data::Validate::Chemistry> - Validate common chemical identifiers
Distribution Data-Validate-Chemistry first released by MERKYS at 2020-01-29T14:38:32Z.
=item * L<Date::strftimeq> - POSIX::strftime() with support for embedded perl code in %(...)q
Distribution Date-strftimeq first released by PERLANCAR at 2020-01-19T01:57:48Z.
=item * L<DateTime::Format::Strftimeq> - Format DateTime object using DateTimeX::strftimeq
Distribution DateTime-Format-Strftimeq first released by PERLANCAR at 2020-01-12T00:05:08Z.
=item * L<DateTimeX::strftimeq> - POSIX::strftime() with support for embedded perl code in %(...)q
Distribution DateTimeX-strftimeq first released by PERLANCAR at 2020-01-05T00:05:58Z.
=item * L<Dist::Zilla::Plugin::Test::ProveDeps> - Add release test to run 'prove' on dependent distributions
Distribution Dist-Zilla-Plugin-Test-ProveDeps first released by PERLANCAR at 2020-01-29T09:03:54Z.
=item * L<Dist::Zilla::Plugin::Test::ProveRdeps> - Add release test to run 'prove' on distributions that depend on us
Distribution Dist-Zilla-Plugin-Test-ProveRdeps first released by PERLANCAR at 2020-01-30T11:45:24Z.
=item * L<Duadua> - Detect User-Agent
Distribution Duadua first released by BAYASHI at 2020-01-31T05:07:25Z.
=item * L<Eircode> - Validation and utilities for Eircodes / Irish postcodes
Distribution Eircode first released by DRAXIL at 2020-01-20T11:11:18Z.
=item * L<FTN::Crypt> - Encryption of the FTN messages.
Distribution FTN-Crypt first released by PIETRO at 2020-01-15T20:49:51Z.
=item * L<File::BackupCopy> - create a backup copy of the file.
Distribution File-BackupCopy first released by SGRAY at 2020-01-20T07:48:10Z.
=item * L<Font::Fontconfig> - An Object Oriented interface to fontconfig
Distribution Font-Fontconfig first released by VANHOESEL at 2020-01-20T16:38:30Z.
=item * L<Font::Selector> - select the right font for rendering
Distribution Font-Selector first released by VANHOESEL at 2020-01-21T08:20:21Z.
=item * L<Geo::Coder::DAMS> - Perl bindings for Japanese Geocoder DAMS
Distribution Geo-Coder-DAMS first released by BOKUTIN at 2020-01-04T19:00:11Z.
=item * L<HarfBuzz::Shaper> - Use HarfBuzz for text shaping
Distribution HarfBuzz-Shaper first released by JV at 2020-01-25T20:50:26Z.
=item * L<Huawei::Info::Ipaddr>
Distribution Huawei-Info-Ipaddr first released by PINGAN at 2020-01-08T15:01:58Z.
=item * L<IO::EPP> - Object and procedure interface of the client-side for work with EPP API of registries and some resellers
Distribution IO-EPP first released by VADIML at 2020-01-12T12:01:15Z.
Acme-CPANModules-Parse-HumanDate
view release on metacpan or search on metacpan
lib/Acme/CPANModules/Parse/HumanDate.pm view on Meta::CPAN
package Acme::CPANModules::Parse::HumanDate;
use strict;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2023-10-31'; # DATE
our $DIST = 'Acme-CPANModules-Parse-HumanDate'; # DIST
our $VERSION = '0.002'; # VERSION
our $LIST = {
summary => "List of modules that parse human date/time expression",
entries => [
{
module=>'DateTime::Format::Natural',
description => <<'_',
Compared to <pm:DateTime::Format::Flexible>, this module can also parse
duration in addition to date/time, e.g.:
2 years 3 months
And it also can extract the date expression from a longer string.
Speed-wise, I'd say the two modules are roughly comparable. For some patterns
one might be faster than the other.
_
bench_code_template => 'DateTime::Format::Natural->new->parse_datetime(<str>)',
},
{
module=>'DateTime::Format::Flexible',
description => <<'_',
One advantage of this over <pm:DateTime::Format::Natural> is its time zone
support, e.g.:
yesterday 8pm UTC
yesterday 20:00 +0800
yesterday 20:00 Asia/Jakarta
Speed-wise, I'd say the two modules are roughly comparable. For some patterns
one might be faster than the other.
_
bench_code_template => 'DateTime::Format::Flexible->new->parse_datetime(<str>)',
},
{
module => 'Date::Parse',
description => <<'_',
This module can parse several formats, but does not really fall into "human
date/time parser" as it lacks support for casual expression like "yesterday" or
3 hours ago".
_
},
],
bench_datasets => [
{args=>{str => 'yesterday'}},
{args=>{str => '2 days ago'}},
{args=>{str => '2021-09-06 20:03:00'}},
],
};
1;
# ABSTRACT: List of modules that parse human date/time expression
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::Parse::HumanDate - List of modules that parse human date/time expression
=head1 VERSION
This document describes version 0.002 of Acme::CPANModules::Parse::HumanDate (from Perl distribution Acme-CPANModules-Parse-HumanDate), released on 2023-10-31.
=head1 DESCRIPTION
=head1 ACME::CPANMODULES ENTRIES
=over
=item L<DateTime::Format::Natural>
Author: L<SCHUBIGER|https://metacpan.org/author/SCHUBIGER>
Compared to L<DateTime::Format::Flexible>, this module can also parse
duration in addition to date/time, e.g.:
2 years 3 months
And it also can extract the date expression from a longer string.
Speed-wise, I'd say the two modules are roughly comparable. For some patterns
one might be faster than the other.
=item L<DateTime::Format::Flexible>
Author: L<THINC|https://metacpan.org/author/THINC>
One advantage of this over L<DateTime::Format::Natural> is its time zone
support, e.g.:
yesterday 8pm UTC
yesterday 20:00 +0800
yesterday 20:00 Asia/Jakarta
Speed-wise, I'd say the two modules are roughly comparable. For some patterns
one might be faster than the other.
=item L<Date::Parse>
Author: L<ATOOMIC|https://metacpan.org/author/ATOOMIC>
This module can parse several formats, but does not really fall into "human
date/time parser" as it lacks support for casual expression like "yesterday" or
3 hours ago".
=back
=head1 FAQ
=head2 What is an Acme::CPANModules::* module?
An Acme::CPANModules::* module, like this module, contains just a list of module
names that share a common characteristics. It is a way to categorize modules and
document CPAN. See L<Acme::CPANModules> for more details.
=head2 What are ways to use this Acme::CPANModules module?
Aside from reading this Acme::CPANModules module's POD documentation, you can
install all the listed modules (entries) using L<cpanm-cpanmodules> script (from
L<App::cpanm::cpanmodules> distribution):
% cpanm-cpanmodules -n Parse::HumanDate
Alternatively you can use the L<cpanmodules> CLI (from L<App::cpanmodules>
distribution):
% cpanmodules ls-entries Parse::HumanDate | cpanm -n
or L<Acme::CM::Get>:
% perl -MAcme::CM::Get=Parse::HumanDate -E'say $_->{module} for @{ $LIST->{entries} }' | cpanm -n
or directly:
% perl -MAcme::CPANModules::Parse::HumanDate -E'say $_->{module} for @{ $Acme::CPANModules::Parse::HumanDate::LIST->{entries} }' | cpanm -n
This Acme::CPANModules module contains benchmark instructions. You can run a
benchmark for some/all the modules listed in this Acme::CPANModules module using
the L<bencher> CLI (from L<Bencher> distribution):
% bencher --cpanmodules-module Parse::HumanDate
This Acme::CPANModules module also helps L<lcpan> produce a more meaningful
result for C<lcpan related-mods> command when it comes to finding related
modules for the modules listed in this Acme::CPANModules module.
See L<App::lcpan::Cmd::related_mods> for more details on how "related modules"
Acme-CPANModules-PortedFrom-Java
view release on metacpan or search on metacpan
;---------------------------------
author = perlancar <perlancar@cpan.org>
copyright_holder = perlancar <perlancar@cpan.org>
license = Perl_5
;---------------------------------
version=0.004
name=Acme-CPANModules-PortedFrom-Java
[Acme::CPANModules]
module=DateTime::Format::Text
[@Author::PERLANCAR]
:version=0.608
[Prereqs]
strict=0
[Prereqs / DevelopX_spec]
-phase=develop
-relationship=x_spec
Acme::CPANModules=0.1.7
Acme-CPANModules-PortedFrom-PHP
view release on metacpan or search on metacpan
lib/Acme/CPANModules/PortedFrom/PHP.pm view on Meta::CPAN
package Acme::CPANModules::PortedFrom::PHP;
use strict;
our $AUTHORITY = 'cpan:PERLANCAR'; # AUTHORITY
our $DATE = '2024-01-09'; # DATE
our $DIST = 'Acme-CPANModules-PortedFrom-PHP'; # DIST
our $VERSION = '0.006'; # VERSION
our $LIST = {
summary => "List of modules/applications that are ported from (or inspired by) ".
"PHP libraries",
description => <<'_',
If you know of others, please drop me a message.
_
entries => [
{module=>'Weasel', summary=>'Perl port of Mink'},
{module=>'PHP::Functions::Password'},
{module=>'PHP::Functions::Mail'},
{module=>'PHP::Functions::File'},
{module=>'PHP::Strings'},
{module=>'PHP::DateTime'},
{module=>'PHP::ParseStr'},
{module=>'PHP::HTTPBuildQuery', summary=>'Implement PHP http_build_query() function'},
{module=>'Acme::Addslashes'},
# old
{module=>'AMF::Perl'},
{module=>'Flash::FLAP'},
],
};
1;
# ABSTRACT: List of modules/applications that are ported from (or inspired by) PHP libraries
__END__
=pod
=encoding UTF-8
=head1 NAME
Acme::CPANModules::PortedFrom::PHP - List of modules/applications that are ported from (or inspired by) PHP libraries
=head1 VERSION
This document describes version 0.006 of Acme::CPANModules::PortedFrom::PHP (from Perl distribution Acme-CPANModules-PortedFrom-PHP), released on 2024-01-09.
=head1 DESCRIPTION
If you know of others, please drop me a message.
=head1 ACME::CPANMODULES ENTRIES
=over
=item L<Weasel>
Perl port of Mink.
Author: L<EHUELS|https://metacpan.org/author/EHUELS>
=item L<PHP::Functions::Password>
Author: L<CMANLEY|https://metacpan.org/author/CMANLEY>
=item L<PHP::Functions::Mail>
Author: L<YAPPO|https://metacpan.org/author/YAPPO>
=item L<PHP::Functions::File>
Author: L<TNAGA|https://metacpan.org/author/TNAGA>
=item L<PHP::Strings>
Author: L<KUDARASP|https://metacpan.org/author/KUDARASP>
=item L<PHP::DateTime>
Author: L<BLUEFEET|https://metacpan.org/author/BLUEFEET>
=item L<PHP::ParseStr>
Author: L<ABAYLISS|https://metacpan.org/author/ABAYLISS>
=item L<PHP::HTTPBuildQuery>
Implement PHP http_build_query() function.
Author: L<MSCHILLI|https://metacpan.org/author/MSCHILLI>
=item L<Acme::Addslashes>
Author: L<JAITKEN|https://metacpan.org/author/JAITKEN>
=item L<AMF::Perl>
Author: L<SIMONF|https://metacpan.org/author/SIMONF>
=item L<Flash::FLAP>
Author: L<SIMONF|https://metacpan.org/author/SIMONF>
=back
=head1 FAQ
=head2 What is an Acme::CPANModules::* module?
An Acme::CPANModules::* module, like this module, contains just a list of module
names that share a common characteristics. It is a way to categorize modules and
document CPAN. See L<Acme::CPANModules> for more details.
=head2 What are ways to use this Acme::CPANModules module?
Aside from reading this Acme::CPANModules module's POD documentation, you can
install all the listed modules (entries) using L<cpanm-cpanmodules> script (from
L<App::cpanm::cpanmodules> distribution):
% cpanm-cpanmodules -n PortedFrom::PHP
Alternatively you can use the L<cpanmodules> CLI (from L<App::cpanmodules>
distribution):
% cpanmodules ls-entries PortedFrom::PHP | cpanm -n
or L<Acme::CM::Get>:
% perl -MAcme::CM::Get=PortedFrom::PHP -E'say $_->{module} for @{ $LIST->{entries} }' | cpanm -n
or directly:
% perl -MAcme::CPANModules::PortedFrom::PHP -E'say $_->{module} for @{ $Acme::CPANModules::PortedFrom::PHP::LIST->{entries} }' | cpanm -n
This Acme::CPANModules module also helps L<lcpan> produce a more meaningful
result for C<lcpan related-mods> command when it comes to finding related
modules for the modules listed in this Acme::CPANModules module.
See L<App::lcpan::Cmd::related_mods> for more details on how "related modules"
( run in 0.427 second using v1.01-cache-2.11-cpan-05444aca049 )