CPANscan

ICANN::RST is a Perl module for working with ICANN's Registry System Testing (RST) machine-readable test specifications, making it easy to load test plans, enumerate cases, and produce human-friendly outputs such as the published HTML test spec. It is aimed at registry operators, registry service providers, and test automation tools that need to validate readiness for TLD delegation, provider transitions, or new registry services. The typical workflow is to instantiate ICANN::RST::Spec, ask for a named plan like StandardPreDelegationTest, and then iterate its cases and resources, so you can build reports or drive automated test runners. Recent changes include a new 0.03 API that replaces the older versions() call with new_from_version for loading a specific released spec; an earlier 0.02 update added support for querying releases via the GitHub API.

Tstregex is a lightweight Perl module and command line utility that helps you quickly diagnose why a regular expression did not match by showing the longest substring that did match and highlighting the exact part that failed. You can run it as a CLI tool to get an annotated string and a pointer to the failing token, or embed it via a simple API that prepares a regex context, runs the diagnostic, and returns whether the input fully matched plus the failing token and match length. The tool uses a "nibbling" strategy to search progressively smaller valid subpatterns so it can pinpoint the precise regex atom or quantifier that caused the break and report execution time to help spot exponential backtracking or ReDoS risk. It is aimed at developers who want a quick, automated way to troubleshoot complex Perl patterns without dropping into a full debugger. Recent releases stabilized the module for CPAN/MetaCPAN indexing, improved Windows compatibility, and formalized the production 1.00 release while adding ReDoS detection and cross-platform fixes.

MARC::Convert::Wikidata converts MARC bibliographic records into Wikibase::Datatype item objects suitable for loading into Wikidata, with a focus on handling real-world library data and many Czech National Library specific cases. You feed it a MARC::Record and it detects the item type (monograph, audiobook, or periodical), extracts identifiers and metadata, and builds a Wikibase::Datatype::Item while letting you plug in callbacks for covers, language mapping, people resolution, publishers and series lookups. The module bundles numerous cleanup and parsing heuristics for messy fields like edition numbers, series ordinals, publication places, page counts and dates so it is especially useful when converting legacy or national-library MARC data into structured Wikidata statements. Key methods include new, wikidata, type, object and look_for_external_id and it relies on MARC::Record and Wikibase::Datatype among other helpers. Recent work in 0.34 added handling for series ordinals, improved conversion of roman numerals to arabic, changed the audiobook instance mapping, and made author-name processing more robust when no QID is available. If you need a pragmatic, callback-driven bridge from MARC to Wikidata and your source resembles Czech national library records this module will save a lot of manual mapping work.

Parse::Syslog::Line is a compact Perl utility that parses a single syslog line into a convenient hash reference containing parsed fields like priority and facility, host and domain, program name and PID, the original and cleaned message, structured data, and multiple timestamp formats including epoch and an ISO‑8601 UTC time. It can auto-detect and decode JSON or Splunk-style key/value pairs, extract RFC5424 structured data, and offers a multiline-aware parse_syslog_lines helper for streamed input. The module exposes simple toggles to control expensive program extraction, date parsing behavior, timezone handling, and pruning of raw or empty fields so you can trade accuracy for speed when needed. Date parsing uses Time::Moment for performance and portability, and the author warns that local timezone strings around daylight saving transitions may be unreliable so prefer epoch or datetime_utc for portability. Recent maintenance releases removed the DateTime dependency and tightened timestamp testing to UTC, improving packaging and test robustness.

Perl::Critic::Policy::RegularExpressions::ProhibitEmptyAlternatives is a static linting rule for Perl that flags empty alternatives in regular expressions, such as /a||b/, because those alternatives always succeed and are usually accidental. By default it forbids empty alternatives anywhere, treats empty entries in bracketed character classes as outright violations, and can be tuned to allow an empty final alternative or to ignore empties inside right-anchored groups via configuration options. This makes it a handy safety check for developers who want to avoid subtle, always-true regex branches that can mask bugs. Support and issue tracking are handled by the author on GitHub, and the most recent release updated packaging and metadata, added SECURITY and CONTRIBUTING documents, and made no functional changes.

Perl::Critic::Policy::ValuesAndExpressions::ProhibitFiletest_rwxRWX is a stand-alone Perl::Critic policy that flags uses of the file test operators -r, -w, -x, -R, -W and -X because they only examine file permission bits and can be misleading when access is affected by ACLs, mount options, corrupt executables, or other runtime conditions. It is classified under the "bugs" theme at low severity and has no configuration options, making it a lightweight rule to help you avoid brittle file-access checks in code where reliability matters. The latest release cleaned up project metadata for GitHub, added a SECURITY policy, fixed example copy-and-paste errors and removed references to the RT tracker, while making no functional changes.

Perl::Critic::Policy::Variables::ProhibitNumericNamesWithLeadingZero is a small Perl::Critic policy that flags variable names made up of digits with a leading zero, a pattern Perl does not reliably support and that can produce obscure bugs or be inaccessible via constructs like "${0nnn}". It is most useful when auditing or preparing older Perl code for upgrades because, as of Perl 5.32, such names are a syntax error and the policy is essentially redundant for modern interpreters. The policy ships with no extra configuration and is maintained by Thomas R. Wyant III with support available via the project GitHub. Recent releases focused on documentation, license packaging, and metadata updates including a security policy and made no functional changes.

Map::Tube::Plugin::FuzzyFind is an add-on for Map::Tube that lets you locate tube lines and stations even when names are misspelled, partial, or entered as patterns. It installs as a Moo role and adds a fuzzy_find method that returns Map::Tube::Line or Map::Tube::Node objects, yielding a list of matches in array context and the best match or undef in scalar context. You can search with plain strings or regexes and choose from many matching strategies such as exact, prefix, substring, regex, phonetic encodings (Soundex, Metaphone, DoubleMetaphone, Koeln, Daitch-Motokoff), edit-distance measures (Levenshtein, Damerau, Jaro-Winkler), and trigram comparison, and you can tune limits like maximum distance or number of results. The module is practical for building tolerant name lookup in apps that use Map::Tube, and some phonetic methods are tuned toward particular languages so results may vary by locale.

Email::Abuse::Investigator inspects raw RFC‑2822 email source to help abuse investigators and security analysts quickly find the message origin, the hosts and domains mentioned, and the appropriate parties to report. It walks the Received header chain to pick the first external hop and enriches that IP with reverse DNS and RDAP/WHOIS data, extracts HTTP/HTTPS URLs from plain and HTML parts and maps their hosts to network owners, and collects contact domains from headers and body to run a domain intelligence pipeline that gathers A/MX/NS records and registrar WHOIS details. The module produces a detailed analyst report, a compact abuse report body suitable for sending to abuse desks, a risk assessment with weighted flags, plus email and web-form contacts to notify, and it can reuse cached lookups across messages when CHI is available for faster bulk processing. Optional modules such as Net::DNS, LWP::UserAgent, AnyEvent::DNS, IO::Socket::IP, and Domain::PublicSuffix enhance DNS, RDAP/WHOIS, parallel resolution, IPv6 WHOIS, and domain normalisation. Recent 0.10 changes add a public header_value() accessor, add per-message caching for abuse_contacts(), and refactor the risk assessment into clearer private checks while expanding tests and robustness. Known limitations documented by the author include no charset conversion for body text, a hand-rolled MIME parser that is not fully RFC compliant, IPv4-only CIDR matching for trusted_relays, no retry handling for WHOIS rate limits, lack of live DMARC DNS lookups, and the class is not thread-safe.

Crypt::PBKDF2 implements the PBKDF2 password hashing algorithm for Perl, letting you generate and verify salted, iterated password hashes with configurable backends and output formats. It is pluggable so you can choose the underlying PRF (default HMAC-SHA256), control iterations, output length and salt size, and produce either an RFC2307-style LDAP string or a crypt-style string while still reading either. The module provides convenience methods to get raw, base64 or hex outputs, to decode stored hashes, and to clone configured instances, so it fits both new projects and those needing compatibility with older PBKDF2 formats. It defaults to a high iteration count and sensible defaults but advises setting a length_limit to protect against denial-of-service attacks from extremely large passwords.

Music::SimpleDrumMachine is a lightweight Perl module that turns your MIDI output into a real-time 16th-note drum sequencer so you can program and play simple drum phrases and fills from code. You define named "parts" and "fills" as Perl callbacks that return the next part and a set of 16-step on/off patterns for individual drum instruments, and the module handles timing, velocity ranges, BPM and routing to a specified MIDI port. It comes with a large default mapping of common percussion MIDI numbers and options for multi-timbral channel use, fill behavior and verbose progress reporting, making it handy for quick prototyping, live jamming or embedding rhythmic backing into scripts. Note that it only supports straight 16th-note divisions and does not do triplets.

Mo::utils::Date provides a compact set of date-validation helpers for Perl, exporting functions to check common formats and to ensure one date precedes another. It validates ISO-like strings such as YYYY-MM-DD, YYYY-MM and YYYY and also accepts D.M.YYYY or DD.MM.YYYY and compact DDMMYY or YYMMDD forms, using DateTime to confirm calendar validity and Error::Pure to report problems. The generic check_date also ensures years are not in the future and the ddmmyy/yymmdd checks treat two-digit years as post-2000. Use this module when you need simple, reusable checks of user input or configuration dates and occasional ordering checks between dates.

Amazon::API is a lightweight Perl base class for making AWS service calls that you can use directly or extend to build small, focused clients for one or a few services. It handles credential discovery and signing, chooses content types and endpoints, supports pagination and basic request/response serialization, and includes a helper tool that uses Botocore metadata to generate full-featured Perl service stubs and shape classes so calls look like native Perl methods. This module is useful if you want a minimal, lower-dependency alternative to larger SDKs like Paws and you are comfortable dealing with AWS API details, but note that the generic interface can require manual tuning for some services, serialization still has occasional edge cases, and some services such as S3 are not a good fit unless you generate the Botocore-based stubs.

RPi::Const is a simple constants library for Raspberry Pi embedded programming that supplies named values used throughout the RPi::WiringPi family, making your code easier to read and freeing you from magic numbers. It optionally exports grouped sets of constants for setup modes, pin modes and alternate functions, pull-up/down settings, input/output states, PWM modes and defaults, interrupt edge types, and MCP23017 expander register addresses, plus wiringPi-specific pin-type and edge-name tags. Use it when you want clear, portable symbolic names for GPIO operations and related hardware registers rather than hard-coded integers. The most recent release added the :wpi_pin and :int_edge export tags so you can use wiringPi's WPIPinType names and native interrupt edge names directly.

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.