CPANscan

Google::Ads::GoogleAds::Client is the main Perl entry point for working with the Google Ads API, providing a single object that manages credentials, OAuth handlers, and access to all service-specific client objects such as GoogleAdsService or AdGroupService. It reads configuration from a properties file or environment variables and lets you override settings like developer token, login or linked customer IDs, API version, proxy and HTTP options when you construct the client. The module exposes helpers to programmatically set OAuth2 application or service account parameters, captures the last request and response for debugging, and supports a die_on_faults mode that makes API errors raise exceptions instead of returning fault objects. You should load this client before other Google::Ads modules to avoid warnings. Use it when you need to run searches, mutations, or automate Google Ads tasks from Perl.

App::CriticDB is a tool for teams that need to run Perl::Critic across large codebases and avoid the cost of re-scanning every file each time. It collects and stores Perl::Critic violations on disk (currently using a Storable file backend), records each file's modification time so unchanged files are skipped on later runs, and can emit formatted violation reports to standard output similar to perlcritic for fast policy counts. It is aimed at incremental scanning and faster reporting across big repositories. Some features are still under development such as reliable file-deletion handling, additional storage backends and richer reporting formats, and the Data::Dumper storage option exists mainly for debugging and is much slower than Storable. There may also be edge cases around parsing perlcritic --format that the author notes.

Object::PadX::Enum is a small extension for Object::Pad that gives you familiar enum-style classes made of named singleton instances. You declare an enum with enum NAME { ... } and list item NAME(...) entries, and the module auto-creates per-item accessors plus class methods values, from_name and from_ordinal, injecting ordinal and name readers into each singleton and preventing direct new() on the enum class so the declared singletons are the only instances. It supports composing roles and simple inheritance for enum classes while keeping each enum's item sequence separate, and it works with Object::Pad fields and methods as usual, but fields you want to set from item arguments must be declared with :param. Note the singletons are constructed at runtime after UNITCHECK so they are not visible to earlier BEGIN or UNITCHECK code, and a few Object::Pad class attributes are intentionally unsupported. This initial release implements the enum and item keywords and adds :isa/:extends and :does support with optional VERSION checking.

Crypt::Argon2 is a Perl wrapper around the Argon2 key-derivation function that makes it straightforward to turn passwords into secure hashes or cryptographic keys. It supports the argon2id, argon2i and argon2d variants and provides functions to produce formatted password strings or raw binary tags, verify passwords, and detect when stored hashes should be rehashed because parameters have changed. You can tune time, memory, parallelism and output length and use the included calibration tool to find appropriate settings. The module bundles the reference implementation and can use optimized CPU variants at runtime, and recent releases fixed an out‑of‑bounds read in verification and added a function to report the active implementation. For secure results be sure to supply a unique, high-quality salt from a reliable randomness source.

Lingua::RO::Numbers is a Perl module that converts numbers to Romanian words and parses Romanian numeric text back into numeric values. It offers two handy functions, number_to_ro and ro_to_number, and can be used either as a simple functional interface or as an object with configurable options. The module handles integers, decimals, negative values and special values like infinity and NaN, and lets you customize formatting choices such as diacritics, the decimal point word, thousands separator and the negative sign so the output matches your style or locale. It is useful for producing human friendly Romanian amounts or for extracting numeric values from Romanian text. The code is open source on GitHub and is released under the Artistic License 2.0.

List::Util::MaybeXS is a drop‑in provider of List::Util functionality that automatically uses the fast XS implementations when they are available and reliable, and falls back to pure‑Perl versions when not, so you get the full set of list helpers like reduce, sum, uniq, shuffle, sample, pairs, zip and mesh across Perl versions without sacrificing performance. It chooses XS or PP on a per‑function basis to avoid introducing slowdowns, exposes a shared $RAND hook for controlling random behavior, and aims to match List::Util behavior closely. The pure‑Perl callbacks do have a minor difference in that @_ inside a callback will be empty compared with the XS variant seeing the outer @_. Recent updates fixed an issue that could leave sample and shuffle incompletely shuffled and made several numeric uniqueness checks more robust.

IO::Socket::IP provides a family-neutral socket class for Perl that transparently supports both IPv4 and IPv6 and is intended as a modern replacement for IO::Socket::INET. It uses getaddrinfo to resolve hostnames and service names and will try suitable address candidates, while offering a familiar constructor API plus extras like non-blocking connects, per-connect timeouts, custom socket options, and an IPV6_V6ONLY toggle for listening sockets. The module includes handy helpers for formatting and resolving local and peer addresses, a method to produce a legacy IO::Socket::INET wrapper when needed, and an optional -register import to make IO::Socket create IP sockets by default. Be aware that some platforms do not allow disabling IPV6_V6ONLY so you may need separate sockets to accept both v4 and v6 connections. Recent maintenance modernized the package to prefer using parent over base for inheritance.

Log::Log4perl::Config::YamlConfigurator lets you supply Log::Log4perl logging settings as YAML so your logging configuration can be written, loaded, and manipulated in a human friendly format. You can hand it a Perl data structure directly or raw YAML text, typically produced by YAML::PP::Load, and it supports external variable substitution via a supplied subst hash as well as environment variable substitution while parsing. The configurator implements the Log::Log4perl configurator interface so you can pass it to Log::Log4perl->init, and it also offers create_appender_instance to build individual appender objects by name even if they are not attached to any logger. It is a convenient choice when you prefer YAML for config files or need programmatic variable substitution for your logging setup.

SBOM::CycloneDX is a Perl library for producing and validating OWASP CycloneDX Bills of Materials in JSON, letting you build complete SBOMs with components, services, dependencies, metadata, vulnerabilities, annotations, licenses and signatures through a rich set of model classes. It supports CycloneDX specification versions 1.2 through 1.7, understands package URLs and SPDX license data, can serialize to JSON or hashes, and will validate output against the CycloneDX JSON Schema so you can catch schema errors before publishing. The API makes it easy to add components and dependency graphs, query components by PURL or bom-ref, and include advanced features like formulations, citations and declarations for supply-chain tracking. Recent updates improved 1.7 coverage and testing and the latest 1.08 release added Composition and Source models and switched BOM timestamps to use GMT. The module is open source on GitHub and is suitable for developers, release engineers and security teams who need to generate standards-compliant SBOMs from Perl tooling.

Clean::Eval is a thin, safer wrapper around Perl's eval that prevents clobbering of the global $@ and always returns a blessed result object that tells you whether the eval succeeded and contains useful diagnostics. The returned object is true on success and false on failure and stringifies to the trapped error, so you can check it directly in conditions and die or warn with it on failure. The block form captures the block's scalar return value in an out field on success while the string form runs code with adjusted #line information but never records a return value or sees the caller's lexical variables. A global last_error helper can retrieve the most recent failure, and the module documents a few practical caveats to watch for such as the scalar-context capture of block returns, a lexical scoping gotcha when declaring and checking the result in a single statement, and the inherent limitations of the string-eval and last_error globals.

Random::Simple replaces Perl's built-in pseudorandom generator with a modern PCG engine and gives you easy, ready-to-use helpers for common tasks like unbiased integer ranges, floating values between 0 and 1, random byte buffers, picking a random array element, and shuffling arrays. It automatically seeds from your operating system entropy so it is safe for general use and it upgrades rand() and srand() to use the better PRNG under the hood while still letting you manually seed two 64 bit values when you need reproducible results for tests. The module is designed to be fast, statistically robust, and simple to use for tasks such as coin flips, die rolls, sampling and secure-looking random bytes, and recent changes improved automatic seeding, corrected 32 bit behavior, switched to a 64 bit PCG variant for larger random values and now require Perl 5.14 or later. Note that PCG needs high quality 64 bit seeds if you choose to seed manually so use large nonzero numbers for repeatable output.

App::cpan2arch is the library behind the cpan2arch command that automates creating Arch Linux PKGBUILD files from CPAN metadata. It reads environment variables and command line options, queries MetaCPAN for distribution metadata and Arch repositories for existing packages, translates CPAN prerequisite declarations into Arch dependency syntax, and then generates a PKGBUILD which it writes to standard output or a file. The module is aimed at packagers and maintainers who want to convert Perl distributions into Arch packages and it handles the common failure modes such as missing runtime modules, network or API errors, tarball or Perl version problems, and file permission issues by reporting to standard error and exiting with appropriate codes. This is the initial v1.0.0 release.

Data::Printer::Filter::EscapeNonPrintable is a small plugin for Data::Printer that makes sure ASCII control and other nonprintable characters are visibly escaped when you dump data. When Data::Printer's print_escapes option misses certain controls like vertical tab or DEL this filter converts those characters to octal escape sequences and applies the "escaped" color styling so they are obvious in output. You enable it by adding the filter to your Data::Printer configuration or importing DDP with print_escapes and the filter name, and you can also call its parse function from another filter if you need to chain processing. This module is a pragmatic workaround rather than a core fix for Data::Printer, so use it when you need complete, colorized escaping of nonprintable ASCII while awaiting an upstream patch.

Software::License::MIT_0 is a small Perl module that supplies the text of the MIT No Attribution (MIT-0) license as a Software::License subclass, making it easy for CPAN authors to attach or print the SPDX-approved, attribution-free MIT-0 license from Perl code by providing holder information. It is focused on a single job and integrates with the familiar Software::License API so you can include a permissive, attribution-free license in your distributions without hand-copying license text. Recent maintenance updates corrected script shebangs, added a minimum Perl version and other metadata fixes, and now require a newer Software::License dependency. Report bugs on the project's GitHub page.

App::pod2gfm is a lightweight Perl helper that implements the logic behind the pod2gfm command-line tool to convert Perl POD documentation into GitHub Flavored Markdown. You create an instance with new, parse command-line options with init(@ARGV), and call run to set up filehandles and invoke Pod::Markdown::Githubert for the actual conversion. The module uses UTF-8 by default, supports writing to multiple output files without clobbering existing files, and deliberately does not attempt to handle POD encoding options the way pod2markdown does. Errors are reported to STDERR and the program exits with a nonzero status for problems like file access or invalid options. The recent 1.1.0 update added optional bash completion and various small fixes and test tidy-ups, making it a handy choice for Perl authors who want to publish POD as Markdown on GitHub.

OpenAPI::Modern is a Perl toolkit that validates HTTP requests and responses against an OpenAPI specification (v3.0, v3.1 or v3.2), letting you check that incoming or outgoing messages match the API contract and get detailed, machine-readable error reports and deserialized parameter and body data. You construct it with your OpenAPI document and optionally a JSON::Schema::Modern evaluator, then call validate_request or validate_response to receive a JSON::Schema::Modern::Result object that contains validation errors, absolute locations into the spec, and a nested data structure of parsed path, query, header, cookie and body values. The module bundles up-to-date metaschemas, supports OpenAPI-specific schema dialects, media-type matching and many parameter styles including cookie and query parsing, and it can populate defaults and be cached for fast startup in preforked apps. It works best with Mojolicious request/response objects and converts several other frameworks’ request/response types on a best-effort basis, but some features are not yet implemented such as multipart and application/x-www-form-urlencoded message bodies and automatic checking of Authorization headers. Recent releases improve OpenAPI 3.2 support and media-type handling and make internal JSON::Schema::Modern configuration updates for more robust behavior.

TUI::Vision is a top-level Perl module that brings a Turbo Vision 2.0 style text user interface toolkit to Perl projects, making it easy to build console applications with windows, dialogs, menus and widgets. It acts as an umbrella that re-exports the framework's main subsystems so you can pull in the common API with a single use TUI::Vision statement instead of importing many modules individually. The module is a Perl implementation and maintenance effort by J. Schneider based on the original Borland Turbo Vision design and is distributed under the permissive MIT license, so it is a practical choice if you want a structured, reusable toolkit for creating rich terminal interfaces in Perl.

LWP::ConsoleLogger is a lightweight debugging helper for Perl HTTP clients such as LWP::UserAgent and WWW::Mechanize that prints readable, configurable traces of requests and responses to your console. It quickly shows URIs, query and POST params, headers, cookies, HTTP status and optionally page titles and response bodies, and includes one-line wrappers (LWP::ConsoleLogger::Easy and ::Everywhere) to get started immediately. You can redact sensitive headers or params, hook in a custom Log::Dispatch logger, and apply content and text pre-filters or HTML::Restrict to transform or clean output before it is displayed. The default output is pretty, table-based formatting but can be switched to raw dumps for easy copy/paste, and all options are mutable at runtime so you can turn parts on or off as needed. The author notes it was written for common text formats like HTML, JSON and XML and that test coverage is not exhaustive, so you may need to tweak filters for unusual content.

WWW::Bizowie::API is a lightweight Perl client for Bizowie's cloud ERP that lets Perl programs make authenticated HTTP calls to the Bizowie API. You construct an object with your api_key, secret_key and site hostname and then call methods by passing a path string and a hashref of parameters. The module supports both the legacy v1 endpoint and the newer v2 endpoint, allows setting an api_version for v2 and a debug flag to help with JSON decoding problems. It handles the HTTP and JSON details using common Perl networking and JSON libraries so you can automate, integrate or script Bizowie operations from Perl without writing low level HTTP code.

EV::cares is a high-performance asynchronous DNS resolver for Perl that embeds the c-ares library directly into the EV event loop so DNS socket I/O and timers run at the C level with no Perl-level event overhead. It gives you nonblocking resolve, reverse, getaddrinfo, raw query and search operations, optional per-record TTL results for cache-friendly behaviour, bulk helpers for firing many queries in parallel, and conveniences for setting servers, local bind addresses, timeouts and retries. The module parses a wide range of record types including MX, SRV, HTTPS/SVCB, TLSA and DNSSEC-related records when your c-ares build is new enough, and falls back to returning the raw DNS packet otherwise. Callbacks are safe to cancel or destroy from within and there are introspection helpers such as active_queries, next_timeout and wait_idle for mostly synchronous workflows. Note that while DNSSEC records are parsed into Perl structures EV::cares does not perform cryptographic validation so rely on a validating recursive resolver and the AD bit if you need authenticated answers. Requires c-ares >= 1.24 and c-ares >= 1.28 for the newest record parsing, and the recent 0.02 release added bulk helpers, DNSSEC and SVCB parsing, custom EV::Loop support and useful utilities like ptr_name and parse_header.

LWP, the libwww-perl collection, is a mature suite of Perl modules that makes it easy to write web clients and simple HTTP servers by modelling web traffic as HTTP::Request and HTTP::Response objects processed by an LWP::UserAgent. It supports common schemes like http, https, ftp, gopher, news, file and mailto, and provides higher level conveniences such as cookie handling, proxy support, basic and digest authentication, HTML form parsing, robots.txt parsing and content negotiation, plus simple command line tools like lwp-request and lwp-download. The API is object oriented but also offers simple procedural helpers so it works well for scripts and larger applications alike. The project is actively maintained on CPAN and recently hardened redirect behavior in version 6.83 to avoid credential leakage by stripping Authorization headers on cross-origin redirects and by refusing https-to-http downgrades by default, with opt-outs available for legacy use. If you need to fetch, submit or negotiate web resources from Perl code, LWP is a solid, widely used choice.

Mojo::Pg is a lightweight Perl module that wraps DBD::Pg to make PostgreSQL easy and productive to use with the Mojolicious web framework. It gives simple APIs for running blocking and non-blocking queries, automatic connection caching and pooling, and integration with SQL::Abstract for generating CRUD statements. It also includes transaction support, built-in migrations for schema management, and a PubSub facility for PostgreSQL notifications so you can build real-time, multi-process apps. Sensible default DBI options and automatic connection handling after forks make it practical for web apps, services and projects that need scalable database access and real-time messaging.

Git::Server is a drop-in replacement for a standard Git server that gives administrators more powerful server-side hooks and much more granular access control than Git’s defaults. It operates via the SSH command in authorized_keys so you can bind actions and enforce per-user ACLs, enable richer hook behavior, and trigger simple push-notification deployments for instant updates. It is aimed at teams and operators who need flexible server logic without heavy dependencies and is similar in purpose to Git::Hooks but designed to be more capable and lighter weight. The project is actively maintained on GitHub and accepts issues and pull requests.

Object::HashBase is a lightweight utility for quickly building hash-based Perl objects by auto-generating a new() constructor, attribute constants and accessor methods from a simple list of field names. You declare attributes when you use the module and it creates getters, set_foo setters and FOO constants, with modifiers for read-only, write-only, deprecated setters, constant-only fields and the ability to opt out of XS generation. It supports hashref and arrayref constructors, single inheritance with inherited constants, class-level hooks for pre- and post-init initialization, and a helper to list a class's attributes. If Class::XSAccessor is installed accessors are generated in XS for speed but that can interfere with taking direct scalar references to the underlying hash slots in rare cases. Recent changes added Class::XSAccessor support, expanded init hook functionality and fixed a double-import bug.

Sys::OsRelease is a lightweight Perl helper that reads the standard /etc/os-release file defined by freedesktop.org and exposes the system or distribution identity to Perl programs, providing a singleton instance with auto-generated read-only accessors for common fields like ID, NAME, VERSION_ID and ID_LIKE plus methods to check and retrieve arbitrary attributes and the file path. It keeps dependencies minimal, lets you tweak the search path or recognized common platform names, and is useful for installers, container tooling and scripts that need to detect OS type on Linux and BSD systems while falling back to Perl's $Config{osname} if no os-release file is present.

Qmail::Deliverable is a Perl module for qmail-based SMTP servers that quickly checks whether a local email address is actually deliverable by applying the same address-to-user and .qmail logic qmail uses. It exports handy functions like qmail_local, qmail_user, dot_qmail and deliverable, and ships with a root-run daemon (qmail-deliverabled) plus a client for use from unprivileged SMTP daemons, so you can reject unknown recipients early and avoid wasting resources on spam scans or generating backscatter. The deliverable call returns fine-grained status codes that indicate not deliverable, temporarily undeliverable, unknown, or various positive delivery indications, and it includes special handling for vpopmail and common Plesk bouncesaying cases. The module intentionally fails safe for .qmail files that run programs so catch-all or program-based deliveries are treated as deliverable, and it has some limitations such as no support for user+ext syntax beyond hyphen, no percent-hack handling, plain-text control file use rather than CDB, refusal of non-ASCII addresses, and relatively limited production history. It is fast in normal setups with thousands of checks per second and offers an experimental caching path for much higher throughput.

Time::Str is a compact toolkit for parsing and formatting date and time strings across many internet and standard formats. It exposes str2time to convert textual timestamps into Unix seconds (optionally with fractional seconds), str2date to return validated components including nanoseconds and timezone annotations, and time2str to render Unix timestamps into standards such as ISO 8601 / RFC 3339, RFC 2822, HTTP, SQL, ASN.1, common log formats and more. The module handles fractional seconds with configurable precision, rounds or truncates predictably and offers a nanosecond override for exact output. For timezone handling it requires a numeric offset or a UTC designator (Z, UTC, GMT) to produce a timestamp and will capture ambiguous abbreviations like EST or IST without resolving them. Limitations include English-only month and day names, no ISO week or ordinal dates, a supported year range of 0001–9999, and deliberate non-resolution of timezone abbreviations. If you need reliable, standards-compliant parsing and formatting across many common timestamp forms with precise fractional-second control, Time::Str is a good fit.

Dist::AutomationPolicy is a small helper for Perl distribution maintainers who want to publish machine-readable policies about automated code and contribution workflows, making it easy to generate and validate the CPAN-META/automation-policy.json file that describes how code is produced, whether third-party bots may file issues or patches, and what repository actions automated agents are allowed to perform. The module provides a simple constructor, a set of predefined templates for common stances such as no_automation, human_supervised or full_automation, validation against the schema, and convenient to_json and from_json methods so you can produce or read the policy file from your build or release tooling. It supports the initial v1 policy schema, complements human-readable AI_POLICY.md or CONTRIBUTING.md files, and is aimed at projects that want a clear, machine-readable signal of their automation practices. This is an initial prototype released to CPAN with source and issue tracking on GitHub and requires Perl 5.24 or later.

Text::JSCalendar is a small Perl utility that maps between traditional iCalendar (RFC 5545) and the newer JSCalendar format so you can parse, compare, normalize, and serialize calendar events in Perl. It converts vCalendar text into Perl event structures and turns one or more events back into an iCal string, provides a cached timezone lookup for speed, a NormaliseEvent helper that removes default-valued fields, and a CompareEvents routine to test equality. This module is useful when you need to bridge CalDAV or iCalendar-based systems with JSCalendar-aware clients or tooling, and it aims to make format conversions and simple event operations straightforward.

Matplotlib::Simple is a Perl convenience layer that turns Perl data structures into Python3 matplotlib scripts and images, saving editable Python files (by default under /tmp) and optionally running them, so you only need python3 and matplotlib installed. It exposes a compact Perl API for common chart types — bar, barh, boxplot, hexbin, hist, hist2d, imshow, pie, plot, scatter, violinplot and colored tables — and supports single plots and multi subplot layouts, colorbars, labels, log scales, shared colorbars, and many matplotlib options via a Perl-friendly options hash. You supply hashes, arrays or nested structures as data and configure per-plot settings like colors, figure size, axis labels and annotations without writing Python code. The module aims to make common plotting tasks much easier than using raw matplotlib and lets you either execute the generated script or keep it for manual editing and faster batch generation.