CPANscan

Pod::CopyrightYears is a small utility for updating copyright years inside POD or Perl module files. You construct it with the path to the POD or module file and optional settings such as which "=head1" sections to target, then call change_years with the current year and it will locate four digit years or year ranges in those sections and update them to include the new last year, turning a single year into a range when appropriate. The module can return the matching Pod::Abstract nodes via license_sections and serialize the updated POD or module text with pod so you can save or display the result. It is useful for maintainers who want an automated, scriptable way to bump copyright years in documentation.

Mojo::Pg is a compact Perl wrapper around DBD::Pg that makes PostgreSQL easy to use from the Mojolicious real‑time web framework, providing a simple API for blocking and non‑blocking queries, automatic connection and statement handle caching, fork safety and sensible DBI defaults. It includes helpers for transactions, JSON encoding/decoding, promise‑friendly async query methods, integration with SQL::Abstract::Pg to generate CRUD statements, built‑in schema migrations and an efficient PubSub helper for PostgreSQL notifications so you can build scalable real‑time web apps without wrestling with low‑level DBI details. Configuration options let you tune pool size, search_path and other connection settings, and the project is actively maintained with fixes and improvements; the recent 4.28 release ships a workaround for a DBD::Pg bug.

Test::HTTP::Scenario lets you capture real HTTP interactions once and replay them in tests so your API client behavior can be exercised offline, quickly, and deterministically. You wrap a test block with with_http_scenario to run in record mode, which performs real requests and writes normalized request/response pairs to a fixture file, or in replay mode, which intercepts requests and returns reconstructed responses from that fixture. The module plugs into HTTP client libraries via adapters (LWP is provided) and stores fixtures with serializers (YAML by default, JSON available). It includes helpful features for test hygiene such as strict mode to ensure all recorded interactions are consumed and diffing to show detailed mismatches. One limitation to note is that matching is currently based on HTTP method and URI only.

greple is a powerful, extensible grep-like tool written in Perl that adds lexical-expression support and region/block handling to let you perform sophisticated text searches and post-process matches. It is aimed at developers and power users who want more than basic pattern matching, offering modular extensions, callbacks, capture-group and DEFINE pattern support, rich formatting and color controls, block/paragraph extraction, and options for selective indexing and result transformation. The project is mature and actively maintained; recent releases added a --filter (-F) mode to use greple as a streaming filter and a --version flag, and v10 raised the minimum Perl requirement to 5.24 to enable newer language features. If you need a highly configurable, scriptable search tool that integrates custom modules and advanced regex capabilities, greple is worth trying, while a plain grep may be simpler for basic one-off searches.

Git::Server is a drop‑in replacement for a standard Git server that gives you much finer control over repository access and automation by extending server-side hooks, ACLs and deployment/webhook capabilities. It runs as the SSH command handler and ships helper tools like a git-client wrapper and git-deploy so you can enforce per-user and per-branch rules, restrict pushes to particular files or email addresses, whitelist client IPs, and trigger instant deployments or HTTP webhook notifications with rich metadata about the push or pull. The module is aimed at administrators and small teams who want stronger, configurable server-side policy and automated workflows without adopting a full hosted service, and it favors compatibility and lower dependency than alternatives such as Git::Hooks. Recent releases focus on more consistent messaging and logging, improved webhook payloads (including server-side timing and version info), better handling of git-client options and chdir behavior, and fixes for security and compatibility around branch and ref handling.

File::Access::Driver is a convenience Perl class that bundles common file operations into a single, easy API so you can create, read, write, delete and inspect files with far less boilerplate. You can construct it with a full path, directory or filename and change those later with setters that automatically manage open handles and an in-memory cache. It aims to be "batteries included" for typical file access and testing workflows, and it reports problems via getErrorCode and getErrorString instead of throwing exceptions so callers should check those after operations. Use it when you want a simple, test-friendly helper for everyday file tasks rather than managing low-level filehandles yourself.

AWS::Lambda makes it easy to run Perl code on AWS Lambda by providing a custom runtime and ready-to-use artifacts so you can deploy handlers as zipped scripts, container images, or Lambda layers without rebuilding a runtime yourself. It offers pre-built public layer ARNs, downloadable zip archives, and Docker images for Amazon Linux 2023, plus helper functions to print or retrieve the correct layer ARNs for your region and Perl version. The module includes conveniences such as preinstalled JSON and TLS modules, optional prebuilt Paws layers for calling AWS APIs, AWS X-Ray tracing support, and response streaming support, and it documents how to build custom module layers and test locally with Docker. Supported Perl releases follow the official Perl policy and the author advises migrating off older legacy layers for Amazon Linux and Amazon Linux 2 because those legacy layers are no longer maintained.

IO::Trace is a small Perl utility and module for recording a spawned program's standard I/O activity so you can inspect reads, writes and closes on STDIN, STDOUT and STDERR without modifying the data streams. Its log format is modeled on Linux strace but is implemented with IPC::Open3 rather than ptrace, making it portable across Windows, macOS, Linux and other platforms. Use it when you need a cross‑platform way to capture and replay terminal I/O for debugging or auditing, but note it only records the three standard streams and will break commands that need a real TTY on STDIN. Recent updates added a -V version flag, improved compatibility with older Perl and Getopt::Long versions and with newer strace releases, and added options like redirecting output to a file.

Parse::PMFile reads a Perl .pm file and extracts the package names and version information using the same logic PAUSE uses to index CPAN, making it useful for tooling that needs reliable, PAUSE-compatible package and $VERSION discovery. It returns structured information about all packages found and can optionally report malformed versions, enforce PAUSE permission checks when given a USERID and PAUSE::Permissions object, and preserve developer underscore versions if requested. The parser uses Safe evaluation where possible and offers an UNSAFE mode to fall back to plain eval for older Perls, and it avoids forking by default for simpler operation. The code is largely derived from PAUSE so behavior is stable, and recent releases improved class and role detection, strip BOMs before scanning, and ensure versions stringify correctly for JSON output. This module does not extract distributions or parse meta files, so it is best when you only need accurate package/version parsing of .pm files.

EMDIS::ECS is a Perl implementation of the EMDIS Communication System that lets organizations exchange EMDIS messages securely using encrypted email and, optionally, AMQP messaging. It integrates with SMTP for outbound mail and IMAP, POP3, or a directory-based inbox for incoming mail, supports PGP and GnuPG encryption and signatures, and includes daemons and utilities for scanning mailboxes, processing messages, handling sequencing and automatic resend requests, and managing node configurations via a NODE_TBL. The distribution also provides tooling such as ecs_setup and ecstool, examples for Docker deployments, and support for document exchange and OAuth2 authentication for cloud mail providers. You will need Perl, an SMTP server, and PGP/GnuPG installed to use it, and GnuPG 2.2 may require a small configuration change to accept passphrases. This module is aimed at sites that need an EMDIS-compatible, scriptable messaging system and is generally compatible with the original specification while adding practical extensions and experimental features.

Lilith is a Perl utility for ingesting EVE JSON logs from Suricata, Sagan and CAPE into PostgreSQL and then letting you create, search and extend that data store from Perl. It provides helpers to create the required tables, a run method that reads named EVE files and inserts events, options to ignore specific SIDs or classes, and a search wrapper that accepts high level filters for IPs, ports, signatures and more so you can pull matching rows without hand‑writing SQL. There are convenience methods for mapping rule classes to short or SNMP‑friendly names and a backfill/extend mode to reprocess recent minutes of logs. In the 2.0.0 release the internals were moved to DBIx::Class::Schema and the search behavior was reworked to leverage that, making query handling more robust. If you operate Suricata/Sagan/CAPE and want a Perl‑centric path to store and query EVE alerts in Postgres, Lilith is designed for that workflow.

Simple::Accessor is a tiny, zero‑dependency Perl module that gives you a minimal object layer with automatic accessors and a constructor so you can declare attributes with a single use line and immediately get new and get/set methods. It merges attributes declared across multiple use statements and supports per-attribute default builders named _build_<attr> so you can supply lazy defaults without boilerplate. You can hook into object creation with build, _before_* and _after_* callbacks and use _validate_* hooks to veto bad values, with the _after_* hooks protected against re-entrant recursion. An optional strict constructor mode lets you catch typos in attribute names at construction time. The module is intentionally small and well suited for scripts or projects where heavier object systems feel like overkill.

TimeDate is a compact Perl toolkit for parsing, formatting and converting dates and times. It bundles Date::Parse to convert a wide range of human readable date strings into Unix timestamps or component values, Date::Format to render timestamps or localtime arrays with familiar strftime-style formats, Date::Language to format and parse dates in over 30 languages, and Time::Zone for named timezone offset lookup and conversion. Use it when you need reliable parsing of many input date forms, consistent formatted output, or simple internationalization and timezone handling in scripts and applications.

Safe::Hole provides a controlled way for code running in a Safe sandbox to invoke subs and object methods back in the original main namespace, effectively creating a deliberate escape hatch so sandboxed code can use trusted routines or objects without running them inside the Safe compartment itself. You can call a code reference through the hole or create wrapper objects so that method calls are dispatched outside the sandbox, and the module can optionally restore aspects of the calling environment such as the opcode mask, %INC and @INC. Use is simple: new constructs a hole, call invokes a code ref through it, and wrap produces callable wrappers for subs or objects. The module warns that you must not share the Safe::Hole object into the Safe compartment itself because that defeats the sandbox, and it includes fixes to catch and rethrow exceptions correctly and to preserve environment state. Safe::Hole is useful when you need sandboxed code to reach back to trusted code while keeping most sandbox restrictions in place, but it should be used with care because it deliberately bridges those restrictions.

Net::SSLeay is the Perl interface to the OpenSSL and LibreSSL libraries that lets you do SSL/TLS and cryptography from Perl code. It provides convenient, high‑level helpers for fetching and posting over HTTPS and a swiss‑army sslcat transport, while also exposing a near one‑to‑one low‑level mapping of libssl and libcrypto so you can build custom clients and servers, manage certificates, CRLs and OCSP, control ciphers and protocols, and install callbacks for things like SNI, ALPN, PSK and advanced TLS features. Use it when you need direct control of TLS handshakes, certificate verification or crypto primitives beyond what higher‑level HTTP libraries expose; the high‑level functions are handy for simple HTTPS tasks while the low‑level API lets you implement complex or server‑side behavior. Net::SSLeay’s available functions and constants depend on the installed OpenSSL/LibreSSL version so you should use a maintained, up‑to‑date libssl for security and check the compatibility notes in the docs. Notable in the recent 1.96 release is official support for OpenSSL 3.3–3.6 and LibreSSL 3.9–4.2 and additional bindings to control supported signature algorithms.

Test::MockFile lets you create an in-memory fake filesystem so your tests can exercise file, directory, symlink and directory-iteration behavior without touching real files on disk. It intercepts core file operations and provides helpers like file, dir, symlink, read, write and append to create and manipulate virtual entries, a default strict mode that dies on any unmocked file access and optional nostrict, warnstrict and trace modes to relax or log accesses, and file_passthrough for allowing specific real paths or glob patterns to be used by XS modules such as SQLite. The module also supports autovivify to auto-create children under a mocked directory and now lets you simulate Unix permissions via set_user and clear_user so permission checks behave realistically. The recent 0.038 release added automatic timestamp updates and parent directory mtime updates, symlink and hard-link handling, flock and truncate overrides, better filehandle behavior and glob fallbacks, and the :trace import tag for logging unmocked accesses. Be aware of documented limits such as no fileno support, hard links not mirroring live writes, debugger/load-order quirks under strict mode and a few edge cases with bareword filehandles, but otherwise this is a practical, well maintained tool for isolating file I/O in unit tests.

Crypt::RIPEMD160 provides a simple Perl interface to the RIPEMD-160 message digest algorithm so you can compute 160-bit hashes of strings or files from Perl code. It offers an object-oriented API where you create a context, feed data with add or addfile, and retrieve a 20-byte binary digest or a hex string via digest or hexdigest, plus convenience hash and hexhash methods for one-shot hashing. The implementation is based on the well-known Antoon Bosselaers C code and supports multiple simultaneous contexts for streaming or chunked input. Recent maintenance modernized the build and packaging, improved test coverage, enabled XSLoader, added warnings, and fixed several portability and compilation issues so it should compile and run cleanly on current Perl toolchains.

Restish::Client is a lightweight Perl client for talking to REST-style HTTP APIs, giving you a simple object that wraps a base URI and common request patterns so you can send GET, POST, PUT, DELETE, PATCH and LIST calls with minimal boilerplate. It supports default headers for things like authentication, URI templating with named interpolation, query parameters, JSON-encoded body parameters, raw body uploads with content type, and a thin_request mode for calling LWP directly when you need low-level control. The client can be configured with SSL/TLS options, an optional persistent cookie jar, request-level headers, and a debug mode that can trim tokens, and it returns parsed JSON for 2xx responses while exposing the response code, headers and body for error handling. This module is suitable for scripts and services that need a straightforward REST wrapper without heavy framework dependencies. The initial CPAN release adds a Moo-based interface, comprehensive tests, and the core features above.

NBI::Slurm is a Perl library that makes it easy to create and submit jobs to a SLURM-managed HPC cluster. It gives you an NBI::Opts object to declare queue, threads, memory and other SLURM options and an NBI::Job object to set the job name, commands and output paths and to submit the job with a simple run call. The module also includes handy utilities for loading configuration, checking for the squeue command, listing and validating queues, computing file age, running system commands and producing timestamped logs. If you need to automate SLURM job submission from Perl scripts or build small command-line tools for cluster workflows, this package provides a straightforward, MIT-licensed toolkit to get started.

CXC::PDL::Bin1D is a Perl extension for PDL that provides practical one dimensional binning tools for scientific data such as spectra, radial profiles, or time series. It includes an adaptive binning routine that groups consecutive points until a target signal to noise ratio is reached and supports different error models including Poisson, sample standard deviation, or root-sum-square of provided errors, with options to enforce minimum or maximum bin size and bin width and to fold the final bin into its neighbor. It also offers a numerically stable binning-on-index routine that computes per-bin counts, sums, weighted sums, means, unnormalized squared deviations, and min/max values while handling weights, out‑of‑bounds indices, and multi dimensional threading. The module returns results as PDL piddles and emphasizes stable algorithms for accuracy, making it useful for astronomers and data scientists who need robust, configurable binning and basic binned statistics.

Module::CoreList is a reference database and API that tells you which modules shipped with each Perl release. It ships with the corelist command line tool and a small programming interface so you can query when a module first appeared, whether it counts as a core module for a given Perl and module version, what module versions were bundled with a particular Perl, and how core contents changed between releases. It also exposes hashes with release dates, release families, deprecations and removals, and pointers to upstream maintainers and bug trackers, making it useful to module authors, packagers and system administrators who need to track compatibility and history. The module is actively maintained and regularly updated to track new Perl releases, most recently refreshed for Perl v5.43.9.

CPAN::Perl::Releases is a compact, data-driven Perl module that maps every Perl release uploaded to CPAN to the authors/id path where its tarball can be found, making it easy for scripts and tools to locate specific perl tarballs without crawling CPAN. You can call perl_tarballs with a Perl version and get back a hashref listing available archive types such as tar.gz, tar.bz2 or tar.xz and their relative authors/id paths, or undef if the version is not present. The module also provides perl_versions to list all supported Perl versions in order and perl_pumpkins to return the PAUSE IDs of Perl maintainers. The data is static and updated as new Perl releases appear on CPAN, so this module is useful for build tools, mirrors, installers, or any automation that needs a reliable mapping from Perl release to CPAN storage location.

Net::Kafka::Producer::Avro is an object oriented Perl module for sending Avro serialized messages to Apache Kafka using the high performance librdkafka client and Confluent Schema Registry for schema validation and registration. It builds on Net::Kafka::Producer and requires a Confluent::SchemaRegistry instance at construction, then lets you call produce with JSON Avro schemas for the message key and value or omit them to use the latest registered versions. The module will validate and, if needed, register schemas under the topic key or value subject, supports message headers, several compression codecs, asynchronous delivery via promises, and customizable error callbacks. Tests expect a running Kafka broker and Schema Registry on localhost by default and installation follows the normal Perl build cycle.

BZ::Client is a lightweight Perl client for talking to Bugzilla’s XML-RPC web services, giving you an easy object interface to authenticate, call API methods and manage session cookies without dealing with raw HTTP yourself. It supports username/password or API key authentication, automatic or manual login and logout, optional IP-restricted logins, and a generic api_call method to invoke any Bugzilla API call while accepting HTTP connection options such as proxies, timeouts and SSL verification. The module includes debugging hooks via a logger coderef and an option to dump raw HTTP traffic to a directory, integrates with BZ::Client::Exception for error reporting, and even shows how to connect through a SOCKS proxy. Keep in mind this client targets Bugzilla’s XMLRPC API used in version 5.0 and earlier, so for Bugzilla 5.1 and newer you should look at the newer WebService API and the WebService::Bugzilla client.

Math::MPFR is a Perl binding for the MPFR C library that gives you arbitrary precision, correctly rounded floating point arithmetic from Perl programs, so you can work with bigfloats, special functions, constants and advanced numeric routines with predictable rounding behavior and configurable rounding modes. It wraps almost the entire MPFR API and adds Perl-friendly conveniences such as operator overloading, conversions to and from Perl and GMP types, formatted I/O, random number generators, and helpers for long double, __float128 and decimal float interoperability when the underlying libraries and build options support them. The module requires the GMP and MPFR C libraries to be installed and handles memory for mpfr objects automatically for blessed objects while offering lower-level control when needed. If you need reliable high-precision math, interval-safe rounding or exact conversions between numeric formats, this module is directly relevant. Recent updates add floating-point interchange import/export to memory buffers, better handling of octal input, a new mpfrtoa_subn printer for subnormal values, and build tweaks to improve compatibility on some Linux and Cygwin environments.

Test::Changes::Strict::Simple is a small test helper for Perl authors that enforces strict, semantic validation of traditional CPAN-style Changes files so you can catch common release mistakes before publishing. It provides a single exported test function, changes_strict_ok, which checks file layout and consistency rules such as uniform indentation, no trailing or non-space whitespace, title and version line formats, version string and date syntax, monotonic version ordering (or the reverse with an option), valid calendar dates that are not in the future or before 1987, and other stylistic conventions like whether items must end with a period or require an empty line after a version. The module is intended for release testing (typically run under RELEASE_TESTING in xt/release), accepts options to customize checks and a few runtime arguments including the Changes filename, an expected module_version and a release_today flag, and reports results via Test::Builder. In the latest release the function now throws an exception if you pass module_version as undef, which hardens argument handling.

Net::API::REST is a Perl framework for building RESTful APIs inside Apache under mod_perl. It provides a central request handler that maps incoming HTTP requests to route definitions and user handlers, gives you convenient request and response objects, and captures path variables as endpoint context so you can write handlers that focus on business logic. The module handles CORS and OPTIONS preflight checks, supports API versioning, configurable HTTP methods, content types and languages, and exposes hooks for access control such as network, method and content type checks so you can enforce security policies early. It also includes JWT encode/decode support with options for encryption and selectable algorithms and encodings, plus utilities for payload limits, gzip compression and easy integration with third‑party services. Net::API::REST has built on Apache2::API since v1.0.0 and continues to refine routing and endpoint handling, with a recent improvement to route endpoint handling in v1.2.5. If you run Perl web services on Apache and want an opinionated, extensible toolkit to implement secure REST endpoints, this module is likely relevant.

Git::RemoteURL::Parse is a small Perl helper for identifying whether a Git remote URL points to GitHub or GitLab and for extracting the repository name and the owner or group path. You call parse_git_remote_url with a remote string and it returns a hashref like { service => "github", user => "user", repo => "repo" } or { service => "gitlab", group_path => "group/subgroup", repo => "repo" } and returns undef for unrecognized URLs. It handles common HTTPS and SSH forms including tokened HTTPS URLs, SSH host aliases, and nested GitLab group paths, making it useful in scripts, hooks, or tooling that need to classify or normalize remotes. The recent 0.05 release added and reorganized author and release tests and completed the module documentation.

GitHub::Config::SSH::UserData is a tiny Perl helper for people who manage multiple GitHub accounts with separate SSH keys and store per-account metadata in their SSH config comments. It provides a single function, get_user_data_from_ssh_cfg, which scans your SSH config (default ~/.ssh/config or a file you supply) for Host entries named github-USERNAME and parses the next comment line that begins with "User:" to extract a full name, one or two email addresses and any trailing string. The function returns a hash reference with keys full_name, email, optional email2 and optional other_data so you can programmatically map SSH hosts to account details. Note that it expects the comment to follow the documented format and will raise a fatal error if the host or correctly formatted comment is not found.

sshca is a lightweight command-line SSH Certificate Authority that helps you create a CA directory, issue user or host SSH certificates from public keys, renew certificates, list outstanding certs, and clean up expired ones while letting you tune defaults via a YAML config or environment variables. It is aimed at making short-lived, identity-tagged SSH authentication simple to manage without complex infrastructure, supporting options for principals and certificate-specific flags and letting you read public keys from files or standard input. The tool exposes familiar commands like init, issue, renew and list and includes options for validity windows and dry-run cleanup, so it is useful for teams who want to move from static keys to certificate-based SSH access. The author notes revocation and historical record features are planned and that the current release stores certificate metadata in the filesystem rather than a database, with future work intended to add configurable storage backends such as SQLite or PostgreSQL.