CPANscan

Business::ISBN::Data is a companion data pack for Business::ISBN that supplies the official ISBN range information derived from the ISBN Agency RangeMessage.xml file so the main module can validate and parse ISBN group and publisher ranges. It is normally auto-loaded by Business::ISBN and can be overridden by setting the ISBN_RANGE_MESSAGE environment variable or by placing an updated RangeMessage.xml where the module can find it, otherwise the code falls back to bundled data or a RangeMessage.xml in the current directory. You must use Business::ISBN 3.005 or later because the data structure changed to fix an ISBN-13 issue. The distribution includes the XML and a helper script to regenerate the default data, and the project is maintained on GitHub for updates and contributions.

SimpleFlow is a lightweight Perl workflow manager and logger that helps you run, track, and debug complex shell-command pipelines from within Perl scripts. You define tasks by giving a command and optional hints such as input.files, output.files, overwrite, die, note, and a log filehandle, and each task runs the command, verifies required inputs and expected outputs, captures stdout and stderr, records duration and exit status, and returns a structured hash with diagnostics and provenance. It is designed to prevent needless re-runs of completed steps, to make failures easy to spot, and to keep concise, machine-readable logs for troubleshooting. If you build multi-step, file-centric pipelines in Perl and want simple orchestration and reliable logging without adopting an external engine, SimpleFlow provides a minimal, familiar interface similar in spirit to Snakemake or Nextflow but native to Perl.

Net::DNS is a mature Perl library for doing everything from simple lookups to full DNS programming that go beyond gethostbyname and gethostbyaddr, offering Resolver objects to send queries, Packet and RR objects to inspect answers and authority/additional sections, and helpers for MX, NS, A/AAAA lookups, zone transfers, asynchronous queries, dynamic DNS updates and zone serial management. It is useful when you need programmatic control over DNS queries or to build or apply dynamic update packets from Perl and includes utilities for sorting RR arrays and creating prerequisites for updates. The module is well established and powerful for scripting and automation but the authors note it can be slower than some alternatives.

Class::Abstract is a tiny helper for plain-Perl object systems that lets you declare a package as an abstract base so it cannot be instantiated directly while still allowing concrete subclasses to call SUPER::new and build real objects. You make a class abstract by adding Class::Abstract to its @ISA with either use parent 'Class::Abstract' or use Class::Abstract and then the module's new will croak if you try to instantiate that abstract class but will return a blessed empty hashref for concrete subclasses. It provides check_abstract for cases where an abstract class overrides new, an is_abstract method to test direct abstract status, and a configurable bypass mechanism to ease testing under harnesses. Note that it only treats a class as abstract when Class::Abstract is directly in its @ISA, the base new discards any constructor arguments so subclasses must populate attributes themselves, and this module is intended for plain-Perl OO rather than Moo or Moose users.

Perl::Critic::Policy::Variables::ProhibitUnusedVarsStricter is a standalone Perl::Critic policy that enforces a tougher check for unused lexical variables in Perl code. It flags lexicals that are declared but never used outside their declaration, while trying to respect lexical scope and common Perl idioms. The policy understands variables interpolated into double-quoted strings and regexes, variables used inside regex code blocks and in s///e replacements, and variables appearing in subroutine signatures. By default it permits globals, variables that are only referenced at creation, and lexicals explicitly returned from subs, and it offers configurable options to change those behaviors or to allow certain computed initializations. Some edge cases are not reported because of limitations in the underlying PPI parser, but overall this module is useful if you want a stricter, configurable check to keep your Perl code free of dead lexical variables.

Test::Pod::LinkCheck::Lite is a lightweight testing tool for Perl authors that scans POD documentation and flags broken links, producing one failing test per broken link or one passing test if none are found, so you must finish with Test::More's done_testing. It is designed for author-time checks rather than installation-time tests and supports checking URLs, man page links, internal and external POD references, Perl builtins, and resolving modules via local or online CPAN indices, with options to cache URL responses, ignore specific URLs, skip server 5xx errors, and control redirect behavior. The module deliberately keeps non-core dependencies to a minimum and avoids spawning many shell commands, but HTTPS checks require optional SSL modules and man links depend on a working man command so those cases may be skipped on some systems. The author notes the code is still alpha-quality and documents sensible defaults and toggles so you can tailor which link kinds are verified for your project.

Test2::Tools::LoadModule is a small Test2::V0 helper for asserting that a Perl module can be loaded, optionally checking its version and requested imports, and for skipping or aborting tests when loading fails. It restores familiar Test::More-style helpers like require_ok and use_ok and provides load_module_ok which records which modules were tried and can be invoked in a BEGIN block when imports must affect compilation. You can skip a fixed number of tests or skip the entire run if a dependency is missing, and all_modules_tried_ok will scan lib/blib directories to ensure every .pm under those paths was exercised by load_module_ok. The module offers POSIX-style options to configure behavior and to format load-error diagnostics. Note that accurate load testing is tricky so you can get false passes if the test helper itself pulls in a missing dependency, and you may need to adjust load order when integrating with non-Test2 testing tools.

MARC::Field008 is a small utility class for working with the fixed-length MARC 008 control field, letting you parse an 008 string into a structured Data::MARC::Field008 object and serialize that object back into the 40-character field string. It understands material-specific layouts such as books, music, maps and visual materials so parsed data is returned as the appropriate subobject, and it accepts a MARC leader when you need context-sensitive parsing. The constructor accepts options to control behavior, including a mode_strict flag that lets the parser tolerate dashes in place of spaces and an ignore_data_errors flag to suppress validation failures from the material objects. Recent updates improved error handling and added the dash-tolerant parsing mode, making the module more robust for real-world MARC data. If you work with bibliographic records or build tools that manipulate MARC metadata, this module makes handling the 008 field simple and reliable.

Data::Dumper::Interp is a polished, human-friendly wrapper around Data::Dumper that produces compact, readable representations of Perl scalars, arrays, hashes and objects and lets you interpolate those representations directly into strings with ivis and dvis. It folds output to terminal width when needed, prints printable Unicode characters normally, shows code refs with the referenced sub name, formats common object types by stringification rather than dumping internals by default, and can show abbreviated reference addresses with addrvis. You can call simple helpers vis, avis and hvis to format one value, lists or key/value pairs, or create a visnew object and tune many options as methods or globals. A flexible naming convention generates modifier-flavored variants on demand so you can ask for features like quoted strings, visible spaces, hex display, depth limits or object-internals by name. It also provides shell-quoting helpers (qsh, qshpath, qshlist), Carp integration to format ref args in tracebacks, and utilities such as quotekey and u to handle undef. Note that ivis/dvis evaluate expressions via Perl’s debugger hooks so some lexicals and @_ may not always appear exactly as in your running subroutine. Recent maintenance releases focused on robustness and diagnostics, for example simplifying dvis interpolation error messages and preventing recursion via localized Carp settings.

Cucumber::TagExpressions is a small Perl library that parses Cucumber-style tag expressions and produces an evaluator you can use to decide whether a Gherkin scenario’s tags match a filter. You give it a human-readable expression like "@fast and not @wip" and it returns an ExpressionNode object with an evaluate method that accepts a list of tags and returns true or false, which makes it handy for test runners, custom filtering tools, or any workflow that needs to include or exclude scenarios by tag. The module is part of the cross-language tag-expressions family used by Cucumber and is MIT licensed. Recent maintenance has focused on packaging and release quality for the Perl build so it is easier to install and include in CI.

Config::IniFiles is a mature Perl utility for reading, editing and writing human-friendly INI-style configuration files. It gives both an object API and a tied-hash interface so you can fetch and set values by section and parameter, handle multi-line values and here-doc style blocks, preserve and manage comments and trailing comments, use default or fallback sections, toggle case sensitivity, and import or overlay one configuration on top of another with optional delta-only writes for compact site-specific files. The module accepts filenames, filehandles or scalar refs and includes helpers to add, copy, rename or delete sections and to write the configuration back to disk. Recent maintenance includes a security fix addressing CVE-2026-11527 in version 3.001000. Be aware that WriteConfig may not preserve original comment placement perfectly and does not perform file locking, so applications that write concurrently should take care.

WWW::Crawl4AI is a Perl client and orchestrator for a self‑hosted Crawl4AI service that runs a tiered crawling strategy and returns normalized, agent-friendly results. It delegates fetching and Markdown extraction to the Crawl4AI server while keeping policy, fallback and attempt tracking on the Perl side so every try is represented as a WWW::Crawl4AI::Attempt and you can see which backend won, its cost class, and why a fetch failed. The module walks a configurable chain of backends from cheap headless text fetches to full browser renders and stealth modes and can include CloakBrowser, proxy or user callback backends when configured. Call crawl or markdown for single pages, deep_crawl for breadth‑first site exploration, or use the underlying client for single‑shot actions like screenshots, PDFs, raw HTML, execute_js, LLM calls or token requests. Configuration covers base URL, API token, timeouts, min_markdown and fallback selection and the module provides health and detect helpers to report reachable backends. Use WWW::Crawl4AI when you run a self‑hosted Crawl4AI and want a Perl-friendly, observable escalation policy with per‑attempt history and simple high‑level crawl APIs.

Number::Phone is a Perl base class and factory for country-specific phone number modules that parses, validates and formats international and national numbers and picks the right country subclass for you. Call Number::Phone->new with a full international number or with a country code plus local number and it will load a Number::Phone::XX module or fall back to libphonenumber-derived stub data; subclasses provide methods to check number properties like is_valid, is_mobile or is_tollfree, to extract metadata such as country, area code, subscriber part, operator and timezones, to produce E.123-compliant or custom formats, and to compute how to dial from one number to another. The distribution is regularly updated from Google’s libphonenumber data, lets you disable stubs or force libphonenumber-derived behavior, and documents how to add new country modules, but it requires a 64-bit Perl and relatively recent Perl versions and some country modules such as Number::Phone::UK can be slower due to large local databases.

Gherkin is the Perl implementation of the Gherkin language parser and compiler used by Cucumber, letting you turn human-readable feature files into the standardized protobuf/NDJSON message stream that downstream tools consume. You use it when you need a programmatic, language-aware way to read feature files, handle international keywords, and produce Source, GherkinDocument (AST) and Pickle messages for tooling or test pipelines; it exposes simple streaming APIs such as from_paths and from_source that take an ID generator and a sink callback and offers options to include source text, the AST, or compiled pickles. The parser is generated from the official grammar and aligns with the Cucumber::Messages format, so modern versions emit Cucumber::Messages objects rather than plain hashes, and recent releases have continued to improve language support and performance while fixing memory and parsing issues, for example the latest 39.1.0 release expanded Turkish keywords and included parser optimizations and stability fixes.

DBD::D1 is a pure-Perl DBI driver that lets your Perl DBI code talk to Cloudflare D1, Cloudflare's serverless SQLite-compatible database, using the D1 REST API. It uses HTTP::Tiny and JSON::PP so no compiled extensions are required, and you connect by supplying your Cloudflare account_id and database_id in the DSN and your API token as the DBI password. Once connected you can prepare and execute SQL and fetch rows using the familiar DBI interface, but prefer fetchrow_hashref because results are returned as JSON objects and column order is not guaranteed. Be aware that the D1 REST API only supports AutoCommit so there is no multi-statement transaction support. The module integrates with typical Perl installations that provide DBI and TLS support.

Sys::Export helps you build a self-contained subset of a Unix filesystem for chroot, initrd or similar needs by copying only the files you request and automatically including needed interpreters and libraries. You can rewrite paths and users or groups so files work in their new locations, inject dynamically generated files, skip specific files, and recurse with filters when adding whole directories. The module is a thin front end that instantiates an OS-specific exporter such as Sys::Export::Linux and exports convenient functions so you can drive the export without dealing with objects directly. It also offers helpers for creating minimal /etc/passwd and group files, lazily loading or memory-mapping file data, expanding shorthand file specifications, and other small utilities for writing archive or image contents. Configuration is done on the use line and the interface supports producing a directory or a CPIO image as the destination. Currently only Linux is fully supported.

Sub::Abstract provides a lightweight way to declare abstract (virtual) methods in plain-Perl object systems without bringing in Moose or Moo. You mark a method with the :Abstract attribute or list method names in the import call and the module installs a runtime wrapper that croaks if the method is ever reached with no subclass implementation, which makes missing overrides fail loudly at runtime. It is easy to use in tests because you can temporarily disable the check with $Sub::Abstract::BYPASS or by the standard HARNESS_ACTIVE convention, and the harness bypass can be turned off via %Sub::Abstract::config. Be aware this works only at runtime so it cannot statically verify all subclasses, it replaces the stash entry so can() will return the stub rather than undef, and it installs the :Abstract attribute in UNIVERSAL which adds a global symbol. This is a focused tool for plain-Perl OO code rather than for Moo or Moose users, and this release is the initial 0.01.

WiringPi::API is a Perl XS wrapper for the wiringPi C library that lets you control Raspberry Pi hardware from Perl, including GPIO pin read/write, PWM, software PWM and tone, I2C, SPI, serial, ADCs, LCD displays, shift registers and sensors such as the BMP180. You can use it procedurally or as an object and must call one of the setup*() routines first to choose your pin-numbering scheme. The module provides a full interrupt subsystem with cooperative dispatch loops, optional signal-driven auto-dispatch, and convenient background handlers that run in their own process, plus a generic worker helper to run background tasks reliably without threads. It exports Perlish snake_case and C-style names and reuses RPi::Const for constants. It requires the wiringPi C library (version 3.18 or later) and the wiringPiDev shared library to be installed. A recent 3.18-era release rewrote and hardened interrupt handling to use a self-pipe model, added background_interrupt(s) and worker() facilities, improved validation and error handling, and expanded I2C/SPI and other wrappers. Note a few hardware-specific caveats such as the byte-bank read/write operations being unsupported on Raspberry Pi 5 and that lcd_init() can return -1 on failure so you should check its return before calling other LCD functions.

Dancer2::Plugin::Auth::OAuth is a lightweight plugin for the Dancer2 web framework that adds third‑party OAuth login with almost no code, letting you enable providers by configuration and automatically creating the standard routes like /auth/<provider> and /auth/<provider>/callback. After a successful login the provider response is saved in the session under the "oauth" key so your app can read id_token and access/refresh tokens for API calls, and the plugin also offers a refresh route to renew tokens without forcing users back to the login page. It ships with built‑in providers (Facebook, Google, Twitter, GitHub, LinkedIn, StackExchange, and more) and simple config options for prefix, success/error URLs, scopes and provider-specific parameters, making it a good choice for adding social login or delegated identity to Dancer2 apps. The module is actively maintained and recent releases include security improvements such as switching nonce generation to a secure random source to address CVE-2026-11832.

Sub::Private lets you mark Perl subs and methods as strictly private so they can only be called from the package that defines them. You can use the :Private attribute on a subroutine or, in the newer enforce mode, declare names with use Sub::Private qw(_helper) to have the module wrap those subs and enforce caller checks at runtime. The module supports two modes: the default "namespace" mode removes the sub from the symbol table for backward compatibility, while the new "enforce" mode (added in 0.05) installs wrapper closures so private routines also work with OO method dispatch. There are convenient test bypasses and configuration hooks exposed via $Sub::Private::BYPASS and %Sub::Private::config so tests can temporarily disable checks and so you can turn off the HARNESS_ACTIVE bypass. Known caveats are documented by the author and include runtime-only enforcement in enforce mode, the possibility of bypass via raw coderefs obtained before wrapping, and that ->can() may reveal private methods in enforce mode; the attribute form and the namespace mode avoid some of those issues. If you need package-level privacy for helper functions or want strict owner-only access for methods, Sub::Private is a small, focused solution that now includes an OO-safe enforcement option and a declarative import form.

Astro::SpaceTrack is a Perl client for fetching satellite orbital data such as TLEs from Space-Track.org and other public sources like CelesTrak and Mike McCants' archives. It gives you high-level methods to log in, search by name, launch date or NORAD ID, retrieve predefined catalogs or supplemental CelesTrak sets, and get results as HTTP::Response objects or parsed lists while also offering an interactive shell and credential support via a Config::Identity file. The module supports JSON output, can update local JSON TLE files, includes simple caching and rate‑throttling to avoid overloading remote APIs, and exposes metadata about the source and type of returned data. Be aware that a Space-Track account is required for many operations and some scraping-based features can be fragile or deprecated, for example AMSAT and legacy Iridium functionality are no longer reliable and some Space-Track favorites were removed. Recent maintenance added CelesTrak's new 'sar' catalog and EUMETSAT supplemental data and included an emergency update to adapt to Space-Track's newer gp/gp_history data classes.

Astro::App::Satpass2 is a Perl application and library for predicting satellite visibility and related events, either from an interactive satpass2 shell or programmatically by instantiating an object. It loads orbital elements (TLEs) and background objects, computes visible passes, flares, almanac items, positions and brightness estimates, and can format output via templates or export iCal; it also supports scripting, macros, and configurable time and geocoding services. Core functionality works out of the box but a few optional CPAN modules greatly expand its capabilities, for example Astro::SpaceTrack to fetch TLEs, Date::Manip for flexible time parsing, Geo::Coder::OSM for geocoding and a USGS elevation client for heights. The package is a modern, tested rewrite of the old satpass tool with most compatibility preserved and clear configuration via an init file, making it a good choice for amateur astronomers, satellite observers, and developers who need programmable, scriptable satellite pass predictions.

Test::Prereq::Meta is a testing helper for Perl distribution authors that checks whether the modules a distribution actually uses are declared in its CPAN meta files (META.* or MYMETA.*). It scans your distribution's Perl files to find use/require lines and then compares those discovered dependencies against the distribution's metadata and provided modules, letting you accept specific modules, treat core modules as covered for a chosen Perl version, and report unused prerequisites as well. The tool works without relying on a particular build system, integrates with Test::More, and offers both per-file and whole-distribution checks, but it uses static analysis so dynamically constructed require or eval'd module names may be missed and it requires Perl 5.10 or newer. Recent changes are purely administrative, updating contact and license packaging and removing references to the RT bug tracker, with no functional changes.

Cucumber::Messages is a Perl library that implements the standard Cucumber message protocol and provides typed classes for every message used in that protocol together with JSON/NDJSON serialization and deserialization. It gives you an in-memory representation of envelopes, pickles, test cases, steps, attachments and related objects so Perl tools can read, write and transform the same event streams other Cucumber components use. You would use it to build or integrate Perl-based formatters, reporters, runners or tooling that must exchange Cucumber messages, including support for large external attachments and timestamps. The module follows the canonical Cucumber messages spec and is available under the MIT license.

Backblaze::B2V4 is a lightweight Perl client for Backblaze B2's V4 API that makes it easy to create buckets and upload, download, list, and delete files from Perl code or from the bundled b2_client command line tool. It supports uploads from disk or from an in-memory scalar, a special path for large-file uploads (recommended for files over 100 MB), downloads by file name or by the B2 file GUID, bucket creation and deletion, listing and file metadata retrieval, and deleting specific file versions while returning B2 responses or file IDs as appropriate. You instantiate the client with your Backblaze application key and key ID and the module handles authorization token exchange and per-bucket upload info, and it exposes a send_request method if you need to call API methods not wrapped by the library. The installer can optionally test credentials by downloading a small file so store your keys securely, and if you prefer Backblaze’s S3-compatible API you may instead use generic S3 clients, but this module is focused on the native B2 API; recent updates improved the documentation and added a convenience current_status_is_ok method.

Map::Tube::CLI is a simple command-line frontend for the Map::Tube family that exposes map data and routing via the supplied map-tube script. It makes it easy to ask for shortest or preferred routes between stations, print results as plain lists or neat tables, enumerate supported maps, lines, or stations, and produce PNG images of entire maps or single lines with a selectable background color. The tool supports many city metro maps out of the box, accepts local or experimental maps with a force option, and offers conveniences like line mappings, line notes, debug output, and short and long command switches. If you need quick terminal access to transit routing or want to generate visual map output from Map::Tube data this module is a practical choice. The latest release adds short option aliases, a --version flag, explicit list options, improved Unicode-aware sorting, and better handling of non-printable characters.

Map::Tube::Exception is a small Moo role that centralizes and standardizes the error conditions used across the Map::Tube family of modules so they all throw the same named exceptions for problems like missing or invalid station and line data, bad color or map formats, plugin or map discovery failures, and route lookup errors. It is intended for module authors and integrators who want consistent, machine-friendly error reporting from map and transit-related code rather than ad hoc die strings. The bundle exposes a comprehensive set of status codes for specific problems so callers can detect and handle precise failure modes programmatically. Recent updates added an explicit exception for a missing map specification and expanded the test coverage and documentation.

JSON::Validator is a Perl library for checking that your data structures match a JSON Schema, making it easy to enforce types, required fields and value constraints in Perl apps. You can feed it a schema as a Perl data structure, JSON or YAML, build schemas programmatically with the Joi DSL, or load schemas from files, data sections or URLs, and it understands multiple JSON Schema drafts plus OpenAPI v2 and an experimental OpenAPI v3 spec. It bundles common specifications so you do not always need to fetch them from the web, supports caching of remote schemas, and integrates with Mojolicious through a plugin, while optional add-ons provide extra format validators and a Sereal encoder for faster checks. Note that the bundled cache does not honor remote cache headers so you must remove cached files yourself to force refresh, and the module recommends configuring validation options on the schema object rather than on the top-level validator.

Test::Simple is a tiny, no-frills testing toolkit for Perl that lets you write TAP-compatible tests with a single primitive. You declare how many tests you plan to run then use ok to record pass or fail and output lines like "ok 1" or "not ok 2", and the module produces sensible exit codes so harnesses and CI can tell success from failure. It is intentionally minimal to get you started quickly and is fully forward compatible with Test::More when you need richer assertions and diagnostics. Test::Simple is mature and well maintained across many Perl versions, and recent work has modernized its internals to use the newer Test2 infrastructure and cleaned up packaging and test reporting so diagnostics and line numbers are more accurate.

Stats::LikeR brings a compact, R-like statistics toolkit into Perl by providing common summary and distribution functions, random generators, many hypothesis tests (t, chi-square, Fisher, Wilcoxon, KS, Shapiro, Kruskal), modeling tools (lm, glm, aov), PCA and matrix utilities, and convenient table I/O and reshaping helpers such as read_table, write_table, filter, group_by, hoh2hoa, col2col, add_data, ljoin, and transpose. It accepts familiar data shapes like array‑of‑hashes, hash‑of‑arrays and hash‑of‑hashes, returns structured Perl hashrefs that mirror R outputs, and is implemented with XS for speed so it is useful when you want R-style analysis directly in Perl without external dependencies. The module aims to match R semantics including formula syntax and handles many edge cases, though some routines assume normality, several functions will die when given undefined values by default, cor fails on zero variance, and the KS p‑value precision is modest. If you are a Perl developer doing exploratory data analysis, statistical testing or table manipulation and prefer staying in Perl for performance and portability, this module is likely to be relevant and helpful.