CPANscan

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.

Business::ISBN::Data is a data-only companion to Business::ISBN that supplies the official ISBN registration-group and publisher-range information used to parse, validate, and split ISBNs. You normally do not load it directly because Business::ISBN will load it for you, and the module ships with a copy of the ISBN Agency's RangeMessage.xml so you get authoritative ranges out of the box. If you need newer or alternate data you can point Business::ISBN at another RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable before loading the module, and if no file is available it falls back to built-in data or looks in the current directory to help bundled apps. Note that it requires Business::ISBN 3.005 or later to match the updated data structures addressing ISBN-13 handling. The project is actively updated with frequent data refreshes through June 2026, includes a recent fix to avoid unintended autovivification when reading ISBN_RANGE_MESSAGE, and is maintained on GitHub under the Artistic License 2.0.

Net::Whois::IP is a Perl module for performing WHOIS lookups on IPv4 addresses and returning the results in a program-friendly form. It will follow referrals across registries to gather progressively more detailed information and returns either a parsed hash of normalized fields or the raw WHOIS text, and it can also hand you the full chain of responses when multiple lookups are required. You can request that all duplicate field values be preserved, and the module can synthesize abbreviated ARIN parent/ancestor records into the response when applicable. Live queries require outbound TCP access to WHOIS servers on port 43. This module is useful if you need to automate IP ownership, contact, or allocation lookups from within Perl and want the data returned in a normalized structure, though poking at the low-level search options can break lookup behavior if used incorrectly.

Crypt::OpenSSL::PKCS12 is a Perl interface to OpenSSL’s PKCS#12 functionality that lets you load, inspect, verify and create .p12/.pfx bundles that pair X.509 certificates with private keys. You can construct objects from files or raw strings, extract the certificate, CA chain and private key in Base64 or binary form, verify the PKCS#12 MAC, change passwords, and produce a new PKCS#12 as a file or as a string; there are also convenience methods to dump OpenSSL-style info or a structured hash of the file contents. The module wraps OpenSSL 1.x and 3.x APIs so it works where OpenSSL is installed and requires Perl 5.8 or newer, and it exports a few optional flags for selective processing. Recent releases include important security and memory-safety fixes and correct handling of edge cases such as zero-length attributes and embedded NULs in passwords, so upgrading to the latest version is recommended if you handle untrusted or complex PKCS#12 files.

Template::Sluz is a lightweight Perl templating engine with a Smarty-like syntax that makes it easy to separate presentation from code by letting you write templates with variable substitution, dot-notation, modifiers, default values, conditionals, loops, includes, literal blocks and comments. It has no CPAN dependencies and requires Perl 5.16 or later so you can drop it into small web apps or scripts without extra baggage. Security features include an escape modifier and a new optional auto_escape mode that HTML-encodes untrusted data by default while still allowing a noescape override for trusted content. You can register any Perl function as a modifier and change the single-character template delimiters to avoid conflicts with embedded JavaScript or JSON. Recent updates added the escape and auto-escape options, alternate delimiters, and a substantial performance boost via caching and inlining.

WebService::OPNsense is a Perl client for the OPNsense firewall REST API that makes it easy to script and automate configuration and status queries from Perl. It provides a Moo-based object with lazy accessors for each API controller so you can interact with firewall rules, NAT, IPsec, DHCP, OpenVPN, DNS, captive portal and many other subsystems via simple method calls. Authentication is handled with HTTP Basic Auth using an API key and secret, and the module wraps WebService::Client to normalize requests, URL-encode query parameters, and convert HTTP errors into exceptions while returning undef for missing resources. This release is alpha and welcomes feedback and patches, and users should be aware that OPNsense does not version its API so the client may need updates when the firewall is upgraded. If you want a straightforward Perl interface to manage an OPNsense instance programmatically, this module is a practical starting point.

App::cpm is a fast command line tool for installing Perl modules from CPAN that focuses on reliability and reproducibility. It stages and prepares all dependencies before doing the final install so complex dependency trees and parallel workflows behave more predictably than with a simple one-by-one installer. By default it installs the requested distributions plus their runtime dependency closure, and it provides documentation and a tutorial to get you started quickly. The project also publishes GitHub artifact attestations for released tarballs if you care about provenance. If you want a quicker, more stable alternative to other CPAN installers like cpanminus or tools such as Carton, App::cpm is worth a look.

Map::Tube::London is a lightweight Perl module that models the London Tube network and helps you find the shortest route between stations across the main Underground, DLR and Overground lines, including Bakerloo, Central, Circle, District, Docklands Light Railway, Hammersmith & City, Jubilee, Metropolitan, Northern, London Overground, Piccadilly, Victoria and Waterloo & City. You create a Map::Tube::London object with no configuration and call get_shortest_route(from, to) to receive a Map::Tube::Route object or an exception on error, and if you install the optional Map::Tube::Plugin::Graph plugin you can also get a base64 PNG of a single line or the whole map via as_image. The module is aimed at developers who need simple routing or map output for apps, scripts or demos, and it is open source on GitHub under the Artistic License 2.0.

Map::Tube is a lightweight Perl framework for modeling metro-style transit maps and finding routes between stations. It provides a simple API to load map data (JSON or XML), look up stations and lines, and compute the shortest route by number of stops, with a preference for routes that minimise line changes. The module can also enumerate all possible routes between two stations, though that listing is experimental and can recurse deeply on very large maps. A plugin system adds useful extras such as generating base64 PNG images of maps, formatting nodes and routes as XML/JSON/YAML/text, and fuzzy name searching, and there are companion test modules to validate map data and routing behaviour. The recent v5.0.1 release made the router line-change-aware so ties by hop count are broken in favour of fewer transfers, making suggested journeys more practical for real passengers.

Module::CPANTS::Analyse is a utility for evaluating Perl distributions against CPAN Kwalitee indicators by unpacking a distribution, running a battery of analysers, and producing a structured result. You point it at a distribution tarball, call run or use the individual methods to unpack, analyse, and calculate Kwalitee, and it returns a stash containing the metrics and findings. It creates a temporary working directory for inspection and uses the Module::CPANTS::Kwalitee::* analyzers to perform checks, so it is useful for CPAN authors, QA automation, and anyone wanting an automated assessment of packaging and metadata quality.

Data::HashMap::Shared provides high-performance, file-backed shared-memory hash maps for 64-bit Perl on Linux, letting multiple processes share typed hash tables via mmap or memfd. It offers type-specialized variants for integer-to-integer, integer-to-string and string-to-string maps so storage and operations are compact and fast, and it uses futex-based read/write locks with a lock-free read path and atomic counter operations for very low-latency lookups and updates. Optional features include LRU eviction, per-key TTLs, an arena allocator for string storage, sharding for parallel writers, a keyword XS API for speed and a full method API, plus cursors, batch ops and rich diagnostics for production use. The module also includes crash-recovery logic to detect and recover stale locks and can be synced to disk for durability while remaining extremely fast compared with LMDB and similar systems in the author benchmarks. Note the platform limits: it is Linux-only and requires 64-bit Perl, and PID-based recovery assumes a shared PID namespace across processes, so cross-container sharing is not supported. After a mid-mutation writer crash a specific entry may be left with partial bytes, so the author recommends calling clear after recovery in safety-critical applications.

DBD::Sybase is the DBI driver that lets Perl programs talk to Sybase databases and compatible servers such as MS‑SQL via the Sybase Open Client or FreeTDS libraries. It provides the usual DBI connect/prepare/execute interface plus Sybase-specific connection options and attributes to control server, host/port, charset, packet size, login timeouts, and more. The driver supports multi-result sets and stored procedures, ?-style placeholders for many queries, tunable transaction behavior, and special methods for handling large TEXT and IMAGE columns or for streaming them with the underlying CT API. It also offers features for formatting datetime output, retrieving output parameters and procedure return status, and an experimental BLK bulk-load path for fast inserts. Be aware of practical limits and quirks inherited from Sybase: placeholders are constrained in where they can be used and do not work for IMAGE/TEXT or for reliably returning @@identity, bulk-load requires the BLK library and can be sensitive to data conversion, and multi-threading and UTF-8 support need specific Perl and client library versions and settings. If you need robust, low-level access from Perl to Sybase or Sybase‑compatible servers and are comfortable tuning driver attributes, DBD::Sybase is a mature and flexible choice.

Aion::Fs is a compact, KISS-oriented Perl toolkit that makes everyday file system work simple and script-friendly by offering small, focused utilities for reading and writing files, traversing and filtering directory trees, creating directory paths with mkdir -p semantics, removing files and empty directories, replacing file contents via callbacks, and querying file metadata and modification times. It defaults to UTF-8 for text operations, provides convenience helpers like catonce to include a file only once, path and transpath for cross-OS path manipulation, and include/to_pkg/from_pkg helpers for mapping between package names and file paths. The find routine accepts flexible filters and can return an iterator in scalar context which suits streaming workflows. Recent releases added lightweight filehandle helpers ilay and icat and moved configuration to Aion::Env, making this module a good fit if you want a minimal, functional alternative to heavier File::Find and File::Slurper style modules.

Algorithm::QuadTree::XS is a high-performance XS (C) backend for the Algorithm::QuadTree family that gives you a drop-in, compatible replacement for the pure-Perl implementation and is used automatically when available. It provides the same quadtree API so you can index and query 2D shapes like rectangles and circles without changing your code, while delivering much faster insert and search operations and dramatically reduced tree-clearing time in recent releases. If your application needs spatial indexing or collision-style queries and the pure-Perl version feels slow, this module provides a straightforward way to get a significant speedup with minimal fuss.

Algorithm::QuadTree is a pure-Perl spatial index that stores rectangular and circular objects in a hierarchical quadtree so you can rapidly find everything that intersects a given rectangular or circular region. You create the tree by giving map bounds and depth, add objects (as rectangles or circles) with add, and then use getEnclosedObjects to retrieve items that overlap a query area; objects can be removed or the whole tree cleared and you can set a window and scale to support zoomed views. The module uses a pure-Perl backend by default but will use an optional XS backend if installed for better performance. It is handy for fast region queries and simple collision detection in canvases or map-like data, and note that you are responsible for providing unique object identifiers if you need them to be distinct.

SPVM::Time::Piece is a compact, feature rich date and time class for SPVM that makes common time handling tasks simple and familiar. You create objects from the epoch, localtime or gmtime, parse strings with strptime and format output with strftime or built in helpers like datetime and cdate. It gives easy access to components such as year, month, day, hour, minute and second and provides weekday, yearday, timezone offset, Julian and modified Julian dates and leap year checks. The module supports arithmetic and comparisons including add, subtract, add_months, add_years and truncate to units like day or hour, and you can clone instances when you need safe copies. If you need a straightforward, Perl style toolkit for manipulating and formatting dates and times in SPVM this module covers the essentials.

SPVM::Time::Local is a compact utility for SPVM programs that converts Sys::Time::Tm objects back into Unix epoch seconds, offering timegm to reverse gmtime and timelocal to reverse localtime. It is useful when you need to reconstruct an epoch timestamp from a broken‑down time structure provided by Sys->gmtime or Sys->localtime, and it enforces a defined Sys::Time::Tm argument or it throws an exception. The module is intentionally small and focused, relies on recent SPVM and SPVM::Sys releases for compatibility, is MIT licensed, and recent releases added MSVC support and portability improvements.