CPANscan

HTTP::Date is a compact Perl utility for converting between Unix epoch times and the date formats used by HTTP and many related systems. It exports time2str and str2time by default so you can easily format a timestamp as the RFC 1123/GMT string used in HTTP headers or parse a wide range of incoming date strings into epoch seconds. The parser accepts HTTP rfc1123 and rfc850 forms, asctime and ctime formats, ISO 8601 and compact ISO, common web logfile timestamps, Unix and Windows listing formats, and many variants with or without time zones. parse_date returns broken-out numeric components or a standardized YYYY-MM-DD hh:mm:ss TZ string, and time2iso/time2isoz produce local or UTC ISO-like strings. You can supply a default time zone to str2time and nonnumeric zone names require the Time::Zone module. If a string is unrecognized you get undef, and dates before the system epoch may not work on every platform.

Apple::AppStoreConnect is a lightweight Perl client for querying the Apple App Store Connect API and the Apple Store Server API. It handles JWT authentication using your App Store Connect key file or key string plus key_id and issuer, caches tokens and lets you tweak scope and expiration, and can include a bundle id in the JWT payload for Store Server calls. The module exposes a simple GET interface plus convenience methods to list apps (with a new platform shortcut), fetch App Store versions (optionally retrieving localizations across pages), and retrieve beta feedback such as screenshot submissions and crash reports, with optional per-item crash log fetching. Requests decode JSON to Perl data structures by default, use LWP::UserAgent with an optional curl fallback, and currently only GET operations are implemented. This is a practical tool for automation and reporting tasks that need app metadata, reviews, version data, or TestFlight beta feedback.

Net::Simplify is a Perl client for the Simplify Commerce payments API that makes it straightforward to integrate card payments and related account operations into a Perl application. It lets you set global public and private API keys or pass an Authentication object per call and exposes high level resource classes so you can create payments, issue refunds, manage customers and subscriptions, and handle webhooks without dealing with raw HTTP calls. The module also surfaces API errors and exceptions in Perl-friendly objects so you can handle failures cleanly. Recent updates have added support for fraud checks and transaction reviews, data tokens, and inclusion of card data in refund responses, making it easier to manage risk and reconciliation.

Ordeal::Model is a compact Perl library for managing cards and grouping them into decks while providing a simple language to compose and shuffle those decks and draw cards from the resulting shuffle. You give it a textual expression or a pre-parsed AST and it returns a Shuffle object you can draw from, or you can fetch individual Card and Deck objects by identifier; storage is pluggable via backend classes with a built‑in PlainFile backend by default and a new Backend::Raw for in-memory data structures added in the 0.004 release. The evaluator uses a configurable random source (it defaults to a ChaCha20 implementation and accepts an explicit generator, a saved state, or a seed) so you can reproduce or control randomness for testing and simulation. Backends are resolved by name but the resolution method is overridable if you need a different lookup policy. The module uses modern Perl features so you need at least Perl 5.20.

Net::Stripe is a Perl client library that wraps the Stripe HTTP API and presents actions as simple methods (for example post_charge, get_customer, create_payment_intent) while returning Moose objects for responses so you can work with Stripe data in an object-oriented way instead of handcrafting HTTP calls. It covers the full range of Stripe functionality you are likely to need from Perl including charges, refunds, customers, cards/sources, subscriptions, invoices, products, plans, coupons, payment methods and payment intents and includes helpers for listing and paginating results. You instantiate it with your Stripe API key and optionally pin an API version; the module enforces a supported API range and offers a force_api_version override if you accept the risk of incompatibilities. This is a good fit for Perl developers building payment integrations who want convenience, objectified responses and tested method wrappers, and be aware the module follows Stripe guidance by deprecating direct handling of PANs. Recent maintenance releases improved form-field serialization and query encoding to avoid URI-related errors, fixed pagination edge cases and test regressions, and added billing_details tax_id support for newer Stripe fields.

Net::Payjp is a lightweight Perl client for the Pay.jp payment API that maps REST endpoints to simple Perl method calls and returns JSON-style response objects. You create an instance with your Pay.jp API key and then use intuitive methods like charge->create, charge->retrieve, customer->create and customer->card to manage payments, customers, cards, subscriptions, plans, tokens, transfers, three_d_secure_request flows, events, and account data. It covers common payment operations such as charging, refunding, capturing, subscription lifecycle actions including pause, resume and cancel, and finishing 3D Secure, so you can integrate Pay.jp into a Perl application without writing raw HTTP calls. The API mirrors the Pay.jp documentation and surfaces errors on the response object, making error handling straightforward for developers.

Sys::GetRandom::PP is a pure-Perl implementation of the getrandom(2) interface that lets Perl programs obtain kernel-provided random bytes without opening device files or compiling C extensions. It exports, on request, getrandom which fills a scalar with up to a requested number of bytes and accepts the usual flags GRND_NONBLOCK and GRND_RANDOM, and random_bytes which returns a string of random bytes up to 256 bytes. By default it behaves like reading from /dev/urandom and may block until the kernel RNG is initialized, or return immediately with EAGAIN when GRND_NONBLOCK is used. The module aims to match the Sys::GetRandom C interface while remaining fatpackable and portable for known platforms such as Linux (x86_64, i686, armv6l, aarch64), FreeBSD, NetBSD, Dragonfly BSD, MidnightBSD and Illumos, and recent releases add OpenBSD support by emulating getrandom via getentropy(2). If you need a lightweight, pure-Perl way to pull secure random bytes that mirrors the familiar getrandom API, this module is a convenient choice, with the caveat that its syscall approach is targeted to the listed platforms.

Sys::GetRandom is a small Perl wrapper around the operating system getrandom(2) facility that gives you raw system-generated random bytes without opening or reading /dev/urandom. It provides a getrandom function that fills a Perl scalar (optionally at an offset) and supports the GRND_NONBLOCK and GRND_RANDOM flags so you can choose nonblocking behavior or read from the same source as /dev/random, plus a convenience random_bytes function that returns a string of up to 256 bytes. The call will block until the kernel’s entropy pool is initialized unless you request nonblocking mode, and the module mirrors system limits and guarantees for atomic reads of small amounts of data. It works on Linux and several BSDs and Illumos, and the latest release adds explicit OpenBSD support by emulating getrandom via getentropy(2). If you need straightforward, low-level access to OS-provided randomness from Perl, this module is a compact and portable choice.

Crypt::OpenSSL::X509 is a Perl wrapper around OpenSSL’s X.509 functionality that lets you load certificates from files or strings and inspect them from Perl code. It provides easy access to common certificate data such as subject and issuer names, serial number, validity window, public key details (RSA modulus and exponent or EC curve), fingerprints, email addresses and Subject Alternative Names, and X.509 extensions, and can emit PEM or DER output. The module is tested to work across a range of OpenSSL releases (including OpenSSL 1.0, 1.1, 3.x and 4.x) and LibreSSL, so it is useful for scripts and tools that need to parse, display, or check certificates for expiry and attributes. The recent 2.1.2 bugfix ensures extension lookups are kept per certificate instance rather than shared across objects, so you should update if you rely on extension queries in long-running processes.

Monitoring::Sneck is a small utility for running Nagios-style checks on a host and exposing the results in LibreNMS-friendly JSON via SNMP. You define environment variables and named checks in a simple text config, the tool runs each command, captures exit codes, output and timings, and returns a structured hash with totals for OK, warning, critical, unknown and errored checks plus per-check details and optional debug entries. It is intended to be used via the supplied sneck script from snmpd or cron rather than as a general-purpose library and supports debug-only checks, including the raw config in output, and options for quieter operation and locking. Recent releases added quiet and locking flags, fixed a missing Proc::PID::File dependency, and increased test coverage.

Lilith is a Perl helper for ingesting Suricata, Sagan, and CAPE EVE JSON logs into a PostgreSQL backend and for querying those stored alerts. You configure it with a DBI DSN and credentials and it can create the necessary tables, read multiple named EVE files or instances, and apply ignore lists for rule IDs and classes while importing. It exposes a run method to process files, an extend helper for time-based lookups, and a search wrapper that makes it easy to filter events by time range, IP, port, rule id, signature, hashes, host, instance, and other common fields without writing raw SQL. The module also provides utilities to convert alert classes into short or SNMP-friendly names. Use Lilith if you want a simple Perl-based bridge between IDS/analysis JSON output and a queryable PostgreSQL store for forensic, monitoring, or SIEM workflows.

SPVM::Regex brings fast, safe regular expressions to SPVM by wrapping Google’s RE2 engine and exposing a Regex class for compiling patterns and running matches, replacements and splits. It also includes a Re convenience interface for a more Perl-like m/s/... style usage. The module supports capturing groups, callback-based replacements, global and offset-limited operations, UTF-8 matches, and in-place replacements via mutable string references, and split will include captured separators when the pattern uses parentheses. If you use SPVM and need reliable, RE2-backed regex features rather than the full Perl regex dialect, this module is a good fit. Recent releases added MSVC support and fixed macOS C++ build issues while updating minimum SPVM and SPVM::Resource::RE2 requirements.

SPVM::Resource::RE2 packages Google's RE2 regular expression engine as a resource for SPVM so you can include RE2 headers and call RE2 APIs from SPVM native C++ code. It bundles the RE2 source and headers (C++17) and integrates via a simple config call like config->use_resource('Resource::RE2'), allowing native methods to invoke functions such as RE2::PartialMatch for fast, safe, non‑backtracking regex matching suited to large or untrusted input. The module is aimed at SPVM developers who need a robust, high‑performance regex engine without embedding RE2 themselves and is distributed under the MIT license. Recent updates improved Windows support by adding MSVC compatibility and the -DNOMINMAX build flag and trimmed the bundled sources for a leaner build.

SPVM::R brings a large subset of R-style numeric and data tools into the SPVM/Perl world so you can work with vectors, matrices, and data frames using familiar R-like operations. It provides N-dimensional arrays in many primitive and complex types, vectorized math and trig functions, matrix algebra, NA handling, sequence and repetition helpers, slicing, ordering and sorting, and a DataFrame API with conditional row selection and column operations. The module is useful to Perl developers who want to perform array-based numerical computing or manipulate tabular data without leaving SPVM, and it includes examples, a tutorial, and a GitHub repository for hands-on guidance.

SPVM::MIME::Base64 is a straightforward SPVM implementation of MIME::Base64 that provides simple class methods to Base64-encode and decode data, making it easy to convert binary or text blobs to and from the well known Base64 text form. Its API includes encode_base64 and decode_base64 plus fast helpers to compute the encoded or decoded length without performing the full conversion, and encode_base64 accepts an optional line-ending argument and defaults to wrapping at 76 characters unless you pass an empty string. The decoder silently ignores non-Base64 characters and stops at padding, and all methods will raise an exception if given an undefined input. The module is actively maintained, released under the MIT license, and recent updates add MSVC support and require a recent SPVM runtime.

SPVM::Math is a thin, high-performance binding to the C math and complex libraries that exposes the standard math.h and complex.h routines as static class methods for SPVM/Perl code. It gives you familiar functions for trigonometry, exponentials, logarithms, rounding, classification of floats, constants like PI and E, special values such as NAN and INFINITY, and full complex arithmetic with float and double variants plus helpers to build and manipulate complex numbers. Most calls map directly to their C counterparts for predictable behavior and speed. A few routines that return extra values require you to pass a defined reference for the output parts or they will raise an exception and the module is distributed under the MIT license.

Perl::Critic::PJCJ provides a small set of Perl::Critic policies to help Perl developers keep code style consistent and readable by enforcing predictable quoting and line length practices. It includes a RequireConsistentQuoting policy that encourages minimal punctuation, prefers interpolated strings where appropriate, and standardizes choice of delimiters so string literals look uniform across a codebase. It also provides ProhibitLongLines to enforce a configurable maximum line length (default 80) with options for per-file overrides via .gitattributes and pattern-based exemptions for intentionally long lines. Recent releases fixed multi-byte handling so line length is now measured in characters rather than octets, avoiding false positives with UTF-8 source, and added other practical refinements for pragmas and quoting edge cases. If you want automated, configurable checks to keep Perl source tidy and consistent, this module is a lightweight, focused addition to a Perl::Critic setup.

SPVM::Digest::SHA is an SPVM-native port of Perl's Digest::SHA that implements the SHA family of hash algorithms and their HMAC variants, including SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, SHA-512/224 and SHA-512/256. It offers simple class methods for one-shot hashing and HMACs with outputs as raw binary, hexadecimal or Base64, and an object-oriented interface for incremental hashing via new, add, clone and digest/hexdigest/b64digest. The module is a drop-in style utility for checksums, data integrity, message digests and HMAC-based authentication in SPVM applications and is actively maintained; recent releases added MSVC support and updated the SPVM version requirement to 0.990191 for improved portability and compatibility.

Crypt::OpenSSL3 is a modern Perl wrapper that gives your Perl code direct access to OpenSSL cryptography and TLS features. It breaks OpenSSL functionality into focused submodules, for example SSL for TLS connections, PKey for asymmetric keys, Cipher for symmetric ciphers, MD for digests, MAC for message authentication codes, KDF for key derivation and X509 for certificate handling. The top-level distribution itself mainly offers error handling and build-configuration introspection so you can query the OpenSSL version and how it was built on your system. Use this module when you need up-to-date, low-level access to OpenSSL primitives from Perl rather than a higher-level abstraction.

SPVM::Digest::MD5 provides MD5 hashing for SPVM programs and mirrors Perl's Digest::MD5 API. You can compute a one-shot hash with the class methods md5 and md5_hex which return the 16-byte binary digest or a 32-character lowercase hexadecimal string respectively. For streaming data use the object interface: create an instance with new, append chunks with add, and obtain the final digest with digest or hexdigest. The methods validate that input data is defined and will throw an exception otherwise. This module is a straightforward, MIT-licensed port of Perl's Digest::MD5 for use when you need standard MD5 checksums in SPVM code.

SPVM::Errno provides SPVM programs with a thin, reliable bridge to the system C errno facility so you can read and set the process errno, convert errno values to human messages via strerror, and obtain native error number constants for POSIX and Windows Winsock errors as static methods. Each constant returns the platform's actual numeric code and will raise an Error::NotSupported-style exception if that symbol does not exist on the host, which makes this module handy when calling native APIs or handling low-level I/O and networking errors. Recent releases improved portability and testing, adding MSVC support and a strict cross‑platform test suite that validates 100+ Errno and WSA constants, and a prior bugfix restored constants that could disappear on some environments.

SPVM::Thread is a lightweight SPVM module that exposes native OS threads through a thin wrapper around C++ std::thread, letting SPVM programs run tasks concurrently by creating threads with Thread->new that accept a Callback and return a Thread object. The API is simple: start a task, call join to wait for completion, and use get_id to obtain the thread identifier. It is aimed at SPVM users who need straightforward, native-thread execution without a large concurrency framework.

Google::Ads::GoogleAds::Client is the primary Perl client for talking to the Google Ads API, providing a single place to manage credentials, OAuth handlers, configuration and access to every API service. It reads settings from a googleads.properties file or environment variables, lets you override options like developer token, login or linked customer IDs, proxy, timeouts and API version when creating the client, and exposes a method for each Google Ads service so you can call operations such as searches and mutations. The module also gives programmatic access to OAuth2 application and service-account handlers, records the last HTTP request and response for debugging, and offers a die_on_faults toggle so you can choose between exception-style or explicit error-handling. Note that this client should be loaded before other Google::Ads modules and that it will die if a specified properties file cannot be read.

Map::Tube::Stuttgart is a small Perl module that gives you a ready-made Stuttgart tube map and tools to compute the shortest route between any two stations. It implements the Map::Tube role so you get the familiar route-finding and helper methods from that interface. You construct it with new and may pass an optional xml callback to supply a different map file, otherwise it uses the included stuttgart-map.xml, and its output can be used directly or fed to visualization tools such as Map::Tube::GraphViz. Note that the constructor will die if the map file is missing or corrupted.

Map::Tube::Paris is a small Perl library for finding the shortest route between stations on Paris local and regional transit networks, including metro, RER, Transiliens and tram lines. It implements the Map::Tube role so you construct a Map::Tube::Paris object and call methods such as get_shortest_route to get a route between two stations. By default it loads a bundled paris-map.xml but you can supply your own XML source via a code reference when creating the object. The XML data were taken from Wikipedia and spot-checked against OpenStreetMap and the RATP site. If the map file is missing or corrupted the constructor will die, otherwise this module is a straightforward choice for scripts or services that need basic journey planning or route lookup for Paris transit.

Map::Tube::Muenchen is a small Perl adapter that models Munich's U‑bahn, S‑bahn and tram network and makes it trivial to compute shortest routes between stations using the Map::Tube API. You instantiate the object and call methods such as get_shortest_route with station names, or provide your own XML map source at construction to override the bundled muenchen-map.xml. The module relies on publicly available map data and follows the Map::Tube role so it integrates with the same route-finding and graph utilities, and it will fail fast if the map data are corrupted. Recent maintenance replaced legacy CPAN signing with Sigstore/cosign and updated compatibility with newer Map::Tube releases.

Map::Tube::KoelnBonn provides a simple Perl interface to the Cologne/Bonn U-Bahn, S-Bahn and tram network so you can programmatically find shortest routes between stations in that region. It implements the Map::Tube role and exposes familiar methods such as new() and get_shortest_route, using a bundled XML map by default or an optional code reference you provide to supply alternate XML content. The map data were taken largely from OpenStreetMap under CC BY-SA 2.0 and the module ships a prepared koelnbonn-map.xml; the constructor will die if the map file is corrupted. This is a handy choice for Perl developers building transit tools, route planners, or network visualizations specific to the Cologne/Bonn area. Recent updates include compatibility preparations for Map::Tube v5 and a switch from deprecated cpansign to Sigstore/cosign for code signing, along with improved tests and Unicode handling.

Map::Tube::Beijing is a lightweight Perl module that gives you programmatic access to a bundled Beijing subway map and lets your code compute shortest routes between any two stations using the Map::Tube routing role. It reads an included XML map file and exposes station names either in original Chinese by default or in pinyin when you instantiate it with nametype => 'alt', and it provides the usual Map::Tube methods for finding and formatting routes. The constructor will fail if the map file is corrupted, and the module is intended for developers who want to add Beijing-specific routing or visualization to their Perl apps. Note that a notable change in recent releases is that attribute semantics were flipped so name now contains pinyin and name_alt holds the original Chinese text to match the Map::Tube ecosystem, and the current release was prepared for Map::Tube v5.x and switched package signing to Sigstore/cosign.

Map::Tube::Chicago is a lightweight Perl adapter that lets you compute shortest routes on Chicago’s L and tram network from your code. It implements the Map::Tube role so you get familiar routing methods such as get_shortest_route, and it handles ambiguous station names by appending the line name so duplicate names and interchanges that require walking or checking out and back in are treated distinctly. Construct it with new and optionally provide a code reference to supply an alternate XML map, otherwise it uses the bundled chicago-map.xml. The constructor will die if the map data are corrupted. This module is a good fit if you need simple, scriptable routing for Chicago transit inside Perl applications and it depends on Map::Tube for core behavior; recent updates ensure compatibility with Map::Tube 5.0.1 and replace legacy code signing with Sigstore/cosign.

Tvh::Htsp::Client is a compact Perl library that lets scripts talk to a Tvheadend server using the HTSP protocol, so you can query channel lists, call the server API, receive live replies, and even deserialize HTSP messages or offline EPG databases without a network connection. It offers a simple constructor with sensible defaults for host, port and debug output and convenience routines for sending and receiving HTSP messages plus helpers to look up channel UUIDs, names and IDs by name, id or channel number. The module is useful if you need to automate Tvheadend tasks, dump the EPG to JSON, or build integrations that consume channel and program data. Recent updates improved error checking and test coverage, made debug output and binary blobs easier to read by converting them to hex, and extended the channel lookup to accept channel numbers. Note that the module requires a modern Perl and is intended for developers familiar with Tvheadend or HTSP.