Acme-CPANModules-Import-CPANRatings-User-perlancar
view release on metacpan or search on metacpan
Rating: 4/10
Perl::Critic
Author: PETDANCE <https://metacpan.org/author/PETDANCE>
Hey, Perl::Critic has not been reviewed for quite a while...
<br><br>Finally take the plunge (again) to include Perl::Critic in
my development work, this time adding critic test in the Dist::Zilla
release process. Already caught a couple of stupid bugs otherwise
uncaught by perl's -w. Aside from that, will help you become more
consistent and a better (Perl) programmer. Invaluable!
Config::Perl
Author: HAUKEX <https://metacpan.org/author/HAUKEX>
Rating Data::Undump::PPI, which currently lives inside Config-Perl:
<br><br>Of course this is a nice proof of concept, but for
"real world" usage, look at Data::Undump which is about
2000x faster :)
Array::Contains
Author: CAVAC <https://metacpan.org/author/CAVAC>
Requires perl 5.20 for no particular reason. Claims to be
replacement of smart match but only covers string comparison. Just
use List::Util's first() which is more flexible and part of the core
Perl distribution, or match::smart which covers more cases.
Rating: 2/10
Array::Unique
Author: SZABGAB <https://metacpan.org/author/SZABGAB>
Mostly unnecessary because this is just a glorified form of a widely
known Perl idiom. Requires perl 5.20 for no particular reason.
Re-sorts the list which is 99% not what user wants. Just use
List::Util's uniq() which is faster and part of core distribution.
Rating: 2/10
Dist::Zilla::Plugin::ReadmeFromPod
Author: FAYLAND <https://metacpan.org/author/FAYLAND>
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
Dist::Zilla::Plugin::Hook
Author: 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.
File::Tail::Dir
Author: JJSCHUTZ <https://metacpan.org/author/JJSCHUTZ>
Interesting features, but mooseware.
Rating: 6/10
Algorithm::Dependency
Author: 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
Data::Match
Author: 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
File::Find::Wanted
Author: 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, but it forces OO
style. <br>
Rating: 8/10
Hash::MD5
Author: 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.
DateTime::Format::Docker
Author: MZIESCHA <https://metacpan.org/author/MZIESCHA>
Isn't this basically ISO8601 (see DateTime::Format::ISO8601)?
WWW::CPANRatings
Author: 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 data on the
/dist/:DISTNAME page. The client library should perhaps cache the
CSV response though. The implementation could also be simplified by
using slimmer libraries for this simple scraping task. But other
than that, does what it says on the tin.
Rating: 8/10
Parse::CPAN::Ratings
Author: BINGOS <https://metacpan.org/author/BINGOS>
Sadly there is not a single perfect Archive::Tar::* module out
there. Either a module offers incomplete API, (was) buggy, or it is
crippled/limited in some way. Plus, the modules are mostly
incompatible with one another. And that's why TIMTOWTDI. <br><br>For
the task of just listing files in an archive, for example, it seems
only Archive::Tar and Archive::Tar::Wrapper are usable. Archive::Tar
is a core module, but relatively slow, and extracts all contents of
an archive in memory so it's not workable for huge archives. <br>
Hash::Util::Pick
Author: PINE <https://metacpan.org/author/PINE>
One can easily use this idiom instead: <br><br>$picked = { map
{(exists $hash{$*} ? ($*=>$hash{$*}):())} @keys }; <br><br>or:
<br><br>$picked = { map {$*=>$hash{$*}} grep {exists $hash{$*}}
@keys }; <br><br>or (if you want non-existing picked keys to be
created instead): <br><br>$picked = { map {$_ => $hash{$_}} @keys
}; <br><br>but Hash::Util::Pick is implemented in XS and can be a
few times faster than the above when the number of keys has reached
thousands. So I guess this module has its uses.
NetObj::IPv4Address
Author: HEEB <https://metacpan.org/author/HEEB>
Cons: more heavyweight (requires Moo), limited operations/methods,
can only handle IPv4 and not IPv6. Pros: some operations are faster
than competing modules, e.g. validation. See also: NetAddr::IP,
Net::CIDR. <br>
NetObj::MacAddress
Author: HEEB <https://metacpan.org/author/HEEB>
Aside from being Moo-based (which, makes it a bit more heavyweight
and with more dependencies), doesn't yet offer anything extra or
more methods compared to previously existing modules like
NetAddr::MAC.
Rating: 4/10
Acme::AsciiArtinator
Author: MOB <https://metacpan.org/author/MOB>
Cool. Now you can create your own Camel Code with ease!
Object::Simple
Author: KIMOTO <https://metacpan.org/author/KIMOTO>
I'd say in terms of footprint and runtime performance, this module
is average (it's not the most lightweight nor the fastest pure-perl
object system, not to mention against XS ones). See my
Bencher::Scenarios::Accessors for a comparison, e.g. <a
href="https://metacpan.org/pod/Bencher::Scenario::Accessors::Get"
rel="nofollow">metacpan.org/pod/Bencher::Scenario::A...</a> and <a
href="https://metacpan.org/pod/Bencher::Scenario::Accessors::Set"
rel="nofollow">metacpan.org/pod/Bencher::Scenario::A...</a> .
<br><br>One drawback of using Mojo::Base and Object::Simple is its
similar but slightly different and incompatible syntax with the Moo*
family, so your code is not "upgradable" to Moo or Moose
once you need more features. And often you'll end up wanting them,
e.g. one day you'll probably read about the wonders of method
modifiers (before, after, around), or roles, or wanting to have a
lazy constructor, or triggers, and so on. <br><br>I'd recommend
instead Mo. It's more lightweight than Object::Simple and you can do
default value, builder, ro/rw, required, even coercion. But the
features are modular and you only pay for what you use. And once you
need more features later, you normally should be able to just
replace 'use Mo' in your code with 'use Moo' or 'use Moose'.
<br><br>Of course, this point is moot if you don't care about
compatibility/upgradability to Moo*.
Rating: 6/10
Test::Needs
Author: HAARG <https://metacpan.org/author/HAARG>
Nice. API is more convenient to use than Test::Requires, especially
if you use subtests. <br>
HTTP::Command::Wrapper
Author: PINE <https://metacpan.org/author/PINE>
There are a few use-cases where this would be useful (mostly, to
access https websites in the absence of required perl library like
LWP::Protocol::https), but it would be more useful to provide an API
that is already familiar to Perl programmers. That's why MIYAGAWA
created HTTP::Tinyish.
File::Util
Author: TOMMY <https://metacpan.org/author/TOMMY>
Point for documentation (lots of examples and cookbook). But the
recipes in the cookbook currently don't really entice me to use the
module. Let's see: <br><br>1) batch file rename: it's much simpler
to use 'rename' or 'perlmv' utility. Or, it's much shorter to just
use plain perl like 'for (grep {-f} <*>) { rename $*,
s/.log$/.txt/r }'. <br><br>2) recursively remove a directory tree:
it's much shorter to just use 'File::Path::remove*tree()'.
<br><br>3) increment a counter file: no locking (it's classic 1990's
counter.cgi race condition all over again). Take a look at, for
example, The Perl Cookbook chapter 7.11. Or I think one of Randal
Schwartz's articles. <br><br>As an alternative, one can also take a
look at Path::Tiny.
Common::Routine
Author: PEKINGSAM <https://metacpan.org/author/PEKINGSAM>
A couple of comments: <br><br>* Some functions like min(), max(),
etc need not be reinvented because they are already in core module
List::Util. But I guess the author wants to be able to say
min([1,2,3]) in addition to min(1,2,3). <br><br>* round() uses
Number::Format, note that rounding number using this module is
hundreds of times slower than using sprintf(). <br><br>
Submodules
Author: ZARABOZO <https://metacpan.org/author/ZARABOZO>
A couple of prior arts: <br><br>* all, <a
href="https://metacpan.org/pod/all"
rel="nofollow">metacpan.org/pod/all</a> (since 2003), nicer
interface and offers "use"/compile-time interface, so it's
more equivalent to the statements it wants to replace. The
Submodules equivalent would be: BEGIN { for my $i
(Submodules->find("Blah")) { $i->require } }.
<br><br>* Module::Require, <a
href="https://metacpan.org/pod/Module::Require"
rel="nofollow">metacpan.org/pod/Module::Require</a> (since 2001),
Exporter::Easy
Author: NEILB <https://metacpan.org/author/NEILB>
I can see the value of Exporter::Easy (although these days the
saving in typing is not as big, with plain Exporter one can just
say: use Exporter 'import'; our @EXPORT = qw(a b c)).
<br><br>However I fail to see the value of Exporter::Easiest. I'd
rather use plain Perl than some DDL which cannot be checked
statically or cannot be syntax-highlighted, just to save some []'s
and ()'s (which I can get my editor to help me type them).
<br><br>In short, I'd rather use plain Exporter than save a few
keystrokes but add a non-core dependency.
Rating: 6/10
App::cpm
Author: SKAJI <https://metacpan.org/author/SKAJI>
Due to parallel processes and defaulting on no_test, can be several
times faster than cpanminus (tried installing a module on a vanilla
perlbrew instance with local CPAN mirror, which pulled +- 200
distributions, "cpanm -n" took 2m9s, while cpm took 38s.)
I hope this gets developed further. Great job. <br>
Zodiac::Chinese
Author: CAVAC <https://metacpan.org/author/CAVAC>
From the doc: "This module generates one's Chinese zodiac.
However, for those born in late January to early February, it may be
wrong." Well, a module that might return wrong results is not
very useful. <br>
Rating: 2/10
JSON::MultiValueOrdered
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
I guess if you want to switch JSON implementation more easily with
JSON, JSON::PP, and JSON::XS, it's better to use
JSON::Tiny::Subclassable instead of JSON::Tiny, because the
interface is more similar to JSON{::XS,::PP}, although it's not
exactly the same. JT:Subclassable also supports pretty() which is
often used when debugging. In short, I found
JSON::Tiny::Subclassable is a better "Tiny JSON" module
than JSON::Tiny.
JSON::Tiny
Author: DAVIDO <https://metacpan.org/author/DAVIDO>
Ah, the many JSON implementation modules out there... <br><br>I
guess if you want to switch JSON implementation more easily with
JSON, JSON::PP, and JSON::XS, it's better to use
JSON::Tiny::Subclassable instead of JSON::Tiny, because the
interface is more similar to JSON{::XS,::PP}, although it's not
exactly the same. <br><br>
Devel::Confess
Author: HAARG <https://metacpan.org/author/HAARG>
Provides some more features compared to Carp::Always, like producing
stack trace even when exception is ref/object, color & dump
function arguments (so you don't need a separate Carp::Always::Dump
and Carp::Always::Color). Recommended. <br>
Carp::Always
Author: FERREIRA <https://metacpan.org/author/FERREIRA>
This module works well for string exceptions (e.g. die "some
message"), but for ref/object exceptions (e.g. die
[404,"Not found"] or die $some_object) it will simply
print/return the ref/object and thus no stack trace information is
produced. <br><br>See also Devel::Confess, which can handle
ref/object. <br><br>References: <br> <a
href="http://blogs.perl.org/users/graham_knop/2013/09/carp-always-ev
enobjects.html"
rel="nofollow">blogs.perl.org/users/graham_knop/2013...</a>
experimental
Author: LEONT <https://metacpan.org/author/LEONT>
Our prayer has been answered. experimental was added to perl core in
5.19.11
Exporter::Lite
Author: NEILB <https://metacpan.org/author/NEILB>
Mostly unnecessary. The main premise of this module is that you
don't need to inherit to use it. But you also can use Exporter (a
core module, BTW) without inherinting it: <br><br>use Exporter
qw(import); <br>
Date::Holidays
Author: JONASBN <https://metacpan.org/author/JONASBN>
The idea is good, but a couple of things prevents me from using this
interface. <br><br>First, the use of TryCatch (which brings the
Moose ecosystem) makes the startup overhead too high for my taste
(about 0.5s on my PC). Which is rather unfortunate because
Date::Holidays itself does not use Moose. <br><br>Second, the
interface assumes that a country has a single set of holidays, which
is too restrictive in some cases. A more flexible/general interface
would allow adding more calendars based not only on country but also
religion, special community, organization, etc. And allow adding
custom calendars. <br>
Furl
Author: SYOHEX <https://metacpan.org/author/SYOHEX>
@Kira S (I wish cpanratings adds a feature to comment on a review):
<br><br>Comparing WWW::Mechanize with Furl is not really
apples-to-apples, since Furl does not support parsing/following
links or form processing. As the Furl POD itself suggests, Furl is
positioned as a faster alternative to LWP, not WWW::Mechanize.
Lingua::EN::Inflect
Author: DCONWAY <https://metacpan.org/author/DCONWAY>
Just add this review to link to Ben Bullock's
Lingua::EN::PluralToSingular if you need to go the other way
(converting English noun from plural to singular). <br><br>BTW, I
don't like the interface either, and wonder why the Env module needs
to be involved. <br>
Lingua::EN::PluralToSingular
Author: BKB <https://metacpan.org/author/BKB>
Not perfect or exhaustive, but good enough and lightweight. With a
dead-simple interface. Just the sort of libraries that are reusable
almost everywhere. Thanks for this. <br><br>Also, this might not be
immediately obvious since there's no mention on the See Also
section: to go the other way (converting English noun from singular
to plural) you can use Lingua::EN::Inflect.
Log::Declare
Author: CHGOVUK <https://metacpan.org/author/CHGOVUK>
I haven't used or evaluated this module in detail, but if there is
one advantage to using procedural/command syntax: <br><br>info blah;
<br><br>as opposed to object syntax: <br><br>$log->info(blah);
<br><br>then this module clearly demonstrates it. Using
Devel::Declare (or the Perl 5.14+ keyword API), the former can be
easily rewritten as something like: <br><br>info && blah;
<br><br>or: <br><br>if (CONST_LOG_INFO) { info blah } <br><br>and
during compilation, Perl can optimize the line away and we get zero
run-time penalty when logging (level) is disabled.
<br><br>(Actually, it's also possible for the object syntax to get
rewritten, e.g. using source filter, but it's more cumbersome).
Benchmark::Timer
Author: DCOPPIT <https://metacpan.org/author/DCOPPIT>
Nice alternative module for benchmarking with a different interface
than Benchmark (marking portion of code to be benchmarked with start
and stop). <br><br>For most Perl programmers familiar to the core
module Benchmark, I recommend looking at Benchmark::Dumb first
though. It has an interface like Benchmark (cmpthese() et all) but
with some statistical confidence.
Getargs::Long
Author: DCOPPIT <https://metacpan.org/author/DCOPPIT>
Nice idea, but some performance concerns. If you want to use
cgetargs (the compiled, faster version), you are restricted to the
getargs() interface, which only features checking for required
arguments and supplying default value. In which case you might as
well use Params::Validate directly as it's several times (e.g. 3-4x)
faster. <br><br>If you want to use the more featured xgetargs, there
is currently no compiled version. <br><br>All in all, I think users
should take a look at Params::Validate first.
Debug::Easy
Author: RKELSCH <https://metacpan.org/author/RKELSCH>
Not as easy as the name might claim. First of all, why do users need
to pass LINE explicitly for every call??? Other logging modules will
get this information automatically via caller(). <br><br>Levels are
a bit confusing: why is debug split to 2 (or 3)? <br><br>Not as
flexible as it should be because the design conflates some things
together. For example, most levels output to STDERR but some level
(VERBOSE) outputs to STDOUT instead. The output concern and levels
should've been separated. Another example would be the DEBUGWAIT
level, where level is DEBUG *and* execution is halted (wait on a
keypress) on log. What if users want a lower level setting *but*
want execution to be halted on log? The halt/keypress setting
should've been separated from the level.
Rating: 4/10
File::Slurper
Author: LEONT <https://metacpan.org/author/LEONT>
Who'da thought that something as seemingly simple as "slurping
a file into a string" would need several modules and false
starts? Well, if you add encodings, Perl I/O layers, scalar/list
context, DWIM-ness, ... it can get complex and buggy. I'm glad there
are people taking care of this and making sure that a simple task
stays simple and correct.
File::Slurp
Author: CAPOEIRAB <https://metacpan.org/author/CAPOEIRAB>
Use the newer File::Slurper instead, which has a clearer API (e.g.
text vs binary, array/lines vs string) and encoding default. It's
arguably "saner" than File::Slurp and File::Slurp::Tiny.
<br>
File::Slurp::Tiny
Author: LEONT <https://metacpan.org/author/LEONT>
Use the newer File::Slurper instead, which has a clearer API (e.g.
text vs binary, array/lines vs string) and encoding default. It's
arguably "saner" than File::Slurp and File::Slurp::Tiny.
<br>
Perl::PrereqScanner::Lite
Author: MOZNION <https://metacpan.org/author/MOZNION>
A significantly faster alternative to Perl::PrereqScanner. It's
*almost* a drop-in replacement, there might still be some bugs in
missing detecting some modules, and you still have to do several
add_extra_scanner() calls like
$scanner->add_extra_scanner('Moose') to match the behavior of
Perl::PrereqScanner. <br><br>
Logfile::Rotate
Author: PAULG <https://metacpan.org/author/PAULG>
First file rotating module I found and tried. Works, but needs to be
modernized a bit. Indirect object notation in doc should be
replaced. Bool option takes "yes" or "no",
should perhaps be 1 or 0. Capitalization adjustment, perhaps.
<br><br>
Rating: 6/10
File::ReadBackwards
Author: PLICEASE <https://metacpan.org/author/PLICEASE>
At the time of this review, I find two modules for reading a file
backwards: File::Bidirectional (FBidi) and File::ReadBackwards
(FRB). <br><br>Both modules have roughly the same footprint and
minimal dependencies. Both provide OO as well as tie interface. Both
respect the $/ setting. <br><br>FRB pro's: <br> - FRB is 15-20%
faster than FBidi when reading backwards; <br><br>FRB con's: <br> -
does not offer the feature of reading forward as well, but of course
this is not the goal of the module. <br><br>FBidi's POD contains
information on benchmarks (it's roughly an order of magnitude slower
than raw Perl's open+read/diamond operator, still the case in 2014).
While FRB's POD contains information on how the thing works behind
the scenes. <br><br>In summary, both modules are roughly the same.
I'd prefer FRB unless in the rarer cases where I need bidirectional
reading. <br>
Rating: 8/10
File::Bidirectional
Author: KIANWIN <https://metacpan.org/author/KIANWIN>
At the time of this review, I find two modules for reading a file
backwards: File::Bidirectional (FBidi) and File::ReadBackwards
(FRB). <br><br>Both modules have roughly the same footprint and
minimal dependencies. Both provide OO as well as tie interface. Both
respect the $/ setting. <br><br>FBidi pro's: <br> - has the unique
feature of reading backward/forward and switch direction in the
middle; <br><br>FBidi con's: <br> - FBidi is 15-20% slower than
FBidi when reading backwards; <br> - reading forward is just as slow
as backward, so if you only need to read forward, obviously there's
no need to use this module; <br><br>FBidi's POD contains information
on benchmarks (it's roughly an order of magnitude slower than raw
Perl's open+read/diamond operator, still the case in 2014). While
FRB's POD contains information on how the thing works behind the
scenes. <br><br>In summary, both modules are roughly the same. I'd
prefer FRB unless in the rarer cases where I need bidirectional
reading. <br>
Rating: 8/10
Signal::StackTrace::CarpLike
Author: SARTAK <https://metacpan.org/author/SARTAK>
Nice, but Signal::StackTrace should've output something carp-like in
the first place.
Devel::Messenger
Author: KOLIBRIE <https://metacpan.org/author/KOLIBRIE>
I think this is basically logging under a fancy name and with a more
cumbersome interface. Look at Log::Any instead.
Term::Twiddle
Author: SCOTTW <https://metacpan.org/author/SCOTTW>
Cute! I didn't know SIGALRM still works even though you're doing
blocking I/O or calling other programs. But unfortunately it doesn't
work if you sleep(), making this approach not as attractive. <br>
CHI Author: ASB <https://metacpan.org/author/ASB>
The move to Moo is very welcome, but I wish there were an
alternative of CHI which is even more lightweight (starts in under
0.01s). CHI::Tiny, anyone?
App::YTDL
Bit of a shame that we currently don't have a working YouTube
download script/module (WWW::YouTube::Download is last updated 2013
and has been broken for a long while). This module actually requires
another *Python* script to do its job. I might as well skip this and
go straight to the Python script. <br><br>UPDATE 2016-03-04: I guess
it's been so for a few years, but this still needs to be said: For
downloading YouTube videos, use youtube-dl (a far more popular
Python project) and just forget the rest. Keeping up with YouTube
changes is many times a full time job. Nothing else comes remotely
close.
XXX Author: INGY <https://metacpan.org/author/INGY>
The part that makes this module convenient is that the functions
return their original arguments. So when debugging (peppering dump
statements), you don't have to change this: <br><br>return
["some", $expr]; <br><br>to this (taking an example from
another dumping module, Data::Dump): <br><br>my $tmp =
["some", $expr]; dd $tmp; return $tmp; <br><br>but just
this: <br><br>return YYY ["some", $expr]; <br><br>This
should be imitated by the other dumper functions.
distribution):
% cpanmodules ls-entries Import::CPANRatings::User::perlancar | cpanm -n
or Acme::CM::Get:
% perl -MAcme::CM::Get=Import::CPANRatings::User::perlancar -E'say $_->{module} for @{ $LIST->{entries} }' | cpanm -n
or directly:
% perl -MAcme::CPANModules::Import::CPANRatings::User::perlancar -E'say $_->{module} for @{ $Acme::CPANModules::Import::CPANRatings::User::perlancar::LIST->{entries} }' | cpanm -n
This Acme::CPANModules module also helps lcpan produce a more meaningful
result for "lcpan related-mods" command when it comes to finding related
modules for the modules listed in this Acme::CPANModules module. See
App::lcpan::Cmd::related_mods for more details on how "related modules"
are found.
HOMEPAGE
Please visit the project's homepage at
<https://metacpan.org/release/Acme-CPANModules-Import-CPANRatings-User-p
erlancar>.
SOURCE
Source repository is at
<https://github.com/perlancar/perl-Acme-CPANModules-Import-CPANRatings-U
ser-perlancar>.
SEE ALSO
Acme::CPANModules - about the Acme::CPANModules namespace
cpanmodules - CLI tool to let you browse/view the lists
AUTHOR
perlancar <perlancar@cpan.org>
CONTRIBUTING
To contribute, you can send patches by email/via RT, or send pull
requests on GitHub.
Most of the time, you don't need to build the distribution yourself. You
can simply modify the code, then test via:
% prove -l
If you want to build the distribution (e.g. to try to install it locally
on your system), you can install Dist::Zilla,
Dist::Zilla::PluginBundle::Author::PERLANCAR,
Pod::Weaver::PluginBundle::Author::PERLANCAR, and sometimes one or two
other Dist::Zilla- and/or Pod::Weaver plugins. Any additional steps
required beyond that are considered a bug and can be reported to me.
COPYRIGHT AND LICENSE
This software is copyright (c) 2023, 2018 by perlancar
<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.
BUGS
Please report any bugs or feature requests on the bugtracker website
<https://rt.cpan.org/Public/Dist/Display.html?Name=Acme-CPANModules-Impo
rt-CPANRatings-User-perlancar>
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.
( run in 1.657 second using v1.01-cache-2.11-cpan-13bb782fe5a )