CPANscan

DBIx::QuickORM is a Perl DSL for building modular, reusable object-relational mappings that lets you declare ORMs, servers, databases, schemas, tables, columns, links and row classes in code instead of plumbing DBI calls by hand. It supports composing pieces across ORMs, grouping connection settings into servers, choosing SQL dialects and DBI drivers, attaching plugins, and defining types, defaults, indexes and constraints so you can both generate schema SQL and shape how rows are inflated into objects. The autofill tool can inspect an existing database and automatically build schema and row classes with hooks to customize naming, skipping, and type mapping. If you need a programmable, repeatable way to map multiple databases or deployments into consistent Perl row classes and queries, DBIx::QuickORM gives a concise, extensible framework to do that.

Test::Simple is a tiny, no-frills testing toolkit for Perl that lets you write TAP-compatible tests with a single primitive. You declare how many tests you plan to run then use ok to record pass or fail and output lines like "ok 1" or "not ok 2", and the module produces sensible exit codes so harnesses and CI can tell success from failure. It is intentionally minimal to get you started quickly and is fully forward compatible with Test::More when you need richer assertions and diagnostics. Test::Simple is mature and well maintained across many Perl versions, and recent work has modernized its internals to use the newer Test2 infrastructure and cleaned up packaging and test reporting so diagnostics and line numbers are more accurate.

DBIx::QuickDB is a small utility for quickly creating disposable database servers for testing and development, letting you spin up PostgreSQL, MySQL/MariaDB, SQLite and optional DuckDB instances on demand. You can declare named databases at compile time that provide connection constants or build them programmatically at runtime, and each instance supports options like autostart/autostop, bootstrap, cleanup (which will delete the data dir so do not use it on production data), loading SQL schemas, driver selection or fallbacks, and global caching of built instances. It is designed for test suites and CI workflows where you need isolated, short-lived servers or cloned database copies, and it includes convenience features like a driver viability checker, pool and clone support, and environment knobs such as QDB_TMPDIR and DB_VERBOSE. Recent releases focus on robust teardown and resource handling including a fast_destroy path and improved watcher shutdowns to avoid leaked resources and stalled shutdowns. The source is on GitHub if you want to inspect drivers or contribute.

Audio::Scan is a fast C-based Perl module for extracting metadata and tag information from most common audio formats including MP3, MP4/M4A, Ogg Vorbis, FLAC, ASF/WMA, WAV, AIFF, Musepack, Monkey's Audio, WavPack and several others. It exposes simple routines to scan a file or filehandle for both technical info and user tags or to get just tags or just file info. You can request an audio-only MD5 to detect identical audio despite differing tags and you can locate byte offsets for seeking or produce rewritten headers for MP4 and Ogg/FLAC to build seeked streams. Embedded artwork can be skipped to save memory by setting an environment flag though some formats still allocate memory for images and FLAC files will use an internal MD5 when present. The module returns normalized, UTF-8 tag data and rich format-specific info such as bitrates, durations, offsets and codec details, making it a practical choice for media servers, taggers and batch metadata tools.

Developer::Dashboard is a Perl-based local "home" for development that unifies a lightweight browser UI, a single CLI entrypoint and a prompt status layer so links, notes, helpers, and status checks live in one place instead of scattered scripts and tabs. It runs a local web app by default on port 7890, ships a "dashboard" command with built-in helpers for opening files, querying JSON/YAML/TOML/properties, and wrapping Docker Compose, and it uses background "collectors" to prepare cached state that feeds compact indicators for the web chrome and shell prompt. The runtime is layered so per-project ./.developer-dashboard trees override a secure home runtime under ~/.developer-dashboard, and the system stages private helper assets and supports custom CLI hooks plus an installable "skills" plugin system for project-specific pages, collectors and commands. It handles lifecycle tasks like starting and supervising web and collector processes, can generate a self-signed local SSL cert, and targets mixed-language teams by keeping workflows, path aliases, file shortcuts and Docker overlays consistent across repositories.

Dist::Zilla::PluginBundle::Author::DBOOK is a ready-made collection of Dist::Zilla plugins that mirrors Dan Book's own build-and-release setup, so you can automate the routine tasks of preparing a CPAN distribution. It wires together metadata and README generation, prereq harvesting from cpanfile or prereqs json/yml, git-aware file gathering, committing, tagging and pushing, version bumping, test and pod checks, and copy-out of release artifacts like META.json, LICENSE and Makefile.PL. You can tweak behavior with a few dist.ini options such as github_user, installer and pod_tests, and the bundle assumes a git repo with a Changes file and a declared set of prereqs; it also supports a FAKE_RELEASE mode to exercise the release steps without uploading.

mb.pm is a lightweight "modulino" that lets you run Perl scripts written in a variety of legacy multibyte encodings by transparently transpiling MBCS literals and regexes into octet-oriented Perl that still behaves sensibly at the codepoint level. You run your script with perl mb.pm [options] script.pl and it produces a temporary transpiled file while adding multibyte anchoring, escaping problematic multibyte sequences, rewriting character classes, and offering an mb:: namespace of codepoint-aware helpers such as mb::length, mb::substr, mb::tr and mb::chop so you can choose byte or codepoint semantics where needed. It supports Big5, Big5-HKSCS, EUC-JP, GB18030, GBK, Shift_JIS/CP932, UHC, UTF-8 and WTF-8, works on common OSes and recent Perl versions, and avoids using Perl's UTF8 flag to reduce mojibake. Because it is a source filter it produces an extra .oo.* file and you invoke it via the mb.pm wrapper rather than changing the interpreter, and there are known limitations such as some regex and Unicode features not being supported (named codepoints, Unicode properties, some look-behind and cloistering), a Windows chdir edge case, and a few behavior differences inherited from the design choices. Use mb.pm if you need JPerl-like convenience for maintaining or running MBCS-encoded Perl scripts without converting them to UTF‑8 or rebuilding Perl itself.

Protobuf is a placeholder CPAN module that simply reserves the Protobuf namespace for future Perl bindings to Google's Protocol Buffers. It does not provide any runtime functionality or helpers and exists only to claim the name so later work can be published under Protobuf. Protocol Buffers are Google's compact, language-neutral format for serializing structured data, so if you need a working Perl implementation today this module is not the implementation you want, but it signals that official bindings may appear here in the future. The package is published under the Apache License 2.0 and attributed to C.J. Collier and contributors.

DesktopWorkspace is a concise specification for declaring what should be opened to set up a desktop workspace — applications, files, directories and browser URLs — so you can create reusable workspace presets (for example coding, writing or project-specific setups) under a DesktopWorkspace:: namespace. A specification is a DefHash containing an items array plus flags such as new_browser_window and kde_activity and each item must be one of url, file, dir or app_path with optional hints like firefox_container or per-item new_browser_window. It is aimed at automating or documenting which windows and browser tabs to open rather than performing the launches itself and currently a single spec only targets one KDE activity. The series is still 1.x/unstable with 2.x planned as the stable API and this release (1.0.0) is an early release.

Linux::Event provides a compact, Linux-native readiness event loop for Perl that uses kernel primitives like epoll, timerfd, signalfd, eventfd, and pidfd to handle timers, signals, wakeups, and child-process exit notifications. It intentionally stays at the loop-and-primitives layer, exposing a simple Loop object with a built-in epoll backend by default and relying on companion modules for higher-level socket, stream, and process helpers. The recent release simplifies the distribution into a single readiness loop, removes the experimental io_uring/proactor machinery and the older operation API, and standardizes the backend abstraction to make the API smaller and easier to use. Choose this module if you need a lightweight, native event loop on Linux for building asynchronous I/O or process integrations in Perl and prefer to assemble higher-level behavior from focused companion modules.

ioqwerty is a tiny placeholder module on CPAN that exists solely to reserve the distribution name "ioqwerty". It provides no runtime features and simply holds the namespace for the author. The package is released under the MIT license and the author lists contact as ping@ioqwerty.com. Installers should not expect functionality from this module; it is useful only for claiming the name or preventing others from taking it.

Dist::Setup is the internal library that powers the perl_dist_setup command and provides a ready-made framework for creating and maintaining Perl distribution skeletons. It generates Makefile targets and CI configuration, wires up testing helpers such as Test::CPANfile, and adds tooling for style checks, spellchecking, perltidy, perlcritic, packaging and uploading so authors can focus on code instead of build plumbing. The module is mainly useful to module authors and to the perl_dist_setup tool rather than for direct use in applications, and full user-facing documentation lives on the perl_dist_setup page. Recent updates improved GitHub CI dependency installation to avoid dependency loops when installing suggested modules and added perltidy processing of test (.pm) files, along with support for newer Perl releases.

I don't see any module POD text to summarize; what I received was only a small JSON mapping that references App::PTP::Cheat_Sheet and a script named ptp but no actual documentation content. I can't create the concise descriptive paragraph you asked for without the module's POD or a link to its CPAN page or README, so please paste the POD or provide the module name or URL and I will produce a clear, one‑paragraph summary tailored to a technically literate audience.

Params::Validate::Strict is a Perl parameter validation library that checks and coerces input against a declarative schema so your code gets well-formed, typed data back. You describe each parameter with types like string, integer, number, arrayref, hashref, coderef or object and add constraints such as min/max, regexes, enums, optional/default values, transforms, callbacks and nested schemas, and the module supports custom reusable types, positional arguments, cross-field validations and relationship rules for common patterns like mutual exclusivity or conditional requirements. It returns a new hash or positional array with coerced values and is useful for input sanitization, building simple WAF rules, generating black‑box tests or improving API documentation. The recent 0.34 release added a stringref type and more robust integer handling including acceptance of valid scientific notation while rejecting infinities and NaNs and fixed a few edge-case bugs around stringref transforms and optional callbacks. If you need a feature-rich, declarative way to validate and normalize incoming parameters in Perl, this module is likely a good fit.

Dist::Zilla::PluginBundle::Codeberg makes it easy to publish and maintain Perl distributions on Codeberg by wiring in two Dist::Zilla plugins that set up Codeberg metadata and updates for your release. It reads your Codeberg repo from a git remote or an explicit repo setting and can pull credentials from git config or a Config::Identity file; you must create a personal access token with the "api" scope. The bundle sets meta fields such as the bug tracker, homepage and wiki and offers options to prefer the dist meta, MetaCPAN or p3rl links, to follow forked repositories, and to choose the git remote name. If you already use Dist::Zilla and host code on Codeberg this bundle automates the bookkeeping and release integration. Note that the 2.0 release is a major update that adapts a GitLab-based bundle for Codeberg and includes API changes and bug fixes.

Mojolicious::Plugin::Fondation is a plugin loader for Mojolicious that helps you build modular web applications from reusable bricks by loading plugins recursively according to declared dependencies and merging their configurations with a clear priority: direct overrides, then application config, then plugin defaults. It automatically shares plugin resources like templates and public files with the application, runs configurable post-load actions to register templates, controllers and static assets, and provides a deferred fondation_finalyze hook so plugins can complete initialization after everything else is loaded. The plugin also supplies convenient helpers and a zone system for assembling HTML or JavaScript fragments from multiple plugins into layout zones. To fully participate in finalization a plugin must return $self from its register method. This initial release introduces hierarchical plugin loading, resource sharing, and a predictable configuration cascade to make composing Mojolicious apps from many small plugins easier.

Type::Guess examines a list of scalar values and infers the most appropriate data type (Str, Int, Num or DateTime when a date role is enabled) while tracking field width, precision and sign and producing an sprintf-style format string you can use to print the original values consistently. The object stringifies to that format and can be invoked like a function to format individual values, which makes it handy in formatting pipelines. Pluggable roles add features such as DateTime parsing, a dependency-free DateTime::Naive detector, Unicode-aware display widths, Type::Tiny integration, and SQL column type generation for dialects like SQLite and Postgres. You can adjust global settings such as tolerance for outliers and whether to skip empty strings, override the generated format, or export the detected attributes as a hash for reuse. Use Type::Guess when you need quick, automated type detection for display formatting or for helping generate sensible database column definitions.

Statistics::Krippendorff computes Krippendorff's alpha, a robust measure of inter‑rater reliability that handles any number of coders, missing values and varying coder participation per item. You provide units as either hashrefs mapping coder identifiers to values or arrayrefs using positions for coders and then call alpha to get the agreement coefficient. The module includes ready-made distance (delta) functions for nominal, ordinal, interval, ratio, Jaccard and MASI comparisons and also accepts a custom code reference so you can define how disagreements are measured for your data. Small helper methods let you validate inputs, inspect value frequencies and count pairable observations, making this a practical, flexible Perl tool for researchers and developers who need to quantify coder agreement.

Dist::Zilla::Plugin::SigStore::SignRelease is a Dist::Zilla plugin that automates signing your CPAN distribution archives with SigStore using the external cosign tool and can upload the resulting signature bundle alongside the release. It integrates into the Dist::Zilla release flow and is intended to replace the usual UploadToCPAN step, offering simple configuration for whether to upload the sigstore bundle, what file extension to use for that bundle, and an option to auto-accept cosign prompts. You do need cosign installed and current PAUSE/CPAN tooling does not yet perform sigstore verification for you, so the module provides guidance and example scripts for manual verification. Recent updates simplified the dist.ini settings and added support for older sigstore JSON bundle formats.

Net::Statsd::Lite is a simple Perl client for sending StatsD metrics that implements the StatsD Metrics Export Specification and can pack multiple metric lines into a single UDP packet. It offers convenient methods for counters, meters, gauges, timings/histograms and sets, supports buffered sending with optional autoflush and manual flush, and provides secure_set_add to HMAC-hash sensitive values before sending so you can record identifiers without exposing them. The API is easy to subclass to add tagging or other extensions, you can configure the socket directly and the module now uses IO::Socket::IP by default, and it performs validation on metric names and values to reduce the risk of metric-injection attacks. It requires Perl 5.20 or later. Recent releases focused on hardening and usability by switching secure hashing to the core Digest::SHA, tightening input validation to address CVEs, and making the socket explicitly configurable.

Dist::Zilla::Plugin::UsefulReadme is a Dist::Zilla plugin that builds a README for your distribution by extracting and combining selected =head1 POD sections from your main module, letting you include only the useful bits rather than dumping all module documentation. You pick which headings to include and the output format, with support for plain text, POD, Markdown, GitHub-flavored Markdown or a custom parser, and you can control filename, encoding, phase and output location from dist.ini. The plugin understands Pod::Weaver readme regions, can generate sensible fallback content for version, requirements, installation and recent changes when those sections are missing, supports appending or prepending snippets to generated sections, and can register needed developer prereqs for the chosen output type. Written as a successor to Pod::Readme and designed to sit well in Pod::Weaver-based workflows, it makes README generation configurable and repeatable for modern Dist::Zilla users. Note that v0.6.0 bumps the minimum Perl requirement to v5.24 and updates the code and build toolchain accordingly.

Net::CIDR::Set is a Perl module for representing and manipulating sets of IP addresses in a natural, set-oriented way. It accepts CIDR blocks, arbitrary start-end ranges, or individual addresses and will merge overlapping ranges for you, and it supports the usual set operations such as membership tests, union, intersection, xor, difference, complement and inversion. You can iterate over addresses, compact CIDR blocks or raw ranges and export results as arrays or formatted strings, and it handles both IPv4 and IPv6 (but not mixed in the same set unless you explicitly choose a coder). The module is handy for access control, network inventory, address summarization and related tasks, but be careful when expanding whole ranges into address arrays because those can be very large, especially for IPv6. It requires Perl 5.14 or later and the project is maintained on GitHub.

Perl::Critic::Policy::BuiltinFunctions::ProhibitForeach is a tiny, opinionated Perl::Critic rule that flags any use of the 'foreach' keyword and enforces the use of 'for' instead to keep loop style consistent across a codebase. It has no special configuration beyond the usual Perl::Critic options, so you add it when you want a single, consistent loop keyword enforced automatically. The 0.02 release modernized the test suite to the standard .run format and added explicit pass and fail cases for the prohibition.

Perl::Critic::Policy::ControlStructures::ProhibitBareBlockLoopControls is a Perl::Critic policy that helps you avoid subtle bugs and confusing control flow by flagging uses of the loop-control keywords next, last, and redo when they appear in blocks that are not actual loops or where their meaning is ambiguous. It recognizes that bare "{ }" blocks, do { }, anonymous subroutines, eval { }, and map/grep blocks do not behave the same as real while/for loops and that unlabeled loop controls in those contexts can exit the wrong block or do nothing obvious. The policy is configurable per keyword to forbid the keyword, require an explicit label, or allow it, and you can also override behavior for specific block kinds such as bare_block and do_block so the checks match your coding style. The recent updates adjusted the package name to help CPAN indexing and improved the clarity of violation messages and tests in earlier releases.

Switch::Declare adds a real, lexically scoped switch/ case keyword to Perl that is parsed at compile time and turned into ordinary Perl operations so you get readable switch syntax with performance comparable to hand‑written if/elsif chains. It evaluates the scrutinee exactly once, stops at the first matching case, and supports both statement and expression forms so a switch can either run a branch or yield a value. Cases accept a small, predictable set of pattern kinds: numeric and string literals, regular expressions, inclusive ranges, literal lists for membership tests, and predicate callbacks or inline subs that close over surrounding lexicals. For string-keyed, constant mappings with several arms the module automatically emits a single compile-time lookup table for O(1) dispatch which is noticeably faster than a long chain of comparisons. The keyword is active only inside use Switch::Declare scope so it never collides with other code, it has no external dependencies and targets core Perl 5.14 or later, and the initial 0.01 release documents these features and performance-oriented design choices.

Perl::Critic::Policy::ControlStructures::ProhibitBareBlockLoopControls is a linting rule for Perl that flags uses of next, last, and redo inside blocks that are not true loops or where their behavior is confusing, such as bare { } blocks, do { } blocks, anonymous subroutines, eval blocks, and map/grep blocks. It helps prevent subtle and hard to spot bugs by enforcing clearer control flow and by making the programmer explicitly target the intended loop when needed. The policy is configurable per keyword and per block type so you can forbid a keyword require a label for it or follow global settings, with sensible defaults that forbid next and redo in non-loops and require labels for last while treating do blocks as forbidden by default. Use this module when you want stricter, configurable checks to avoid ambiguous loop control usage and make your Perl code safer and easier to read.

PPIx::Regexp provides a safe, read-only parser and navigable parse tree for Perl regular expressions, much like PPI does for Perl code, so you can turn a regex or a PPI regexp token into an object you can inspect, query, and round-trip back to the original text. It is aimed at tools that need to analyze regexes rather than execute them, offering methods to extract regexes from PPI::Document objects, list capture names, inspect modifiers, get the pattern and replacement portions, and cache parse results for reuse. The constructor accepts strings or PPI tokens and supports options such as default modifiers, character encoding, strict re parsing, and optional indexing of element locations so parse positions match the surrounding document. PPIx::Regexp intentionally does not provide heavy-weight mutation or operator overloading and focuses on producing a stable, modern parse that tracks relevant Perl regexp changes across versions. Be aware that static parsing has limits, so ambiguous constructs and dynamic interpolation can be interpreted heuristically and nonstandard Perl extensions or source filters may not be recognized. Recent changes are mostly maintenance and documentation updates, and postfix dereference handling has been standardized so the formerly supported postderef constructor flag has been removed.

PPIx::QuoteLike is a focused Perl parsing utility that breaks down string literals and string-like constructs so you can inspect their parts, detect whether they interpolate, and extract interpolated variables for tools such as linters and code analysers. You can feed it a raw string or a PPI::Element and it returns a parsed object with methods to get content, delimiters, start and finish tokens, child elements, locations, and whether the string interpolates, plus helpers like find() and perl_version_introduced() to detect feature usage. It understands modern features such as indented here-documents and postfix dereferencing and integrates with PPI for richer context, but it is still a static parser so it cannot handle every dynamic or nonstandard syntax change introduced by external modules. The variables() helper is provided but discouraged for complex cases, and recent releases removed a deprecated postderef argument while largely making administrative updates including a SECURITY policy and licensing metadata with no functional changes.

Business::KontoCheck is a Perl XS wrapper around the konto_check C library that validates German and Austrian bank account numbers and related identifiers. It provides functions to check account check digits for German BLZ-based accounts and Austrian accounts, validate IBAN and BIC, and generate or read compact lookup tables (LUT files) created from Bundesbank or Austrian INPAR data. The module also lets you look up bank metadata such as name, short name, postal code, city, BIC, branch counts and successor BLZ entries, convert numeric status codes into readable messages with selectable encodings, run flexible searches across the LUT by name, BIC, PLZ or complex multi-field queries, and rebuild or customize LUT files for fast local lookups. Note that LUT generation uses a modern compressed format and older formats are deprecated, the Austrian LUT generator is not thread safe and some features require the official input files or optional compression libraries. The Perl glue code is distributable under the same terms as Perl while the underlying C library is LGPL.

Mojolicious::Plugin::Qooxdoo is a Mojolicious plugin that makes it easy to host Qooxdoo web frontends and their JSON-RPC backends from a Perl app. It installs the routes and static asset handlers you need and provides a JsonRpcController base class you can subclass to implement server-side RPC methods, with simple options to set a URL prefix, path, controller class and namespace. During development it can serve your Qooxdoo source directly by flipping an environment variable so POST callbacks still work, while in production it will serve the generated build from your public directory. The plugin supports asynchronous responses and Mojo::Promise, keeps error details out of client responses by default, and warns about verbose debug logging. A recent 1.1.0 update added full JSON‑RPC 2.0 support while preserving the legacy qooxdoo protocol; the dispatcher auto-detects the envelope and routes requests to the appropriate handler so you can use modern RPC semantics without breaking older clients.