| algorithm-diff-perl |
1.1903 |
Compute `intelligent' differences between two files / lists but use the old (<=0.59) interface. |
| apache-logformat-compiler-perl |
0.35 |
Compile a log format string to perl-code. For faster generation of access_log lines. |
| app-cmd-perl |
0.331 |
App::Cmd is intended to make it easy to write complex command-line applications without having to think about most of the annoying things usually involved. |
| appconfig-perl |
1.71 |
USING THE AppConfig MODULE To import and use the AppConfig module the following line should appear in your Perl script: |
| archive-peek-libarchive-perl |
0.37 |
This module lets you peek into archives without extracting them. This is a wrapper to the libarchive C libary (http://code.google.com/p/libarchive/), which you must have installed (libarchive-dev package for Debian/Ubuntu). It supports many different archive formats and compression algorithms and is fast. |
| b-hooks-endofscope-perl |
0.21 |
This module allows you to execute code when perl finished compiling the surrounding scope. |
| b-hooks-op-check-perl |
0.22 |
This module provides a C API for XS modules to hook into the callbacks of "PL_check". |
| bareword-filehandles-perl |
0.005 |
This module lexically disables the use of bareword filehandles with builtin functions, except for the special builtin filehandles "STDIN", "STDOUT", "STDERR", "ARGV", "ARGVOUT" and "DATA". |
| business-isbn-data-perl |
20140910.003 |
You don't need to load this module yourself in most cases. "Business::ISBN" will load it when it loads. |
| business-isbn-perl |
3.004 |
This modules handles International Standard Book Numbers, including ISBN-10 and ISBN-13. |
| capture-tiny-perl |
0.46 |
Capture::Tiny provides a simple, portable way to capture almost anything sent to STDOUT or STDERR, regardless of whether it comes from Perl, from XS code or from an external program. Optionally, output can be teed so that it is captured while being passed through to the original filehandles. Yes, it even works on Windows (usually). Stop guessing which of a dozen capturing modules to use in any particular situation and just use this one. |
| cgi-deurl-xs-perl |
0.08 |
This module decodes a URL-encoded parameter string in the manner of CGI.pm. However, as it uses C code from libapreq to perform the task, it's somewhere from slightly to much faster (depending on your strings) than using CGI or a functionally similar module like CGI::Deurl. |
| cgi-perl |
4.38 |
CGI.pm is a stable, complete and mature solution for processing and preparing HTTP requests and responses. Major features including processing form submissions, file uploads, reading and writing cookies, query string generation and manipulation, and processing and preparing HTTP headers. |
| class-data-inheritable-perl |
0.08 |
Class::Data::Inheritable is for creating accessor/mutators to class data. That is, if you want to store something about your class as a whole (instead of about a single object). This data is then inherited by your subclasses and can be overriden. |
| class-inspector-perl |
1.32 |
Class::Inspector allows you to get information about a loaded class. Most or all of this information can be found in other ways, but they aren't always very friendly, and usually involve a relatively high level of Perl wizardry, or strange and unusual looking code. Class::Inspector attempts to provide an easier, more friendly interface to this information. |
| class-load-perl |
0.24 |
"require EXPR" only accepts "Class/Name.pm" style module names, not "Class::Name". How frustrating! For that, we provide "load_class 'Class::Name'". |
| class-load-xs-perl |
0.10 |
This module provides an XS implementation for portions of Class::Load. See Class::Load for API details. |
| class-method-modifiers-perl |
2.12 |
Method modifiers are a convenient feature from the CLOS (Common Lisp Object System) world. |
| class-singleton-perl |
1.5 |
This is the \"Class::Singleton\" module. A Singleton describes an object class that can have only one instance in any system. An example of a Singleton might be a print spooler or system registry. This module implements a Singleton class from which other classes can be derived. By itself, the \"Class::Singleton\" module does very little other than manage the instantiation of a single object. In deriving a class from \"Class::Singleton\", your module will inherit the Singleton instantiation method and can implement whatever specific functionality is required. |
| class-tiny-perl |
1.006 |
This module offers a minimalist class construction kit in around 120 lines of code. Here is a list of features: |
| class-xsaccessor-perl |
1.19 |
Class::XSAccessor implements fast read, write and read/write accessors in XS. Additionally, it can provide predicates such as "has_foo()" for testing whether the attribute "foo" exists in the object (which is different from "is defined within the object"). It only works with objects that are implemented as ordinary hashes. Class::XSAccessor::Array implements the same interface for objects that use arrays for their internal representation. |
| clone-choose-perl |
0.008 |
"Clone::Choose" checks several different modules which provides a "clone()" function and selects an appropriate one. The default preference is |
| clone-perl |
0.39 |
This module provides a "clone()" method which makes recursive copies of nested hash, array, scalar and reference types, including tied variables and objects. |
| common-sense-perl |
3.74 |
“Nothing is more fairly distributed than common sense: no one thinks he needs more of it than he already has.” |
| compress-raw-bzip2-perl |
2.074 |
"Compress::Raw::Bzip2" provides an interface to the in-memory compression/uncompression functions from the bzip2 compression library. |
| compress-raw-zlib-perl |
2.076 |
The *Compress::Raw::Zlib* module provides a Perl interface to the *zlib* compression library (see "AUTHOR" for details about where to get *zlib*). |
| config-any-perl |
0.32 |
Config::Any provides a facility for Perl applications and libraries to load configuration data from multiple different file formats. It supports XML, YAML, JSON, Apache-style configuration, Windows INI files, and even Perl code. |
| config-autoconf-perl |
0.315 |
Config::AutoConf is intended to provide the same opportunities to Perl developers as GNU Autoconf <http://www.gnu.org/software/autoconf/> does for Shell developers. |
| constant-defer-perl |
6 |
"constant::defer\" creates a subroutine which on the first call runs given code to calculate its value, and on any subsequent calls just returns that value, like a constant. The value code is discarded once run, allowing it to be garbage collected. |
| convert-color-perl |
0.11 |
This module provides conversions between commonly used ways to express colors. It provides conversions between color spaces such as RGB and HSV, and it provides ways to look up colors by a name. |
| convert-color-xterm-perl |
0.05 |
This subclass of Convert::Color::RGB8 provides lookup of the colors that xterm uses by default. Note that the module is not intelligent enough to actually parse the XTerm configuration on a machine, nor to query a running terminal for its actual colors. It simply implements the colors that are present as defaults in the XTerm source code. |
| cookie-baker-perl |
0.09 |
Cookie::Baker provides simple cookie string generator and parser. |
| cookie-baker-xs-perl |
0.09 |
Cookie::Baker::XS provides cookie string parser that implemented by XS. This modules only provides parser, does not have a generator function. |
| cpan-meta-check-perl |
0.014 |
This module verifies if requirements described in a CPAN::Meta object are present. |
| cpanel-json-xs-perl |
4.02 |
This module converts Perl data structures to JSON and vice versa. Its primary goal is to be *correct* and its secondary goal is to be *fast*. To reach the latter goal it was written in C. |
| crypt-cbc-perl |
2.33 |
This module is a Perl-only implementation of the cryptographic cipher block chaining mode (CBC). In combination with a block cipher such as DES or IDEA, you can encrypt and decrypt messages of arbitrarily long length. The encrypted messages are compatible with the encryption format used by the OpenSSL package. |
| crypt-pbkdf2-perl |
0.161520 |
PBKDF2 is a secure password hashing algorithm that uses the techniques of "key strengthening" to make the complexity of a brute-force attack arbitrarily high. PBKDF2 uses any other cryptographic hash or cipher (by convention, usually HMAC-SHA1, but "Crypt::PBKDF2" is fully pluggable), and allows for an arbitrary number of iterations of the hashing function, and a nearly unlimited output hash size (up to 2**32 - 1 times the size of the output of the backend hash). The hash is salted, as any password hash should be, and the salt may also be of arbitrary size. |
| crypt-rijndael-perl |
1.13 |
This module implements the Rijndael cipher, which has just been selected as the Advanced Encryption Standard. |
| crypt-ripemd160-perl |
0.06 |
The Crypt::RIPEMD160 module allows you to use the RIPEMD160 Message Digest algorithm from within Perl programs. The module is based on the implementation from Antoon Bosselaers from Katholieke Universiteit Leuven. A new RIPEMD160 context object is created with the new operation. Multiple simultaneous digest contexts can be maintained, if desired. The context is updated with the add operation which adds the strings contained in the *LIST* parameter. Note, however, that \"add('foo', 'bar')\", \"add('foo')\" followed by \"add('bar')\" and \"add('foobar')\" should all give the same result. The final message digest value is returned by the digest operation as a 20-byte binary string. This operation delivers the result of add operations since the last new or reset operation. Note that the digest operation is effectively a destructive, read-once operation. Once it has been performed, the context must be reset before being used to calculate another digest value. Several convenience functions are also provided. The addfile operation takes an open file-handle and reads it until end-of file in 8192 byte blocks adding the contents to the context. The file-handle can either be specified by name or passed as a type-glob reference, as shown in the examples below. The hexdigest operation calls digest and returns the result as a printable string of hexdecimal digits. This is exactly the same operation as performed by the unpack operation in the examples below. The hash operation can act as either a static member function (ie you invoke it on the RIPEMD160 class as in the synopsis above) or as a normal virtual function. In both cases it performs the complete RIPEMD160 cycle (reset, add, digest) on the supplied scalar value. This is convenient for handling small quantities of data. When invoked on the class a temporary context is created. When invoked through an already created context object, this context is used. The latter form is slightly more efficient. The hexhash operation is analogous to hexdigest. |
| crypt-urandom-perl |
0.36 |
This Module is intended to provide an interface to the strongest available source of non-blocking randomness on the current platform. Platforms currently supported are anything supporting /dev/urandom and versions of Windows greater than or equal to Windows 2000. |
| dancer-plugin-database-core-perl |
0.20 |
Shared core for D1 and D2 Database plugins |
| dancer2-perl |
0.205002 |
Dancer2 is the new generation of Dancer, the lightweight web-framework for Perl. Dancer2 is a complete rewrite based on Moo. |
| dancer2-plugin-auth-yarbac-perl |
0.009 |
YARBAC is a role based user authentication and authorisation framework for Dancer2 apps. Designed with security and a medium to large user base in mind. This framework was heavily inspired by the excellent Dancer::Plugin::Auth::Extensible framework which I'd highly recommend. YARBAC was designed to support secure password checking, enforced password hashing, multiple authentication realms and the ability to create your own backend provider. YARBAC was also designed to to be as flexible and as feature rich as possible in the hope that I'll never have to write RBAC code for Dancer again. :) While similar to Extensible in some ways, this framework has some significantly different approaches. These differences were born out of my own experiences writing RBAC code for various Dancer apps and finding myself always having to extend existing modules or starting from scratch or worse still, copy/paste my old code then reworking it. The major difference with YARBAC is that it tries to be a complete solution to the problem. However in order to be a little more flexible and feature rich in some areas it is also a little more opinionated in others. The main area of opinion in YARBAC is how it achieves role-based access control. YARBAC is structed with users, roles, groups and permissions. A user can have many roles but it might be a good idea in larger enviornments to only allow a user to have one role and then assign that role have many groups. Think of a role as being a role-group. Then there are groups which have many permissions. A user can have one or more roles, a role can have one or more groups and groups can have one or more permissions. This means when deciding if a user is authorised we could require they be logged in, or have a specifc role, or specific group, or a specific group with a specific permission and so on. To put it another way, this design moves the access control down to the role-group relationship thus allowing one to quickly and easily see, assign or revoke permissions to a user even when dealing with a fairly complex authorisation environment. |
| dancer2-plugin-database-perl |
2.17 |
Provides an easy way to obtain a connected DBI database handle by simply calling the database keyword within your Dancer2 application |
| dancer2-session-cookie-perl |
0.008 |
This module implements a session factory for Dancer 2 that stores session state within a browser cookie. Features include: |
| data-dump-perl |
1.23 |
This module provide a few functions that traverse their argument and produces a string as its result. The string contains Perl code that, when \"eval\"ed, produces a deep copy of the original arguments. |
| data-munge-perl |
0.097 |
This module defines a few generally useful utility functions. I got tired of redefining or working around them, so I wrote this module. |
| data-optlist-perl |
0.110 |
Hashes are great for storing named data, but if you want more than one entry for a name, you have to use a list of pairs. Even then, this is really boring to write: |
| data-record-perl |
0.02 |
Sometimes we need data split into records and a simple split on the input record separator ($/) or some other value fails because the values we're splitting on may allowed in other parts of the data. Perhaps they're quoted. Perhaps they're embedded in other data which should not be split up. |
| data-tumbler-perl |
0.010 |
NOTE: This is alpha code and liable to change while it and Test::WriteVariants mature. |
| data-uuid-perl |
1.221 |
This module provides a framework for generating v3 UUIDs (Universally Unique Identifiers, also known as GUIDs (Globally Unique Identifiers). A UUID is 128 bits long, and is guaranteed to be different from all other UUIDs/GUIDs generated until 3400 CE. |
| datetime-format-duration-perl |
1.04 |
Format and parse DateTime::Durations |
| datetime-format-strptime-perl |
1.75 |
This module implements most of strptime(3), the POSIX function that is the reverse of strftime(3), for "DateTime". While "strftime" takes a "DateTime" and a pattern and returns a string, "strptime" takes a string and a pattern and returns the "DateTime" object associated. |
| datetime-locale-perl |
1.17 |
DateTime::Locale is primarily a factory for the various locale subclasses. It also provides some functions for getting information on all the available locales. |
| datetime-perl |
1.46 |
DateTime is a class for the representation of date/time combinations, and is part of the Perl DateTime project. For details on this project please see <http://datetime.perl.org/>. The DateTime site has a FAQ which may help answer many "how do I do X?" questions. The FAQ is at <http://datetime.perl.org/wiki/datetime/page/FAQ>. |
| datetime-timezone-perl |
2.17 |
This class is the base class for all time zone objects. A time zone is represented internally as a set of observances, each of which describes the offset from GMT for a given time period. |
| dbd-sqlite-perl |
1.54 |
SQLite is a public domain file-based relational database engine that you can find at <http://www.sqlite.org/>. |
| dbi-perl |
1.640 |
The DBI is a database access module for the Perl programming language. It defines a set of methods, variables, and conventions that provide a consistent database interface, independent of the actual database being used. |
| devel-caller-perl |
2.06 |
caller_cv($level) gives you the coderef of the subroutine being invoked at the call frame indicated by the value of \$level |
| devel-checkbin-perl |
0.04 |
Devel::CheckBin is a perl module that checks whether a particular command is available. |
| devel-cycle-perl |
1.12 |
This is a simple developer's tool for finding circular references in objects and other types of references. Because of Perl's reference-count based memory management, circular references will cause memory leaks. |
| devel-globaldestruction-perl |
0.14 |
Perl's global destruction is a little tricky to deal with WRT finalizers because it's not ordered and objects can sometimes disappear. |
| devel-globaldestruction-xs-perl |
0.03 |
This is an XS backend for Devel::GlobalDestruction and should be used through that module. |
| devel-hide-perl |
0.0009 |
Given a list of Perl modules/filenames, this module makes \"require\" and \"use\" statements fail (no matter the specified files/modules are installed or not). |
| devel-leak-object-perl |
1.01 |
This module provides tracking of objects, for the purpose of detecting memory leaks due to circular references or innappropriate caching schemes. |
| devel-lexalias-perl |
0.05 |
Devel::LexAlias provides the ability to alias a lexical variable in a subroutines scope to one of your choosing. |
| devel-mat-perl |
0.33 |
A "Devel::MAT" instance loads a heapdump file, and provides a container to store analysis tools to work on it. Tools may be provided that conform to the Devel::MAT::Tool API, which can help analyse the data and interact with the explorer user interface by using the methods in the Devel::MAT::UI package. |
| devel-overloadinfo-perl |
0.005 |
Devel::OverloadInfo returns information about overloaded operators for a given class (or object), including where in the inheritance hierarchy the overloads are declared and where the code implementing them is. |
| devel-stacktrace-ashtml-perl |
0.15 |
Devel::StackTrace::AsHTML adds "as_html" method to Devel::StackTrace which displays the stack trace in beautiful HTML, with code snippet context and function parameters. If you call it on an instance of Devel::StackTrace::WithLexicals, you even get to see the lexical variables of each stack frame. |
| devel-stacktrace-perl |
2.03 |
The "Devel::StackTrace" module contains two classes, "Devel::StackTrace" and Devel::StackTrace::Frame. These objects encapsulate the information that can retrieved via Perl's "caller" function, as well as providing a simple interface to this data. |
| digest-hmac-perl |
1.03 |
This module provide HMAC-MD5 hashing. |
| digest-md5-perl |
2.55 |
The "Digest::MD5" module allows you to use the RSA Data Security Inc. MD5 Message Digest algorithm from within Perl programs. The algorithm takes as input a message of arbitrary length and produces as output a 128-bit "fingerprint" or "message digest" of the input. |
| digest-md6-perl |
0.11 |
The \"Digest::MD6\" module allows you to use the MD6 Message Digest algorithm from within Perl programs. The algorithm takes as input a message of arbitrary length and produces as output a \"fingerprint\" or \"message digest\" of the input. |
| digest-sha-perl |
6.01 |
Digest::SHA is written in C for speed. If your platform lacks a C compiler, you can install the functionally equivalent (but much slower) Digest::SHA::PurePerl module. |
| digest-sha3-perl |
1.03 |
Digest::SHA3 is written in C for speed. If your platform lacks a C compiler, perhaps you can find the module in a binary form compatible with your particular processor and operating system. |
| dist-checkconflicts-perl |
0.11 |
One shortcoming of the CPAN clients that currently exist is that they have no way of specifying conflicting downstream dependencies of modules. This module attempts to work around this issue by allowing you to specify conflicting versions of modules separately, and deal with them after the module is done installing. |
| encode-locale-perl |
1.05 |
In many applications it's wise to let Perl use Unicode for the strings it processes. Most of the interfaces Perl has to the outside world are still byte based. Programs therefore need to decode byte strings that enter the program from the outside and encode them again on the way out. |
| encode-perl |
2.97 |
The "Encode" module provides the interface between Perl strings and the rest of the system. Perl strings are sequences of *characters*. |
| eval-closure-perl |
0.14 |
String eval is often used for dynamic code generation. For instance, "Moose" uses it heavily, to generate inlined versions of accessors and constructors, which speeds code up at runtime by a significant amount. String eval is not without its issues however - it's difficult to control the scope it's used in (which determines which variables are in scope inside the eval), and it's easy to miss compilation errors, since eval catches them and sticks them in $@ instead. |
| exception-class-perl |
1.44 |
RECOMMENDATION 1: If you are writing modern Perl code with Moose or Moo I highly recommend using Throwable instead of this module. |
| experimental-perl |
0.019 |
This pragma provides an easy and convenient way to enable or disable experimental features. |
| exporter-tiny-perl |
1.000000 |
Exporter::Tiny supports many of Sub::Exporter's external-facing features including renaming imported functions with the "-as", "-prefix" and "-suffix" options; explicit destinations with the "into" option; and alternative installers with the "installer" option. But it's written in only about 40% as many lines of code and with zero non-core dependencies. |
| extutils-cbuilder-perl |
0.280230 |
This module can build the C portions of Perl modules by invoking the appropriate compilers and linkers in a cross-platform manner. It was motivated by the "Module::Build" project, but may be useful for other purposes as well. However, it is *not* intended as a general cross-platform interface to all your C building needs. That would have been a much more ambitious goal! |
| extutils-config-perl |
0.008 |
ExtUtils::Config is an abstraction around the %Config hash. By itself it is not a particularly interesting module by any measure, however it ties together a family of modern toolchain modules. |
| extutils-cppguess-perl |
0.12 |
"ExtUtils::CppGuess" attempts to guess the system's C++ compiler that is compatible with the C compiler that your perl was built with. |
| extutils-depends-perl |
0.405 |
This module tries to make it easy to build Perl extensions that use functions and typemaps provided by other perl extensions. This means that a perl extension is treated like a shared library that provides also a C and an XS interface besides the perl one. |
| extutils-helpers-perl |
0.026 |
This module provides various portable helper functions for module building modules. |
| extutils-installpaths-perl |
0.011 |
This module tries to make install path resolution as easy as possible. |
| extutils-makemaker-perl |
7.32 |
This utility is designed to write a Makefile for an extension module from a Makefile.PL. It is based on the Makefile.SH model provided by Andy Dougherty and the perl5-porters. |
| extutils-parsexs-perl |
3.35 |
"ExtUtils::ParseXS" will compile XS code into C code by embedding the constructs necessary to let C functions manipulate Perl values and creates the glue necessary to let Perl access those functions. The compiler uses typemaps to determine how to map C function parameters and variables to Perl values. |
| extutils-typemaps-default-perl |
1.05 |
"ExtUtils::Typemaps::Default\" is an \"ExtUtils::Typemaps\" subclass that provides a set of default mappings (in addition to what perl itself provides). These default mappings are currently defined as the combination of the mappings provided by the following typemap classes which are provided in this distribution: |
| extutils-xspp-perl |
0.18 |
XS++ is just a thin layer over plain XS, hence to use it you are supposed to know, at the very least, C++ and XS. This means that you may need typemaps for both the normal XS pre-processor xsubpp and the XS++ pre-processor xspp. |
| file-configdir-perl |
0.018 |
This module is a helper for installing, reading and finding configuration file locations. It's intended to work in every supported Perl5 environment and will always try to Do The Right Thing(tm). |
| file-configdir-system-image-update-perl |
git |
System::Image::Update helps managing updates of OS images in embedded systems |
| file-copy-recursive-perl |
0.40 |
This module copies and moves directories recursively (or single files, well... singley) to an optional depth and attempts to preserve each file or directory's mode. |
| file-find-rule-perl |
0.34 |
File::Find::Rule is a friendlier interface to File::Find. It allows you to build rules which specify the desired files and directories. |
| file-find-rule-perl-perl |
1.15 |
I write a lot of things that muck with Perl files. And it always annoyed me that finding \"perl files\" requires a moderately complex File::Find::Rule pattern. |
| file-homedir-perl |
1.002 |
File::HomeDir is a module for locating the directories that are "owned" by a user (typicaly your user) and to solve the various issues that arise trying to find them consistently across a wide variety of platforms. |
| file-libmagic-perl |
1.16 |
The "File::LibMagic" is a simple perl interface to libmagic from the file package (version 4.x or 5.x). You will need both the library (libmagic.so) and the header file (magic.h) to build this Perl module. |
| file-listing-perl |
6.04 |
This module exports a single function called parse_dir(), which can be used to parse directory listings. |
| file-pushd-perl |
1.014 |
File::pushd does a temporary "chdir" that is easily and automatically reverted, similar to "pushd" in some Unix command shells. It works by creating an object that caches the original working directory. When the object is destroyed, the destructor calls "chdir" to revert to the original working directory. By storing the object in a lexical variable with a limited scope, this happens automatically at the end of the scope. |
| file-sharedir-install-perl |
0.11 |
File::ShareDir::Install allows you to install read-only data files from a distribution. It is a companion module to File::ShareDir, which allows you to locate these files after installation. |
| file-sharedir-perl |
1.104 |
The intent of File::ShareDir is to provide a companion to Class::Inspector and File::HomeDir, modules that take a process that is well-known by advanced Perl developers but gets a little tricky, and make it more available to the larger Perl community. |
| file-slurp-tiny-perl |
0.004 |
This module provides functions for fast and correct slurping and spewing. All functions are optionally exported. |
| file-touch-perl |
0.11 |
Perl5 module to update file access and modification times |
| file-which-perl |
1.22 |
File::Which finds the full or relative paths to executable programs on the system. This is normally the function of "which" utility. "which" is typically implemented as either a program or a built in shell command. On some platforms, such as Microsoft Windows it is not provided as part of the core operating system. This module provides a consistent API to this functionality regardless of the underlying platform. |
| filesys-notify-simple-perl |
0.13 |
Filesys::Notify::Simple is a simple but unified interface to get notifications of changes to a given filesystem path. It utilizes inotify2 on Linux, fsevents on OS X, kqueue on FreeBSD and FindFirstChangeNotification on Windows if they're installed, with a fallback to the full directory scan if they're not available. |
| find-lib-perl |
1.04 |
The purpose of this module is to replace |
| future-perl |
0.38 |
A "Future" object represents an operation that is currently in progress, or has recently completed. It can be used in a variety of ways to manage the flow of control, and data, through an asynchronous program. |
| getopt-long-descriptive-perl |
0.102 |
Getopt::Long::Descriptive is yet another Getopt library. It's built atop Getopt::Long, and gets a lot of its features, but tries to avoid making you think about its huge array of options. |
| getopt-long-perl |
2.50 |
The Getopt::Long module implements an extended getopt function called GetOptions(). It parses the command line from @ARGV, recognizing and removing specified options and their possible values. |
| growl-gntp-perl |
0.21 |
Growl::GNTP is Perl implementation of GNTP Protocol (Client Part) |
| hash-fieldhash-perl |
0.15 |
"Hash::FieldHash" provides the field hash mechanism which supports the inside-out technique. |
| hash-merge-perl |
0.300 |
Hash::Merge merges two arbitrarily deep hashes into a single hash. That is, at any level, it will add non-conflicting key-value pairs from one hash to the other, and follows a set of specific rules when there are key value conflicts (as outlined below). The hash is followed recursively, so that deeply nested hashes that are at the same level will be merged when the parent hashes are merged. Please note that self-referencing hashes, or recursive references, are not handled well by this method. |
| hash-merge-simple-perl |
0.051 |
Hash::Merge::Simple will recursively merge two or more hashes and return the result as a new hash reference. The merge function will descend and merge hashes that exist under the same node in both the left and right hash, but doesn't attempt to combine arrays, objects, scalars, or anything else. The rightmost hash also takes precedence, replacing whatever was in the left hash if a conflict occurs. |
| hash-moreutils-perl |
0.05 |
Similar to \"List::MoreUtils\", \"Hash::MoreUtils\" contains trivial but commonly-used functionality for hashes. |
| hash-multivalue-perl |
0.16 |
Hash::MultiValue is an object (and a plain hash reference) that may contain multiple values per key, inspired by MultiDict of WebOb. |
| html-parser-perl |
3.72 |
Objects of the "HTML::Parser" class will recognize markup and separate it from plain text (alias data content) in HTML documents. As different kinds of markup and text are recognized, the corresponding event handlers are invoked. |
| html-tagset-perl |
3.20 |
This module contains several data tables useful in various kinds of HTML parsing operations. |
| http-body-perl |
1.22 |
HTTP::Body parses chunks of HTTP POST data and supports application/octet-stream, application/json, application/x-www-form-urlencoded, and multipart/form-data. |
| http-cookiejar-perl |
0.008 |
This module implements a minimalist HTTP user agent cookie jar in conformance with RFC 6265 <http://tools.ietf.org/html/rfc6265>. |
| http-cookies-perl |
6.04 |
This class is for objects that represent a "cookie jar" -- that is, a database of all the HTTP cookies that a given LWP::UserAgent object knows about. |
| http-daemon-perl |
6.01 |
Instances of the \"HTTP::Daemon\" class are HTTP/1.1 servers that listen on a socket for incoming requests. The \"HTTP::Daemon\" is a subclass of \"IO::Socket::INET\", so you can perform socket operations directly on it too. |
| http-date-perl |
6.02 |
This module provides functions that deal the date formats used by the HTTP protocol (and then some more). Only the first two functions, time2str() and str2time(), are exported by default. |
| http-entity-parser-perl |
0.21 |
HTTP::Entity::Parser is a PSGI-compliant HTTP Entity parser. This module also is compatible with HTTP::Body. Unlike HTTP::Body, HTTP::Entity::Parser reads HTTP entities from PSGI's environment "$env->{'psgi.input'}" and parses it. This module supports application/x-www-form-urlencoded, multipart/form-data and application/json. |
| http-headers-fast-perl |
0.21 |
HTTP::Headers::Fast is a perl class for parsing/writing HTTP headers. |
| http-message-perl |
6.14 |
An "HTTP::Message" object contains some headers and a content body. The following methods are available: |
| http-multipartparser-perl |
0.02 |
This class provides a low-level API for processing MultiPart MIME data streams conforming to MultiPart types as defined in RFC 2616 <http://tools.ietf.org/html/rfc2616#section-3.7.2>. |
| http-negotiate-perl |
6.01 |
This module provides a complete implementation of the HTTP content negotiation algorithm specified in draft-ietf-http-v11-spec-00.ps chapter 12. Content negotiation allows for the selection of a preferred content representation based upon attributes of the negotiable variants and the value of the various Accept* header fields in the request. |
| http-parser-xs-perl |
0.17 |
HTTP::Parser::XS is a fast, primitive HTTP request/response parser. |
| http-tiny-perl |
0.070 |
This is a very simple HTTP/1.1 client, designed for doing simple requests without the overhead of a large framework like LWP::UserAgent. |
| http-xscookies-perl |
0.000021 |
This module implements cookie creation (baking) and parsing (crushing) using XS, therefore improving the speed of a pure Perl implementation. |
| http-xsheaders-perl |
0.400003 |
By loading HTTP::XSHeaders anywhere, you replace any usage of HTTP::Headers and HTTP::Headers::Fast with a fast C implementation. |
| import-into-perl |
1.002005 |
Writing exporters is a pain. Some use Exporter, some use Sub::Exporter, some use Moose::Exporter, some use Exporter::Declare ... and some things are pragmas. |
| importer-perl |
0.025 |
This module acts as a layer between Exporter and modules which consume exports. It is feature-compatible with Exporter, plus some much needed extras. You can use this to import symbols from any exporter that follows Exporters specification. The exporter modules themselves do not need to use or inherit from the Exporter module, they just need to set @EXPORT and/or other variables. |
| inc-latest-perl |
0.500 |
WARNING -- THIS IS AN EXPERIMENTAL MODULE. It was originally bundled (as an experiment) with Module::Build and has been split out for more general use. |
| indirect-perl |
0.38 |
When enabled, this pragma warns about indirect method calls that are present in your code. |
| inline-perl |
0.80 |
The Inline module allows you to put source code from other programming languages directly \"inline\" in a Perl script or module. The code is automatically compiled as needed, and then loaded for immediate access from Perl. |
| io-async-perl |
0.71 |
This collection of modules allows programs to be written that perform asynchronous filehandle IO operations. A typical program using them would consist of a single subclass of IO::Async::Loop to act as a container of other objects, which perform the actual IO work required by the program. As well as IO handles, the loop also supports timers and signal handlers, and includes more higher-level functionality built on top of these basic parts. |
| io-captureoutput-perl |
1.1104 |
This module is no longer recommended by the maintainer - see Capture::Tiny instead. |
| io-compress-perl |
2.074 |
This module provides a Perl interface that allows writing compressed data to files or buffer as defined in RFC 1952. |
| io-html-perl |
1.001 |
IO::HTML provides an easy way to open a file containing HTML while automatically determining its encoding. It uses the HTML5 encoding sniffing algorithm specified in section 8.2.2.2 of the draft standard. |
| io-socket-ip-perl |
0.39 |
This module provides a protocol-independent way to use IPv4 and IPv6 sockets, intended as a replacement for IO::Socket::INET. Most constructor arguments and methods are provided in a backward-compatible way. For a list of known differences, see the "IO::Socket::INET" INCOMPATIBILITES section below. |
| io-socket-portstate-perl |
0.03 |
You can use it to check if a port is open or closed for a given host and protocol. |
| io-socket-ssl-perl |
2.056 |
IO::Socket::SSL makes using SSL/TLS much easier by wrapping the necessary functionality into the familiar IO::Socket interface and providing secure defaults whenever possible. This way, existing applications can be made SSL-aware without much effort, at least if you do blocking I/O and don't use select or poll. |
| io-tiecombine-perl |
1.005 |
produce tied (and other) separate but combined variables |
| ipc-run3-perl |
0.048 |
This module allows you to run a subprocess and redirect stdin, stdout, and/or stderr to files and perl data structures. It aims to satisfy 99% of the need for using \"system\", \"qx\", and \"open3\" with a simple, extremely Perlish API. |
| json-maybexs-perl |
1.003010 |
This module first checks to see if either Cpanel::JSON::XS or JSON::XS is already loaded, in which case it uses that module. Otherwise it tries to load Cpanel::JSON::XS, then JSON::XS, then JSON::PP in order, and either uses the first module it finds or throws an error. |
| json-perl |
2.97001 |
This module is a thin wrapper for JSON::XS-compatible modules with a few additional features. All the backend modules convert a Perl data structure to a JSON text as of RFC4627 (which we know is obsolete but we still stick to; see below for an option to support part of RFC7159) and vice versa. This module uses JSON::XS by default, and when JSON::XS is not available, this module falls back on JSON::PP, which is in the Perl core since 5.14. If JSON::PP is not available either, this module then falls back on JSON::backportPP (which is actually JSON::PP in a different .pm file) bundled in the same distribution as this module. You can also explicitly specify to use Cpanel::JSON::XS, a fork of JSON::XS by Reini Urban. |
| lexical-sealrequirehints-perl |
0.011 |
This module works around two historical bugs in Perl's handling of the "%^H" (lexical hints) variable. One bug causes lexical state in one file to leak into another that is "require"d/"use"d from it. This bug, [perl #68590] , was present from Perl 5.6 up to Perl 5.10, fixed in Perl 5.11.0. The second bug causes lexical state (normally a blank "%^H" once the first bug is fixed) to leak outwards from "utf8.pm", if it is automatically loaded during Unicode regular expression matching, into whatever source is compiling at the time of the regexp match. This bug, [perl #73174], was present from Perl 5.8.7 up to Perl 5.11.5, fixed in Perl 5.12.0. |
| libwww-perl-perl |
6.33 |
The libwww-perl collection is a set of Perl modules which provides a simple and consistent application programming interface (API) to the World-Wide Web. The main focus of the library is to provide classes and functions that allow you to write WWW clients. The library also contain modules that are of more general use and even classes that help you implement simple HTTP servers. |
| linux-inotify2-perl |
1.22 |
This module implements an interface to the Linux 2.6.13 and later Inotify file/directory change notification system. |
| list-moreutils-perl |
0.428 |
List::MoreUtils provides some trivial but commonly needed functionality on lists which is not going to go into List::Util. |
| list-moreutils-xs-perl |
0.428 |
List::MoreUtils::XS is a backend for List::MoreUtils. Even if it's possible (because of user wishes) to have it practically independent from List::MoreUtils, it technically depend on \"List::MoreUtils\". Since it's only a backend, the API is not public and can change without any warning. |
| list-utilsby-perl |
0.11 |
This module provides a number of list utility functions, all of which take an initial code block to control their behaviour. They are variations on similar core perl or "List::Util" functions of similar names, but which use the block to control their behaviour. For example, the core Perl function "sort" takes a list of values and returns them, sorted into order by their string value. The "sort_by" function sorts them according to the string value returned by the extra function, when given each value. |
| log-any-adapter-daemontools-perl |
0.101 |
In the daemontools way of thinking, a daemon writes all its logging output to STDOUT (or STDERR), which is a pipe to a logger process. Doing this instead of other logging alternatives keeps your program simple and allows you to capture errors generated by deeper libraries (like libc) which aren't aware of your logging API. If you want complicated logging you can keep those details in the logging process and not bloat each daemon you write. |
| log-any-adapter-dispatch-perl |
0.08 |
This Log::Any adapter uses Log::Dispatch for logging. |
| log-any-perl |
1.705 |
"Log::Any" provides a standard log production API for modules. Log::Any::Adapter allows applications to choose the mechanism for log consumption, whether screen, file or another logging mechanism like Log::Dispatch or Log::Log4perl. |
| log-dispatch-perl |
2.67 |
This module manages a set of Log::Dispatch::* output objects that can be logged to via a unified interface. |
| log-log4perl-perl |
1.49 |
Log::Log4perl lets you remote-control and fine-tune the logging behaviour of your system from the outside. It implements the widely popular (Java-based) Log4j logging package in pure Perl. |
| lwp-mediatypes-perl |
6.02 |
This module provides functions for handling media (also known as MIME) types and encodings. The mapping from file extensions to media types is defined by the media.types file. If the ~/.media.types file exists it is used instead. For backwards compatibility we will also look for ~/.mime.types. |
| lwp-protocol-https-perl |
6.07 |
The LWP::Protocol::https module provides support for using https schemed URLs with LWP. This module is a plug-in to the LWP protocol handling, so you don't use it directly. Once the module is installed LWP is able to access sites using HTTP over SSL/TLS. |
| math-base-convert-perl |
0.11 |
This module provides fast functions and methods to convert between arbitrary number bases from 2 (binary) thru 65535. |
| math-bigint-perl |
1.999811 |
Math::BigInt provides support for arbitrary precision integers. Overloading is also provided for Perl operators. |
| math-complex-perl |
1.59 |
This package lets you create and manipulate complex numbers. By default, *Perl* limits itself to real numbers, but an extra "use" statement brings full complex support, along with a full set of mathematical functions typically associated with and/or extended to complex numbers. |
| math-libm-perl |
1.00 |
This module is a translation of the C math.h file. It exports the following selected constants and functions. |
| math-planepath-perl |
126 |
This is a base class for some mathematical paths which map an integer position $n to and from coordinates "$x,$y" in the 2D plane. |
| math-random-isaac-perl |
1.004 |
As with other Pseudo-Random Number Generator (PRNG) algorithms like the Mersenne Twister (see Math::Random::MT), this algorithm is designed to take some seed information and produce seemingly random results as output. |
| math-random-isaac-xs-perl |
1.004 |
See Math::Random::ISAAC for the full description. |
| mime-charset-perl |
1.012.2 |
MIME::Charset provides information about character sets used for MIME messages on Internet. |
| mime-types-perl |
2.17 |
MIME types are used in many applications (for instance as part of e-mail and HTTP traffic) to indicate the type of content which is transmitted. or expected. See RFC2045 at https://www.ietf.org/rfc/rfc2045.txt |
| module-build-perl |
0.4224 |
\"Module::Build\" is a system for building, testing, and installing Perl modules. It is meant to be an alternative to \"ExtUtils::MakeMaker\". Developers may alter the behavior of the module through subclassing in a much more straightforward way than with "MakeMaker". It also does not require a \"make\" on your system - most of the "Module::Build" code is pure-perl and written in a very cross-platform way. |
| module-build-tiny-perl |
0.039 |
Many Perl distributions use a Build.PL file instead of a Makefile.PL file to drive distribution configuration, build, test and installation. Traditionally, Build.PL uses Module::Build as the underlying build system. This module provides a simple, lightweight, drop-in replacement. |
| module-build-withxspp-perl |
0.14 |
This subclass of Module::Build adds some tools and processes to make it easier to use for wrapping C++ using XS++ (ExtUtils::XSpp). |
| module-implementation-perl |
0.09 |
This module abstracts out the process of choosing one of several underlying implementations for a module. This can be used to provide XS and pure Perl implementations of a module, or it could be used to load an implementation for a given OS or any other case of needing to provide multiple implementations. |
| module-pluggable-perl |
5.2 |
Provides a simple but, hopefully, extensible way of having 'plugins' for your module. Obviously this isn't going to be the be all and end all of solutions but it works for me. |
| module-runtime-conflicts-perl |
0.003 |
This module provides conflicts checking for Module::Runtime, which had a recent release that broke some versions of Moose. It is called from Moose::Conflicts and "moose-outdated". |
| module-runtime-perl |
0.016 |
The functions exported by this module deal with runtime handling of Perl modules, which are normally handled at compile time. This module avoids using any other modules, so that it can be used in low-level infrastructure. |
| moo-perl |
2.003004 |
"Moo" is an extremely light-weight Object Orientation system. It allows one to concisely define objects and roles with a convenient syntax that avoids the details of Perl's object system. "Moo" contains a subset of Moose and is optimised for rapid startup. |
| moose-perl |
2.2010 |
Moose is an extension of the Perl 5 object system. |
| moox-cmd-perl |
0.017 |
Eases the writing of command line utilities, accepting commands and subcommands and so on. These commands can form a tree, which is mirrored in the package structure. On invocation each command along the path through the tree (starting from the toplevel command through to the most specific one) is instanciated. |
| moox-configfromfile-perl |
0.008 |
This module is intended to easy load initialization values for attributes on object construction from an appropriate config file. The building is done in MooX::ConfigFromFile::Role - using MooX::ConfigFromFile ensures the role is applied. |
| moox-file-configdir-perl |
0.006 |
This module is a helper for easily find configuration file locations. Whether to use this information for find a suitable place for installing them or looking around for finding any piece of settings, heavily depends on the requirements. |
| moox-locale-passthrough-perl |
0.001 |
"MooX::Locale::Passthrough" is made to allow CPAN modules use translator API without adding heavy dependencies (external software) or requirements (operating resulting solution). |
| moox-log-any-perl |
0.004004 |
A logging role building a very lightweight wrapper to Log::Any for use with your Moo or Moose classes. Connecting a Log::Any::Adapter should be performed prior to logging the first log message, otherwise nothing will happen, just like with Log::Any |
| moox-options-perl |
4.103 |
Create a command line tool with your Moo, Moose objects. |
| moox-role-logger-perl |
0.005 |
This role provides universal logging via Log::Any. The class using this role doesn't need to know or care about the details of log configuration, implementation or destination. |
| moox-roles-pluggable-perl |
0.003 |
This module allows a class consuming several roles based on rules passed to Module::Pluggable::Object. |
| moox-types-mooselike-perl |
0.29 |
This module provides a possibility to build your own set of Moose-like types. These custom types can then be used to describe fields in Moo-based classes. |
| moox-typetiny-perl |
0.001003 |
This module optimizes Moo type checks when used with Type::Tiny to perform better. It will automatically apply to isa checks and coercions that use Type::Tiny. Non-Type::Tiny isa checks will work as normal. |
| mozilla-ca-perl |
20180117 |
Mozilla::CA provides a copy of Mozilla's bundle of Certificate Authority certificates in a form that can be consumed by modules and libraries based on OpenSSL. |
| mro-compat-perl |
0.13 |
The "mro" namespace provides several utilities for dealing with method resolution order and method caching in general in Perl 5.9.5 and higher. |
| multidimensional-perl |
0.013 |
Perl's multidimensional array emulation stems from the days before the language had references, but these days it mostly serves to bite you when you typo a hash slice by using the "$" sigil instead of "@". |
| namespace-autoclean-perl |
0.28 |
When you import a function into a Perl package, it will naturally also be available as a method. |
| namespace-clean-perl |
0.27 |
Keeping packages clean When you define a function, or import one, into a Perl package, it will naturally also be available as a method. This does not per se cause problems, but it can complicate subclassing and, for example, plugin classes that are included via multiple inheritance by loading them as base classes. |
| net-async-http-perl |
0.41 |
This object class implements an asynchronous HTTP user agent. It sends requests to servers, returning Future instances to yield responses when they are received. The object supports multiple concurrent connections to servers, and allows multiple requests in the pipeline to any one connection. Normally, only one such object will be needed per program to support any number of requests. |
| net-async-http-server-perl |
0.09 |
This module allows a program to respond asynchronously to HTTP requests, as part of a program based on IO::Async. An object in this class listens on a single port and invokes the "on_request" callback or subclass method whenever an HTTP request is received, allowing the program to respond to it. |
| net-dns-perl |
1.15 |
Net::DNS is a collection of Perl modules that act as a Domain Name System (DNS) resolver. It allows the programmer to perform DNS queries that are beyond the capabilities of "gethostbyname" and "gethostbyaddr". |
| net-http-perl |
6.17 |
The "Net::HTTP" class is a low-level HTTP client. An instance of the "Net::HTTP" class represents a connection to an HTTP server. The HTTP protocol is described in RFC 2616. The "Net::HTTP" class supports "HTTP/1.0" and "HTTP/1.1". |
| net-server-perl |
2.009 |
"Net::Server" is an extensible, generic Perl server engine. |
| net-ssleay-perl |
1.84 |
Net::SSLeay module contains perl bindings to openssl (<http://www.openssl.org>) library. |
| netaddr-ip-perl |
4.079 |
This module provides an object-oriented abstraction on top of IP addresses or IP subnets that allows for easy manipulations. Version 4.xx of NetAddr::IP will work with older versions of Perl and is compatible with Math::BigInt. |
| ntlm-perl |
1.09 |
This module provides methods to use NTLM authentication. It can be used as an authenticate method with the Mail::IMAPClient module to perform the challenge/response mechanism for NTLM connections or it can be used on its own for NTLM authentication with other protocols (eg. HTTP). |
| number-compare-perl |
0.03 |
Number::Compare compiles a simple comparison to an anonymous subroutine, which you can call with a value to be tested again. |
| number-tolerant-perl |
1.708 |
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. |
| object-tiny-perl |
1.08 |
There's a whole bunch of class builders out there. In fact, creating a class builder seems to be something of a rite of passage (this is my fifth, at least). |
| package-deprecationmanager-perl |
0.17 |
This module allows you to manage a set of deprecations for one or more modules. |
| package-stash-perl |
0.37 |
Manipulating stashes (Perl's symbol tables) is occasionally necessary, but incredibly messy, and easy to get wrong. This module hides all of that behind a simple API. |
| package-stash-xs-perl |
0.28 |
This is a backend for Package::Stash, which provides the functionality in a way that's less buggy and much faster. It will be used by default if it's installed, and should be preferred in all environments with a compiler. |
| padwalker-perl |
2.3 |
PadWalker is a module which allows you to inspect (and even change!) lexical variables in any subroutine which called you. It will only show those variables which are in scope at the point of the call. |
| params-util-perl |
1.07 |
"Params::Util\" provides a basic set of importable functions that makes checking parameters a hell of a lot easier |
| params-validate-perl |
1.29 |
The Params::Validate module allows you to validate method or function call parameters to an arbitrary level of specificity. I would recommend you consider using Params::ValidationCompiler instead. That module, despite being pure Perl, is *significantly* faster than this one, at the cost of having to adopt a type system such as Specio, Type::Tiny, or the one shipped with Moose. |
| params-validationcompiler-perl |
0.27 |
This module creates a customized, highly efficient parameter checking subroutine. It can handle named or positional parameters, and can return the parameters as key/value pairs or a list of values. |
| path-class-perl |
0.37 |
"Path::Class" is a module for manipulation of file and directory specifications (strings describing their locations, like '/home/ken/foo.txt' or 'C:\\Windows\\Foo.txt') in a cross-platform manner. It supports pretty much every platform Perl runs on, including Unix, Windows, Mac, VMS, Epoc, Cygwin, OS/2, and NetWare. |
| path-tiny-perl |
0.104 |
This module provides a small, fast utility for working with file paths. It is friendlier to use than File::Spec and provides easy access to functions from several other core file handling modules. It aims to be smaller and faster than many alternatives on CPAN, while helping people do many common things in consistent and less error-prone ways. |
| perl-tidy-perl |
20180220 |
This module makes the functionality of the perltidy utility available to perl scripts. Any or all of the input parameters may be omitted, in which case the @ARGV array will be used to provide input parameters as described in the perltidy(1) man page. |
| plack-middleware-fixmissingbodyinredirect-perl |
0.12 |
This module sets body in redirect response, if it's not already set. |
| plack-middleware-removeredundantbody-perl |
0.07 |
This module removes body in HTTP response, if it's not required. |
| plack-perl |
1.0047 |
Plack is a set of tools for using the PSGI stack. It contains middleware components, a reference server and utilities for Web application frameworks. Plack is like Ruby's Rack or Python's Paste for WSGI. |
| posix-strftime-compiler-perl |
0.42 |
POSIX::strftime::Compiler provides GNU C library compatible strftime(3). But this module will not affected by the system locale. This feature is useful when you want to write loggers, servers and portable applications. |
| probe-perl-perl |
0.03 |
This module provides methods for obtaining information about the currently running perl interpreter. It originally began life as code in the \"Module::Build\" project, but has been externalized here for general use. |
| ref-util-perl |
0.203 |
Ref::Util introduces several functions to help identify references in a smarter (and usually faster) way. In short: |
| ref-util-xs-perl |
0.117 |
Ref::Util::XS is the XS implementation of Ref::Util, which provides several functions to help identify references in a more convenient way than the usual approach of examining the return value of "ref". |
| regexp-common-perl |
2017060201 |
By default, this module exports a single hash (%RE) that stores or generates commonly needed regular expressions (see "List of available patterns"). |
| regexp-util-perl |
0.003 |
This module provides the following functions: |
| return-multilevel-perl |
0.05 |
This module provides a way to return immediately from a deeply nested call stack. This is similar to exceptions, but exceptions don't stop automatically at a target frame (and they can be caught by intermediate stack frames using "eval"). In other words, this is more like setjmp(3)/longjmp(3) than "die". |
| role-tiny-perl |
2.000006 |
"Role::Tiny" is a minimalist role composition tool. |
| rrdtool-oo-perl |
0.36 |
"RRDTool::OO\" is an object-oriented interface to Tobi Oetiker's round robin database tool *rrdtool*. It uses *rrdtool*'s \"RRDs\" module to get access to *rrdtool*'s shared library. |
| safe-isa-perl |
1.000008 |
Call isa, can, does and DOES safely on things that may not be objects |
| scalar-list-utils-perl |
1.50 |
"List::Util" contains a selection of subroutines that people have expressed would be nice to have in the perl core, but the usage would not really be high enough to warrant the use of a keyword, and the size so small such that being individual extensions would be wasteful. |
| scope-guard-perl |
0.21 |
This module provides a convenient way to perform cleanup or other forms of resource management at the end of a scope. It is particularly useful when dealing with exceptions: the "Scope::Guard" constructor takes a reference to a subroutine that is guaranteed to be called even if the thread of execution is aborted prematurely. This effectively allows lexically-scoped "promises" to be made that are automatically honoured by perl's garbage collector. |
| scope-upper-perl |
0.30 |
This module lets you defer actions *at run-time* that will take place when the control flow returns into an upper scope. Currently, you can: |
| sereal-decoder-perl |
4.005 |
This library implements a deserializer for an efficient, compact-output, and feature-rich binary protocol called *Sereal*. Its sister module Sereal::Encoder implements an encoder for this format. The two are released separately to allow for independent and safer upgrading. |
| sereal-encoder-perl |
4.005 |
This library implements an efficient, compact-output, and feature-rich serializer using a binary protocol called *Sereal*. Its sister module Sereal::Decoder implements a decoder for this format. The two are released separately to allow for independent and safer upgrading. If you care greatly about performance, consider reading the Sereal::Performance documentation after finishing this document. |
| server-starter-perl |
0.34 |
It is often a pain to write a server program that supports graceful restarts, with no resource leaks. Server::Starter solves the problem by splitting the task into two. One is start_server, a script provided as a part of the module, which works as a superdaemon that binds to zero or more TCP ports or unix sockets, and repeatedly spawns the server program that actually handles the necessary tasks (for example, responding to incoming connections). The spawned server programs under Server::Starter call accept(2) and handle the requests. |
| session-storage-secure-perl |
0.010 |
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. |
| socket-perl |
2.027 |
This module provides a variety of constants, structure manipulators and other functions related to socket-based networking. The values and functions provided are useful when used in conjunction with Perl core functions such as socket(), setsockopt() and bind(). It also provides several other support functions, mostly for dealing with conversions of network addresses between human-readable and native binary forms, and for hostname resolver operations. |
| specio-perl |
0.42 |
The "Specio" distribution provides classes for representing type constraints and coercion, along with syntax sugar for declaring them. |
| spiffy-perl |
0.46 |
"Spiffy\" is a framework and methodology for doing object oriented (OO) programming in Perl. Spiffy combines the best parts of Exporter.pm, base.pm, mixin.pm and SUPER.pm into one magic foundation class. It attempts to fix all the nits and warts of traditional Perl OO, in a clean, straightforward and (perhaps someday) standard way. |
| sql-statement-perl |
1.412 |
The SQL::Statement module implements a pure Perl SQL parsing and execution engine. While it by no means implements full ANSI standard, it does support many features including column and table aliases, built-in and user-defined functions, implicit and explicit joins, complex nested search conditions, and other features. |
| starman-perl |
0.4014 |
Starman is a PSGI perl web server that has unique features such as: |
| stream-buffered-perl |
0.03 |
Stream::Buffered is a buffer class to store arbitrary length of byte strings and then get a seekable filehandle once everything is buffered. It uses PerlIO and/or temporary file to save the buffer depending on the length of the size. |
| strictures-perl |
2.000003 |
I've been writing the equivalent of this module at the top of my code for about a year now. I figured it was time to make it shorter. |
| string-compare-constanttime-perl |
0.312 |
This module provides one function, "equals" (not exported by default). |
| string-rewriteprefix-perl |
0.007 |
rewrite strings based on a set of known prefixes |
| string-tagged-perl |
0.15 |
This module implements an object class, instances of which store a (mutable) string buffer that supports tags. A tag is a name/value pair that applies to some non-empty extent of the underlying string. |
| string-tagged-terminal-perl |
0.02 |
This subclass of String::Tagged provides a method, "build_terminal", for outputting the formatting tags embedded in the string as terminal escape sequences, to render the the output in the appropriate style. |
| struct-dumb-perl |
0.09 |
"Struct::Dumb" creates record-like structure types, similar to the "struct" keyword in C, C++ or C#, or "Record" in Pascal. An invocation of this module will create a construction function which returns new object references with the given field values. These references all respond to lvalue methods that access or modify the values stored. |
| sub-exporter-perl |
0.987 |
This module provides a number of utility functions for performing common or useful operations when setting up a Sub::Exporter configuration. All of the utilities may be exported, but none are by default. |
| sub-exporter-progressive-perl |
0.001013 |
Sub::Exporter is an incredibly powerful module, but with that power comes great responsibility, er- as well as some runtime penalties. This module is a "Sub::Exporter" wrapper that will let your users just use Exporter if all they are doing is picking exports, but use "Sub::Exporter" if your users try to use "Sub::Exporter"'s more advanced features, like renaming exports, if they try to use them. |
| sub-identify-perl |
0.14 |
"Sub::Identify" allows you to retrieve the real name of code references. |
| sub-info-perl |
0.002 |
Tool to inspect subroutines. |
| sub-install-perl |
0.928 |
This module makes it easy to install subroutines into packages without the unsightly mess of \"no strict\" or typeglobs lying about where just anyone can see them. |
| sub-name-perl |
0.21 |
This module has only one function, which is also exported by default: |
| sub-quote-perl |
2.005000 |
This package provides performant ways to generate subroutines from strings. |
| sub-uplevel-perl |
0.2800 |
Like Tcl's uplevel() function, but not quite so dangerous. The idea is just to fool caller(). All the really naughty bits of Tcl's uplevel() are avoided. |
| task-weaken-perl |
1.05 |
One recurring problem in modules that use Scalar::Util's "weaken" function is that it is not present in the pure-perl variant. |
| template-tiny-perl |
1.12 |
Template::Tiny is a reimplementation of a subset of the functionality from Template Toolkit in as few lines of code as possible. |
| template-toolkit-perl |
2.27 |
comprehensive template processing system |
| term-table-perl |
0.012 |
This is used by some failing tests to provide diagnostics about what has gone wrong. This module is able to generic format rows of data into tables. |
| test-base-perl |
0.88 |
Testing is usually the ugly part of Perl module authoring. Perl gives you a standard way to run tests with Test::Harness, and basic testing primitives with Test::More. After that you are pretty much on your own to develop a testing framework and philosophy. Test::More encourages you to make your own framework by subclassing Test::Builder, but that is not trivial. |
| test-cleannamespaces-perl |
0.22 |
This module lets you check your module's namespaces for imported functions you might have forgotten to remove with namespace::autoclean or namespace::clean and are therefore available to be called as methods, which usually isn't want you want. |
| test-deep-perl |
1.127 |
If you don't know anything about automated testing in Perl then you should probably read about Test::Simple and Test::More before preceding. Test::Deep uses the Test::Builder framework. |
| test-differences-perl |
0.64 |
When the code you're testing returns multiple lines, records or data structures and they're just plain wrong, an equivalent to the Unix "diff" utility may be just what's needed. Here's output from an example test script that checks two text documents and then two (trivial) data structures: |
| test-directory-perl |
0.041 |
Testing code can involve making sure that files are created and deleted as expected. Doing this manually can be error prone, as it's easy to forget a file, or miss that some unexpected file was added. This module simplifies maintaining test directories by tracking their status as they are modified or tested with this API, making it simple to test both individual files, as well as to verify that there are no missing or unknown files. |
| test-eol-perl |
2.00 |
This module scans your project/distribution for any perl files (scripts, modules, etc) for the presence of windows line endings. |
| test-exception-perl |
0.43 |
This module provides a few convenience methods for testing exception based code. It is built with Test::Builder and plays happily with Test::More and friends. |
| test-failwarnings-perl |
0.008 |
This module hooks $SIG{__WARN__} and converts warnings to Test::More \"fail()\" calls. It is designed to be used with \"done_testing\", when you don't need to know the test count in advance. |
| test-fatal-perl |
0.014 |
Test::Fatal is an alternative to the popular Test::Exception. It does much less, but should allow greater flexibility in testing exception-throwing code with about the same amount of typing. |
| test-file-perl |
1.443 |
This modules provides a collection of test utilities for file attributes. |
| test-file-sharedir-perl |
1.001002 |
Create a Fake ShareDir for your modules for testing. |
| test-identity-perl |
0.01 |
This module provides a single testing function, \"identical\". It asserts that a given reference is as expected; that is, it either refers to the same object or is \"undef\". It is similar to \"Test::More::is\" except that it uses \"refaddr\", ensuring that it behaves correctly even if the references under test are objects that overload stringification or numification. |
| test-leaktrace-perl |
0.16 |
"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 given blocks. |
| test-longstring-perl |
0.17 |
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 you. |
| test-memory-cycle-perl |
1.06 |
Verifies code hasn't left circular references |
| test-mockobject-perl |
1.20161202 |
It's a simple program that doesn't use any other modules, and those are easy to test. More often, testing a program completely means faking up input to another module, trying to coax the right output from something you're not supposed to be testing anyway. |
| test-mockrandom-perl |
1.01 |
This perhaps ridiculous-seeming module was created to test routines that manipulate random numbers by providing a known output from "rand". Given a list of seeds with "srand", it will return each in turn. After seeded random numbers are exhausted, it will always return 0. Seed numbers must be of a form that meets the expected output from "rand" as called with no arguments -- i.e. they must be between 0 (inclusive) and 1 (exclusive). In order to facilitate generating and testing a nearly-one number, this module exports the function "oneish", which returns a number just fractionally less than one. |
| test-mocktime-perl |
0.16 |
This module was created to enable test suites to test code at specific points in time. Specifically it overrides localtime, gmtime and time at compile time and then relies on the user supplying a mock time via set_relative_time, set_absolute_time or set_fixed_time to alter future calls to gmtime,time or localtime. |
| test-most-perl |
0.35 |
Test::Most exists to reduce boilerplate and to make your testing life easier. We provide "one stop shopping" for most commonly used testing modules. In fact, we often require the latest versions so that you get bug fixes through Test::Most and don't have to keep upgrading these modules separately. |
| test-needs-perl |
0.002005 |
Skip test scripts if modules are not available. The requested modules will be loaded, and optionally have their versions checked. If the module is missing, the test script will be skipped. Modules that are found but fail to compile will exit with an error rather than skip. |
| test-nowarnings-perl |
1.04 |
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 it occurred. |
| test-number-delta-perl |
1.06 |
At some point or another, most programmers find they need to compare floating-point numbers for equality. The typical idiom is to test if the absolute value of the difference of the numbers is within a desired tolerance, usually called epsilon. This module provides such a function for use with Test::More. Usage is similar to other test functions described in Test::More. Semantically, the \"delta_within\" function replaces this kind of construct: |
| test-output-perl |
1.031 |
Test::Output provides a simple interface for testing output sent to "STDOUT" or "STDERR". A number of different utilities are included to try and be as flexible as possible to the tester. |
| test-pod-perl |
1.51 |
Check POD files for errors or warnings in a test file, using \"Pod::Simple\" to do the heavy lifting. |
| test-refcount-perl |
0.08 |
The Perl garbage collector uses simple reference counting during the normal execution of a program. This means that cycles or unweakened references in other parts of code can keep an object around for longer than intended. To help avoid this problem, the reference count of a new object from its class constructor ought to be 1. This way, the caller can know the object will be properly DESTROYed when it drops all of its references to it. |
| test-regexp-perl |
2017040101 |
This module is intended to test your regular expressions. Given a subject string and a regular expression (aka pattern), the module not only tests whether the regular expression complete matches the subject string, it performs a "utf8::upgrade" or "utf8::downgrade" on the subject string and performs the tests again, if necessary. Furthermore, given a pattern with capturing parenthesis, it checks whether all captures are present, and in the right order. Both named and unnamed captures are checked. |
| test-requires-perl |
0.10 |
Test::Requires checks to see if the module can be loaded. |
| test-requiresinternet-perl |
0.05 |
Easily test network connectivity |
| test-script-perl |
1.23 |
The intent of this module is to provide a series of basic tests for 80% of the testing you will need to do for scripts in the script (or bin as is also commonly used) paths of your Perl distribution. |
| test-sharedfork-perl |
0.35 |
Test::SharedFork is utility module for Test::Builder. |
| test-simple-perl |
1.302130 |
** If you are unfamiliar with testing read Test::Tutorial first! ** |
| test-tcp-perl |
2.19 |
Test::TCP is a test utility to test TCP/IP-based server programs. |
| test-time-perl |
0.05 |
Test::Time can be used to test modules that deal with time. Once you "use" this module, all references to "time" and "sleep" will be internalized. You can set custom time by passing time => number after the "use" statement: |
| test-trap-perl |
v0.3.3 |
Primarily (but not exclusively) for use in test scripts: A block eval on steroids, configurable and extensible, but by default trapping (Perl) STDOUT, STDERR, warnings, exceptions, would-be exit codes, and return values from boxed blocks of test code. |
| test-warn-perl |
0.32 |
A good style of Perl programming calls for a lot of diverse regression tests. |
| test-warnings-perl |
0.026 |
If you've ever tried to use Test::NoWarnings to confirm there are no warnings generated by your tests, combined with the convenience of "done_testing" to not have to declare a test count, you'll have discovered that these two features do not play well together, as the test count will be calculated *before* the warnings test is run, resulting in a TAP error. (See "examples/test_nowarnings.pl" in this distribution for a demonstration.) |
| test-without-module-perl |
0.20 |
This module allows you to deliberately hide modules from a program even though they are installed. This is mostly useful for testing modules that have a fallback when a certain dependency module is not installed. |
| test-writevariants-perl |
0.014 |
Test::WriteVariants is a utility to create variants of a common test. |
| test-yaml-perl |
1.06 |
Test::YAML is a subclass of Test::Base with YAML specific support. |
| test2-plugin-nowarnings-perl |
0.06 |
Loading this plugin causes your tests to fail if there any warnings while they run. Each warning generates a new failing test and the warning content is outputted via "diag". |
| test2-suite-perl |
0.000106 |
Rich set of tools, plugins, bundles, etc built upon the Test2 testing library. If you are interested in writing tests, this is the distribution for you. |
| text-csv-perl |
1.95 |
Text::CSV is a thin wrapper for Text::CSV_XS-compatible modules now. All the backend modules provide facilities for the composition and decomposition of comma-separated values. Text::CSV uses Text::CSV_XS by default, and when Text::CSV_XS is not available, falls back on Text::CSV_PP, which is bundled in the same distribution as this module. |
| text-csv-xs-perl |
1.34 |
Text::CSV_XS provides facilities for the composition and decomposition of comma-separated values. An instance of the Text::CSV_XS class will combine fields into a "CSV" string and parse a "CSV" string into fields. |
| text-diff-perl |
1.45 |
"diff()" provides a basic set of services akin to the GNU "diff" utility. It is not anywhere near as feature complete as GNU "diff", but it is better integrated with Perl and available on all platforms. It is often faster than shelling out to a system's "diff" executable for small files, and generally slower on larger files. |
| text-glob-perl |
0.11 |
Text::Glob implements glob(3) style matching that can be used to match against text, rather than fetching names from a filesystem. If you want to do full file globbing use the File::Glob module instead. |
| time-hires-perl |
1.9754 |
The "Time::HiRes" module implements a Perl interface to the "usleep", "nanosleep", "ualarm", "gettimeofday", and "setitimer"/"getitimer" system calls, in other words, high resolution time and timers. See the "EXAMPLES" section below and the test scripts for usage; see your system documentation for the description of the underlying "nanosleep" or "usleep", "ualarm", "gettimeofday", and "setitimer"/"getitimer" calls. |
| timedate-perl |
2.30 |
"Date::Parse" provides two routines for parsing date strings into time values. |
| try-tiny-perl |
0.30 |
This module provides bare bones "try"/"catch"/"finally" statements that are designed to minimize common mistakes with eval blocks, and NOTHING else. |
| type-tie-perl |
0.009 |
This module exports a single function: \"ttie\". \"ttie\" ties a variable to a type constraint, ensuring that whatever values stored in the variable will conform to the type constraint. If the type constraint has coercions, these will be used if necessary to ensure values assigned to the variable conform. |
| type-tiny-perl |
1.002001 |
Type::Tiny is a tiny class for creating Moose-like type constraint objects which are compatible with Moo, Moose and Mouse. |
| type-tiny-xs-perl |
0.012 |
This module is optionally used by Type::Tiny 0.045_03 and above to provide faster, C-based implementations of some type constraints. (This package has only core dependencies, and does not depend on Type::Tiny, so other data validation frameworks might also consider using it!) |
| unicode-linebreak-perl |
2017.004 |
Unicode::LineBreak performs Line Breaking Algorithm described in Unicode Standard Annex #14 [UAX #14]. East_Asian_Width informative property defined by Annex #11 [UAX #11] will be concerned to determine breaking positions. |
| unicode-utf8-perl |
0.62 |
This module provides functions to encode and decode UTF-8 encoding form as specified by Unicode and ISO/IEC 10646:2011. |
| universal-can-perl |
1.20140328 |
The UNIVERSAL class provides a few default methods so that all objects can use them. Object orientation allows programmers to override these methods in subclasses to provide more specific and appropriate behavior. |
| universal-isa-perl |
1.20171012 |
Whenever you use "isa" in UNIVERSAL as a function, a kitten using Test::MockObject dies. Normally, the kittens would be helpless, but if they use UNIVERSAL::isa (the module whose docs you are reading), the kittens can live long and prosper. |
| unix-statgrab-perl |
0.111 |
Unix::Statgrab is a wrapper for libstatgrab as available from <http://www.i-scream.org/libstatgrab/>. It is a reasonably portable attempt to query interesting stats about your computer. It covers information on the operating system, CPU, memory usage, network interfaces, hard-disks etc. |
| uri-perl |
1.73 |
This module implements the "URI" class. Objects of this class represent "Uniform Resource Identifier references" as specified in RFC 2396 (and updated by RFC 2732). |
| uri-simple-perl |
1.00 |
This module is a direct port of javascript parseURI regex by Steven Levithan Please See Original Code <http://blog.stevenlevithan.com/archives/parseuri> |
| url-encode-perl |
0.03 |
This module provides functions to encode and decode strings into and from the \"application/x-www-form-urlencoded\" encoding. |
| url-encode-xs-perl |
0.03 |
The main URL::Encode package will use this package automatically if it can find it. Do not use this package directly, use URL::Encode instead. |
| variable-magic-perl |
0.62 |
Magic is Perl's way of enhancing variables. This mechanism lets the user add extra data to any variable and hook syntactical operations (such as access, assignment or destruction) that can be applied to it. With this module, you can add your own magic to any variable without having to write a single line of XS. |
| www-form-urlencoded-perl |
0.24 |
WWW::Form::UrlEncoded provides application/x-www-form-urlencoded parser and builder. This module aims to have compatibility with other CPAN modules like HTTP::Body's urlencoded parser. |
| www-robotrules-perl |
6.02 |
This module parses /robots.txt files as specified in \"A Standard for Robot Exclusion\", at <http://www.robotstxt.org/wc/norobots.html> Webmasters can use the /robots.txt file to forbid conforming robots from accessing parts of their web site. |
| xml-namespacesupport-perl |
1.12 |
This module offers a simple 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 checks. |
| xml-sax-base-perl |
1.09 |
This module has a very simple task - to be a base class for PerlSAX drivers and filters. It's default behaviour is to pass the input directly to the output unchanged. It can be useful to use this module as a base class so you don't have to, for example, implement the characters() callback. |
| xml-sax-expatxs-perl |
1.33 |
XML::SAX::ExpatXS is a direct XS extension to Expat XML parser. It implements Perl SAX 2.1 interface. See http://perl-xml.sourceforge.net/perl-sax/ for Perl SAX API description. Any deviations from the Perl SAX 2.1 specification are considered as bugs. |
| xml-sax-perl |
1.00 |
XML::SAX is a SAX parser access API for Perl. It includes classes and APIs required for implementing SAX drivers, along with a factory class for returning any SAX parser installed on the user's system. |
| yaml-libyaml-perl |
0.69 |
Kirill Siminov's "libyaml" is arguably the best YAML implementation. The C library is written precisely to the YAML 1.1 specification. It was originally bound to Python and was later bound to Ruby. |
| yaml-perl |
1.24 |
The YAML.pm module implements a YAML Loader and Dumper based on the YAML 1.0 specification. <http://www.yaml.org/spec/> |