CPANscan

Dist::Zilla::App::Command::cover is a Dist::Zilla plugin that adds a "cover" command to generate test coverage reports for your Perl distribution using Devel::Cover. It runs only after your normal tests pass and deliberately ignores author and release tests so those checks do not skew your coverage numbers. You can pass extra arguments to the underlying cover tool and direct output to a chosen directory. The module is available on CPAN and the development source is hosted on GitHub. Recent updates include a new maintainer, documentation fixes, and a switch to loading dependencies at runtime to reduce upfront loading.

Net::Connection::ncnetstat is the Perl backend used by ncnetstat to produce a colorized, enhanced netstat-style display for programs and scripts. It gathers connection information (using lsof or sockstat depending on the platform), formats it into a table, and exposes options to show or hide process commands, use full command lines, suppress PID and user columns, apply match filters via Net::Connection::Match, and control sorting via Net::Connection::Sorter; you instantiate the object with the desired options and call run to get the formatted output string. The 0.8.0 release stopped attempting to sort by default. If you want scriptable, programmatic network-connection listings with filtering and nicer formatting this module is a good match, though the author notes future work to add more collection methods and configurable colors and column ordering.

Net::Connection::Linux_ss is a small utility that builds Net::Connection objects by parsing the output of the Linux ss command, typically running ss -p4an and ss -p6an to enumerate IPv4 and IPv6 sockets, or accepting those outputs as input strings for non‑Linux environments. It can optionally resolve port names, reverse DNS PTRs, and user names, and can enrich results with process details from Proc::ProcessTable and /proc so you get more complete information about owning processes, CPU and memory usage, and start times. The module returns one Net::Connection object for each process listed against a socket, matching lsof behavior so shared sockets may appear multiple times, and it skips sockets with no associated process by default to avoid undefined PIDs. Use this when you need a programmatic, Perl-native inventory of active network connections and the processes that own them on Linux.

Net::Connection::FreeBSD_sockstat converts the output of FreeBSD's "sockstat -46s" into Net::Connection objects so you can programmatically examine active TCP and UDP sockets. It offers simple flags to control whether port names and PTRs are resolved, whether to enrich entries from the process table, whether to skip zombie-style placeholder lines, and it can parse a supplied string instead of running sockstat for testing or non-FreeBSD use. The module is FreeBSD-focused and will die if you try to invoke sockstat on another OS unless you pass a string to parse. The most recent release fixed a missing dependency by adding Proc::ProcessTable.

Net::Connection::lsof is a small utility that runs the system lsof command and converts active TCP and UDP socket listings into Perl Net::Connection objects, making it easy to programmatically inspect local network connections. Call lsof_to_nc_objects to receive an array of Net::Connection objects and optionally pass a hash reference to control whether port names, reverse DNS PTRs, UID-to-username resolution, and extra process information are resolved or skipped. All those resolutions are enabled by default. The module shells out to lsof so lsof must be available on the host and the call will die if lsof exits with a nonzero status. Use this module when you want a quick, structured snapshot of system network sockets inside a Perl script.

Net::Connection::Sort is a lightweight Perl helper that sorts arrays of Net::Connection objects by common connection attributes, making it easier to present or analyze lists of network connections. You create a sorter with new by specifying a sort type and an optional invert flag, then call sorter with an array reference to receive the sorted objects. The module offers sorts for hosts, ports, protocol, process id, connection state, user id or name and an unsorted pass through, and it validates the requested type so only the documented options are allowed. The recent 0.2.0 release fixes a bug so the invert option is actually honored, closes a potential code injection vector in sort type selection, improves port and host sorting including handling of IPv6 zone ids, and requires Net::Connection 0.2.0 or newer. If you write tools that inspect or display connection tables this module saves you from rolling your own sorting logic.

Net::Connection::Match is a helper for filtering Net::Connection objects by running a configurable stack of checks and returning a simple boolean match result. You create it with a list of checks, each named after a Net::Connection::Match::* test and optionally inverted, and then call match with a Net::Connection instance to see if it passes the tests; if you supply no checks it defaults to an All test that always matches. Common checks cover ports, protocols, PTR lookups, CPU and memory usage and other connection attributes, so this module is useful when building monitoring, auditing or connection-handling tools that need to select sockets or processes by those properties. Errors from checks are reported via Error::Helper and recent updates improve cross-platform memory detection on BSDs, tighten argument validation, and change match behavior so a failing check raises an error instead of silently acting as a non-match.

Google::Auth is a small Perl library that handles Application Default Credentials and project ID detection so your Perl programs can authenticate to Google Cloud services without manual token handling. It provides an easy object interface and a default($scopes, $options) method that returns the appropriate credentials for the current environment, which is handy for local development, CI pipelines, or cloud-hosted services that rely on standard Google credential sources. The module is maintained by Google, is part of the google-auth-library-perl family, and is distributed under the Apache 2.0 license with issue tracking on GitHub and CPAN.

BATsh is a pure‑Perl bilingual shell that lets you write and run scripts mixing Windows batch (cmd.exe) and POSIX shell (bash/sh) syntax in the same file, with automatic line‑by‑line mode switching and a shared variable store so values set in one mode are immediately visible in the other. It implements most common cmd and sh builtins, pipelines, redirection, functions, arrays, command substitution, traps, interactive input, a REPL, inline source execution, and proper exit status propagation, and it runs entirely inside Perl so no external cmd or bash is required. The module includes encoding support and auto-detects CP932/Shift_JIS for Japanese Windows scripts, returns the script exit code for use in programs, and installs a command‑line wrapper for direct invocation. Not everything is reimplemented though, so nonbuiltins are invoked as external programs and therefore depend on the host OS, a few niche cmd features and some shell job control behaviors are limited or unimplemented, and you need Perl 5.005_03 or later.

Data::Displaycolour is a small Perl helper for assigning consistent display colours to arbitrary subjects such as usernames, real names, emails, free text or objects, making it easy for applications to pick a reproducible RGB or named colour for things that need visual identity. You create an instance with the subject or an explicit colour and the module will return an origin, abstract or specific colour or a concrete "#rrggbb" RGB value, with support for selectable palettes and language-aware lookups via the Data::Identifier ecosystem. It is useful when you want deterministic, human-friendly colours for people, items or messages without hand-picking values, and it can also list known palettes and colours so you can discover what it will choose. The package is still marked experimental in parts, notably palette matching, explicit import options and the new mark/register features introduced in v0.06 that let you register colours and tag objects for later retrieval, so expect refinements in future releases.

Data::Entropy provides a simple, globally accessible way to nominate an entropy source so algorithms that need randomness can obtain it without threading source objects through every call. It exposes entropy_source to read the current source and with_entropy_source to temporarily select a different source for the dynamic scope of a code block, which makes it convenient when a single entropy source is used across a program. The module ships with a reasonable default (an AES counter-mode generator seeded from a secure RNG) but it is now deprecated, and for most uses especially cryptography you should prefer modern alternatives such as Crypt::URandom, Crypt::SysRandom or Crypt::PRNG. Recent updates focused on security by seeding the default generator from Crypt::URandom and switching networked random-number services to HTTPS.

Test::RedisServer makes it easy to spawn a real redis-server for integration tests so your code can exercise a live Redis instance without manual setup. It starts a temporary server by default, accepts redis.conf options as a simple Perl hash, and returns a connect_info blob you can feed directly to the Redis client module. You can disable auto-start and use start, exec or stop to integrate with Test::TCP or other test harnesses, and the object cleans up the server and temp files on destruction while also exposing pid and wait_exit for finer control. The module is maintained to work with modern Redis and Perl releases and recent updates fixed tmpdir handling and a compatibility issue with newer Perl Time::HiRes behavior while improving tests and CI. If your tests need a disposable, configurable Redis process rather than a mock, this module is a straightforward choice, but note it requires the redis-server binary to be present on the test system.

Devel::MAT::Dumper is a small utility module that writes a snapshot of a running Perl process to disk so you can inspect its heap later with Devel::MAT::Dumpfile and related tools. It provides non-exported functions to write a PMAT-format heap dump to a file or filehandle and can be configured at import time to automatically dump on die, warn, END, or on receipt of signals (including an unsafe SIGABRT handler to capture native/XS context). You can control the output filename (with an NNN token for unique numbering), the maximum string length to capture, and whether the file is opened eagerly. The module is useful for diagnosing memory leaks, crashes, and mysterious runtime state on production or remote systems where analysis tools may not be installed. It was split out from the main Devel::MAT distribution so the dumper can be deployed independently. Recent updates add support for Perl internals changes such as Magic v2 from Perl 5.45.2 and related bug fixes to stay compatible with newer Perls.

Hyperman is a high-performance PSGI web server that combines a prefork supervisor with a per-worker event loop to run Plack apps efficiently. You start it with your PSGI app and a worker count and it can handle synchronous responses or async ones via Hyperman::Future so handlers can await timers or I/O without blocking the worker. It supports HTTP/2 (via nghttp2) and TLS with client-cert verification and SNI when built with the appropriate libraries, and it exposes simple timer and io_ready futures plus per-worker stats for introspection. A supervisor process manages worker lifecycles with zero-downtime reload and graceful shutdown, and the implementation is mostly XS/C for low-level performance. If you need extreme throughput for Perl web apps and want built-in async, HTTP/2, and TLS support, Hyperman is worth evaluating, but note that per-worker SO_REUSEPORT accepts scaling can behave differently on macOS so that option is off by default there.

ACME::Base64::Hexagram is a playful Perl module that implements a Base64-style encoding using the 64 I Ching hexagrams as its symbol set. It exposes two simple functions, encode_base64h and decode_base64h, to convert strings to and from a hexagram-based representation, so you can produce a whimsical or obfuscated form of data instead of standard Base64. The mapping follows the King Wen order of hexagrams, a detail clarified in the latest release, and the module is best suited for novelty, themed output, or lighthearted obfuscation rather than serious cryptography.

App::plx is a lightweight command-line helper for creating and using per-project Perl execution environments so you can run your app, tests, or one-liners with the right perl, library paths, and environment without manual fiddling. It records a project layout in a .plx directory, lets you choose or resolve a specific perl binary, composes ordered local::lib and lib directories via simple "libspec" entries, and prepends the appropriate entries to PATH and PERL5LIB while clearing other PERL* variables to keep runs hermetic. Once initialized you can run scripts and commands with a single plx myapp or plx --perl ..., inspect or print the environment with --env, bootstrap dependencies with a layout-aware --cpanm helper, and fine tune configs with --config, --which and --commands. There are convenience modes for bare or user-level setups, ways to install plx into the layout and append a shell hook, and a packed standalone script if you lack cpanm. Note that the bundled --cpanm usage is intended mainly for bootstrapping and requires specifying a local::lib target, and the automatic shell install currently supports bash only.

App::BlurFill::Web is a lightweight web frontend for App::BlurFill that lets users upload an image, specify output width and height, and receive a blurred version in the browser or as a downloadable file. It provides a simple root form for uploads, a POST /blur endpoint that processes the image and returns an HTML result page with a download link, and a GET /download/:filename route to fetch the processed image. Defaults are 650 by 350 pixels but both dimensions can be overridden, and it runs as a PSGI application so you can mount it in any Perl web stack or run the provided Dancer2 container. This release separates the web interface into its own distribution and the recent 0.1.0 update pins App::BlurFill 0.1.0 and adopts a dedicated web container for easier deployment.

App::BlurFill is a small Perl library and command line tool for quickly creating blurred background images from an existing picture. You point it at an input file and specify an output width and height (defaults are 650 by 350), and it scales the image, applies a Gaussian blur, and writes a new image, returning the path to the saved file. If you do not provide an output filename it generates one beside the original with a "_blur" suffix. The web interface was split into a separate App::BlurFill::Web distribution, so installing this module gives you a lightweight Perl API and the blurfill command without pulling in web frameworks such as Dancer2, Plack, or Starman.

App::ElasticSearch::Utilities bundles a collection of Perl command-line tools and a compact library to simplify interacting with Elasticsearch and OpenSearch clusters. It provides ready-made scripts for searching and aggregating index contents, monitoring cluster and node metrics, performing index maintenance and alias management, and copying or applying settings across indices, while also exposing a programmatic API so you can write your own Perl utilities using helpers like es_connect and es_request. The toolkit supports TLS and basic auth with a secure password-exec mechanism, pattern and date-aware index selection, human-friendly size and count formatting, and a noop mode to avoid accidental changes, with configuration driven by simple YAML files. The recent 9.0 release refactors connection handling and centralizes version detection into a Connection component to improve compatibility with different server versions and produce clearer error messages.

Data::Identifier is a format‑independent identifier object that gives you a single, consistent way to work with many kinds of identifiers such as UUIDs, OIDs, URIs and other well known types like GTIN, IBAN and DOI. It stores both the raw value and its type, offers conversion and normalization routines, can generate new identifiers, and provides helpers to extract or produce UUID/OID/URI/ISE forms, compare and sort identifiers, and supply human friendly names or persistent tagnames. The module does some validation and deduplication but does not guarantee to catch every invalid value so you should not rely on it as the sole validator. There are performance knobs such as the experimental option to disable OID support and a register method to cache frequently used identifiers. Recent changes in v0.32 add a global allow_use option to permit selected helper modules, improved support for subobjects, and a digest algorithm generator to expand generation options.

Map::Tube::Plugin::Graph is a Moo role that plugs into the Map::Tube family to turn tube network data into graph objects and rendered maps. It can produce a multiedged Graph object for programmatic graph analysis or hand that graph to GraphViz2 to generate images of an entire network or a single line. You can render PNG, SVG, PDF, DOT/GV and other formats, pick layout engines like dot or neato, output to a file or STDOUT, or return base64-encoded image data for embedding. Key methods are as_graph to get the Graph, render for flexible output, as_png and as_image convenience helpers, and list_drivers/list_formats to discover available GraphViz options. The module requires the GraphViz2 Perl interface and the GraphViz executables, so you need GraphViz installed and Perl 5.8.8 or newer. It is a good fit if you want to visualize or export tube-style maps and also do graph-theory work on the network.

Convert::Pheno is a Perl conversion engine for clinical and phenotypic data that lets you translate between common standards such as Beacon v2 Models Format (BFF), Phenopackets v2 (PXF), OMOP-CDM, REDCap, CDISC-ODM, CDISC Dataset-JSON, FHIR R4, openEHR and simple tabular forms. It is the library behind the convert-pheno command line tool and can operate on decoded in-memory Perl data structures or on file/stream routes, returning converted structures for in-memory calls or writing output and returning a completion status for streaming and file-based routes. You create a converter with Convert::Pheno->new and specify the route via the method argument; mapping-based conversions require Mapping V2 files and older mapping formats are rejected. Failures and unsupported inputs raise exceptions so callers should wrap conversions in eval or other error handling. Full usage details, examples and the project citation are provided in the project documentation.

Net::NATS2::Client is a compact Perl client for the NATS messaging system that makes it easy to connect to a NATS server, publish messages, subscribe asynchronously, and perform request/reply interactions. It supports message headers and header-aware publish and receive operations, optional TLS via IO::Socket::SSL options, configurable read buffer size, and synchronous request waiting for use cases like JetStream APIs, while JetStream features are accessed through a companion Net::NATS2::JetStream module. The client can be configured to attempt automatic reconnection and will restore subscriptions on reconnect, but reconnection is off by default and failed publishes are not retried automatically to avoid accidental duplicate delivery. UTF-8 flagged strings are encoded to UTF-8 when sent so text payloads behave as expected. The module is actively maintained under the MIT license.

Number::ZipCode::JP is a lightweight Perl module for validating Japanese postal codes against Japan Post rules. It accepts common input styles such as a single 7-digit string, a hyphenated form like 100-0001, or separate area and suffix parts, and lets you restrict checks to area-specific codes, company or P.O. box codes, or both. You create an object, set or change the target zip code, optionally import the category table you need, and call is_valid_number to get a simple true or false answer. The module ships with maintainable tables and is updated regularly to track postal changes, making it a handy choice for scripts and applications that need to verify Japanese addresses before processing or storing them.

Common::CodingTools is a lightweight utility module that bundles a handful of ready-made constants and small helper functions you will often reimplement in scripts, making common checks and text/file operations trivial to import and use. It provides named boolean and status constants like TRUE/FALSE, ON/OFF, ACTIVE/INACTIVE, CLEAN/DIRTY and others for clearer code, plus grouped import tags so you can pull in only what you need. Useful convenience functions include slurp_file for reading a whole file into a string, ltrim/rtrim/trim for trimming whitespace, center for basic text centering, tfirst for title-casing, schwartzian_sort for fast custom sorting, and uc_lc/leet_speak for playful case transformations. Recent updates fixed the Schwartzian sort and added the leet_speak alias, and the module is aimed at scripts and small projects that want readable constants and a few handy text and file utilities without pulling in heavier dependencies.

MojoX::Authentication is a batteries-included helper for Mojolicious applications that simplifies common authentication needs by offering local credential logins (in-memory or SQLite) and SAML 2.0 single sign-on support. It wires into your app with an app_startup helper that installs the authentication plugin and injects the current user into the stash, and it exposes opinionated controller helpers for credential login, logout, initiating SAML2 redirects and handling the SAML2 SSO response. You can supply or let it discover a model object, configure the stash key used for templates, and set a default provider name for SAML workflows which assumes a single identity provider by default. The module aims to get you up and running quickly with sensible defaults while still letting you override routes and models as needed, and it requires Perl 5.24 or newer.

Schedule::Cron lets you embed a cron-like scheduler inside a Perl program so you can call Perl subroutines on crontab-style schedules rather than spawning separate scripts with system cron. You define jobs with familiar five- or six-field crontab expressions, add or remove entries at runtime, and choose whether each entry uses a default dispatcher or a specific subroutine with arguments passed literally or via eval. The module supports daemonizing, optional forking so each job runs in its own process, a nofork mode for in-process execution, logging hooks, a customizable sleep hook for integrating IO, and utilities to list, update or compute next run times. It also offers convenience features like a global timeshift and control over process name and logging verbosity. One caveat is daylight savings handling around the backward clock change, which the authors note can produce inconsistent behavior depending on time zone due to the underlying date parser. If you need a lightweight, flexible scheduler inside a long-running Perl program with dynamic job control, Schedule::Cron is a solid fit.

Net::SAML2 is a Perl toolkit for implementing the SAML 2.0 Web Browser SSO flow on the Service Provider side, letting your app build and sign AuthnRequests, generate SP metadata, handle Redirect, POST and SOAP bindings, decrypt EncryptedAssertions and verify IdP responses. It handles common tasks like creating redirect URLs, parsing POSTed SAML responses, validating signatures and metadata, and integrates with many IdPs such as Auth0, Azure, Google, Okta and Shibboleth, so it is useful if you need to integrate Perl web apps with SAML identity providers. Note that it is SP-only and expects XML metadata from the IdP. Recent releases include important security hardening that defends against XML signature wrapping and now require a trust anchor (cacert or cert_text) to validate Responses and Assertions, so upgrading is strongly recommended if you rely on response verification.

XML::Sig is a Perl toolkit for creating and verifying W3C XML Digital Signatures, useful when you need to authenticate or tamper-proof XML documents or fragments such as SAML messages. It can insert signatures into XML or verify signatures already present, supports RSA, DSA, ECDSA and HMAC methods and can embed X.509 certificates, and it understands the usual canonicalization methods and transforms needed so signatures remain valid across equivalent XML serializations. The API is straightforward with sign($xml) to produce signed XML and verify($xml) to check signatures, it can sign elements identified by an ID or by an xpath via id_attr, and after verification you can retrieve the embedded signer certificate. The recent 0.71 release includes important security fixes that enforce a safe subset of characters for ID attributes and reject duplicate or ambiguous ID references, making signature verification more robust. If you work with SAML, XML-based protocols, or any system that must sign or validate XML at the element level, this module is likely relevant.

Task::WebDyne::PAGI is a simple task-style meta-distribution that bundles and installs the Perl modules needed to use PAGI together with WebDyne, saving you from tracking down each prerequisite manually. Install it with cpan or cpanm and it will pull in the required dependencies so you can get on with building your application rather than resolving module requirements. The package is maintained by Andrew Speer and is distributed under the same license terms as Perl itself.