This module adds lightweight hooks into the inner workings of POE.
Currently, one can add hooks into POE that get called before/after an
event is dispatched and/or before/after a Session is created. These
callbacks receive the exact same argument list as their Kernel/Session
counterpart. For event dispatch related callbacks, see _dispatch_event
in POE::Kernel. For session related callbacks, see create in
POE::Session.
The most of the code of this module is taken from the PAUSE code as of
April 2013 almost verbatim. Thus, the heart of this module should be
quite stable. However, I made it not to use pipe ("-|") as well as I
stripped database-related code. If you encounter any issue, that's
most probably because of my modification.
This module doesn't provide features to extract a distribution or
parse meta files intentionally.
ReadonlyX combines the best features of p5-Readonly and p5-Readonly-XS,
and is a drop-in replacement. It creates read-only scalars, arrays, and
hashes. It was created by maintainer of Readonly itself.
The author says: "ReadonlyX is the best of recent versions of Readonly
without the old API and without the speed penalty of tie(...). It's what
I'd like to do with Readonly if resolving bugs in it wouldn't break 16
years of code out there in Darkpan."
This simple module serves one purpose - to provide a simple means to read (or
slurp) an entire file into memory for processing. This module allows the
replacement of the prototypical foreach- or while- loops used for opening
and reading of files with single-line constructs.
Of note with this module is that the magic of the @ARGV variable and the
input record separator, $/, are used to facilitate the reading of entire
files into either an array or scalar using minimal code.
This module has two main goals: to make it easy to create correct sort
functions, and to make it simple to select the optimum sorting algorithm
for the number of items to be sorted. Sort::Maker generates complete
sort subroutines in one of four styles, plain, orcish manouver,
Schwartzian Transform and the Guttman-Rosler Transform. You can also get
the source for a sort sub you create via the sorter_source call.
This module provides one function, delete_sub, that deletes the
subroutine whose name is passed to it. (To load the module without
importing the function, write use Sub::Delete();.)
This does more than simply undefine the subroutine in the manner of
undef &foo, which leaves a stub that can trigger AUTOLOAD (and,
consequently, won't work for deleting methods). The subroutine is
completely obliterated from the symbol table (though there may be
references to it elsewhere, including in compiled code).
Spoon - A Spiffy Application Building Framework
Spoon is an Application Framework that is designed primarily for
building Social Software web applications. The Kwiki wiki software is
built on top of Spoon.
Spoon::Base is the primary base class for all the Spoon::* modules.
Spoon.pm inherits from Spiffy.pm.
Spoon is not an application in and of itself. (As compared to Kwiki) You
need to build your own applications from it.
Taint is a good thing. However, few people use taint even though they should.
The goal of this module isn't to use taint less, but to actually encourage its
use more.
This module aims to make using taint as painless as possible (This can be an
argument against it - often implementation of security implies pain - so taking
away pain might lessen security - sort of).
An xUnit style testing framework inspired by Test::Class and built using Moose.
It can do all the important things Test::Class can do and more.
The prime advantages of using this module instead of Test::Class are
flexibility and power. Namely, Moose.
This module was created for a few of reasons:
To address perceived limitations in, and downfalls of, Test::Class.
To leverage existing Moose expertise for testing.
To bring Moose to the Perl testing game.
Sometimes using Test::More's is test isn't good enough. Its diagnostics may make
it easy to miss differences between strings. By using is_binary instead of is,
the "!" tells us that the lines differ, and we can quickly scan the bytes that
make up the line to see which differ. When comparing very long strings, we can
stop after we've seen a few differences.