AnyEvent-KVStore
- Ebuilds: 1, Testing: 0.1.2 Description:
The AnyEvent::KVStore framework intends to be a simple, pluggable API for abstracting away the details of key-value store integratoins in event loop for the standard operations one is likely to experience in an event loop.
The idea is to make key-value stores reasonably pluggable for variou skinds of operations so that when one fails to scale in one scenario, another can be used and alaternatively, the same app can support several different stores.
The framework uses Moo (Minimalist Object Orientation) to procide the basic interface specifications, and modules providing drivers here are expected to use Moo for defining accessors, etc.
License: BSD-2
AnyEvent-PgRecvlogical
- Ebuilds: 1, Testing: 1.20.0 Description:
AnyEvent::PgRecvlogical provides perl bindings of similar functionality to that of pg_recvlogical. The reasoning being that pg_recvlogical does afford the consuming process the opportunity to emit feedback to PostgreSQL. This results is potentially being sent more data than you can handle in a timely fashion.
Array-PrintCols
- Ebuilds: 1, Testing: 2.600.0 Description: Format or print values from an array or hash in sorted, vertical columns
Beam-Emitter
- Ebuilds: 1, Testing: 1.7.0 Description:
This role is used by classes that want to add callback hooks to allow users to add new behaviors to their objects. These hooks are called "events". A subscriber registers a callback for an event using the "subscribe" or "on" methods. Then, the class can call those callbacks by emitting an event with the emit() method.
Using the Beam::Event class, subscribers can stop an event from being processed, or prevent the default action from happening.
Beam-Service
- Ebuilds: 1, Testing: 0.1.0 Description:
This role adds extra functionality to an object that is going to be used as a service in a Beam::Wire container. While any object can be configured with Beam::Wire, consuming the Beam::Service role allows an object to know its own name and to access the container it was configured in to fetch other objects that it needs.
Class-Factory
- Ebuilds: 1, Testing: 1.60.0 Description:
This is a simple module that factory classes can use to generate new types of objects on the fly, providing a consistent interface to common groups of objects.
Factory classes are used when you have different implementations for the same set of tasks but may not know in advance what implementations you will be using. Configuration files are a good example of this. There are four basic operations you would want to do with any configuration: read the file in, lookup a value, set a value, write the file out. There are also many different types of configuration files, and you may want users to be able to provide an implementation for their own home-grown configuration format.
With a factory class this is easy. To create the factory class, just subclass Class::Factory and create an interface for your configuration serializer. Class::Factory even provides a simple constructor for yo
DBD-Mock
- Ebuilds: 1, Testing: 1.590.0 Description:
Testing with databases can be tricky. If you are developing a system married to a single database then you can make some assumptions about your environment and ask the user to provide relevant connection information. But if you need to test a framework that uses DBI, particularly a framework that uses different types of persistence schemes, then it may be more useful to simply verify what the framework is trying to do -- ensure the right SQL is generated and that the correct parameters are bound. DBD::Mock makes it easy to just modify your configuration (presumably held outside your code) and just use it instead of DBD::Foo (like DBD::Pg or DBD::mysql) in your framework.
Data-DPath
- Ebuilds: 1, Testing: 0.580.0 Description: DPath is not XPath!
DateTime-Format-Duration-ISO8601
- Ebuilds: 1, Testing: 0.8.0 Description:
This module formats and parses ISO 8601 durations to and from DateTime::Duration instances.
ISO 8601 intervals are not supported.
Email-Stuffer
- Ebuilds: 1, Testing: 0.18.0 Description:
Email::Stuffer, as its name suggests, is a fairly casual module used to stuff things into an email and send them. It is a high-level module designed for ease of use when doing a very specific common task, but implemented on top of the light and tolerable Email:: modules.
Email::Stuffer is typically used to build emails and send them in a single statement, as seen in the synopsis. And it is certain only for use when creating and sending emails. As such, it contains no email parsing capability, and little to no modification support.
To re-iterate, this is very much a module for those "slap it together and fire it off" situations, but that still has enough grunt behind the scenes to do things properly.
Etcd
- Ebuilds: 1, Testing: 0.4.0 Description:
This is a client library for accessing and manipulating data in an etcd cluster. It targets the etcd v2 API.
This module is quite low-level. You're expected to have a good understanding of etcd and its API to understand the methods this module provides. See "SEE ALSO" for further reading.
Excel-Writer-XLSX
- Ebuilds: 1, Testing: 1.90.0 Description:
This module provides a comprehensive toolkit for writing the 2007+ Excel
XLSX file format. One can create multiple workbooks, add images and charts
and much more.
License: Artistic
Feature-Compat-Try
- Ebuilds: 1, Testing: 0.50.0 Description:
This module makes syntax support for try/catch control flow easily available.
Perl added such syntax at version 5.34.0, and extended it to support optional finally blocks at 5.35.9, which is enabled by
use feature 'try';
On that version of perl or later, this module simply enables the core feature equivalent to using it directly. On such perls, this module will install with no non-core dependencies, and requires no C compiler.
On older versions of perl before such syntax is available, it is currently provided instead using the Syntax::Keyword::Try module, imported with a special set of options to configure it to recognise exactly and only the same syntax as the core perl feature, thus ensuring that any code using it will still continue to function on that newer perl.
File-Path-Tiny
- Ebuilds: 1, Testing: 1.0.0 Description:
The goal here is simply to provide recursive versions of mkdir() and rmdir() with as little code and overhead as possible.
This module is in no way meant to derogate File::Path and is in no way an endorsement to go out and replace all use of File::Path with File::Path::Tiny.
File::Path is very good at what it does but there's simply a lot happening that we can do without much of the time.
HTML-Escape
- Ebuilds: 1, Testing: 1.110.0 Description:
This modules provides a function which escapes HTML's special characters. It performs a similar function to PHP's htmlspecialchars.
This module uses XS for better performance, but it also provides a pure perl version.
HTTP-AcceptLanguage
- Ebuilds: 1, Testing: 0.20.0 Description: Accept-Language header parser and find available language
HTTP-Parser-XS
- Ebuilds: 1, Testing: 0.170.0 Description:
A fast, primitive HTTP request/response parser.
This can be used for writing either synchronous HTTP servers or
event-driven counterparts. The response parser can be used for
writing HTTP clients.
HTTP-Tiny
- Ebuilds: 1, Testing: 0.88.0 Description:
This is a very simple HTTP/1.1 client, designed for doing simple requests without the overhead of a large framework like LWP::UserAgent.
It is more correct and more complete than HTTP::Lite. It supports proxies and redirection. It also correctly resumes after EINTR.
If IO::Socket::IP 0.25 or later is installed, HTTP::Tiny will use it instead of IO::Socket::INET for transparent support for both IPv4 and IPv6.
Cookie support requires HTTP::CookieJar or an equivalent class.
Iterator
- Ebuilds: 1, Testing: 0.30.0 Description:
This module is meant to be the definitive implementation of iterators, as popularized by Mark Jason Dominus's lectures and recent book (Higher Order Perl, Morgan Kauffman, 2005).
An "iterator" is an object, represented as a code block that generates the "next value" of a sequence, and generally implemented as a closure. When you need a value to operate on, you pull it from the iterator. If it depends on other iterators, it pulls values from them when it needs to. Iterators can be chained together (see Iterator::Util for functions that help you do just that), queueing up work to be done but not actually doing it until a value is needed at the front end of the chain. At that time, one data value is pulled through the chain.
Contrast this with ordinary array processing, where you load or compute all of the input values at once, then loop over them in memory. It's analogous to the difference between looping over a file one line at a time, and reading the entire file into an array of lines before operating on it.
Iterator.pm provides a class that simplifies creation and use of these iterator objects. Other Iterator:: modules (see "SEE ALSO") provide many general-purpose and special-purpose iterator functions.
Some iterators are infinite (that is, they generate infinite sequences), and some are finite. When the end of a finite sequence is reached, the iterator code block should throw an exception of the type Iterator::X::Am_Now_Exhausted; this is usually done via the "is_done" function.. This will signal the Iterator class to mark the object as exhausted. The "is_exhausted" method will then return true, and the "isnt_exhausted" method will return false. Any further calls to the "value" method will throw an exception of the type Iterator::X::Exhausted. See "DIAGNOSTICS".
Note that in many, many cases, you will not need to explicitly create an iterator; there are plenty of iterator generation and manipulation functions in the other associated modules. You can just plug them together like building blocks.
Iterator-Util
- Ebuilds: 1, Testing: 0.20.0 Description:
This module implements many useful functions for creating and manipulating iterator objects.
An "iterator" is an object, represented as a code block that generates the "next value" of a sequence, and generally implemented as a closure. For further information, including a tutorial on using iterator objects, see the Iterator documentation.
JSONSchema-Validator
- Ebuilds: 1, Testing: 0.11.0 Description: OpenAPI specification and JSON Schema Draft4/Draft6/Draft7 validators with minimum dependencies.
This supports specifications from Drafts 4, 6, and 7, as well as the OAS30 spec.
License: MIT
Locale-CLDR
- Ebuilds: 1, Testing: 0.34.1 Description:
This module provides a locale object you can use to localise your output. The localisation data comes from the Unicode Common Locale Data Repository. Most of this code can be used with Perl version 5.10.1 or above. There are a few parts of the code that require version 5.18 or above.
Locales
- Ebuilds: 1, Testing: 0.340.0 Description:
Locales lets you create an object for a certain locale that lets you access certain data harvested directly from CLDR.
http://cldr.unicode.org/index/downloads
Currently the data/methods include translated locale names and territory names.
For simplicity Locales does not work with or know about Variants or Scripts. It only knows about languages and territories.
Also it does not contain all the data contained in CLDR. For example, DateTime’s localization already has all the calender/date/time info from CLDR. Other information has not had any demand yet.
For consistency all data is written in utf-8. No conversion should be necessary if you are (wisely) using utf-8 as your character set everywhere.
Note: You probably [don't need to/should not] use utf8 in regards to the data contained herein.
Mock-MonkeyPatch
- Ebuilds: 1, Testing: 1.20.0 Description:
Mocking is a common tool, especially for testing. By strategically replacing a subroutine, one can isolate segments (units) of code to test individually. When this is done it is important to know that the mocked sub was actually called and with what arguments it was called.
Mock::MonkeyPatch injects a subroutine in the place of an existing one. It returns an object by which you can revisit the manner in which the mocked subroutine was called. Further when the object goes out of scope (or when the "restore" method is called) the original subroutine is replaced.
Module-Build-Pluggable
- Ebuilds: 1, Testing: 0.100.0 Description:
Module::Build::Pluggable adds pluggability for Module::Build.
HOW CAN I WRITE MY OWN PLUGIN?
Module::Build::Pluggable call HOOK_prepare on preparing arguments for Module::Build->new, HOOK_configure on configuration step, and HOOK_build on build step.
That's all.
And if you want a help, you can use Module::Build::Pluggable::Base as base class.
Module-Extract-Use
- Ebuilds: 1, Testing: 1.51.0 Description:
Extract the names of the modules used in a file using a static analysis. Since this module does not run code, it cannot find dynamic uses of modules, such as eval "require $class". It only reports modules that the file loads directly or are in the import lists for parent or base.
The module can handle the conventional inclusion of modules with either use or require as the statement:
Module-Want
- Ebuilds: 1, Testing: 0.600.0 Description: Sometimes you want to lazy load a module for use in, say, a loop or function. First you do the eval-require but then realize if the module is not available it will re-search @INC each time. So then you add a lexical boolean to your eval and do the same simple logic all over the place. On and on it goes :)
This module encapsulates that logic so that have_mod() is like eval { require X; 1 } but if the module can't be loaded it will remember that fact and not look in @INC again on subsequent calls.
MooX-ClassAttribute
- Ebuilds: 1, Testing: 0.11.0 Description:
This module adds support for class attributes to Moo. Class attributes are attributes whose values are not associated with any particular instance of the class.
For example, the Person class might have a class attribute "binomial_name"; its value "Homo sapiens" is not associated with any particular individual, but the class as a whole.
Class attributes may be defined in roles, however they cannot be called as methods using the role package name. Instead the role must be composed with a class; the class attributes will be installed into that class.
This module mostly tries to behave like MooseX::ClassAttribute.
Net-Etcd
- Ebuilds: 1, Testing: 0.22.0 Description:
Net::Etcd is object oriented interface to the v3 REST API provided by the etcd grpc-gateway.
Number-Tolerant
- Ebuilds: 1, Testing: 1.709.0 Description:
Number::Tolerant creates a number-like object whose value refers to a range of possible values, each equally acceptable. It overloads comparison operations to reflect this.
I use this module to simplify the comparison of measurement results to specified tolerances.
OpenOffice-OODoc
- Ebuilds: 1, Testing: 2.125.0 Description:
This toolbox is an extensible Perl interface allowing for direct read/write
pperations on files which comply with OASIS Open Document Format for Office
Applications (ODF).
It provides a high-level document-oriented language and isolates the programmer
from the details of the file format. It can process different document classes
(texts, spreadsheets, presentations, and drawings). It can retrieve and update
styles and images, document metadata, and text content.
PGObject
- Ebuilds: 1, Testing: 2.4.0 Description:
PGObject contains the base routines for object management using discoverable stored procedures in PostgreSQL databases. This module contains only common functionality and support structures, and low-level API's. Most developers will want to use more functional modules which add to these functions.
The overall approach here is to provide the basics for a toolkit that other modules can extend. This is thus intended to be a component for building integration between PostgreSQL user defined functions and Perl objects.
Because decisions such as state handling are largely outside of the scope of this module, this module itself does not do any significant state handling. Database handles (using DBD::Pg 2.0 or later) must be passed in on every call. This decision was made in order to allow for diversity in this area, with the idea that wrapper classes would be written to implement this.
License: BSD-2
PGObject-Simple
- Ebuilds: 1, Testing: 3.1.0 Description:
PGObject::Simple a top-half object system for PGObject which is simple and inspired by (and a subset functionally speaking of) the simple stored procedure object method system of LedgerSMB 1.3. The framework discovers stored procedure APIs and dispatches to them and can therefore be a base for application-specific object models and much more.
PGObject::Simple is designed to be light-weight and yet robust glue between your object model and the RDBMS's stored procedures. It works by looking up the stored procedure arguments, stripping them of the conventional prefix 'in_', and mapping what is left to object property names. Properties can be overridden by passing in a hashrefs in the args named argument. Named arguments there will be used in place of object properties.
This system is quite flexible, perhaps too much so, and it relies on the database encapsulating its own logic behind self-documenting stored procedures using consistent conventions. No function which is expected to be discovered can be overloaded, and all arguments must be named for their object properties. For this reason the use of this module fundamentally changes the contract of the stored procedure from that of a fixed number of arguments in fixed types contract to one where the name must be unique and the stored procedures must be coded to the application's interface. This inverts the way we typically think about stored procedures and makes them much more application friendly.
License: BSD-2
PGObject-Type-BigFloat
- Ebuilds: 1, Testing: 2.1.1 Description:
PGObject::Type::BigFloat subclasses Math::BigFloat and adds functionality needed to transparently serialize and deserialize these objects to PGObject's database calls.
This is mostly needed if you are using PGObject and are doing arbitrary precision math via the Math::BigFloat library.
License: BSD-2
PGObject-Type-ByteString
- Ebuilds: 1, Testing: 1.2.3 Description:
This module provides a basic wrapper around Perl strings, mapping them to BYTEA database columns.
PGObject::Type::ByteString objects have no traditional properties, however dereferencing them will yield the raw string they contain.
License: BSD
PGObject-Type-DateTime
- Ebuilds: 1, Testing: 2.1.1 Description:
This module subclasses DateTime, adding the necessary interfaces to
provide transparent serialization and deserialization to the database
in PGObject calls.
License: BSD-2
PGObject-Type-JSON
- Ebuilds: 1, Testing: 2.1.1 Description:
This module provides a way to automatically serialize and deserialize
JSON and optionally JSONB objects from PostgreSQL.
License: BSD-2
PGObject-Util-DBAdmin
- Ebuilds: 1, Testing: 1.6.1 Description:
This module provides an interface to the basic Postgres db manipulation utilities.
This includes creating and dropping databases, running SQL files against a database, and backing up a database via pg_dump.
License: BSD-2
PGObject-Util-DBMethod
- Ebuilds: 1, Testing: 1.10.0 Description: Declarative stored procedure <-> object mappings for the PGObject Framework
License: BSD-2
PGObject-Util-LogRep-TestDecoding
- Ebuilds: 1, Testing: 0.1.4 Description:
This module provides parse capabiltiies for the test_decoding plugin for
PostgreSQL's logical replication. The test_decoding plugin does not recognize
or handle publications and simply replicates everything.
Messages follow formats like:
table public.data: INSERT: id[integer]:3 data[text]:'5'
or for begin or commit messages:
BEGIN 529
COMMIT 529
Transactions are always processed sequentially in the test decoding stack.
This module can be combined with AnyEvent::PGRecvLogical to create programs
which process PostgreSQL's logical replication streams.
Note that PostgreSQL's logical replication sends out transactions in commit
order and this module assumes that it will process most messages if transaction
information is important (which it might not be for some applications).
License: BSD-2
PGObject-Util-PseudoCSV
- Ebuilds: 1, Testing: 2 Description:
This module provides automatic ways to parse PostgreSQL array and tuple literals.
License: BSD-2
Plack-Builder-Conditionals
- Ebuilds: 1, Testing: 0.50.0 Description:
Plack::Builder::Conditionals extends Plack::Builder with a match-based rule set.
This allows you to set authentication, reverse proxy logic, etc based on request directory, client or host address, and more.
Plack-Middleware-ReverseProxy
- Ebuilds: 1, Testing: 0.160.0 Description:
Plack::Middleware::ReverseProxy resets some HTTP headers, which changed by reverse-proxy. You can specify the reverse proxy address and stop fake requests using 'enable_if' directive in your app.psgi.
Plack-Request-WithEncoding
- Ebuilds: 1, Testing: 0.140.0 Description:
Plack::Request::WithEncoding is a subclass of Plack::Request that supports encoded requests. It overrides many Plack::Request attributes to return decoded values. This feature allows a single application to seamlessly handle a wide variety of different language code sets. Applications that must be able to handle many different translations at once will find this extension able to quickly solve that problem.
The target attributes to be encoded are described at "SPECIFICATION OF THE ENCODING METHOD".
Pod-Coverage-TrustPod
- Ebuilds: 1, Testing: 0.100.5 Description:
This is a Pod::Coverage subclass (actually, a subclass of Pod::Coverage::CountParents) that allows the POD itself to declare certain symbol names trusted.
Here is a sample Perl module:
package Foo::Bar;
=head1 NAME
Foo::Bar - a bar at which fooes like to drink
=head1 METHODS
=head2 fee
returns the bar tab
=cut
sub fee { ... }
=head2 fie
scoffs at bar tab
=cut
sub fie { ... }
sub foo { ... }
=begin Pod::Coverage
foo
=end Pod::Coverage
=cut
This file would report full coverage, because any non-empty lines inside a block of POD targeted to Pod::Coverage are treated as trustme patterns. Leading and trailing whitespace is stripped and the remainder is treated as a regular expression anchored at both ends.
Remember, anywhere you could use =begin and =end as above, you could instead write:
=for Pod::Coverage foo
In some cases, you may wish to make the entire file trusted. The special pattern *EVERYTHING* may be provided to do just this.
Keep in mind that Pod::Coverage::TrustPod sets up exceptions using the "trust" mechanism rather than the "privacy" mechanism in Pod::Coverage. This is unlikely ever to matter to you, but it's true.
Promises
- Ebuilds: 1, Testing: 1.40.0 Description:
This module is an implementation of the "Promise/A+" pattern for asynchronous programming. Promises are meant to be a way to better deal with the resulting callback spaghetti that can often result in asynchronous programs.
Session-Storage-Secure
- Ebuilds: 1, Testing: 1.0.0 Description:
This module implements a secure way to encode session data. It is primarily intended for storing session data in browser cookies, but could be used with other backend storage where security of stored session data is important.
Features include:
Data serialization and compression using Sereal
Data encryption using AES with a unique derived key per encoded session
Enforced expiration timestamp (optional)
Integrity protected with a message authentication code (MAC)
The storage protocol used in this module is based heavily on A Secure Cookie Protocol by Alex Liu and others. Liu proposes a session cookie value as follows:
Starman
- Ebuilds: 1, Testing: 0.401.600 Description:
Starman is a PSGI perl web server that has unique features such as:
High Performance
Uses the fast XS/C HTTP header parser
Preforking
Spawns workers preforked like most high performance UNIX servers do. Starman also reaps dead children and automatically restarts the worker pool.
Signals
Supports HUP for graceful worker restarts, and TTIN/TTOU to dynamically increase or decrease the number of worker processes, as well as QUIT to gracefully shutdown the worker processes.
Superdaemon aware
Supports Server::Starter for hot deploy and graceful restarts.
Multiple interfaces and UNIX Domain Socket support
Able to listen on multiple interfaces including UNIX sockets.
Small memory footprint
Preloading the applications with --preload-app command line option enables copy-on-write friendly memory management. Also, the minimum memory usage Starman requires for the master process is 7MB and children (workers) is less than 3.0MB.
PSGI compatible
Can run any PSGI applications and frameworks
HTTP/1.1 support
Supports chunked requests and responses, keep-alive and pipeline requests.
UNIX only
This server does not support Win32.
String-Compare-ConstantTime
- Ebuilds: 1, Testing: 0.321.0 Description:
This module provides one function, equals (not exported by default).
You should pass this function two strings of the same length. Just like perl's eq, it will return true if they are string-wise identical and false otherwise. However, comparing any two differing strings of the same length will take a fixed amount of time. If the lengths of the strings are different, equals will return false right away.
NOTE: This does byte-wise comparison of the underlying string storage, meaning that comparing strings with non-ASCII data with different states of the internal UTF-8 flag is not reliable. You should always encode your data to bytes before comparing.
String-Random
- Ebuilds: 1, Testing: 0.320.0 Description:
This module makes it trivial to generate random strings.
As an example, let's say you are writing a script that needs to generate a random password for a user. The relevant code might look something like this:
use String::Random;
my $pass = String::Random->new;
print "Your password is ", $pass->randpattern("CCcc!ccn"), "\n";
This would output something like this:
Your password is UDwp$tj5
NOTE!!!: currently, String::Random defaults to Perl's built-in predictable random number generator so the passwords generated by it are insecure. See the rand_gen option to String::Random constructor to specify a more secure random number generator. There is no equivalent to this in the procedural interface, you must use the object-oriented interface to get this functionality.
String-UnicodeUTF8
- Ebuilds: 1, Testing: 0.230.0 Description:
Unicode is awesome. utf-8 is also awesome. They are related but different. That difference and all the little twiggles in between make it appear to be too hard but its really not, honest!
The unicode problem is a solved one.
String-Unquotemeta
- Ebuilds: 1, Testing: 0.100.0 Description: This module provides one simple function, unquotemeta(), that undoes the escaping that quotemeta() does.
It handles undefined values, no values, too many values, etc the same way as quotemeta(). Think of it as quotemeta()'s evil twin.
Sub-Attribute
- Ebuilds: 1, Testing: 0.70.0 Description:
Sub::Attribute is a role to define attribute handlers for specific subroutine attributes.
The feature of this module is similar to that of Attribute::Handlers, but has less functionality and more reliability. That is, while Attribute::Handlers provides many options for ATTR(CODE), Sub::Attribute provides no options for ATTR_SUB. However, the attribute handlers defined by Sub::Attribute are always called with informative arguments. Attribute::Handlers's ATTR(CODE) is not called in run-time eval(), so ATTR(CODE) is not reliable.
Sub-Exporter
- Ebuilds: 1, Testing: 0.990.0 Description:
Sub::Exporter - a sophisticated exporter for custom-built routines
Test-API
- Ebuilds: 1, Testing: 0.10.0 Description:
This simple test module checks the subroutines provided by a module. This is useful for confirming a planned API in testing and ensuring that other functions aren't unintentionally included via import.
License: Apache-2.0
Test-Carp
- Ebuilds: 1, Testing: 0.200.0 Description:
Call given code (with given arguments) and tests whether the given Carp function (or their imported versions) are called (with a given value) or not.
Test-LWP-UserAgent
- Ebuilds: 1, Stable: 0.34.0, Testing: 0.34.0 Description: A LWP::UserAgent suitable for simulating and testing network calls
Test-Lib
- Ebuilds: 1, Testing: 0.3.0 Description:
Searches upward from the calling module for a directory t with a lib directory inside it, and adds it to the module search path. Looks upward up to 5 directories. This is intended to be used in test modules either directly in t or in a subdirectory to find their included testing libraries located in t/lib.
Test-Prereq
- Ebuilds: 1, Testing: 2.3.0 Description:
Extract the names of the modules used in a file using a static analysis. Since this module does not run code, it cannot find dynamic uses of modules, such as eval "require $class". It only reports modules that the file loads directly or are in the import lists for parent or base.
The module can handle the conventional inclusion of modules with either use or require as the statement:
Test2-Plugin-pgTAP
- Ebuilds: 1, Testing: 0.1.105 Description:
This plugin adds support for executing pgTAP PostgreSQL tests under Test2::Harness and yath.
This consists of the Test2::Harness plugin, the YATH plugin, and the test runner
License: || ( Artistic GPL-1+ )
Unicode-Regex-Set
- Ebuilds: 1, Testing: 0.40.0 Description:
Perl 5.8.0 misses subtraction and intersection of characters, which is described in Unicode Regular Expressions (UTS #18). This module provides a mimic syntax of character classes including subtraction and intersection, taking advantage of look-ahead assertions.
The syntax provided by this module is considerably incompatible with the standard Perl's regex syntax.
Version-Compare
- Ebuilds: 1, Testing: 0.140.0 Description: Compare version strings Version::Compare - Comparing version strings
Workflow
- Ebuilds: 1, Testing: 1.610.0 Description:
This is a standalone workflow system. It is designed to fit into your system rather than force your system to fit to it. You can save workflow information to a database or the filesystem (or a custom storage). The different components of a workflow system can be included separately as libraries to allow for maximum reusibility.
Please note: Workflow::Persister::SPOPS in this distribution will not work because SPOPS has not been maintained for some versions and does not work with modern Perl. The functionality has been deprecated by the Workflow project and will be removed in a near-term major release. Per the deprecation notice:
With release 2.00 Workflow::Persister::SPOPS will no longer be included in the distribution, it will possibly be made available as a separate distribution, but with decreased maintenance efforts. SPOPS does no longer seem to be actively supported and issues with Perls versions from 5.11.1 and onwards underline this fact.
SPOPS was developed by the original author of Workflow and the two have worked in parallel for a long time. The Workflow developers have come to a crossroad and focus of resources and efforts are aimed at modernizing workflow.
X12
- Ebuilds: 1, Testing: 0.800.0 Description:
This module is used to parse X12 (EDI) files for a variety of types of business operations.
For details on Transaction sets refer to: National Electronic Data Interchange Transaction Set Implementation Guide. Implementation guides are available for all the Transaction sets.
curry
- Ebuilds: 1, Testing: 2.0.1 Description:
curry - Create automatic curried method call closures for any class or object