Ever wished the compactness of shell scripts be put into a real programming
language? Say hello to Plumbum Shell Combinators. Plumbum (Latin for lead, which
was used to create pipes back in the day) is a small yet feature-rich library
for shell script-like programs in Python. The motto of the library is ?Never
write shell scripts again?, and thus it attempts to mimic the shell syntax
(shell combinators) where it makes sense, while keeping it all Pythonic and
cross-platform.
Apart from shell-like syntax and handy shortcuts, the library provides local and
remote command execution (over SSH), local and remote file-system paths, easy
working-directory and environment manipulation, and a programmatic Command-Line
Interface (CLI) application toolkit. Now let?s see some code!
Surely the CPAN doesn't need yet another CSV parsing module.
Text::CSV_XS is the standard parser for CSV files. It is fast
as hell, but unfortunately it can be a bit verbose to use.
A number of other modules have attempted to put usability
wrappers around this venerable module, but they have all
focussed on parsing the entire file into memory at once.
This method is fine unless your CSV files start to get large.
Once that happens, the only existing option is to fall back
on the relatively slow and heavyweight XML::SAXDriver::CSV
module.
Parse::CSV fills this functionality gap. It provides a flexible
and light-weight streaming parser for large, extremely large,
or arbitrarily large CSV files.
This module provides encoding to LaTeX escapes from utf8 using mapping
tables in Pod::LaTeX and HTML::Entities. This covers only a subset of the
Unicode character table (undef warnings will occur for non-mapped chars).
Mileage will vary when decoding (converting TeX to utf8), as TeX is in
essence a programming language, and this module does not implement TeX.
I use this module to encode author names in BibTeX and to do a rough job
at presenting LaTeX abstracts in HTML. Using decode rather than seeing
$\sqrt{\Omega^2\zeta_n}$ you get something that looks like the formula.
The next logical step for this module is to integrate some level of TeX
grammar to improve the decoding, in particular to handle fractions and
font changes (which should probably be dropped).
Serialize your RSS as JavaScript.
Perhaps you use XML::RSS to generate RSS for consumption by RSS parsers.
Perhaps you also get requests for how to use the RSS feed by people who
have no idea how to parse XML, or write Perl programs for that matter.
Enter XML::RSS::JavaScript, a simle subclass of XML::RSS which writes your
RSS feed as a sequence of JavaScript print statements. This means you
can then write the JavaScript to disk, and a users HTML can simple
include it like so:
<script language="JavaScript" src="/myfeed.js"></script>
What's more the javascript emits HTML that can be fully styled with
CSS. See the CSS examples included with the distribution in the css directory.
This module provides all of the same functionality of WWW::Mechanize, but
adds support for plugins using Module::Pluggable; this means that any
module named WWW::Mechanize::Plugin::whatever... will be found and loaded
when WWW::Mechanize::Pluggable is loaded.
Big deal, you say. Well, it becomes a big deal in conjunction
with WWW::Mechanize::Pluggable's other feature: plugin hooks. When plugins
are loaded, their import() methods can call WWW::Mechanize::Pluggable's
prehook and posthook methods. These methods add callbacks to the plugin
code in WWW::Mechanize::Pluggable's methods. These callbacks can act
before a method or after it, and have to option of short-circuiting the
call to the WWW::Mechanize::Pluggable method altogether.
These methods receive whatever parameters the WWW::Mechanize::Pluggable
methods received, plus a reference to the actvive Mech object.
All other extensions to WWW::Mechanize::Pluggable are handled by the
plugins.
The Servlet API for Perl (libservlet) is a formulation of the Java (TM)
Servlet API in Perl.
While the servlet concept originated with Java (TM), its component model is
quite natural for Perl as well. By writing servlet applications and deploying
them in a servlet container, application authors can spare themselves the
effort of writing commonly needed web application infrastructure components
for each new project. Furthermore, servlet applications are portable between
deployment environments; they can be executed in any servlet container using
any process model with only a few configuration changes and no application
code changes. Servlet applications are insulated from changes in vendor or
platform and are able to portably take advantage of standard web
infrastructure services offered by any servlet container.
Transmission Web Interface (Clutch) is a WebUI for the Transmission BitTorrent
client. It allows you to manage your torrents from anywhere you can access the
internet, and runs on OS X and various flavors of *nix. It provides most of
the basic features of the desktop client, including torrent upload, torrent
start/stop, file path selection, speed limiting etc.
Transmission has been built from the ground up to be a lightweight, yet
powerful BitTorrent client. Its simple, intuitive interface is designed
to integrate tightly with whatever computing environment you choose to
use. Transmission strikes a balance between providing useful functionality
without feature bloat. Furthermore, it is free for anyone to use or modify.
You will need to install either transmission-daemon, transmission-gtk2 or
both to use WebUI.
xclip is a command line utility that is designed to run on any system with an
X11 implementation. It provides an interface to X selections ("the clipboard")
from the command line. It can read data from standard in or a file and place it
in an X selection for pasting into other X applications. xclip can also print
an X selection to standard out, which can then be redirected to a file or
another program.
FEATURES
========
* Reads data piped to standard in or files given as arguments
* Prints contents of selection to standard out
* Accesses the XA_PRIMARY, XA_SECONDARY or XA_CLIPBOARD selection
* Supports the INCR mechanism for large transfers
* Connects to the X display in $DISPLAY, or specified with -display host:0
* Waits for selection requests in the background
A data domain is a description of a set of values, either scalar or structured
(arrays or hashes). The description can include many constraints, like minimal
or maximal values, regular expressions, required fields, forbidden fields, and
also contextual dependencies. From that description, one can then invoke the
domain's inspect method to check if a given value belongs to it or not. In case
of mismatch, a structured set of error messages is returned.
The motivation for writing this package was to be able to express in a compact
way some possibly complex constraints about structured data. Typically the data
is a Perl tree (nested hashrefs or arrayrefs) that may come from XML, JSON, from
a database through DBIx::DataModel, or from postprocessing an HTML form through
CGI::Expand. Data::Domain is a kind of tree parser on that structure, with some
facilities for dealing with dependencies within the structure, and with several
options to finely tune the error messages returned to the user.
Aegis is a transaction-based software configuration management system. It
provides a framework within which a team of developers may work on many
changes to a program independently, and Aegis coordinates integrating these
changes back into the master source of the program, with as little disruption
as possible. Some key features:
* All operations on the repository are based on change sets.
* True configurations. All changes are reproducible snapshots. Every change
set has a unique configuration identifier.
* Ability to rename files without losing their history.
* Binary files are supported.
* File meta-data are versioned. Aegis versions permissions also.
* Commits are truly atomic. No part of a commit takes effect until the entire
commit has succeeded. Log messages are attached to the change set, not
stored redundantly in each file.
* Access controls on lines of development (branches). Creating a branch in
Aegis can be accomplished with a single, fast command.
* Repository synchronization, geographically distributed development.
* Optimal performance for all users, local or remote (no difference).
* Disconnected commits.
* Peer-to-peer architecture. Work may flow in without involving a master site.
* Costs are proportional to change size, not data size.