Acme-CPANModules-Import-CPANRatings-User-stevenharyanto
view release on metacpan or search on metacpan
user page.
This list is generated by scraping CPANRatings (cpanratings.perl.org)
user page.
ACME::CPANMODULES ENTRIES
Log::Any
Author: PREACTION <https://metacpan.org/author/PREACTION>
(REMOVED)
Process::Status
Author: 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 convenience.
Archive::Any
Author: 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 files, extract some
files only, find files, and so on.
Rating: 8/10
Devel::Confess
Author: 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).
SQL::Statement
Author: REHSACK <https://metacpan.org/author/REHSACK>
The concept is truly cool, unfortunately the parser is currently
flaky/buggy: one SQL query might work but another valid and
seemingly simple SQL would fail with weird error message. See
distribution's RT queue. <br>
Rating: 6/10
PerlMongers::Hannover
Author: PTC <https://metacpan.org/author/PTC>
Instead of just printing some info, why not make it an Acme::PM or
Acme::PerlMongers like Acme::CPANAuthors? Various stats can then be
produced about the various Perl Mongers. <br>
App::multiwhich
Note that File::Which can also search for all matches too if you use
it in a list context, e.g. @paths = which('foo'). File::Which also
comes with a pwhich CLI utility which also accepts multiple
arguments and has the -a switch to print all matches. The output
format is slightly different than 'multiwhich' though. <br><br>In
fact, the Unix 'which' command (or at least its Debian variant) also
sports the -a switch.
Object::Anon
Author: ROBN <https://metacpan.org/author/ROBN>
Nice idea. Some notes: 1) to be widely used, it really needs to be
very efficient; 2) if the goal is simply to objectify a hash,
perhaps Hash::Objectify or Object::From::Hash or Hash::To::Object
(or Data::Objectify and so on) is a more descriptive name. <br>
Data::Seek
The "extremely fast and efficient" claim currently doesn't
hold, as this module creates a *whole* flattened tree for *every*
search operation. <br><br>A simple benchmark: <br><br>### <br> use
Benchmark qw(timethese); <br> use Data::Seek; <br> use Data::DPath
qw(dpath); <br> use JSON::Path; <br><br>my $data = { map { $_ =>
{map {$*=>[1..4]} 1..20} } "a".."z" };
<br><br>timethese(-0.25, { <br><br>dseek => sub { $ds =
Data::Seek->new(data=>$data);
$ds->search("j.1.\@")->data },
<br><br>dseek*cacheobj=>sub{ state
$ds=Data::Seek->new(data=>$data);
$ds->search("j.1.\@")->data },
<br><br>dpath=>sub{ dpath("/j/1/*")->match($data) },
<br><br>jpath=>sub{
JSON::Path->new(q[$.j.1.[*]])->values($data) }, <br> }); <br>
=head2 #
<br><br>### <br> Benchmark: running dpath, dseek, dseek_cacheobj,
jpath for at least 0.25 CPU seconds... <br><br>dpath: 1 wallclock
secs ( 0.27 usr + 0.00 sys = 0.27 CPU) @ 8292.59/s (n=2239)
<br><br>(warning: too few iterations for a reliable count)
<br><br>dseek: 1 wallclock secs ( 0.29 usr + 0.00 sys = 0.29 CPU) @
37.93/s (n=11) <br><br>(warning: too few iterations for a reliable
count) <br> dseek_cacheobj: 0 wallclock secs ( 0.33 usr + 0.00 sys =
0.33 CPU) @ 42.42/s (n=14) <br><br>(warning: too few iterations for
a reliable count) <br><br>jpath: 0 wallclock secs ( 0.27 usr + 0.00
sys = 0.27 CPU) @ 11711.11/s (n=3162) <br><br>(warning: too few
iterations for a reliable count) <br> =head2 #
<br><br>Also: 1) the syntax is rather inconsistent: ':n' for array
index access, but '.@' (instead of ':@') for grabbing all elements.
2) currently cannot select subtree (must always select leaf node).
<br><br>As alternatives, I recommend the much simpler JSON::Path, or
the more powerful Data::DPath. <br>
Games::2048
Author: BLAIZER <https://metacpan.org/author/BLAIZER>
My favorite 2048 implementation (it's text-mode, written in Perl,
uses my module Color::ANSI::Util, and what else... oh yeah, it's the
only implementation where I've reached 2048 :-) ). <br><br>One tip:
enlarge the fonts of your terminal emulator (e.g. Ctrl-+ on Konsole)
until it's big and convenient enough.
App::D
Author: BESSARABV <https://metacpan.org/author/BESSARABV>
As an alternative, one can also do: <br><br>alias d=' <br><br>TZ=UTC
date; # show date in UTC <br><br>date ; # show date in local
timezone <br><br>cal -3 ; # show monthly calendar for curmon-1,
curmon, curmon+1 <br> ' <br><br>
Getopt::Long
Author: JV <https://metacpan.org/author/JV>
Having worked for quite some time with option processing and several
other similar modules, I have to say that most of the time you
probably want to use Getopt::Long instead of the other alternatives.
Or at least pick the alternatives which are based on Getopt::Long,
instead of those that reinvent the wheel and do their own option
parsing. <br><br>Most other modules that reinvent option parsing
either don't bother to do short option bundling (-abc instead of -a
-b -c), or abbreviation (--long-o instead --long-option-name), or
the choice to (dis)allow mix-mashing options and arguments, or
support '--' to end option processing, or respect ordering, or
support multiple options (--verbose --verbose), or support
'--foo=val' *as well as* '--foo val', and so on. These are features
and conveniences that are taken for granted by people working daily
in Unix command-line. <br>
Text::Table::Tiny
Author: NEILB <https://metacpan.org/author/NEILB>
Very fast, several times faster than Text::TabularDisplay or
Text::Table (and many times faster than the other slower
table-generator modules). It uses sprintf() to format a whole row
instead of formatting each cell separately using sprintf() and
joining cells together with join(). <br><br>I did a comparison in:
<a
href="http://blogs.perl.org/users/steven_haryanto/2014/07/benchmarki
ng-several-ascii-table-generator-modules.html"
rel="nofollow">blogs.perl.org/users/steven_haryanto/...</a>
Mo Author: TINITA <https://metacpan.org/author/TINITA>
A great alternative when Moo is a bit too much for you. Useful for
scripts that must start really fast. Mind you, Moo loads about 5K
lines of code and more than a dozen files, all of which takes +-
10ms on my computer. Mo on the other hand is only a single line of
+-500 characters, and it's inlinable. It loads in under 1ms. If a
script must be executed thousands of times a day, that 9ms
difference will matter more. <br><br>I use this for a very
lightweight parent class. A richer subclass then uses Moo.
<br><br>Isn't it great that we have the choices and upgrade path
from the very minimal Mo, to Moo for normal cases, to Moos and Moose
for even richer (but heavier) alternatives. Truly TIMTOWTDI! <br>
App::ChangeShebang
Author: SKAJI <https://metacpan.org/author/SKAJI>
Given that the name of this module/app is "change shebang"
(instead of "change shebang to samedir perl") perhaps this
app can be made more generic? For example, I've had to change all
shebangs from "#!/usr/bin/env perl" to "#!perl"
and vice versa. Perhaps this module/app can become a tool to easily
switch between shebangs. <br>
Hash::Ordered
Author: DAGOLDEN <https://metacpan.org/author/DAGOLDEN>
Overall looks ok, with the exception that it does not look and feel
like a regular Perl hash at all. Now someone just needs to create a
tie interface on top of this :) <br>
App::whatthecommit
Author: MUDLER <https://metacpan.org/author/MUDLER>
From the description: "App::whatthecommit is just another
lazy-to-lazy line command utility." I'd thought the definition
of laziness would be something like 'alias gc=git commit
--allow-empty-message'. This is more like hubris. Or whatever. :)
<br>
Opt::Imistic
Author: ALTREUS <https://metacpan.org/author/ALTREUS>
Very nifty for short scripts and some clever design inside (all
options are stored as arrayref, but there is some overloading to
make getting boolean/flag and normal scalar value convenient).
<br><br>For more "proper" scripts though (anything above
say 20-30 lines) I'd recommend using something like Getopt::Long
with a real spec. Some of the features I like in G::L not in
Opt::Imistic: the ability to get --noOPT for free for flag options,
the ability to configure permute/no_permute (mix mashing options
with arguments), some data validation, and of course:
autoabbreviation of long option names, which requires a spec after
all.
Devel::STrace
Author: DARNOLD <https://metacpan.org/author/DARNOLD>
The doc looks promising, it really looks like it could be the
"strace for Perl functions", but the usage is awkward (you
have to open two terminals, one for running your program and
producing trace file, and another for reading this file). And I'm
probably an idiot, but I can't get this module to work for me.
<br><br>One alternative if you're looking for a similar module is
Debug::LTrace. <br><br>
Devel::TraceSubs
Author: PARTICLE <https://metacpan.org/author/PARTICLE>
For an alternative, try Debug::LTrace, which roughly provides the
same basic feature but is more convenient to use from the
command-line and give extra information like timing. <br><br>
Devel::TraceCalls
Author: COSIMO <https://metacpan.org/author/COSIMO>
Might be powerful and flexible, but not convenient to use especially
from command-line. (I was searching for something like "strace
for Perl function"). <br>
Debug::LTrace
Author: KOORCHIK <https://metacpan.org/author/KOORCHIK>
One of the more convenient and usable subroutine tracing modules on
CPAN. If you're looking for something like "strace for Perl
functions", try this. <br>
Debug::Trace
Author: JV <https://metacpan.org/author/JV>
Good module, but try its derivative Debug::LTrace instead.
Debug::Trace doesn't fake caller() yet so traced/wrapped subroutines
get caller() results that are "off-by-1" (see
Hook::LexWrap). Plus, Debug::LTrace gives more information like
timing. <br><br>
App::Trace
Author: SPADKINS <https://metacpan.org/author/SPADKINS>
The name and abstract is slightly inaccurate/misleading. This module
is supposed to be a general logging framework instead of just
subroutine entry/exit tracer. For alternative subroutine tracer, I'd
recommend Devel::TraceSubs or Devel::TraceCalls (or even
Devel::Trace + variants). <br><br>Not very convenient to use. It
still requires you to put 'if $App::Trace' clause everytime. For
general logging that can be switched on/off upon runtime, I'd
recommend using Log::Any instead. <br><br>Lastly, this module is
tied to App::Options and thus only really usable if you use both.
Tie::Hash::Identity
Author: CINDY <https://metacpan.org/author/CINDY>
Hash::Identity has a use case of convenience when embedding
expression in double-quote strings. I fail to see the point of
Tie::Hash::Identity though. Can't you just say: <br><br>'abc' eq
'abc'; # true <br><br>(1+2+3) eq '6'; # true <br>
Hash::Identity
Author: CINDY <https://metacpan.org/author/CINDY>
At first I thought, hey, cute trick. But then Perl already has:
<br><br>print "You could use expr like this:
${(2**3)}.\n"; <br><br>print "Or you could use ident ${(
'a' . 'b' )} as well.\n"; <br><br>So you're trading a backslash
and a couple of parentheses against having to depend on a non-core
module and making your code reader raise her eyebrow when she first
sees your code. Pick your poison :-) <br><br>I wonder if this
belongs in Acme:: <br><br>On the other hand and slightly off-topic,
a module that can do Perl6-style interpolation (lexically) would be
cool, I think: <br><br>$s = "perl${(6-1)}-style
interpolation"; <br> { <br><br>use v6str; <br><br>$s =
"perl{ 5+1 }-style interpolation"; <br> } <br>
Data::Structure::Util
Author: ANDYA <https://metacpan.org/author/ANDYA>
@Tom Browder: If you just need unblessing, there's also another
module Acme::Damn which is more minimalist. You can also create a
the help of any module (Both Acme::Damn and Data::Structure::Util
are XS modules, JFYI). <br><br>Re Data::Structure::Util: nifty
module that provides speedy alternative for several things like
checking for circular references, weaken them, unblessing a
reference, etc. You can do many of the routines in pure Perl. This
module lets you do them in C. <br>
Fsdb
Author: JOHNH <https://metacpan.org/author/JOHNH>
An interesting tool that has been developed since 1991 (which is
roughly around the time the WWW and Linux was born, whew). Kudos to
the author for the dedication and consistency. <br><br>Since
nowadays SQL is pretty much ubiquitous, users might also want to
check out an alternative tool, App::fsql. For example (taking a
similar example from the module's doc), to select entries in
/etc/passwd where UID is between 1000 and 2000: <br><br>$ ( echo -e
"login\tpassword\tuid\tgid\tgecos\thome\tshell"; sed
's/:/\t/g' /etc/passwd ) | fsql --add-tsv - 'SELECT * FROM stdin
WHERE uid >= 1000 AND uid <= 2000' --format text --aoh
Date::Tie
Author: FGLOCK <https://metacpan.org/author/FGLOCK>
Cool, but personally I'd rather have something like JavaScript's
properties (since Perl does have lvalue subroutine support):
<br><br>$date->year = 2014; <br>
File::Slurp::Tiny
Author: LEONT <https://metacpan.org/author/LEONT>
More effort needs to be made with regards to documentation,
especially for File::Slurp users looking for alternatives. Why is
this module needed? What are the differences with File::Slurp? How
do the functions behave on I/O errors (since err_mode option is not
supported)? <br>
Clone::PP
Author: NEILB <https://metacpan.org/author/NEILB>
Thanks for providing a pure-Perl alternative for deep cloning.
Otherwise we are stuck with core module Storable's dclone, which
cannot handle Regexp objects out of the box, must use deparse to
handle coderefs, and not to mention is not as fast as it should be
because it's a marshall+unmarshall algrorithm (ab)used for deep
cloning. <br><br>Of course, there are faster XS-based cloning
modules on CPAN (all currently non-core, believe it or not there are
no core modules for cloning except Storable). I'd recommend
Data::Clone. But it's nice to have a pure-Perl implementation, e.g.
for creating a dependency-free script using App::FatPacker.
IPC::System::Simple
Author: JKEENAN <https://metacpan.org/author/JKEENAN>
This is a well-designed module with a good interface. The core
system()'s behavior of whether to invoke shell or not depending on
the number of arguments is ... unfortunate. This module fixes that.
<br><br>However, the previous review's comparing of
IPC::System::Simple with IPC::Run or IPC::Simple is rather
misguided. They focus on different things: IPC::System::Simple
focuses on providing shell/no-shell versions of invoking commands
and making a command's result easier to parse. It does not support
feeding text to STDIN, handlers for STDOUT/STDERR, timeouts, or the
other features that IPC::{Run,Cmd} support.
IPC::Cmd
Author: BINGOS <https://metacpan.org/author/BINGOS>
IPC::Cmd does its job, but the interface is inconsistent, probably
because a different author wrote run_forked() (and didn't follow the
same convention). run() accepts a hash of arguments, but
run_forked() accepts a scalar + hashref. run() returns a list, but
run_forked() returns a hashref. Command in run_forked() cannot be an
arrayref, but in run() it can be.
Umask::Local
Author: ROUZIER <https://metacpan.org/author/ROUZIER>
Please consider a simpler non-OO interface instead, a la
File::chdir: <br><br>use File::Umask; # or whatever, the
"Local" thing is redundant <br> { <br><br>local $UMASK =
0077; <br><br>open(...); <br><br>copy(...); <br> } <br> =head1
previous umask is restored
<br><br>which is arguably better (to me at least) than the current:
<br><br>use Umask::Local; <br> { <br><br>my $umask_local =
Umask::Local->new(0077); <br><br>open(...); <br><br>copy(...);
<br> } <br> =head1 previous umask is restored
<br>
Proc::PidUtil
Author: MIKER <https://metacpan.org/author/MIKER>
No file locking is currently done to the PID file to avoid race
condition. Look at Proc::PID::File for a more proper implementation.
<br><br>
Data::Dumper::Sorted
Author: MIKER <https://metacpan.org/author/MIKER>
Unnecessary. Data::Dumper does have the option to sort hash keys
($Sortkeys, look for 'sort' in 'perldoc Data::Dumper'). <br><br>This
module also does not handle circular refs yet (and probably lacks
other features of Data::Dumper too). <br><br>Also the choice of
returning error ("$Var00 = not a reference" when given
Dumper(1) for example) as result is arguably unwise. <br>
Archive::Probe
Author: FGZ <https://metacpan.org/author/FGZ>
I would personally pick a non-OO, no-nonsense interface based on
File::Find, like: <br><br>use File::Find::Archive qw(find); # or
find_archive <br> find(sub { ... }, "some.tar.gz");
<br><br>instead of the multiline, tedious setup just to search a
file. <br>
App::DBBrowser
Author: KUERBIS <https://metacpan.org/author/KUERBIS>
A nice, minimalistic, terminal-based user interface for browsing
your database and tables. Might be useful for simple cases.
Author: MILSO <https://metacpan.org/author/MILSO>
At the current form, simply too simplistic to be an alternative to
Data::Dump or Data::Dumper. No support for blessed refs,
filehandle/globs, circular references, and so on. Changes numbers to
stringy numbers or vice versa. <br><br>Currently also contains some
bugs like for -1 (changes it to string), "\" (produces
invalid dump, does not handle backslash yet currently), <br><br>And
Data::Dump's dump of {} and [] are currently more compact ;-)
<br><br>Need to be improved significantly first. But keep up the
effort.
P Author: LAWALSH <https://metacpan.org/author/LAWALSH>
I personally don't mind the namespace choice. There are other
single-letter CPAN modules too like B, L, U, V. If you have a beef
with regard to namespace, don't single out P and perhaps downvote
the other modules too. <br><br>Having said that, I would like to
comment on the design and implementation of this module. <br><br>1)
The choice of Unicode character U+2204 as representation of undef.
Unless one does something like 'binmode STDOUT, ":utf8"',
with 'say P undef' I am just trading one warning ("Use of
uninitialized value") with another ("Wide character in
say/print"). The wide character warning is avoided if you do 'P
"%s", undef' though, which means... <br><br>2) P loads
utf8 by default. For ultra-lightweight cases, this is sometimes not
desirable. There is currently no way to turn this off. <br><br>3)
The arbitrary choice of three levels deep when printing references.
This can be customized but with an unusual syntax. But again, the
arbitrary choice of three. <br><br>4) The "complex" rules
of newline printing. p() is like puts, it can optionally add a
newline. But unlike puts, the doc says it can also remove newlines.
The behavior can also change if the string to be printed ends with
0x83. <br><br>I might use P for a sprintf/printf replacement, but
for debugging values, I'd prefer something "dumber" like
Data::Dump::Color (or Data::Printer, if that's your thing).
Xporter
Author: LAWALSH <https://metacpan.org/author/LAWALSH>
A couple of comments. First, if you want to import the default
exports *as well as* some additional others, you can use Exporter's
feature (the :DEFAULT tag): <br><br>use SomeModule qw(:DEFAULT a b
c); <br><br>or you can also "use" twice: <br><br>use
SomeModule; # imports default exports <br><br>use SomeModule qw(a b
c); # import a, b, c <br><br>Second, if you use Xporter, your module
will behave unlike most CPAN modules out there, because a majority
of modules use Exporter. When people see this Perl code: <br><br>use
SomeModule qw(a b c); <br><br>normally they will expect only a, b,
and c are exported. If SomeModule uses Xporter, it will also by
default export the default exports. <br><br>Basically Xporter is
just Exporter with a different default (not arguably better or more
user-friendly). For the sake of minimizing surprise to my users, I
would avoid the use of Xporter. <br><br>UPDATE 2014-01-24: some
edits. I appreciate the effort of the author to defend her module,
though I am not convinced by her arguments.
Dist::Zilla::Shell
Author: DOLMEN <https://metacpan.org/author/DOLMEN>
Nice tool that lets you type dzil commands like 'build', 'test', etc
while sending all the other unknown commands like 'ls -l', 'man Foo'
to the underlying shell. Also lets you avoid multiple startup
overhead of dzil :-)
CPANPLUS::Shell::Curses
Author: MARCUS <https://metacpan.org/author/MARCUS>
Unmaintained. Installs but no longer runs.
Rating: 2/10
Task::Mechanistic
If you peek into its Makefile.PL, you'll see a seemingly
random/heterogenous collection of modules to install (instead of
just WWW::Mechanize). This is probably a Task::BeLike::$AUTHOR in
disguise. <br><br>
Sereal
Author: YVES <https://metacpan.org/author/YVES>
So far the best of the bunch. <br><br>FAST: much faster than
Storable, roughly the same speed as (sometimes slightly faster than)
Data::Clone for cloning. <br><br>FEATUREFUL: Can handle circular
references, Regexp objects (trips out-of-the-box Storable),
JSON::{PP,XS}::Boolean objects (trips Data::Clone). <br><br>COMPACT:
definitely more compact (up to several times) than Storable.
<br><br>I'm sold. What more do you want? Le Storable est mort, vive
le Sereal!
Test::Tester
Author: EXODIST <https://metacpan.org/author/EXODIST>
If you write test functions, you need this. It's like the
"Test::More" for "Test::More". However, it
currently does not work out of the box with subtests (submitted as
wishlist to RT). <br><br>PS: Thanks to Toby Inkster for pointing
this module out. <br><br>
Text::CharWidth
Author: 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 with
Unicode::GCString.
Rating: 2/10
App::Options
Author: 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
code and voila, your script suddenly can accept command line
arguments, has --help message et al, read from config files (in
several preset locations). <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, causing confusion for some of my users. 2) 'perl -c'
doesn't work under this module, it will still trigger command-line
processing. <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
Filesys::Notify::Simple
Author: 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
experimental
Author: LEONT <https://metacpan.org/author/LEONT>
Vote +1 to add this to core. Please make coding in Perl 5 relatively
painless.
MIME::Lite::HTML
Author: 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! searching using "mail
web" or "email url" at first didn't get results).
<br><br>Blackberry is having trouble displaying the resulting email
though. No problem with Gmail or Thunderbird/Icedove.
Term::Size
Author: 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
DateTime::Format::Flexible
Author: 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 phrases it
supports. And probably add more :-) <br><br>
Rating: 8/10
DateTime::Format::Natural
Author: SCHUBIGER <https://metacpan.org/author/SCHUBIGER>
Module::Quote
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
Wouldn't a function like
load_module("Math::Module")->new(42) be more obvious?
Is there a specific goal for using custom quote operator (which
requires Devel::Declare, and thus a C compiler to build)? <br>
Module::Hash
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
Wouldn't a function like
load_module("Math::Module")->new(42) be more obvious?
Is there a specific goal for using a tied hash (since there is
already %INC)?
Promises
Author: YANICK <https://metacpan.org/author/YANICK>
5-star for its documentation. <br>
Lingua::ITA::Numbers
Author: PETAMEM <https://metacpan.org/author/PETAMEM>
Does the author care to explain the sudden influx of
Lingua::<3-letter-code>:: modules (which look like mostly just
repackaging of their corresponding Lingua::<2-letter-code>::
modules with no mention of purpose in the PODs)? The original
modules are not orphaned either (for example, I still maintain
Lingua::ID::*). <br><br>No Changes file. Versioning synchronized for
all 3-letter modules with no indication of what version of the
2-letter-code module is used. For example, Lingua::ITA::Numbers' doc
still says "decimals don't work properly", while
Lingua::IT::Numbers' doesn't (however, needless use of
Regexp::Common does gets removed).
HTTP::Headers::Patch::DontUseStorable
Author: PERLANCAR <https://metacpan.org/author/PERLANCAR>
@zaxon: I'm not sure if it's a bug with HTTP::Headers, more like a
workaround for Storable. See the FAQ in the updated v0.03 for more
details. <br>
Storable
Author: NWCLARK <https://metacpan.org/author/NWCLARK>
Balancing previous glowing reviews. Storable has it faults, for
example historically its track record for file format backwards
compatibility is poor, making programs fail when loading Storable
files after the module is upgraded. <br><br>Also, more importantly,
add builtin support for Regexp object already! It's almost 2013,
Regexp object has been around for, what, more than a decade? I can
understand not supporting serializing filehandle or coderef, but
Regexp object?
Rating: 2/10
WWW::YouTube::Download
Author: OALDERS <https://metacpan.org/author/OALDERS>
Works for me too ATM. I've tried several command-line scripts (most
of them Python-based, like youtube-dl, tubenick, etc). Sometimes
they work, sometimes they broke. It's the nature of this kind of
script. The quality comes from persistence. This module has been
maintained since 2009, through several YouTube's changes. I commend
the author, good job, and thanks!
Number::Zero
From the module's POD: "The number zero and undef are difficult
to determine in Perl." <br><br>Are they? <br><br>say
!defined($data) ? "undef" : "not undef";
<br><br>say defined($data) && $data==0 ? "zero" :
"not zero"; # yes, warn if non-numeric <br><br>use
Scalar::Util 'looks_like_number'; <br> say looks_like_number($data)
&& $data==0 ? "zero" : "not zero";
<br><br>Though I understand the need for a convenient
"is_zero" function if you need to test for zero in a
program a lot.
Syntax::SourceHighlight
Author: MATLIB <https://metacpan.org/author/MATLIB>
IMO, currently the only usable (read: non-crap) code syntax
highlighting library on CPAN. Cons: you'll need to install GNU
Source-highlight (and its development library/header) which pulls
over 100MB of packages on my Debian. <br>
Rating: 8/10
Syntax::Highlight::Engine::Kate
Author: MANWAR <https://metacpan.org/author/MANWAR>
Highlighter engine doesn't seem updated (for example, defined-or is
not yet interpreted correctly by this module but already correctly
by Kate itself). Does not provide default theme (must specify all
colors). Seem to be very slow (takes 1.5s for a 18K Perl .pm file
while Pygments only takes 0.2s). <br><br>
Rating: 2/10
Syntax::Highlight::JSON
Author: MART <https://metacpan.org/author/MART>
No documentation. Combines formatting and syntax-highlighting, so
you cannot preserve original formatting. Only outputs to HTML and no
default "theme" (CSS) provided. <br>
Rating: 2/10
Syntax::Highlight::Engine::Simple
Author: AKHUETTEL <https://metacpan.org/author/AKHUETTEL>
Output looks decent. However, it currently only formats to HTML/CSS
(no ANSI, LaTeX, etc). Also, it needs more languages support. <br>
Rating: 6/10
Syntax::Highlight::Universal
Author: PALANT <https://metacpan.org/author/PALANT>
Only targets (X)HTML (i.e. no alternative output like ANSI or
<br>
Rating: 8/10
Data::Compare
Author: DCANTRELL <https://metacpan.org/author/DCANTRELL>
Pros: handle hashes as well as arrays, handle nested and cyclic
structure, plugins. <br><br>Cons: No cmp-like functionality
(returning -1, 0, 1), slow (even slower than Array::Compare).
<br><br>See also: Array::Compare, JSON/YAML/Storable. <br>
Rating: 6/10
Array::Compare
Author: DAVECROSS <https://metacpan.org/author/DAVECROSS>
Pros: has a perm() function to check whether the two arrays contain
the same things but in different order (although you can simply just
run sort() over the arrays first). Allow skipping some elements from
comparison. <br><br>Cons: no cmp-like functionality (returning -1,
0, 1), slow (for equality test, you might as well compare the
json_encode() result of the arrays, which is way faster), no nested
comparison. No procedural interface. <br><br>See also:
Data::Compare, JSON/YAML/Storable.
Rating: 4/10
Mozilla::Mechanize
Author: SLANNING <https://metacpan.org/author/SLANNING>
No longer builds (tested on a current Debian). A pity, since drop-in
replacements for WWW::Mechanize (using different backend like curl,
IE, Mozilla, Chrome, etc) might be handy. <br><br>
LWP::Curl
Author: LORN <https://metacpan.org/author/LORN>
Those looking for LWP drop-in replacement might want to take a look
at the recently released LWP::Protocol::Net::Curl instead, which
supports WWW::Mechanize. <br><br>
LWP::Protocol::Net::Curl
Author: SYP <https://metacpan.org/author/SYP>
Shows great promise. I personally need this for HTTPS proxy support.
After testing, the module still doesn't work to login to my internet
banking sites. But I'll still check in from time to time. <br>
Devel::SizeMe
Author: TIMB <https://metacpan.org/author/TIMB>
Wow, just wow. Hopefully now that we can use this tool to know how
big things are, we are encouraged to create leaner, faster, more
efficient Perl modules.
Oktest
Author: KWATCH <https://metacpan.org/author/KWATCH>
A reinvention of Perl testing modules (it even comes with an
equivalent for 'prove' command), with probably no added features and
some added quirks. (Nested) topic can already be done using
Test::More's subtests. Filtering and setup/teardown can be done with
Test::Class. And I am supposed to replace specific assertion
functions (with specific, helpful error messages) like is(), isnt(),
like(), is_deeply(), etc with just OK()? <br>
Rating: 4/10
HTML::Escape
Author: TOKUHIROM <https://metacpan.org/author/TOKUHIROM>
Still a bit slower than PHP's htmlspecialchars(), but in the same
ballpark. An order of magnitude faster than HTML::Entities. Does not
provide unescaping, but it's okay since escaping is the majority of
use cases.
Clone::Fast
Casual benchmarking on my PC shows that Data::Clone is up to twice
faster than this.
Rating: 6/10
Perl::Strip
Author: MLEHMANN <https://metacpan.org/author/MLEHMANN>
Balancing previous unhelpful review. Slowish (can't complain,
PPI-based) but works and comes with a command-line utility.
<br><br>Beware though that the command-line utility modifies file in
place without backup, without warning, and without option to create
backup. <br>
Rating: 8/10
Perl::Squish
Author: ADAMK <https://metacpan.org/author/ADAMK>
Have failed to build for 1.5 years (reported bug RT#66958 left
untouched, users need to install Module::Install first). No usage
documentation. <br><br>
Rating: 2/10
perlsecret
Author: BOOK <https://metacpan.org/author/BOOK>
Nice collection of perl shortcuts. Today I forgot about the name for
"x!!" and nicely found it in this module.
PerlX::ArraySkip
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
Cute idea as always, though I'd rather use comments rather than
taking multiple sub calls hit.
App::perlfind
Author: MARCEL <https://metacpan.org/author/MARCEL>
A timesaver. Using it on a daily basis (aliased to "pod").
Thanks, Marcel!
PerlX::Maybe
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
A nice syntax addition for avoiding passing or writing a bunch of
undefs. More convenient to write than using ternary operator or
grep. I'm beginning to adore syntax modules like this (as long as it
adds negligible overhead). <br><br>
File::Path::Tiny
Author: DMUEY <https://metacpan.org/author/DMUEY>
I like the concept, but do not like the overly short names mk() and
rm(). Instead of mk(), how about mkdir_p() or mkpath() like in
File::Path. Instead of rm(), how about rm_r() or rmtree() like in
File::Path. <br>
Rating: 6/10
Exporter::Lite
Author: NEILB <https://metacpan.org/author/NEILB>
2011-10-04: I am now using Exporter::Lite exclusively instead of
Exporter. Got bit once by Exporter when using for an OO module due
to clash of assigning to @ISA vs 'use base'. +1 for putting it into
core. <br><br>EDIT 2012-08-08: Nowadays I revert back to Exporter
most of the time because Exporter is core. To avoid @ISA issue, one
simply needs to import import() instead setting @ISA: <br><br>use
Exporter qw(import); <br>
1) perl was executed with a relative path and the script has
chdir()ed; 2) because $^X originates in C's argv[0] (in the main()
function) it is possible for the calling program to exec() in such a
way that argv[0] isn't the path to the interpreter; 3) HP/UX can do
weird stuff in scripts that use #!; 4) VMS. (Not clear about #4
though :) ).
Taint::Util
Author: AVAR <https://metacpan.org/author/AVAR>
IMO this is the best module to deal with tainting. BTW there are
several other modules like Taint (only provides taint + tainted, no
untaint), Untaint (only provides untaint with awkward interface,
like $v = untaint(qr/.../, $v)), Scalar::Util (only provides
tainted), Test::Taint (does not provide untaint but provides
taint_deeply and test predicates), and several others.
Markdown::Pod
Author: KEEDI <https://metacpan.org/author/KEEDI>
I use Markdown::Pod for my module Perinci::To::POD. <br><br>This
module does not output proper POD for many (not so) edge cases,
like: <br><br>">" and the likes are not yet escaped, producing
C<>> when it should have been C<< > >> or
C<E<gt>>. <br><br>Ordered list numbering does not yet
work, e.g. "2. ...\n3. ...\n" produces "=item 1. ...
=item 1. ..." <br><br>Ordered list with item numbered other
than 1 does not work (see above). This should be supported in POD
because POD allows us to write the bullets/numbers for each item.
<br><br>Inline markup is not smart enough to differentiate
word_with_underscore. So "foo_bar and foo_baz" becomes
"fooI<bar and foo>baz". <br><br>Plus it segfaults
sometimes (might be my perl though).
Rating: 4/10
Lingua::Metadata
Author: MAJLIS <https://metacpan.org/author/MAJLIS>
As previous reviewer noted, this module is actually just a front-end
to the author's web service. Plus license is specifically BSD (which
allows this module to be included in closed source projects), this
is rather ironic to me. <br>
Finance::Currency::Convert::WebserviceX
Author: CLACO <https://metacpan.org/author/CLACO>
Simple, no-fuss interface, recommended. As mentioned in the doc, the
alternatives have some downsides: Finance::Currency::Convert::Yahoo
is based on web scraping while ::XE has usage limits. <br>
Carp::Always::Color
Author: DOY <https://metacpan.org/author/DOY>
Like Carp::Always? Want something better? Here it is. <br>
CHI Author: ASB <https://metacpan.org/author/ASB>
The DBI of caching. Stop reinventing your caching framework and just
use this. <br><br>UPDATE 2013-01-16: unfortunately, the use of Moose
reduces the usefulness of CHI for command-line scripts (0.2s/146
files/53k lines startup overhead just to initialize a File cache).
So 4 stars instead of 5. Let's hope the author migrates to Moo
someday. <br>
Rating: 8/10
Monkey::Patch
Author: FRODWITH <https://metacpan.org/author/FRODWITH>
Compared to several other monkey-patching modules (like Sub::Monkey
or Class::Monkey) I prefer this one because the interface is
simplest and the documentation is the most straightforward. Plus it
can do stacked patching and unordered restore, which is cool.
<br><br>
Log::AutoDump
Author: CAGAO <https://metacpan.org/author/CAGAO>
This module is simple and to the point. Unfortunately, if you're a
user of Log4perl or other logging framework, you'll have to switch
just for a single feature (autodumping). <br><br>An alternative is
to use Log::Any, which also features autodumping (via
$log->debugf("%s", $complex), $log->warnf(), and
friends), while still allowing you to use Log4perl and other
frameworks supported by Log::Any. <br><br>
List::Pairwise
Author: TDRUGEON <https://metacpan.org/author/TDRUGEON>
Two nice and possibly very useful functions. But IMO the names
'mapp' and 'grepp' are two similar to 'map' and 'grep', making it
prone to typos and misreading. Perhaps consider 'map2' and 'grep2'?
Log::Log4perl::Appender::File::FixedSize
Author: HOREA <https://metacpan.org/author/HOREA>
Module name should perhaps be
Log::Log4perl::Appender::File::RoundRobin to make it clearer that
the backend is File::RoundRobin. <br>
Any::Mo
Why exclude Moo? <br><br>Also the issue with any Any::* (or Any::*)
modules is that there should be a mechanism (preferably a common
one) to adjust the ordering. Sometimes I prefer Moose first, for
full capability or compatibility or whatever. Sometimes I prefer
Mouse or Moo, for quick startup (but don't mind Moose if those are
not available). This also happens to me for YAML::Any: in some cases
I prefer YAML::Syck, in others YAML::XS, this depends on the data
that I'm handling. <br>
PerlX::Perform
Author: TOBYINK <https://metacpan.org/author/TOBYINK>
I personally don't see much value of this syntactic sugar since Perl
already allows us to express clearly. Pick one: <br><br>for ($foo) {
say $_ if defined } <br><br>for (grep {defined} $foo) { say $_ }
<br><br>do { say $_ if defined } for $foo <br><br>say $_ for grep
{defined} $foo <br><br>And save yourself from having to remember
whether we should add a comma or not before "wherever".
<br>
TOBYINK::PerlX::A
I have nothing against bundles like this, but beware that adding
'use TOBYINK::PerlX::A' will cause Perl to load 460 files and
compile +- 160k lines (takes 1s on my Core i5 machine and 8s on my
Atom netbook).
WWW::Google::Images
Just adding a note that this module is unmaintained (as expressed by
the author) and has stopped working for some time. If you are
looking for alternatives, try REST::Google (which includes
REST::Google::Search::Images). The latter has been working OK for
me.
Acme::Damn
Author: IBB <https://metacpan.org/author/IBB>
5 stars for cute metaphor (there's also Acme::Holy by the same
author, but that is just another implementation of Scalar::Util's
blessed()) and for prompt support from the author. <br><br>I'm sure
there exists a real use case to move this out of Acme::, however
obscure that might be. Can't come up with any right now, all I can
think of is reblessing, which can be handled with bless() from the
start. <br><br>UPDATE 2013-09-11: I found a real use-case for it!
Cleaning up data to be sent to JSON. BTW, Data::Structure::Util also
has an unbless() function, but Acme::Damn is smaller and faster.
Data::Structure::Util also currently doesn't build on Windows. <br>
WWW::Parallels::Agent
@Justin Case: The name is unfortunate, but it's already proper
(WWW:: followed by website or company name). HTTP client libraries
are in LWP::. But VM:: is also an apt choice. <br>
Underscore
I don't know why Sawyer X's review is marked as unhelpful (2 out of
8), but I agree with him. This is *not* an Acme module, it's a port
of a JavaScript library of the same name. <br>
Locale::Geocode
Author: DIZ <https://metacpan.org/author/DIZ>
Sorry to have to rate with 1 star. I don't have problem with the
interface/documentation. The 1-star rating is just to warn people
that the data used by this module is not up to date. And that
YEARS-old bugs are not being fixed. <br><br>At the time of this
writing, this module still uses ISO 3166-2:1998 (first edition) +
the newsletters (minor updates) up to 2006. When it should be
updated to ISO 3166-2:2007 (second edition) + all the newsletters.
For example, this module does not report 3 newer provinces in
Indonesia. <br><br>Sadly we live in a world where countries and
subcountries change all the time.
Rating: 2/10
Locale::SubCountry
Author: KIMRYAN <https://metacpan.org/author/KIMRYAN>
UPDATE 2012-08-30: I am not sure if the module is now fully
compliant to the new ISO 2007, but bug reports are certainly being
<br>
Rating: 2/10
Time::Mock
Author: EWILHELM <https://metacpan.org/author/EWILHELM>
Balancing previous 1 rating by @Ingo. <br><br>To Ingo: You said
module's documentation is okay, one feature you use works okay, and
other features you don't use. Why only 1 star then? <br><br>This
module is a worthy alternative to Test::MockTime. It offers extra
features such as working across forks, mocking Time::HiRes
(eventually), and speeding/slowing down time.
Sakai::Stats
Release early, release often indeed. First you release nothing but
boilerplate :)
Rating: 2/10
Spreadsheet::Perl
Author: NKH <https://metacpan.org/author/NKH>
Good documentation. All modules' documentation should similarly
strive to contain at least: rationale for existence, pointer to
alternatives, and task-oriented organization.
Unix::PasswdFileOps
Author: BMAYNARD <https://metacpan.org/author/BMAYNARD>
Less-than-descriptive name (module's main function seems to be
sorting entries, can't be guessed from the name). No unit tests.
Doesn't handle /etc/shadow. Also, it might be useful to explain why
one needs to sort entries in passwd file. <br>
Rating: 4/10
Array::Diff
Author: NEILB <https://metacpan.org/author/NEILB>
Yes, simple and gets the job done. Though I'm a bit curious with the
implementation. If the interface is only to get number of deleted
and added items (instead of positions of deletion/insertion), why
depend on Algorithm::Diff (or use the name 'diff', for that matter).
<br>
DZ1 Why do we need this uploaded to CPAN?
Rating: 2/10
Passwd::Unix
Author: STRZELEC <https://metacpan.org/author/STRZELEC>
No tests. No detailed error status, only true/false (yes, there is a
'warnings' parameter on constructor, but this doesn't give out
warnings on all operations, only some). No locking (although there
is backup, but still). <br><br>Also, some weird choices, why use
bzip2 when creating backup? Or, why still require running as root
(checking $() if we are allowing custom database file location?
<br><br>Between this and Unix::ConfigFile, I'm seriously considering
using Unix commands instead (useradd, userdel, gpasswd, et al).
<br><br>UPDATE 2011-04-21: I created a fork of Passwd::Unix 0.52
called Passwd::Unix::Alt instead, which add some tests and
modifications. Try it out if your needs are also not met by
Passwd::Unix. <br><br>UPDATE 2012-08-30: I created a new module
called Unix::Passwd::File. Try it out if your needs are also not met
by Passwd::Unix.
Rating: 2/10
Unix::ConfigFile
Author: SSNODGRA <https://metacpan.org/author/SSNODGRA>
Outdated module that doesn't handle /etc/shadow and /etc/gshadow.
Rating: 2/10
lib::xi
Author: GFUJI <https://metacpan.org/author/GFUJI>
Handy module for installing dependencies. There are previous
efforts, but the arrival of cpanm makes autoinstall process less
tedious, so hats off also to the creator of cpanm. <br>
Capture::Tiny::Extended
Author: MITHALDU <https://metacpan.org/author/MITHALDU>
Indispensable. Provides nice enhancement to Capture::Tiny
(particularly the real-time teeing). <br>
google_talk_bot
Improperly packaged, improper POD formatting, bot messages hardcoded
in script, and yes... idiotic license. Basically a "trial"
script to bait users into consultation gig. CPAN is not a place for
this kind of thing. Please try again. <br>
Rating: 2/10
Clone::Any
Author: EVO <https://metacpan.org/author/EVO>
Using Clone::Any nowadays is more trouble than it's worth.
<br><br>First, there are annoying incompatibilities between cloning
modules. Most notably Storable, which is the default cloning module
if Clone is not available, *still* doesn't support storing Regexp
objects out-of-the-box after all these years. <br><br>Second, this
module has not been updated for a long time and newer alternatives
like the fast Data::Clone is not recognized. <br><br>Right now I'm
replacing all code from using Clone::Any code to Data::Clone.
<br><br>
Rating: 4/10
Array::OrdHash
Author: WOWASURIN <https://metacpan.org/author/WOWASURIN>
Fun module to play with, especially for those among us infected with
a bit of PHP envy (me, never!). <br>
Bash::Completion
Author: MELO <https://metacpan.org/author/MELO>
Author: 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
CGI::Struct
Author: 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 values.
<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.
DateTime::BusinessHours
Author: 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
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 all might
have been one too, at one time or another. I'm not saying that this
bundle is a case of the above, but it's giving me a similar feeling.
:-) <br><br>A commendable effort, David. But there really are a lot
of wheels being reinvented here.
Net::BitTorrent::File
Author: 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 pretty sure that
when I leave my server for days/weeks, I don't run out of disk space
because I put in too many torrent files. <br>
Module::CoreList
Author: 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-since-when to save some
typing. <br>
WWW::Mechanize
Author: 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 does
self-rate-limiting and uses the Firefox or IE engine? A subclass
exists for each feature, but how do you use them together?
WWW::Mechanize needs to be more role/plugin-oriented instead of
inheritance-oriented. <br>
Mail::Sendmail
Author: 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::Sendmail are
not quite up to date in style (though they still might work), for
example the low level way of building HTML email. Also, the
Changelog file doesn't seem to be maintained?
Rating: 6/10
autodie
Author: 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>
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. <br><br>This is an early
release, there are quite a few things I find lacking. Most
importantly, I suggest adding a test suite as soon as possible. The
filesystem differences can be tricky, and CPAN Testers can help
providing feedback. <br><br>Keep up the good work.
Rating: 8/10
Script::State
Date::Manip. There are other alternatives. Pick wisely. <br>
Rating: 6/10
App::pmuninstall
Author: 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 flawlessly
(submitted in RT). Keep up the good work! <br><br>
App::lntree
Author: 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 NTFS). <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>
Data::Clone
Author: 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>
Data::Pond
Author: 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 fewer data
types directly". <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
File::Which
Author: 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 that. <br><br>Btw,
there's also File::Which::Cached.
String::ShellQuote
Author: 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 few months
ago after the millionth time I said enough is enough and started to
look around in CPAN, and found this module. <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! <br>
Capture::Tiny
Author: DAGOLDEN <https://metacpan.org/author/DAGOLDEN>
Another very handy little module that takes the hassle out of
figuring the various mechanisms of capturing output. <br><br>Nice
interface, great documentation, very easy to use. But....
<br><br>Currently it cannot just capture stdout *ONLY* or stderr
*ONLY* (while leaving the other alone). I believe this is one of the
most commonly requested feature (already in RT). If that feature is
implemented, this module deservers a 7-star rating.
Rating: 8/10
File::chdir
Author: DAGOLDEN <https://metacpan.org/author/DAGOLDEN>
This is a handy little module, with a simple and nice interface. One
of the more common bugs encountered in my scripts is forgetting to
track the current working directory after doing chdir() in
subroutines. By localizing $CWD, I don't have to worry that
subroutines mess up current working directory anymore.
FAQ
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 Acme::CPANModules for more
details.
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 cpanm-cpanmodules
script (from App::cpanm::cpanmodules distribution):
% cpanm-cpanmodules -n Import::CPANRatings::User::stevenharyanto
Alternatively you can use the cpanmodules CLI (from App::cpanmodules
distribution):
% cpanmodules ls-entries Import::CPANRatings::User::stevenharyanto | cpanm -n
or Acme::CM::Get:
% perl -MAcme::CM::Get=Import::CPANRatings::User::stevenharyanto -E'say $_->{module} for @{ $LIST->{entries} }' | cpanm -n
or directly:
% perl -MAcme::CPANModules::Import::CPANRatings::User::stevenharyanto -E'say $_->{module} for @{ $Acme::CPANModules::Import::CPANRatings::User::stevenharyanto::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-s
tevenharyanto>.
SOURCE
Source repository is at
<https://github.com/perlancar/perl-Acme-CPANModules-Import-CPANRatings-U
ser-stevenharyanto>.
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-stevenharyanto>
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 2.378 seconds using v1.01-cache-2.11-cpan-5b529ec07f3 )