POE::Component::Syndicator is a base class for POE components which need to
handle a persistent resource (e.g. a connection to an IRC server) for one or
more sessions in an extendable way.
This module (as well as Object::Pluggable, which this module inherits from)
was born out of POE::Component::IRC, the guts of which quickly spread to
other POE components. Now they can all inherit from this module instead.
The component provides an event queue, which can be managed with the methods
documented below. It handles delivery of events to the object itself, all
interested plugins, and all interested sessions.
Parallel::Scoreboard is a pure-perl implementation of a process
scoreboard. By using the module it is easy to create a monitor for
many worker process, like the status module of the Apache HTTP server.
Unlike other similar modules, Parallel::Scoreboard is easy to use and
has no limitation on the format or the length of the statuses to be
stored. Any arbitrary data (like JSON or frozen perl object) can be
saved by the worker processes as their status and read from the
manager process.
The idea behind this module is to provide a sort of plugin architecture for
Perl templating systems. Callbacks are executed by the contents of a request
to the Perl templating server, before the templating system itself executes.
This approach allows you to carry out logical processing of data submitted
from a form, to affect the contents of the request parameters before they're
passed to the templating system for processing, and even to redirect or abort
the request before the templating system handles it.
This is yet another file/directory handler that does a bit more than
Path::Class for some parts, and a bit less for other parts. One of
the main difference is Path::Extended always tries to use forward
slashes when possible, ie. even when you're on the MS Windows, so that
you don't need to care about escaping paths that annoys you from time
to time when you want to apply regexen to a path, especially in file
tests that use 'like' or 'compare'.
Smart comments provide an easy way to insert debugging and tracking code into
a program. They can report the value of a variable, track the progress of a
loop, and verify that particular assertions are true.
Best of all, when you're finished debugging, you don't have to remove them.
Simply commenting out the use Smart::Comments line turns them back into
regular comments. Leaving smart comments in your code is smart because if you
needed them once, you'll almost certainly need them again later.
SVN-Hooks is a Perl framework for creating Subversion hooks.
It comes with a bunch of plugins (actually, sub-modules of SVN::Hooks)
that implement some of the most used standalone Subversion hooks
available, such as pre-commit hooks for enforcing:
- the log message format
- property settings
- the repository structure
- restrictions on the modification of repository areas (e.g., /tags)
- restrictions on filenames
- the integration with ticketing systems
It also comes with post-commit hooks for:
- sending commit emails
- updating configuration files in the server from changes made in
the repository
But as a framework, it can be extended to implement all types of
hooks.
This module provides a framework to produce sprite animations using
ASCII art. Each ASCII 'sprite' is given one or more frames, and placed
into the animation as an 'animation object'. An animation object can
have a callback routine that controls the position and frame of the
object.
If the constructor is passed no arguments, it assumes that it is
running full screen, and behaves accordingly. Alternatively, it can
accept a curses window (created with the Curses newwin call) as an
argument, and will draw into that window.
Term::Screen is a very simple screen positioning module that should work
wherever `Term::Cap' does. It is set up for Unix using stty's but these
dependencies are isolated by evals in the `new' constructor. Thus you may
create a child module implementing Screen with MS-DOS, ioctl, or other
means to get raw and unblocked input. This is not a replacement for
Curses -- it has no memory. This was written so that it could be easily
changed to fit nasty systems, and to be available first thing.
Tie::Hash::TwoWay will take a list of one-way associations and
transparently create their reverse. For instance, say you have a list
of machines, and a list of classes that each machine belongs to.
Tie::Hash::TwoWay will take the machines, one by one, with an associated
array reference of class names, and build the reverse mapping of classes
to machines. All the mappings are stored as hashes. You can access the
secondary mappings as if they were hash keys in their own right.
Someone asked on Perlmonks if a hash could do fuzzy matches on keys - this
is the result.
If there's no exact match on the key that you pass to the hash, then the
key is treated as a regex and the first matching key is returned. You can
force it to leap straight into the regex checking by passing a qr'ed regex
into the hash like this:
my $val = $h{qr/key/};
exists and delete also do regex matching. In the case of delete all values
matching your regex key will be deleted from the hash.