CPANscan

DBIx::QuickDB makes it trivial to spin up temporary database servers for testing and development so you can get a real PostgreSQL, MySQL/MariaDB/Percona, SQLite or optional DuckDB instance up and running in a disposable directory and connect to it with DBI. You can declare named databases at compile time that expose connectable constants or create them on the fly with build_db, and each instance can be tuned with a spec (autostart/autostop, bootstrap, cleanup, data directory, driver choice, SQL to preload, and more). It is designed for test suites and short-lived environments and will automatically manage startup, shutdown and optional cleanup of the data directory, so do not enable cleanup on any important persistent database. Environment variables like QDB_TMPDIR and DB_VERBOSE control temp locations and server output, and recent improvements added a no_disconnect_handles option for callers that keep live DBI handles and made teardown and Windows cleanup far more robust.

MooX::LazierAttributes provides a compact DSL for declaring Moo or Moose attributes so you can write far less boilerplate when building attribute-heavy classes. It exports an attributes() helper that turns concise array-style specifications into full has declarations and a set of small constants like is_ro, is_rw, lzy, bld and handy defaults such as lzy_array or dstr to reduce repetition when declaring read-only or read-write, lazy, typed, built or required attributes. The module understands Types::Standard and Type::Tiny constraints, accepts CODE-ref defaults and lazy builders, and includes support for extending parent attributes with a '+name' syntax. Recent notable improvements added attribute extension with '+', Type::Tiny support, defaulting to ro when omitted, and a coe constant for coercion, making it a simple way to keep attribute declarations clear and concise.

Eshu is an XS-powered tool that automatically fixes indentation and produces syntax-highlighted HTML for a wide range of programming and markup languages. It rewrites only leading whitespace while tracking language-specific nesting so your code content stays intact and the output is consistently formatted. You can call per-language methods from Perl or use the convenience dispatcher to detect language by filename, and there is a command-line tool and a vim plugin for editing workflows. The library supports many languages out of the box including C, Perl, JavaScript and TypeScript, Python, Go, Rust, Java, PHP, Ruby, Lua, Bash, SQL, YAML, JSON, XML/HTML, CSS and POD, and it offers options to use tabs or spaces and to set indent width. It also provides file and directory helpers that can run dry runs, produce diffs, write fixes back to disk, and skip binary or oversized files. The highlighting API returns HTML with span classes for tokens so it can be styled easily. Recent releases added an XS-backed highlighting pass and expanded language support to TypeScript, Python, Go, Rust, Java, PHP, Ruby, Lua, Bash, SQL, YAML and JSON.

Font::Metrics gives you accurate glyph advance widths, kerning adjustments, and basic typographic metrics for the PDF Standard 14 fonts and for TrueType/OpenType fonts loaded from disk, so you can measure text in points at any requested size. It exposes simple methods to get a single character's advance, the width of a string, ascender and descender distances, cap and x heights, natural line height, and the kerning adjustment for a pair of characters; note that string width does not apply kerning automatically so you can add kern_pair between pairs when you need exact layout. Standard 14 metrics come from Adobe AFM data and include the most visually important Latin kern pairs for Helvetica and Times families while Courier, Symbol and ZapfDingbats have no kerning. TrueType/OpenType loading reads the usual font tables including head, hhea, hmtx, cmap, OS/2, kern and GPOS and merges kerning from kern and GPOS with GPOS taking precedence, and cap/x height values come from OS/2 when available with sensible fallbacks for older fonts. This initial release implements the core measurements and table parsing needed for accurate typography and page layout.

Mnet is a compact toolkit of Perl modules for building testable network automation and reporting scripts with minimal fuss. It provides Expect-based CLI helpers for reliable SSH and device interaction, stanza parsing for indented device configs, a report table engine that can emit csv, json or sql, a test recorder/replayer to record expect sessions and replay them for offline regression tests, batch processing for concurrent device runs, and small helpers for logging, command line options with password redaction, and IP parsing. You can use the pieces independently or together to log into routers and switches, capture and parse configuration or interface data, aggregate results, and run repeatable tests during development. The project is actively maintained and the latest release removed parsed environment variables after option parsing to reduce credential exposure and fixed minor warnings.

Mojolicious::Plugin::Fondation::Menu is a small plugin for the Mojolicious Fondation framework that provides database-backed, declarative menu management for web applications. Menus are declared in a share/menus.json file inside each plugin and synchronized to the database with a single "menu sync" command. The system supports hierarchical menus, ordering, icons and colors, visibility conditions based on groups or permissions, open-tab flags and optional descriptions. It installs helpers to fetch and render menus and breadcrumbs and to check visibility conditions, and it exposes a simple REST API with CRUD endpoints and permission checks for admin tooling. This is a lightweight way to centralize and manage navigation items across plugins while keeping rendering ACL aware. The module is at version 0.02 and provides the initial feature set.

Mojolicious::Plugin::Fondation::MigrationDBIx adds an integrated "db" command suite to Mojolicious applications that use DBIx::Class via the Fondation DBIx::Async plugin, letting you generate and apply schema migrations, copy and load fixture data, and inspect or change the database version from the command line. It can bootstrap a minimal Schema class, produce migration SQL from your Result classes, discover and copy fixtures shipped by plugins into your app, run installs, incremental upgrades and downgrades, show migration status, and populate the database from versioned fixture sets. Backend selection and database driver are resolved from your configured DB backends so you do not need to hardcode drivers, and a schema drift helper warns if your live schema differs from prepared migration files while leaving the app running. Configure the target backend and migrations directory if you need nonstandard locations. This plugin is useful if you want a straightforward, plugin-aware workflow for managing DBIx::Class schema changes and test or seed data in Fondation-based Mojolicious apps.

Mojolicious::Plugin::Fondation::Perm is a small plugin that brings permission management into Fondation-based Mojolicious applications, letting developers centralize authorization logic and enforce access rules within their web app. It is aimed at projects using the Fondation stack that need a built-in way to check and apply permissions so you do not have to invent your own access-control wiring. The module is lightweight and focused on integration rather than changing Fondation itself and the recent 0.02 release simply cleans up the package by removing unnecessary fixtures.

Mojolicious::Plugin::Fondation::Setup provides an interactive web setup wizard at /setup to configure Fondation-based Mojolicious apps. It discovers Fondation plugins on MetaCPAN, shows which are installed and which are missing, and helps you select plugins while automatically including dependencies. For missing modules it displays the exact cpanm command to run and pauses configuration until they are installed. For each installed plugin that exposes a setup schema via fondation_meta the wizard presents a simple form with fields prefilled from any existing .conf file, then generates a final application configuration file (e.g. myapp.conf). All wizard state is stored in Mojolicious sessions so no database or files are required to track progress and a reset route clears the session. The plugin integrates with the Fondation workflow and uses Fondation::Layout::Bootstrap for its pages.

EV::Etcd is a high-performance asynchronous etcd v3 client that embeds the native gRPC Core C API into the EV/libev event loop to provide non-blocking access to the full etcd feature set. It supports key-value operations, watches, lease management and keepalives, distributed locks, authentication and role/user management, maintenance and cluster administration, leader election and transactions. Streaming operations return handle objects you can cancel and can optionally auto-reconnect with configurable retry limits and health callbacks. Callbacks receive structured response and error hashrefs with a retryable flag so you can implement application-level retry for unary RPCs which do not retry automatically. Keys and values are treated as raw bytes so you must encode and decode character data yourself. Be aware that callbacks are stored in C structures which can retain references until streams are cancelled and that client objects are not safe to use after fork.

Alien::SNMP is an "Alien" installer that downloads, builds, and exposes the Net‑SNMP C library and its Perl bindings so you do not have to provide libnetsnmp yourself. It makes the library available to other Perl modules and build scripts by providing bin_dir for the net‑snmp utilities, plus cflags and libs for compiling and linking against the installed library. The build is tuned for a client-side footprint with IPv6 and AES support enabled and with the SNMP agent, manuals, MIBs, embedded Perl, and extra scripts disabled, so it is a good choice if you only need the library and Perl extension for SNMP tasks rather than a full SNMP agent deployment.

BATsh is a pure-Perl bilingual shell interpreter that lets you mix Windows cmd.exe batch syntax and POSIX sh/bash syntax in the same script and switches between modes automatically on a line-by-line basis. CMD and SH sections share a common variable store so data set on one side is immediately visible to the other. The module implements many familiar shell features such as pipelines, I/O redirection, functions, arrays, tilde expansion, getopts and traps and runs entirely inside Perl so you do not need an external cmd.exe or bash to execute scripts. Non-builtins are still executed by the host operating system so availability of commands like FINDSTR or SORT depends on the platform. BATsh also supports CP932/Shift_JIS auto-detection and character-aware substring/length operations for Japanese Windows scripts. Recent 0.07 updates include important security hardening to make SH redirection and process-substitution safe against quoting and injection issues and fix several quoting and subshell bugs.

Devel::Cover::Report::Codecovbash converts Devel::Cover output into the JSON file the Codecov bash uploader expects, making it easy to push your Perl coverage results to codecov.io. By default it writes cover_db/codecov.json when you run cover -report codecovbash and that file can then be uploaded with the official Codecov bash script. The reporter bridges a small semantics gap between Devel::Cover, which reports statement coverage, and Codecov, which measures line coverage; by default a line is treated as covered if any statement on it is covered and you can opt in to require all statements on a line to be covered via the DEVEL_COVER_CODECOVBASH_COVER_ALL_STATEMENTS environment flag. The module is lightweight, MIT licensed, and its source is available on GitHub. Recent work added the per-line policy option so you can choose stricter line coverage semantics when needed.

DBI is the standard, database‑independent interface for Perl that gives your scripts a single, consistent way to connect to many different databases through driver modules (DBD::*) and to perform SQL work with a simple API: connect, prepare, execute, fetch, commit and disconnect. It supports prepared statements and placeholders for safe, efficient queries, transaction control, and convenience helpers such as selectrow_*/selectall_* and selectcol_arrayref, plus cached prepares and cached connections to reduce overhead. Error handling and behavior are configurable via handle attributes like RaiseError, PrintError and AutoCommit, and it also provides tracing and profiling facilities to diagnose performance or correctness issues. Because DBI is an API layer and not a database driver, the exact capabilities available to you depend on the DBD driver you choose, but DBI’s wide adoption and active community mean drivers exist for most mainstream databases. The recent 1.651 series includes important security and robustness fixes, addressing several CVEs, tightening placeholder handling and out‑of‑bounds checks, and improving DBD::File safety, and the project warns that the next release will require Perl 5.12, so plan upgrades and driver compatibility checks accordingly.

Crypt::SysRandom is a small, portable Perl module that gives you cryptographically secure random bytes straight from the operating system via a single function, random_bytes($count). It automatically selects the best available backend for your platform, trying an XS implementation first, then Windows RtlGenRandom via Win32::API, and finally /dev/urandom on Unix. Use it when you need true system randomness for keys, nonces, salts, session tokens or any other security-sensitive data. The API is minimal and easy to drop into existing code so you can rely on OS-provided entropy without implementing randomness algorithms yourself.

Test::CPANfile is a small test helper for Perl distributions that checks whether your cpanfile actually lists every module your code "use"s. It scans your source and test files and reports a failing test when a used module is only declared as a recommend or suggest instead of a require, while ignoring core modules by default unless you change perl_version or set exclude_core. You can tune its behavior to include test helper PMs, add extra library directories for private modules, ignore specific files or patterns, and extend checks to recommends, suggests or develop phases. For ambiguous cases you can pass a CPAN::Common::Index instance so a used module passes if its distribution contains a sibling module listed in cpanfile. It integrates with Test::More and exposes a single cpanfile_has_all_used_modules() call with options to customize scanning and matching.

Syntax::Construct is a small utility for Perl authors who want to explicitly declare which language syntax extensions their code uses so users on older Perls get clear, actionable error messages instead of cryptic parse failures. You add the non-feature constructs you rely on with a simple use Syntax::Construct qw(...); and the module will report which construct is unsupported on an older interpreter. It also exposes introduced() and removed() helpers so tools or install-time checks can query when particular constructs appeared or were removed, which makes it easier to avoid needlessly bumping a script's required Perl version or to identify replacements for ancient runtimes. The module is actively maintained to follow new Perl releases and its recent updates track the latest Perl versions and add new constructs and minor fixes so it stays useful as the language evolves.

Business::ISBN::Data is a companion data package for Business::ISBN that provides the official ISBN range and publisher code information derived from the ISBN Agency's RangeMessage.xml, so Business::ISBN can validate, parse, and format ISBNs correctly. The module is normally loaded automatically by Business::ISBN and ships with a copy of RangeMessage.xml while also falling back to built‑in data or a RangeMessage.xml found in the current directory, and you can point it at an alternate file by setting the ISBN_RANGE_MESSAGE environment variable before loading Business::ISBN. Note that the data structure changed to address an ISBN‑13 prefix bug so you should use Business::ISBN 3.005 or later. The data are updated frequently and available on GitHub, and a recent fix stopped unintended autovivification of ISBN_RANGE_MESSAGE to avoid accidental creation of that variable.

Org::Parser is a Perl module that reads Emacs Org-mode files and turns them into a structured Org::Document tree so you can programmatically inspect headlines, lists, tables, timestamps, links, drawers and other Org elements. It accepts input as a string, array of lines, filehandle or filename and offers a parse_file helper that can optionally cache parsed results to speed up repeated reads, while the resulting document provides walk-style traversal and element methods for querying and manipulation. The parser is regex-based and aimed at being "good enough" for handling real notes and todo files rather than being a drop-in replacement for Emacs parsing, and it will die on syntax errors so you get immediate feedback. Recent updates added a document attribute to ignore unknown drawers along with a bugfix that correctly passes that option through, and a companion command-line utility in a separate distribution helps with debugging and inspection.

Chandra::Markdown is a small helper for Chandra apps that converts Markdown into safe, styled HTML and can inject that output straight into your app's webview. It defaults to GitHub Flavored Markdown so you get tables, task lists, autolinks and other GFM features, and it can optionally syntax highlight fenced code blocks and inject a built‑in stylesheet for token colors and layout. It also offers utilities to scan a directory of .md files, register routes for each document, build a searchable index and return a navigation HTML fragment, plus a search_widget that registers a handler and emits a search input you can embed in your layout. Constructor flags let you toggle GFM, hard breaks, highlighting, target element id and CSS injection. If you are building documentation pages, blogs or other content-driven screens inside a Chandra application this module makes rendering, routing and client-side search simple to set up.

Markdown::Simple is a fast XS-based Perl module that converts Markdown into HTML with GitHub Flavored Markdown as the default and easy options to toggle strict CommonMark or individual features like tables, strikethrough, task lists, autolinks, raw-HTML handling and soft line breaks. You can use the simple functional call for one-off conversions or create a Markdown::Simple object to reuse the native parser arena when rendering many documents for better performance. There is also a strip_markdown helper to produce plain text without losing scan-readable list and table structure. Recent releases added SIMD-accelerated code paths for speed and a new highlight option that leverages the Eshu library to syntax-highlight fenced code blocks when a language tag is present.

PDF::Make is a comprehensive Perl toolkit for creating, parsing, and editing PDF documents. It offers a high-level, chainable Builder API that handles page management, coordinate translation, word wrapping, and font metrics so you can assemble reports, forms, and image-rich pages quickly, and it also exposes a low-level XS API for direct manipulation of PDF objects and content streams when you need full control. The distribution includes support for standard and TrueType fonts, JPEG/PNG images, annotations, interactive AcroForm fields, encryption and digital signatures, optional content layers, attachments, redaction and metadata sanitisation, tagged PDF structure for accessibility, watermarks, linearisation for fast web view, and tools to extract text, annotations, forms, and tables from existing PDFs. Runtime dependencies are minimal. The most recent update improves the Builder layout engine by switching row rendering to a flex-based layout for both width distribution and height calculation and adds an example that demonstrates weighted columns, auto height, gaps, and mixed font sizes. Use PDF::Make when you want a Perl-native way to build, inspect, or modify PDFs ranging from simple generated reports to complex, spec-level document editing.

Layout::Flex is a fast C/XS implementation of the CSS Flexible Box layout algorithm for Perl that computes exact positions and sizes for a list of items inside a container. You give it container dimensions and item descriptors and it returns an ordered list of [x, y, w, h] rectangles ready for rendering or further processing. It supports row and column directions, single-line and multi-line wrapping, justify and align behaviors, per-item margins, min/max constraints, gap between items and lines, and per-item grow and shrink factors. For content-driven layouts you can supply a built-in approximate measurer or a custom callback that returns natural widths and heights, and items that need text wrapping can trigger a second measurement pass once their final width is known. The engine follows CSS flexbox semantics including align_content distribution of wrapped lines and always reports the content box excluding margins. This module is useful when you need programmatic, CSS-like layout in Perl applications such as GUI toolkits, PDF or image composition, or custom rendering pipelines.

Map::Tube::Plugin::Graph is a Moo role that plugs into Map::Tube classes to turn tube network data into GraphViz graphs and ready-to-use images, letting you produce full network maps or per-line diagrams in formats like PNG, SVG, PDF or raw DOT. You can extract a Graph object for analysis or visualization with as_graph, or use render/as_png/as_image to produce binary files or base64-encoded images and to write output to disk, with control over output format and layout engine. The module relies on GraphViz2 and the system GraphViz tools, and it also exposes helper methods to list available drivers and formats on your machine. The recent 1.1.0 release modernizes the API with a flexible render() call, safer automatic output naming, GraphViz capability introspection, and tidy wrappers for as_png and as_image, while bumping the minimum Perl requirement and adding explicit dependencies for reliable environment detection. If you need to visualize or export tube networks programmatically this module provides a straightforward bridge from Map::Tube data to GraphViz-powered diagrams.

MojoX::Authentication is a compact, opinionated helper for adding authentication to Mojolicious web applications, providing ready-made flows for local logins (in-memory or SQLite) and SAML 2.0 single sign on. It wraps common tasks such as wiring up Mojolicious::Plugin::Authentication, injecting the current user into the stash, handling credential-based login and logout, and initiating and finishing SAML2 SSO, with sensible defaults like looking for username and password parameters and stashing the user as "user". The module expects a simple model object and assumes a single identity provider for SAML, so it is best suited to developers who want a batteries-included, easy path to add authentication rather than a fully generic framework. Documentation is light but an example app demonstrates usage, the minimum Perl version is 5.24, and recent updates include refactoring and stricter error behavior on creation in version 0.004.

CPAN::Maker is a command line tool for Perl authors that turns a simple YAML "buildspec" into a complete CPAN distribution tarball, handling file staging, dependency resolution, Makefile.PL generation and the standard build steps so you do not need external bash scripts. It can validate buildspec files against a JSON schema for CI, preview or emit a Makefile.PL, and generate cpanfile dependency manifests from plain text lists, and it exposes options to control version pinning, test execution, cleanup of the temporary build area and output location. The workflow is declarative and reproducible, making CPAN::Maker a good fit for module maintainers who want an automated, schema-validated way to package and publish Perl distributions.

App::Codit is a lightweight, Perl/Tk-based integrated development environment built for Perl developers who prefer an editor written in Perl. It provides a multi-document interface with syntax highlighting, code folding, smart undo/redo, auto-indent, auto-brackets and completion, plus bookmarks, snippets and a configurable GUI. Codit is plugin-driven, shipping plugins for Console, FileBrowser, Git, Pod viewing, search and replace, sessions and more, and it is fully configurable via a settings window and command-line options. Because it uses Tk::CodeText and Tk::AppWindow it runs on systems that support Perl/Tk and is a good fit if you want a customizable, extensible editor implemented entirely in Perl. The recent 0.20 release improved compatibility with newer Tk::FileBrowser versions and includes several plugin fixes, making it easier to run with updated Tk components.

Tk::ListBrowser is a canvas-based, chameleon list widget for Perl/Tk that can present items as a single-column list, multi-column rows or columns, a horizontal bar, an HList or a Tree and supports images and multiline text. It offers sortable headers and side columns, per-item data and column items, keyboard and mouse navigation, on-the-fly filtering, configurable selection modes and options to control cell sizing, wrapping and text layout. You interact with it through simple methods to add, hide, show, sort and refresh entries and to create headers or side columns, making it a handy choice for building rich list views in desktop Tk apps. It is aimed at small to medium sized lists (a few hundred entries) and the author notes that custom fonts and very large lists will slow refresh and updates. Recent releases tightened up anchor and selection drawing in multi-column setups, improved header handling and added finer control over item drawing and refresh behavior.

Schedule::Cron is a lightweight cron-style scheduler for Perl that runs inside a single long‑running program and calls Perl subroutines on a crontab-like schedule. It understands common crontab syntax and Vixie extensions, supports an optional seconds field, lets you load crontab files or add entries dynamically, and can dispatch either a default handler or a per-job subroutine with arbitrary arguments or evaled argument lists. You can run jobs in forked child processes or in the main process with controls to skip overdue jobs, catch exceptions, and receive an after_job callback. The module also offers hooks for custom logging, process title control, custom sleep handling, daemonization with pid file, and a global timeshift feature. Note that daylight saving time changes are handled in a best-effort way and behavior during the fallback hour is platform dependent, as documented by the author. The recent release updates a DST-related test to use America/Los_Angeles.