CPANscan

Map::Tube::Hamburg provides a simple way to compute shortest routes between stations in the greater Hamburg rail network, covering U-Bahn, S-Bahn and the AKN line. It implements the Map::Tube role so you can call familiar methods such as get_shortest_route after creating an object with Map::Tube::Hamburg->new. The constructor accepts an optional xml code reference to supply a custom map file or XML content, otherwise it uses the bundled hamburg-map.xml, and it will die if the map file appears corrupted. Map data were derived mainly from OpenStreetMap under CC BY-SA 2.0 and the module itself is licensed under the same terms as Perl. Recent updates moved the repository and issue tracker to GitHub and replaced deprecated code signing with Sigstore/cosign while improving the build script.

Map::Tube::Glasgow provides a simple Perl interface to the Glasgow Subway map so you can query and compute the shortest route between any two Glasgow stations. It implements the Map::Tube role and ships with an XML map file by default, while the constructor also accepts an optional code reference to supply alternate XML content. The module acts as a lightweight data adapter that enables Map::Tube's route-finding features for Glasgow stations and will die at construction if the map file is corrupted. The map data come from a Wikipedia source under CC BY-SA and the module is distributed under the same terms as Perl. Recent maintenance moved the code and issue tracking to GitHub, replaced deprecated code signing with Sigstore/cosign, and updated packaging and dependency requirements to match newer Map::Tube and Perl versions.

IO::Socket::SSL is a widely used Perl module that brings SSL/TLS into your socket code by wrapping OpenSSL (via Net::SSLeay) behind the familiar IO::Socket API, so you can make secure clients and servers with minimal changes. It provides sensible, security-minded defaults for protocol versions and ciphers, does hostname verification and SNI automatically, supports OCSP stapling, ALPN/NPN, TLS 1.3 features, PSK, certificate pinning by fingerprint, session caching and many advanced hooks for fine control, and it can upgrade plain sockets for STARTTLS-style workflows. Because TLS has tricky behaviors, the module documents important differences for non‑blocking I/O, select/poll-based event loops and thread interactions and offers helpers such as pending(), $SSL_ERROR and start_SSL/stop_SSL to manage them. Recent releases fixed layering and upgrade edge cases and restored the old behavior of closing sockets on failed handshakes created with new while leaving upgraded sockets open on start_SSL. If you need robust, configurable TLS support in Perl code that works like regular sockets, IO::Socket::SSL is the right choice.

JSON::JSONFold reformats pretty-printed JSON into a more compact yet still readable layout by folding arrays, objects and simple nested structures to reduce unnecessary vertical space. It offers a functional API, an object-oriented formatter, a streaming writer for incremental post-processing, and drop-in replacements for JSON::encode_json and JSON::to_json, so you can use it wherever you already produce JSON. You can control the target line width, choose presets or per-call overrides, tweak indentation and key sorting, and plug in a custom JSON encoder when needed. The streaming writer accepts pretty JSON chunks and writes folded output without buffering the whole document, and write operations return simple formatting statistics. JSON::JSONFold is useful when you want human-friendly JSON that takes fewer lines while staying clear and easy to scan.

Map::Tube::Brussels provides a simple Perl interface to find shortest routes on the Brussels metro system by reusing the common Map::Tube routing role and a bundled brussels-map.xml data file. You create an object, optionally choose Dutch rather than the default French station names with nametype => 'alt', and call the familiar Map::Tube methods to compute and format routes between stations. The module is useful if you need programmatic routing or human-readable directions for Brussels specifically and it ships with verified station and line data drawn from Wikipedia and OpenStreetMap. The constructor will die if the map file is corrupted and the author notes occasional minor source discrepancies that need verification. The code is free software under the same terms as Perl and recent maintenance moved the project to GitHub and updated signing and packaging practices.

CPAN::MetaPackager is a small utility for turning CPAN's package index into a local, queryable SQLite database named cpan.metapackager.sqlite, so you can import the 02packages.details.txt.gz file and work with CPAN metadata offline or in automated workflows. It is aimed at developers and maintainers who need machine-readable package information or who want to generate and manage changelogs programmatically. The module provides import/populate routines and records timing information during import, and its changelog was converted to a machine-friendly Changelog.ini format. The project is maintained on GitHub by Ron Savage, is released under the Perl 5 license, and recent updates (1.04) refreshed the instructions and rebuilt the database from a new 02packages.details.txt.gz.

CPAN::MetaCurator is a toolkit for building and maintaining a curated SQLite database of CPAN metadata and Perl Wiki content and for turning that data into browsable web trees and exports. It ingests CPAN package lists and Perl Wiki tiddlers into cpan.metacurator.sqlite, offers scripts to rebuild and validate the data, and can export the curated information as HTML, CSV and jsTree-friendly structures so you can produce clickable, searchable module catalogs and topic trees for a website. The distribution also includes search and validation helpers, support for optionally reading a CPAN::MetaPackager database, and utilities to collect statistics and generate module tables. Recent work focuses on producing an explicit tree structure before rendering, now using Tree::DAG_Node, plus improved export parsing and HTML-escaping to make generated links safer and easier to use. If you maintain a CPAN-related index, documentation site, or want a programmatic way to turn Perl Wiki and CPAN data into a navigable tree, this module provides a practical, scriptable foundation.

HTML::Composer is a Perl library that lets you build validated HTML from plain Perl arrays and hashes using a concise, data-driven syntax inspired by TyXML and Hiccup. You describe elements, attributes and content as nested Perl data structures and the module renders a complete HTML document or a single partial, automatically handling tags, attributes, escaping and a DOCTYPE. It can produce raw unescaped fragments via an unsafe wrapper when you need to inject prebuilt script or markup, and it can optionally cache generated templates for better performance. The builder croaks on validation errors so you get immediate feedback, making it a good fit for web apps, static page generators, testing tools or any code that needs a clear, programmatic way to produce correct HTML.

SPVM::File::Spec is a lightweight port of Perl's File::Spec that gives SPVM programs a portable, platform-aware way to build, split, normalize and convert file paths. It exposes familiar class methods such as catfile, catdir, join, splitpath, splitdir, canonpath, abs2rel, rel2abs and helpers like tmpdir, rootdir and devnull, and each method simply forwards to a singleton File::Spec::Instance so the platform specific behavior is handled by instance implementations for Unix or Win32. Use this module when you need to manipulate file names without hardcoding path separators or platform conventions. See the File::Spec::Instance implementations or the project repository for platform details and source.

SPVM::Compress::Raw::Zlib is a low-level SPVM wrapper around the zlib compression library that gives SPVM programs direct access to Deflate and Inflate operations and zlib constants. It provides classes for streaming or in-memory compression and decompression and adds convenient gzip and gunzip static methods that compress and uncompress strings while handling common options like AppendOutput and WindowBits for you. This module is useful when you need efficient, controllable zlib behavior from SPVM code rather than a high-level abstraction. It is actively maintained on GitHub under the MIT license and recent releases added gzip/gunzip and the AppendOutput option and improved Windows/MSVC support and builds so it works well on modern SPVM environments.

App::KBLIUtils is a small toolkit for working with Indonesian KBLI codes (Klasifikasi Baku Lapangan Usaha Indonesia), providing command line utilities and library routines to look up titles and descriptions for the 2020 and 2025 KBLI releases, list codes, and compare mappings between the two versions. The distribution exposes a set of CLIs such as get-kbli-2020-title, get-kbli-2025-description, list-kbli-2020-codes and compare-kbli-2020-2025-codes for quick scripting and automation, while the underlying functions return programmatic, HTTP-like enveloped results with status, reason and payload for integration into Perl programs. It is handy for developers, data analysts and anyone who needs to validate, transform or report on Indonesian industry classification codes. The recent 0.003 release consolidated the command line tools into version-specific names and added the title/description and comparison commands. Source and documentation are available on CPAN and GitHub.

TableDataBundle::Business::ID::KBLI is a CPAN distribution that provides ready-made Perl table datasets for Indonesia's KBLI business classification, bundling modules for the 2020 categories and the 2020 and 2025 code lists. It is meant for developers who need a reliable, program-friendly source of KBLI codes for tasks such as validating business activity data, normalizing or mapping activity descriptions, building forms or APIs that require standard codes, and producing reports. The datasets are delivered as TableData:: modules so they integrate easily with code that consumes table-style data. The package is free software available on CPAN with source on GitHub and is useful whenever you need an authoritative, versioned KBLI lookup inside a Perl application.

SPVM::Go brings the Go language style of concurrency to SPVM, providing a Go class that lets you spawn lightweight goroutines, create buffered or unbuffered channels, perform select-style multiplexing, and coordinate work with wait groups, timers and contexts. It exposes scheduler primitives to yield and to block on IO with optional timeouts, plus sleep helpers and signal utilities, and ships companion modules such as Go::Channel, Go::Select, Go::Sync::WaitGroup, Go::Time and Go::Context. The implementation builds on coroutines so you can use familiar Go patterns inside SPVM programs, and note that some scheduler operations must be invoked from the main thread. Development and examples are on the project GitHub and runtime debugging can be toggled with the SPVM_GO_DEBUG environment variable.

Plerd is a tiny static-blog engine that turns Markdown files kept in a Dropbox-synced directory into a complete web site and feeds, making it easy to write and maintain a blog from plain files. You configure a few basics like the content path, blog title, base URI, and author info, provide templates, and Plerd renders post pages, recent and archive listings, tag indexes, and syndication feeds without a database or heavy stack. It supports tags, social-media metadata (now emitting Open Graph tags for better link previews), optional webmention handling, JSON Feed and Atom/RSS, and a watcher that performs incremental publishes so changes scale well as your archive grows. Recent releases also ensure atomic writes so your web server never sees half-written files, normalize Windows line endings, and make filenames robust for titles with unusual characters. If you want a minimal, file-first blog workflow that integrates with Dropbox and emphasizes simplicity and predictable static output, Plerd is a good fit.

App::Test::Generator is a toolkit for automatically generating robust black‑box tests for Perl code by turning a concise input/output schema into ready‑to‑run Test::Most fuzz and property tests. You give it a YAML or Perl schema that describes parameter types, constraints and expected outputs and it emits .t harnesses that combine randomized fuzzing, deterministic boundary cases, optional static corpora and Test::LectroTest property checks, with support for semantic generators (email, uuid, url, ipv4/6, semver, json, etc.), transforms that express input→output relationships, and Return::Set/Params::Validate style validation. It also integrates with mutation testing and LCSAJ coverage to drive a feedback loop that writes TODO stubs or runnable augmented schemas for surviving mutants so CI can iteratively kill regressions, and it includes scripts and a dashboard workflow to run scheduled fuzzing on GitHub Actions. You can run it from the CLI (fuzz-harness-generator, extract-schemas, test-generator-index, generate-test-dashboard) or call App::Test::Generator->generate() from Perl, and control reproducibility with seed and iterations plus many configuration knobs for edge cases and timeouts. If you publish CPAN modules or maintain critical Perl code and want to broaden test coverage beyond hand‑written unit tests, this suite delivers automated fuzzing, property testing, and mutation‑guided test generation to uncover boundary errors and regressions. The recent 0.40 release focused on hardening the CI and mutation pipeline, fixing a long list of cross‑platform and correctness bugs so dashboards, per‑mutant reporting, and schema extraction behave more reliably on CI and Windows.

Map::Tube::RheinRuhr is a small Perl module that makes it easy to find routes on the public transit network in Germany's Rhein/Ruhr region, covering Dusseldorf, the Ruhr area and nearby cities. It loads a bundled XML map and, by using the common Map::Tube role, provides handy methods such as get_shortest_route to compute the best connection between two stations. You can supply your own XML source at construction time if you need a custom map. The constructor will fail if the map data are corrupted. The map content was gathered from operators' websites and the module is free software under the same terms as Perl. Recent maintenance moved the project to GitHub and replaced deprecated cpansign signatures with Sigstore/cosign, and the distribution now requires newer Map::Tube and Perl versions.

XML::PugiXML is a Perl binding for the pugixml C++ XML parser that gives you a fast, memory-efficient DOM API with full XPath support and convenient read/write functions. It expects UTF-8 input and produces UTF-8 output and offers parsing options to include or skip comments, CDATA, processing instructions, DOCTYPE and whitespace nodes. You can load or save files, serialize to strings with formatting flags, navigate and modify the tree, clone nodes and attributes, and compile XPath expressions for repeated use. Node and attribute handles keep the underlying document alive so you can hold onto handles even after the document variable goes out of scope. The parser does not process external entities and does not expand user-defined internal entities, so it is safe against common XXE and entity-expansion attacks by default. Benchmarks included by the author show substantial speed gains over XML::LibXML for parsing, traversal and modification. Be aware that concurrent access to the same document is not thread safe and that parse failures return false and set $@ while XPath syntax errors raise exceptions.

Alien::pugixml is an Alien::Base wrapper that makes the pugixml C++ XML parser available to Perl builds by either locating a system installation or downloading and compiling the library from source. It exposes the standard Alien methods and supplies cflags and libs for ExtUtils::MakeMaker or other build tools so XS modules can easily link against pugixml, and it will use pkg-config when available to detect system installs. The current release updates the source build to pugixml 1.16 and treats system pugixml versions 1.8 and newer as acceptable. This module is a good fit when your Perl extension or application depends on pugixml but you want installs to work without manual library setup, and it is distributed under the same license terms as Perl.

Zuzu is a tiny Perl helper for running ZuzuScript code from Perl. It exposes zuzu_eval for parsing and evaluating a ZuzuScript source string and zuzu_evalfile for loading a UTF-8 script file and evaluating it. Both accept runtime options like module denial lists and library paths so you can restrict or extend the script environment. Use this module to embed quick one-off evaluations, run or test Zuzu scripts from Perl, or glue Zuzu modules into a Perl workflow. It is free software distributed under the Artistic License 1.0 or the GNU GPL v2.

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.

CLI::Simple is a small, object-oriented helper for building Perl command-line programs that follow the modulino pattern so the same file can be used as a module or an executable. It wires up Getopt::Long-style option parsing, automatic getter/setters for options, simple command dispatch with positional arguments, and optional Log::Log4perl logging while keeping dependencies low. For larger projects it can load a YAML manifest and compose Role::Tiny roles so you can declare commands and options data‑driven and scaffold role stubs automatically with built‑in actions like -dump-spec, -scaffold and -migrate, and it can also generate bash completion scripts for your wrapper. The design is intentionally minimal rather than a full framework, making it a good fit for internal tools, admin scripts, and projects that want a lightweight, testable CLI surface without heavyweight frameworks. Recent 2.0.x releases introduced the role-based workflow and scaffolding, and the 2.0.4 update fixes an uninitialized warning in the usage output.

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.