CPANscan

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.

Test::Mockingbird is an advanced mocking toolkit for Perl test suites that makes it easy to replace or wrap methods, record calls, inject fake dependencies, intercept constructors, verify call order, and work with async Future-based stubs via the companion Async module. It supports both shorthand and longhand target syntax, stacked LIFO mock layers, scoped guards that automatically restore on scope exit, and a set of convenience helpers for fixed returns, exceptions, sequences and one-shot mocks, plus diagnose_mocks/diagnose_mocks_pretty to inspect active layers and restore_all to clean up. The recent 0.12 release adds before, after and around wrappers so you can run hooks before or after the original or receive the original coderef to implement call-through behaviour cleanly and predictably. The author documents a few practical limitations such as spy() emitting prototype-mismatch warnings when wrapping prototyped subs and Package->can sometimes appearing truthy for auto-vivified but non-callable stubs, with recommended workarounds in the documentation.

Email::Abuse::Investigator is a tool for analysts and security teams that inspects the raw source of suspected spam or phishing messages and extracts the facts you need to file abuse reports. It parses RFC‑2822 messages, walks the Received headers to find the likely originating IP and its owner, pulls every http/https URL from text and HTML parts and resolves their hosts, and gathers domain intelligence from mailto links, From/Reply-To/DKIM/List‑Unsubscribe/Message‑ID fields including WHOIS/RDAP, MX, NS and registrar details so you can identify who to contact. The module produces analyst-facing plain text reports and compact abuse-report bodies ready to send, collates email and web‑form recipients, computes a heuristic risk score with flagged issues, follows common cloud-storage and shortener redirect cloakers when LWP::UserAgent is available, and supports IPv6 and cross‑message caching via CHI to avoid repeated lookups. Optional modules such as Net::DNS, LWP::UserAgent, Domain::PublicSuffix, AnyEvent::DNS and CHI greatly improve accuracy and performance. Known limitations documented by the author include no automatic charset conversion, a hand‑rolled MIME parser that is not fully RFC conformant, IPv4‑only CIDR matching for trusted_relays, lack of WHOIS rate‑limit handling, and non thread‑safe global cache and no live DMARC TXT lookups. In the recent 0.14 release the provider abuse table was expanded to cover Google Translate cloaker hosts and Google Workspace SMTP domains so those hosts now resolve to actionable abuse@google.com contacts and unresolved_contacts() handling was corrected, making it easier to identify and report Google‑hosted cloaked phishing pages.

Termbox::PP is a compact, pure-Perl implementation of the Termbox terminal UI library that makes it easy to build text-mode interfaces without XS or external C libraries. It gives you a simple, cell-based back buffer for drawing text and attributes, functions to initialize and restore the terminal, helpers to print formatted UTF-8 text, and event objects for keyboard, mouse and resize handling so you can write a single-threaded render loop that responds to user input. The module aims to mirror the termbox2 API while staying small and portable, works out of the box on Unix with core Perl and can be used on Windows with the usual console support libraries, and it exposes utility routines for Unicode handling, color modes and low-level raw output when needed. The project is still evolving so expect occasional API tweaks, and recent updates have restored Windows Virtual Terminal support, improved Unicode width handling and performance, and fixed a few export and initialization edge cases.

YAML is a Perl module that provides simple Load and Dump functions to read and write YAML, the human-readable data serialization format, converting between YAML documents and Perl data structures. It handles mappings, sequences, scalars, aliases, multi-document streams, optional preservation of key order via YAML::Node, and even experimental support for code references and typeglobs, plus convenience helpers for files and an interactive YAML shell. This distribution is the original, Perl-native YAML implementation and is handy for producing readable dumps and working with YAML in scripts, but the author cautions that it is old, has known bugs and limited maintenance and recommends newer alternatives such as YAML::PP or YAML::PP::LibYAML for most production use.

Business::NAB is a lightweight top-level Perl namespace for working with National Australia Bank interchange file formats, not a standalone tool but a hub that exposes focused modules for creating and parsing BPAY batches and remittances, Direct Entry payments/returns/reports, NAI/BAI2 account information files, and XML acknowledgements, along with a small type library. It lets Perl apps handle NAB-specific file interchange without making you implement the record formats yourself. Recent updates (0.06) improved robustness by guarding against rare rounding errors and preventing partial file writes, and earlier releases added account-number padding to match bank expectations. The code is free under the same terms as Perl and development happens on GitHub if you want to report issues or contribute.

CPAN::Maker::Bootstrapper is a command-line scaffold that creates a ready-to-build Perl CPAN distribution with one command by installing a managed Makefile, a prefilled buildspec.yml, .pm.in/.pl.in source stubs, tests, and supporting make snippets and then running make to produce a distributable tarball. It is aimed at developers who want a reproducible, local build system that enforces good practices out of the box such as dependency scanning, syntax checks, perltidy and perlcritic gates, modulino support, and an upgrade-safe extension point via project.mk so you can customize builds without touching the managed Makefile. It also bundles AI-assisted workflows tied to the Anthropic Claude API for iterative code and POD reviews, annotation-driven review rounds, and LLM-generated release notes and changelogs, with prompt profiles and dry-run token estimates to control cost. The importer can bring existing .pm, .pl and test files into a new project and the CI builder helper and workflow targets make it easy to reproduce builds in Docker or GitHub Actions. Note that import and stub modes are mutually exclusive, imported files are copied as “.in” sources and are not auto-tidied, the importer relies on package declarations to place modules under lib, and inter-module build-order issues may require declaring dependencies in project.mk. Recent releases have refined release-notes generation and LLM tooling and added features such as an ExtraFiles role and other improvements to the build and prompt handling.

CLI::Simple is a lightweight, object-oriented base class for building modulino-style command line Perl tools that need options, subcommands and positional arguments. It uses Getopt::Long parsing and auto-generates getters for options and extra properties, integrates with Log::Log4perl including per-command log levels, and supports an optional role-based architecture driven by a YAML manifest so you can split commands into Role::Tiny roles and scaffold a CPAN-ready project. The module ships useful internal commands and helpers such as -dump-spec, -scaffold and -generate-completion for bash completions, a create-modulino helper, customizable help sections and optional pager output, and it keeps lifecycle and validation explicit via a simple init/run flow so you stay in control. The design favors minimal dependencies and pragmatic features like option and command aliases, custom error handlers and easy defaults. Recent updates add an automatic color appender for logging and make Term::ANSIColor an optional recommended dependency so you can get colored log output without forcing a hard dependency.

CallBackery is an application framework that wires a Mojolicious web engine to a ready-made frontend framework so you can build appliance-style web user interfaces quickly. It centralizes configuration, database access, RPC dispatch and security headers and exposes convenient attributes for config files, a pluggable database backend, RPC controller and initial documentation index so the server side can drive a Qooxdoo frontend. The module is aimed at developers who want a batteries-included backend for interactive web apps and it includes sensible defaults such as an etc/callbackery.cfg config file with an override via the CALLBACKERY_CONF environment variable. Recent work modernized the RPC layer to JSON‑RPC 2.0 and improved session expiry handling and frontend error/ retry behavior, plus ongoing frontend bug fixes to form loading and triggers. The distribution is released under the GNU GPL.

Sys::OsRelease::Lite is a lightweight Perl helper that reads the standard /etc/os-release file and exposes the operating system and distribution metadata to your scripts in a simple, consistent way. It provides a singleton interface with ready-made accessors for common fields like id, id_like, version_id and pretty_name, plus generic methods to list, check and fetch any discovered attributes, and a platform helper that maps common ID_LIKE values to familiar platform names. The module keeps dependencies minimal so it is suitable for use in system scripts, installers and containers and it will fall back to Perl's native osname if no os-release file is found. Recent changes added a Sys::OsRelease::Lite packaging variant to maintain compatibility with older Perls before 5.22 and adjusted the Lite delivery for CPAN, making the same functionality available on legacy systems.

Sys::OsRelease is a lightweight Perl helper for reading the standard /etc/os-release file used by Linux and BSD to identify the operating system and distribution. It provides a singleton-based interface with convenient read-only accessors like id(), id_like(), name() and many more, plus generic methods such as get(), has_attr(), found_attrs() and platform() to return a normalized platform name. The module keeps minimal dependencies and supports both class-style and object-style usage so scripts can easily detect OS type for configuration, packaging or installation logic. It requires Perl 5.22 or newer and a repackaged Sys::OsRelease::Lite exists for older Perl versions.

Perl::Dist::APPerl delivers APPerl, a single-file portable Perl runtime that runs the same binary across multiple x86_64 operating systems and can carry Perl modules and scripts inside the executable as a ZIP filesystem. Using the apperlm command you can create and manage build configurations, build from an existing APPerl or compile Perl and the Cosmopolitan libc from scratch for static builds that support XS extensions, and include CPAN distributions by pointing apperlm at tarballs or folders. At runtime APPerl can dispatch embedded scripts by path, by an environment variable, or by argv[0] so you can ship standalone Perl applications, bundle a consistent interpreter for teams, or carry Perl on a USB drive without installing anything. It also supports debugging features like syscall tracing and function tracing and notes that building from source requires Linux. Recent releases added official builds for Perl 5.42 and 5.44 along with a variety of build and test fixes to improve compatibility.

Getopt::Class is a lightweight wrapper around Getopt::Long that lets you declare a dictionary of typed command‑line options and group them into named classes so you can collect, validate and access related sets of options for different features of your program. You define each option with type, aliases, defaults and validation rules and the module converts parsed values into convenient typed objects (scalars, booleans, arrays, files, URIs, datetimes, hashes) that you can access as hash keys or as methods. It supports mirrored enable/disable and with/without forms, required and regexp checks, action callbacks, and class-level helpers to extract only the values relevant to a given feature, and it reports structured errors instead of dying. If you build command line tools that expose multiple feature areas or need richer validation and objectified option values, Getopt::Class simplifies wiring Getopt::Long into that workflow. The module is mature and actively maintained with a recent v1.2.0 release and updated dependencies.

Pod::Man converts Perl's POD documentation into *roff using the man macros so you can produce standard Unix manual pages viewable with man or nroff. You can run it via the pod2man script or use it as a parser object to read POD from files, strings, or filehandles and write formatted output to a file, handle, or string. The module defaults to UTF-8 output and provides options to control headers, footers, section number, output encoding, quote characters, and optional "guesswork" rules that simplify common Perl documentation patterns. On modern systems that use groff or mandoc UTF-8 output renders correctly but very old troff/nroff implementations may not support Unicode and Pod::Man offers a legacy "roff" mode for backward compatibility at the cost of poor non‑ASCII rendering. Note that some *roff quirks remain, such as sentence spacing and the treatment of hyphens and quotes, which Pod::Man handles conservatively to preserve command names and copy/paste behavior. Pod::Man is included in Perl core and is actively maintained.

OpenAPI::Modern is a Perl library that validates HTTP requests and responses against an OpenAPI v3.0, v3.1 or v3.2 document and returns a detailed JSON::Schema::Modern::Result describing any errors and the deserialized request or response data. It loads your OpenAPI description, uses the JSON::Schema::Modern evaluator to resolve $ref and schema dialects, and provides convenient methods such as validate_request, validate_response, find_path_item and recursive_get so you can map an incoming Mojo, Plack, Catalyst or Dancer2 message to the right operation and check parameters, headers, cookies, querystrings and bodies against the spec. The module bundles up-to-date metaschemas and media-type decoders, supports type coercion and optional default-population of missing values, and can be cached or serialized for faster startup in preforked deployments. Note that some less common features are not yet implemented, multipart messages are unsupported and the module does not itself enforce Authorization schemes, so for best results parse network messages into Mojolicious objects before validating. The most recent release fixes path matching for URIs containing URL-escaped characters and improves restoration of cached documents and format handlers after deserializing an OpenAPI::Modern object.

mb.pm is a single-file Perl tool that makes it easy to write and run Perl scripts containing multibyte literal text in many legacy encodings as well as UTF-8 and WTF-8, by transpiling MBCS source into safe octet-oriented Perl or by providing a runtime mb:: API for selective codepoint-aware operations. It supports Big5, Big5-HKSCS, EUC-JP, EUC-TW, GB18030, GBK, Shift_JIS / CP932, UHC, Johab, HP-15 and others, automatically escapes problematic multibyte sequences that collide with ASCII metacharacters, and rewrites regular expressions and character classes so they behave sensibly for multibyte codepoints while leaving traditional byte-oriented builtins unchanged. You can use it as a source filter on modern Perls, as a modulino wrapper (perl mb.pm script.pl) for older Perls, or call mb:: routines at runtime to get codepoint semantics where needed, and it also includes helpers for Windows globbing and filename handling. The author notes some tradeoffs and limits, for example the modulino wrapper path writes a transpiled .oo file and there are intentional omissions such as full Unicode property support and non ASCII casing, plus a few platform-specific quirks, but for anyone maintaining or writing Perl that must work with MBCS source text or porting JPerl-era scripts this module is highly practical.

CBOR::Free is a fast XS-based Perl library for encoding and decoding CBOR data, aimed at making compact binary data interchange easy from Perl. It converts common Perl values to CBOR and back, supports tagged values, Types::Serialiser booleans, optional preservation of shared or circular references, and several string-encoding modes so you can choose how text and binary data are represented. Decoding yields UTF-8-decoded Perl strings for CBOR text and undecoded scalars for binary, and the module will warn or throw on invalid or extra input so you get predictable error handling. Be aware that floating point behavior depends on your Perl build and that integer handling follows CBOR and Perl limits, so very large integers or non-IEEE floating types may need special handling. The distribution is experimental and its interface may change, but it is lightweight, performs competitively with other CBOR and binary serializers, and is licensed under the same terms as Perl.

JQ::Lite is a pure-Perl implementation of a jq-like JSON query engine that lets you run familiar dot-notation filters and pipelines from Perl code or the bundled jq-lite command-line tool without installing external binaries or XS modules. It supports traversal, optional-safe key access, array flattening and indexing, boolean filtering, pipe-style chaining, mapping/reduction helpers, many jq-compatible built-in functions, and an interactive REPL, and it returns native Perl scalars, arrayrefs, and hashrefs for further processing. The module is especially useful in minimal, locked-down, containerized, or air-gapped environments where the jq binary cannot be installed but jq-style querying is needed, and it can use JSON::PP by default with optional faster decoders if available. In the current 2.48 release the author fixed comparison handling for values produced by piped filters and restored reliable access to object fields named "count", improving correctness for chained queries.

JSON::Schema::Modern is a full-featured Perl evaluator and validator for JSON Schema that implements the current draft2020-12 specification and earlier drafts, letting you validate Perl data structures or JSON strings against rich schema documents. It provides a configurable evaluator with options for short-circuiting, strict unknown-keyword checking, format validation, custom format and media-type handlers, content decoding, and an option to surface default values discovered during validation, and it can register schema documents or resolved resources for reuse and caching. The module returns detailed result objects rather than just a pass/fail flag and includes traversal and schema-validation helpers useful for tooling such as OpenAPI processing. It supports serialization for caching large evaluator objects and provides hooks for adding custom encodings, media types and vocabularies. Note that it does not automatically load schema files from disk or the network, formats are treated as annotations by default unless enabled, and you should use a trusted JSON decoder such as Cpanel::JSON::XS to ensure correct typing. Recent updates improved media handling for application/x-www-form-urlencoded payloads and made cached schema deserialization more robust. If you need a standards-compliant, extensible JSON Schema engine in Perl for validation or API tooling, this module is highly relevant.

CPANSA::DB is a data-only Perl module that packages the CPAN Security Advisory database as a ready-to-use Perl data structure. Calling its single db() subroutine returns a hash reference containing all advisory reports so tools like CPAN::Audit or your own scripts can programmatically check modules and versions for known security issues. The distribution also provides the same data in JSON and is published on GitHub with GPG signatures and GitHub Attestations so you can verify authenticity. The dataset is updated regularly and recent releases have focused on trimming the data into a more compact format and keeping the advisory records current.

Catalyst::Plugin::JSONRPC::Server is a small plugin that adds JSON-RPC 2.0 request handling to Catalyst apps by giving your context two helpers, jsonrpc_register and jsonrpc_dispatch, so you can register method handlers inside a request and have the plugin parse, route and respond to JSON-RPC calls over HTTP. It builds a fresh dispatcher per request so handlers and any closures do not leak between requests, and you can tune behavior with configuration like max_body_bytes (default 10 MiB) or supply your own dispatcher to change limits such as max_batch (default 1000). Handlers receive the JSON-RPC params and return results or throw a Catalyst::Plugin::JSONRPC::Server::Error to signal JSON-RPC errors while a plain die becomes a guarded internal error. Dispatch writes the appropriate HTTP response, returning the response payload or undef for notifications, and there is a jsonrpc_dispatch_with method if you need to reuse or preconfigure a dispatcher. The distribution includes a runnable example app and client so you can see echo and sum handlers in action.

Stats::LikeR brings a compact, R-like toolkit of data frame operations and statistical routines to Perl with an emphasis on speed and familiar idioms, offering frame-aware functions that work on array-of-arrays, array-of-hashes, hash-of-arrays, and hash-of-hashes and a large suite of stats tools such as lm, glm, aov, anova, t_test, wilcox_test, chisq_test, fisher_test, kruskal_test, and many correlation and descriptive routines, plus data wrangling helpers like agg, group_by, merge, concat/rbind, melt, pivot_table, assign, dropna, fillna, ffill/bfill, drop_duplicates, select/drop_cols, csort, and utilities like vals, colnames, rownames, qcut, quantile, rank, and uniq. The API is styled to feel like List::Util and R idioms so you can group, aggregate, reshape, and join tables with concise calls while benefiting from XS-accelerated numeric cores for heavy work. The module also includes robust I/O with read_table and write_table that handle CSV/TSV and XLSX, the latter much faster and leaner in recent releases, and it aims to be portable back to older Perl 5.10. In the recent 0.24 release the interpolate routines were moved into XS giving large speedups for linear, pchip and spline methods and now match pandas/scipy behavior to high precision, read_table gained much faster XLSX parsing and lower memory use, and several convenience frame operations such as bfill, ffill, melt, pivot_table and drop_duplicates were added, so if you need R-style data frame workflows or statistical tests inside Perl with production performance, Stats::LikeR is likely relevant.

Gherkin is the Perl implementation of the Gherkin language parser and compiler used by the Cucumber project. It reads feature files (including Markdown-formatted Gherkin), parses them into an AST and compiles executable scenarios known as pickles, and emits protobuf-based Cucumber::Messages wrapped as NDJSON envelopes so downstream tools can consume a standard message stream. The API is stream-oriented: call Gherkin->from_paths or from_source and supply a unique-ID generator coderef and a sink coderef to receive Envelope messages, and control whether the Source, GherkinDocument (AST) and/or Pickle messages are included via options. The module respects encoding headers in feature files and provides a to_json helper on envelopes for UTF-8 NDJSON output. Note that older releases used plain hashes but modern versions send Cucumber::Messages objects, and recent updates added Markdown Gherkin support and the ability for a step to carry both a DocString and a data table, keeping the parser aligned with the evolving Gherkin grammar. If you are building Cucumber tooling or any pipeline that needs a canonical Gherkin parser in Perl, this module is directly relevant.

Pod::Simpler::Aoh is a small Perl module that takes POD documentation and converts it into a simple, program-friendly array of hashes so you can inspect, search, and manipulate sections of documentation from code. You create a parser, feed it a file or a string, and it returns an arrayref or array of hashes where each entry represents a POD section with keys like identifier, title, and content. There is an option to split content into element-level hashes for finer-grained processing, and convenience methods let you retrieve a single section by index or search the parsed POD by a key and value. The module builds on Pod::Simple and aims to make POD easier to work with in scripts and tools that need structured access to documentation.