Involved Projects and Packages
Although, for historical reasons, the Test::Harness distribution takes its name
from this module it now exists only to provide TAP::Harness with an interface
that is somewhat backwards compatible with Test::Harness 2.xx. If you're
writing new code consider using TAP::Harness directly instead.
Emulation is provided for runtests and execute_tests but the pluggable 'Straps'
interface that previous versions of Test::Harness supported is not reproduced
here. Straps is now available as a stand alone module: Test::Harness::Straps.
See TAP::Parser, TAP::Harness for the main documentation for this distribution.
Test::LeakTrace provides several functions that trace memory leaks. This module
scans arenas, the memory allocation system, so it can detect any leaked SVs in
Leaked SVs are SVs which are not released after the end of the scope they have
been created. These SVs include global variables and internal caches. For
example, if you call a method in a tracing block, perl might prepare a cache
for the method. Thus, to trace true leaks, no_leaks_ok() and leaks_cmp_ok()
executes a block more than once.e
Goro Fuji(gfx) .
This module provides some drop-in replacements for the string comparison
functions of Test::More, but which are more suitable when you test against long
strings. If you've ever had to search for text in a multi-line string like an
HTML document, or find specific items in binary data, this is the module for
In general, your tests shouldn't produce warnings. This modules causes any
warnings to be captured and stored. It automatically adds an extra test that
will run when your script ends to check that there were no warnings. If there
were any warings, the test will give a "not ok" and diagnostics of where, when
and what the warning was, including a stack trace of what was going on when the
If some of your tests are supposed to produce warnings then you should be
capturing and checking them with Test::Warn, that way Test::NoWarnings will not
see them and so not complain.
The test is run by an END block in Test::NoWarnings. It will not be run when
any forked children exit.
Text::CSV provides facilities for the composition and decomposition of comma-separated values using Text::CSV_XS or its pure Perl version.
An instance of the Text::CSV class can combine fields into a CSV string and parse a CSV string into fields.
The module accepts either strings or files as input and can utilize any user-specified characters as delimiters, separators, and escapes so it is perhaps better called ASV (anything separated values) rather than just CSV.
This is a rather incomplete implementaion of work done by Gudrun Putze-Meier. I
have to confess that I never read her original paper. So all credit belongs to
her, all bugs are mine. I tried to get some insight from an implementation of
two students of mine. They remain anonymous because their work was the wost
piece of code I ever saw. My code behaves mostly as their implementation did
except it is about 75 times faster.
Text::Quoted examines the structure of some text which may contain multiple
different levels of quoting, and turns the text into a nested data structure.
The structure is an array reference containing hash references for each
paragraph belonging to the same author. Each level of quoting recursively adds
another list reference.
Best Practical Solutions
It often happens that you have non-Roman text data in Unicode, but you can't
display it -- usually because you're trying to show it to a user via an
application that doesn't support Unicode, or because the fonts you need aren't
accessible. You could represent the Unicode characters as "???????" or
"\15BA\15A0\1610...", but that's nearly useless to the user who actually wants
to read what the text says.
What Text::Unidecode provides is a function, unidecode(...) that takes Unicode
data and tries to represent it in US-ASCII characters (i.e., the universally
displayable characters between 0x00 and 0x7F). The representation is almost
always an attempt at transliteration -- i.e., conveying, in Roman letters, the
pronunciation expressed by the text in some other writing system. (See the
example in the synopsis.)
Text::vFile::asData reads vFile format files, such as vCard (RFC 2426) and
vCalendar (RFC 2445).
The original Wiki web site had a very simple interface to edit and to add
pages. Its formatting rules are simple and easy to use. They are also easy to
translate into other, more complicated markup languages with this module. It
creates HTML by default, but can produce valid POD, DocBook, XML, or any other
The most important function is format(). It is not exported by default.
Text::Wrapper provides simple word wrapping. It breaks long lines, but does not
alter spacing or remove existing line breaks. If you're looking for more
sophisticated text formatting, try the Text::Format module.
Reasons to use Text::Wrapper instead of Text::Format:
Text::Wrapper is significantly smaller.
It does not alter existing whitespace or combine short lines. It only breaks long lines.
Again, if Text::Wrapper doesn't meet your needs, try Text::Format.
Christopher J. Madsen
This module in an fully object-oriented implementation of a simple n-ary tree.
It is built upon the concept of parent-child relationships, so therefore every
Tree::Simple object has both a parent and a set of children (who themselves may
have children, and so on). Every Tree::Simple object also has siblings, as they
are just the children of their immediate parent.
It is can be used to model hierarchal information such as a file-system, the
organizational structure of a company, an object inheritance hierarchy,
versioned files from a version control system or even an abstract syntax tree
for use in a parser. It makes no assumptions as to your intended usage, but
instead simply provides the structure and means of accessing and traversing
This module uses exceptions and a minimal Design By Contract style. All method
arguments are required unless specified in the documentation, if a required
argument is not defined an exception will usually be thrown. Many arguments are
also required to be of a specific type, for instance the $parent argument to
the constructor must be a Tree::Simple object or an object derived from
Tree::Simple, otherwise an exception is thrown. This may seems harsh to some,
but this allows me to have the confidence that my code works as I intend, and
for you to enjoy the same level of confidence when using this module. Note
however that this module does not use any Exception or Error module, the
exceptions are just strings thrown with die.
I consider this module to be production stable, it is based on a module which
has been in use on a few production systems for approx. 2 years now with no
issue. The only difference is that the code has been cleaned up a bit, comments
added and the thorough tests written for its public release. I am confident it
behaves as I would expect it to, and is (as far as I know) bug-free. I have not
stress-tested it under extreme duress, but I don't so much intend for it to be
used in that type of situation. If this module cannot keep up with your Tree
needs, i suggest switching to one of the modules listed in the "OTHER TREE
MODULES" section below.
This module provides bare bones try/catch statements that are designed to
minimize common mistakes with eval blocks, and NOTHING else.
This is unlike TryCatch which provides a nice syntax and avoids adding another
call stack layer, and supports calling return from the try block to return from
the parent subroutine. These extra features come at a cost of a few
dependencies, namely Devel::Declare and Scope::Upper which are occasionally
problematic, and the additional catch filtering uses Moose type constraints
which may not be desirable either.
The main focus of this module is to provide simple and reliable error handling
for those having a hard time installing TryCatch, but who still want to write
correct eval blocks without 5 lines of boilerplate each time.
It's designed to work as correctly as possible in light of the various
pathological edge cases (see BACKGROUND) and to be compatible with any style of
error values (simple strings, references, objects, overloaded objects, etc).
Provides an adapter layer between core routines for converting to and from
UTF8 and other encodings. In essence, a way to give multiple existing
Unicode modules a single common interface so you don't have to know the
underlaying implementations to do simple UTF8 to-from other character set
encoding conversions. As such, it wraps the Unicode::String, Unicode::Map8,
Unicode::Map and Jcode modules in a standardized and simple API.
This also provides general character set conversion operation based on UTF8
- it is possible to convert between any two compatible and supported
character sets via a simple two step chaining of conversions.
As with most things Perlish - if you give it a few big chunks of text to
chew on instead of lots of small ones it will handle many more characters
By design, it can be easily extended to encompass any new charset encoding
conversion modules that arrive on the scene.
This module is intended to provide good Unicode support to versions of Perl
prior to 5.8. If you are using Perl 5.8.0 or later, you probably want to be
using the Encode module instead. This module does work with Perl 5.8, but
Encode is the preferred method in that environment.
It makes it easier to use WWW::Curl::(Easy|Multi), or so I hope
This module offers a simple way to process namespaced XML names
(unames) from within any application that may need them. It also helps
maintain a prefix to namespace URI map, and provides a number of basic
Author: Robin Berjon
XML::SAX consists of several framework classes for using and building
Perl SAX2 XML parsers, filters, and drivers. It is designed around the
need to be able to "plug in" different SAX parsers to an application
without requiring programmer intervention. Those of you familiar with
the DBI will be right at home. Some of the designs come from the Java
JAXP specification (SAX part), only without the javaness.
This module implements a bare-bones class specifically for the purpose of
capturing data from the XML::Writer module. XML::Writer expects an IO::Handle
object and writes XML data to the specified object (or STDOUT) via it's print()
method. This module simulates such an object for the specific purpose of
providing the required print() method.
It is recommended that $writer->end() is called prior to calling $s->value() to
check for well-formedness.
This module defines a standard simplified interface to the dynamic linking
mechanisms available on many platforms. Its primary purpose is to implement
cheap automatic dynamic loading of Perl modules.
For a more complicated interface, see DynaLoader. Many (most) features of
DynaLoader are not implemented in XSLoader, like for example the dl_load_flags,
not honored by XSLoader.
This package is based on the package 'perl-YAML-Syck' from project 'openSUSE:Factory'.
YAML::Syck is a fast, lightweight YAML loader and dumper library The
module interfaces libsyck.
Request Tracker (RT) is an enterprise-grade ticketing system which enables a
group of people to intelligently and efficiently manage tasks, issues, and
requests submitted by a community of users. It features a web, email and
Written in object-oriented Perl, RT is a high-level, portable, platform
independent system that eases collaboration within organizations and makes it
easy for them to take care of their customers.
RT manages key tasks such as the identification, prioritization, assignment,
resolution and notification required by enterprise-critical applications
including project management, help desk, NOC ticketing, CRM and software
If your library is a basic building block (-> subject to interpretation) and topically does not fit into another project, this may be the place for it.
1. We only build against the standard repositories for the distros
2. Users only get access to their packages. We should keep the number of project maintainers as small as possible