CPANscan

HTTP::Validate is a Perl utility for validating and cleaning HTTP request parameters against reusable, human-readable rulesets so your web routes, forms and APIs only receive well-formed input. You define named rulesets composed of parameter rules (mandatory, optional, multiple, split, aliases, defaults, cleaners) and inclusion rules (allow, require, require_any, require_one, etc.) then call either the procedural check_params or an OO validator to get a result object that contains cleaned values, errors, warnings and convenience accessors. The module ships a set of common validators for integers, decimals, enums, booleans and flags, lets you write or parametrize custom validators, and can auto-generate Pod documentation from the rules so your docs stay in sync with validation logic. It works with Dancer, Mojolicious, Catalyst and similar frameworks and can be used with CGI when combined with a persistent handler. The 1.0 release adds list_rulesets, list_rules and value_list methods and fixes a number of bugs to improve reliability and test coverage.

Tree::DAG_Node provides a simple, battle-tested object for building and manipulating N-ary trees by treating each node as an object you can name, attach attributes to, and link into a parent/children structure. It can be used directly or extended as a base class and protects you from invalid linkages like cycles or multiple parents while offering a rich set of convenience methods for adding, removing and replacing children and siblings, traversing depth first, copying subtrees or whole trees, serializing to and from list-of-lists notation, and rendering ASCII diagrams of your tree. The module also includes utilities for reading and writing tree text with UTF-8, for producing test networks, and for explicit tree destruction via delete_tree to break Perl reference cycles and free memory. The API is large and featureful, so it can feel heavyweight for tiny tasks but is efficient for simple use and flexible when you need advanced tree operations or to subclass it for domain-specific behavior. Note that a couple of helpers such as random_network were written for testing and may not be suitable for production randomization without review. If you need a straightforward, well proven way to represent parse trees, syntax trees, game trees or other hierarchical structures in Perl, this module is likely relevant.

Tree::Cladogram renders phylogenetic trees (cladograms) into image files using either Imager or Image::Magick, reading a plain tab-separated text format that lists parent, placement (above/below) and node names. It ships command-line scripts and sample .clad inputs so you can generate publication or web-ready diagrams quickly and tune appearance with options for branch color and width, margins, title and leaf fonts, font sizes, and spacing; the output image type is chosen by the output filename suffix and Image::Magick in particular supports a very large range of formats. The module builds the tree with Tree::DAG_Node, handles overlap of leaf labels, and provides methods to adjust most drawing parameters programmatically, so it fits easily into scripts or batch workflows. Be aware that font support can vary by renderer and platform so TrueType rendering may require the appropriate backend in Imager or use of Image::Magick, a limitation the author documents and accounted for in testing. Recent updates modernize the packaging and licensing files and add an AI_POLICY.md alongside a refreshed LICENSE.

Crypt::PasswdMD5 is a compact Perl module for creating MD5-based password hashes that interoperate with Unix MD5-crypt implementations and Apache .htpasswd files. It provides unix_md5_crypt and apache_md5_crypt to produce compatible hashed password strings and a utility random_md5_salt to generate salts when you do not supply one. The implementation follows the common FreeBSD-style MD5-crypt so hashes can be used with existing systems that expect that format. Use this module when you need to generate or validate legacy MD5-crypt password entries for authentication, but not as a general-purpose encryption tool.

Dist::Mgr is a practical toolkit and command line helper for automating the full lifecycle of a Perl distribution from creation to release. It scaffolds a Module::Starter-based skeleton, wires up Makefile.PL/ExtUtils::MakeMaker metadata, integrates with Git/GitHub and GitHub Actions for CI, manages version numbers and Changes files, updates copyright years, builds testable dists and can upload tarballs to PAUSE/CPAN. The module is designed as a set of utilities invoked from the provided distmgr script and assumes GitHub and Module::Starter for many workflows. Recent releases improved compatibility with newer Module::Starter and modern Perls and fixed a bug that could mis-handle nested module directories when moving generated files after initialization.

Template::Sluz is a compact, dependency-free Perl templating engine that brings a Smarty-like syntax to Perl projects and makes it easy to separate presentation from code. You assign variables in Perl and render template files or strings with familiar constructs such as {$var} and {$obj.field}, modifiers via the pipe syntax, default values, if/elseif/else conditionals, foreach loops, includes, literal blocks, and comments. Any Perl function can be used as a modifier and you can change the single-character delimiters if your templates contain curly braces. The 0.9.4 release introduced an HTML escape modifier and an optional auto-escape mode with a |noescape override, added alternate delimiter support, and significantly improved performance through caching and inlining. It targets Perl 5.16 or newer, has no CPAN dependencies, and is a good fit when you want a small, familiar templating layer for web pages or simple view rendering while retaining control over escaping and output.

String::Util is a compact Perl utility module that bundles a set of small, practical string-manipulation helpers for everyday scripting and web work. It offers trimming and whitespace tools such as trim, ltrim, rtrim, collapse and nospace, safe output helpers like htmlesc and jsquote, quote and brace stripping with unquote, and simple checks and comparisons including contains, startswith, endswith, eqq and neqq. It also provides ords and deords for converting characters to numeric representations, repeat for simple repetition, crunchlines for collapsing blank lines, sanitize for making filenames or slugs safe, file_get_contents to read whole files into scalars or arrays, and substr_count to count substring occurrences. Nothing is exported by default so you import only what you need and you can opt to export everything with the :all tag. Installable from CPAN via cpanm String::Util, it is a lightweight, handy toolkit if you need reliable small building blocks to clean, check, and prepare text.

Concierge is an orchestration layer that bundles authentication, session lifecycle, and user record storage behind a single, consistent API so your app never has to wire those pieces together manually. It uses Argon2 for password hashing and keeps credentials out of user records, supports multiple backends for sessions and users such as SQLite, YAML, CSV/TSV or in-memory, and stores desk configuration and data in a filesystem directory called a desk. The module returns Concierge::Desk::User objects for three participation levels — visitor, guest, and logged-in user — enforces one active session per user, maps cookie-style user_keys for restore flows, and can convert guest sessions into full accounts. Its component pattern makes it easy to swap in alternative auth methods like LDAP or OAuth or to add additional record stores while preserving the same high-level API. If you want a ready-made, extensible identity layer for web applications that separates authentication, sessions, and user data, Concierge is a practical, well-structured choice.

Concierge::Auth is a tiny runtime factory that turns a fully qualified backend class name into a usable authentication backend instance. It does not guess short names or provide defaults, so you must call Concierge::Auth->new with backend => 'Concierge::Auth::Pwd' or another fully-qualified, conforming class and any backend-specific options. The module require's the named backend at runtime, passes all remaining arguments straight through to that backend's constructor, and returns the backend object directly so you can call domain methods like authenticate, is_id_known, enroll, change_credentials and revoke. It will croak if no backend is supplied or if the backend cannot be loaded or constructed. Recent 0.5.0 changes are a breaking refactor: Concierge::Auth was simplified from a monolithic password implementation into this thin dispatcher and the authentication behavior now lives in backends that implement Concierge::Auth::Base; the distribution also includes a built-in file-backed backend Concierge::Auth::Pwd and generator helpers for backends.

App::Greple::xlate is an add-on for the greple search tool that locates specific text blocks in files and replaces them with machine translations, letting you translate only the parts you want rather than whole documents. It supports modern LLM engines (gpt-5.5 via the llm command) and DeepL, caches translations per file so unchanged text is not re-sent, and can re-translate only edited paragraphs while supplying surrounding context to preserve wording. The module provides masking and anonymization features to protect markup and sensitive strings before they are sent to the API, understands template expressions and YAML front matter so generated documents and macros survive translation, and emits results in several convenient formats including git-style conflict markers and plain translated text. A command line tool and Emacs helper are included and Docker images are available so the workflow runs without local dependencies. In the recent 2.00 release the default LLM backend was moved to the llm command and the module gained context-aware differential translation, anonymization and templating features and cache-seeding for recurring reports, making it especially useful for translating structured documents, templates, and large projects while minimizing API calls and preserving consistency.

Inline::CLIPS is a lightweight Perl wrapper that lets you run CLIPS expert-system programs from Perl. CLIPS is a rule‑based engine for expressing facts, templates and rules, and this module provides a simple object interface so you can feed CLIPS code and commands into a CLIPS executable and capture the output. It locates CLIPS from your PATH, from the INLINE_CLIPS_EXECUTABLE environment variable, or via Alien::CLIPS when available, so you can integrate rule‑based logic into scripts without rewriting CLIPS code. If you need a quick way to drive CLIPS from Perl and return results, this module does that with minimal fuss.

App::FileCleanerByDiskUage is a small Perl utility for reclaiming disk space by removing the oldest files under a given directory until disk usage falls below a configured threshold. You call its clean method with a target path and a disk-usage percentage and it will check the current usage, scan for candidate files only when cleaning is needed, optionally preserve a minimum number of newest files, skip names matching a supplied regex, and either perform removals or run as a dry run for testing. It returns a detailed hashref that lists found files, files removed, any unlink errors, and counts so you can log or act on the results, and it can create a PID file to prevent concurrent runs. Note that if you pass multiple paths only the first is used to determine disk usage, so keep paths on the same partition when using more than one.

IPC::Shareable lets Perl programs share variables by tying scalars, arrays, hashes or even objects to System V shared memory so multiple processes can read and write the same data using a common key string. It supports arbitrarily complex nested structures by mapping each referenced child into its own shared segment and it serializes data with JSON by default or with Storable when you need richer Perl-specific types. The module provides flock-like locking with shared and exclusive locks, optional enforcement and warning modes to catch unsafe reads or writes, plus convenience helpers such as singleton() to permit only one running instance, seg_map and shm_segments for inspection, sysv_info for kernel limits, and a suite of cleanup and testing utilities to remove or reclaim leaked segments. Be aware that nested references consume additional system segments and that overall capacity depends on your OS kernel limits. Recent releases focused on robustness under heavy or parallel test loads and on platforms with small semaphore budgets, adding reclamation of orphaned semaphore sets and avoiding leaks that previously caused failures on OpenBSD and other constrained environments.

Web3::Tiny is a compact, dependency-light Perl toolkit for talking to Ethereum nodes that makes it easy to fetch chain data, read contract state, and sign and send simple transactions. It bundles JSON-RPC transport and Solidity ABI encoding/decoding, provides thin contract and wallet wrappers, and uses core Perl modules for HTTP, JSON and big integers while delegating crypto to a small wrapper around the audited libtomcrypt library. The module supports common Solidity scalar types and one-dimensional arrays, EIP-155 replay-protected legacy transactions, and EIP-55 checksummed addresses, so it is well suited for small scripts and services that need basic onchain interactions without heavy dependencies. It does not implement EIP-1559 transactions, event log decoding, ENS resolution, or complex ABI types like tuples and nested arrays, so choose it when you want a minimal, practical client rather than a full-featured Ethereum framework.

SIRTX::Font is a Perl library for reading, writing and manipulating SIRTX bitmap font files and related bitmap formats. It gives you a font object to inspect and edit glyphs and codepoint mappings, tweak font metadata like size, baseline and version, import fonts from SIRTX, PSF and Roman .hex sources, generate simple missing glyphs, deduplicate unused glyphs with garbage collection and export alias maps or images of glyphs. The module also ships named character lists (ASCII, DEC sets, CP437/850/858 and an SIRTX-specific list) and utilities to test, strip or fill codepoints against those lists, which makes it useful for preparing terminal or legacy bitmap fonts. Recent v0.08 work added unified import_font/export_font APIs, a new SIRTX::Font::Renderer with proportional rendering and size calculation, basic glyph attributes and support for exporting .hex, while some older methods such as import_psf, import_hex and the built in render() are now deprecated. Be aware many utilities are marked experimental, methods will die on error, and glyph attributes cannot yet be stored to font files in this release.

HTML::Object is a comprehensive Perl toolkit for parsing, querying and modifying HTML that aims to be fast and safe by only changing the parts of a document you edit instead of rebuilding and re-encoding the entire tree. It ships three usage layers: a lightweight Element API, a full Web API compatible DOM implementation so you can script HTML much like browser JavaScript, and an XQuery layer that offers a jQuery-like interface for convenient DOM manipulation. The parser accepts strings, files, globs or URLs, supports utf8 handling, exposes utilities to create, traverse and replace nodes, and relies on an external JSON tag dictionary to stay aligned with HTML semantics. If you need to fetch remote pages the module returns the HTTP::Response for inspection and it can be configured to provide a global DOM or enable xquery-style shortcuts. The recent 0.6.2 release made no API changes but fixed a bug in XQuery removeClass, switched to DateTime::Lite by default, updated dependencies and improved the documentation.

Stats::LikeR brings a broad, R-flavored toolkit of statistics and data-frame utilities to Perl, offering fast XS-backed implementations of common numeric reducers, hypothesis tests, modeling and reshaping tools and table I/O so you can do R-like analysis without leaving Perl. It understands multiple data shapes (array-of-hashes, hash-of-arrays, hash-of-hashes and array-of-arrays) and provides convenient operations such as read_table/write_table, add_data/assign, reshape helpers (aoh2hoa, hoa2aoh, aoh2hoh, hoh2hoa), summary and view, binning and quantiles, correlation and covariance, many tests (t, wilcox, kruskal, chi-sq, Fisher, KS), linear and generalized linear models with predict, PCA and more. The API returns plain Perl hashrefs and arrayrefs so results are easy to consume, it tries to follow R semantics where useful and it handles missing data and common edge cases explicitly. The module emphasizes speed and practical usability, but documents a few limitations such as Type I (sequential) ANOVA behavior and some factor-level handling in predict that require manual preprocessing when re-expanding categorical variables. If you want a comprehensive, R-like stats toolbox implemented for Perl with attention to performance and familiar data-frame idioms, this module is very relevant.

Sieve::Generator is a small Perl library that helps you build correct, nicely formatted Sieve (RFC 5228) email filter scripts programmatically by composing a tree of objects that each render themselves via an as_sieve method. It is aimed at any developer who needs to generate or assemble Sieve programs from reusable pieces rather than hand-writing strings, and it provides a friendly sugar layer Sieve::Generator::Sugar with short constructor functions so you can write filter logic tersely and readably. The module makes it easy to cut up and stitch together subtrees, produces properly indented output, and supports commands, blocks, heredocs, comments, and now numeric literals and negation helpers. The recent 0.003 release introduced a common Element role, made documents immutable, added bracket-style comments and improved command and heredoc handling, and added sugar for number and negate to simplify authoring. If you need to generate Sieve scripts from code, this module gives you a clear, composable API to do it, though you should note it does not promise a fixed future minimum Perl version.

Asm::X86 is a Perl utility for working with x86 assembly mnemonics and operands that can tell you whether a string is a valid register or instruction, validate 16/32/64-bit addressing modes in Intel or AT&T syntax, and convert addresses or whole instructions between the two syntaxes. The module exposes a large set of optional exportable lists and predicates for different register sizes and types so you can build linters, assemblers, transpilers, disassemblers, or any tool that needs to recognize or normalize x86 assembly. Most routines work best on input that has already been preprocessed so macros and constants are expanded. The 0.73 release updated the instruction list to match NASM 3.02 and includes some build-system refinements.

Syntax::Infix::EqualityInsensitive adds two lexical infix operators, eqi and nei, for clear, readable case-insensitive string comparisons that honor full Unicode case-folding. They sit at the same precedence as eq and ne and are non-associative, so you can write conditionals like a simple equality test without calling fc or using regex /i, and they handle tricky cases such as the German sharp-s correctly. The operators are active only in the lexical scope that uses the module and can be turned off with no Syntax::Infix::EqualityInsensitive, and the implementation uses Perl's Unicode folding routines for correctness. Note that the module relies on Perl 5.38 or newer.

MsgPack::Raw provides lightweight Perl bindings to the MessagePack C library so you can efficiently serialize and deserialize Perl data into MessagePack's compact binary format for fast storage or cross-language exchange. It exposes simple Packer and Unpacker objects plus helpers for extension types and booleans, letting you pack Perl structures into a small binary blob and stream them back out again with minimal overhead. This module is aimed at developers who need a low-level, high-performance serializer that is smaller and faster than JSON while remaining language-agnostic. It supports older Perl releases and has an active maintenance history, with the most recent release fixing a buffer overflow in the Unpacker for improved stability and safety.

Business::ISBN::Data is a data-only companion for Business::ISBN that supplies the official ISBN group and publisher ranges used to validate and parse ISBNs, and it is normally loaded automatically by Business::ISBN. The module ships a copy of the ISBN Agency RangeMessage.xml and also embeds a default dataset so your code can work offline, and you can point to a different RangeMessage.xml at runtime with the ISBN_RANGE_MESSAGE environment variable or place it in the current directory for app bundlers. The data are regularly refreshed to match the ISBN Agency updates and the project is on GitHub if you need newer data or want to contribute. Note that the data structure changed to fix ISBN-13 prefix handling so you must use Business::ISBN 3.005 or later, and recent releases also include packaging and behavior fixes such as avoiding unintended autovivification when looking up ISBN_RANGE_MESSAGE.

Music::VoicePhrase is a lightweight Perl helper for algorithmic music that builds measured phrases of simultaneous voices with both pitch and rhythm, making it easy to generate motifs and voice lines for MIDI or composition tasks. It wraps Music::Scales, Music::VoiceGen and Music::Duration::Partition to produce lists of rhythmic motifs and corresponding pitch voices and exposes simple methods like build_motifs and build_voices so you can regenerate material quickly. The module is aimed at real-time or programmatic workflows and includes convenience attributes for base note, scale, octave, pitch and interval selections, phrase size and duration pools, MIDI patch and channel, and runtime state such as a priority queue, index, current note and onsets. Defaults are musical and sensible so you can get started immediately, and recent updates made all attributes read/write and added named pitch and interval attributes plus other real-time friendly fields to make integrating this into live or iterative systems straightforward.

CPANSA::DB exposes the CPAN Security Advisory dataset as a ready-to-use Perl data structure so auditors and tools can check CPAN modules for known vulnerabilities. Its single db subroutine returns a hashref containing all advisory reports and the distribution also ships a JSON copy for non-Perl consumers. Releases are signed with GPG and published with GitHub Attestations so you can verify integrity of the archive, and the project is actively updated with new reports and CVE mappings. If you need an authoritative, machine-readable list of CPAN security advisories to drive audits, alerts, or tooling, this module gives you that dataset in a simple, importable form.

App::bcrypt is a lightweight Perl distribution that supplies a simple command-line utility for creating and verifying bcrypt password hashes and mainly exists to reserve the App::bcrypt namespace and to install the tool's prerequisites. The actual hashing work is handled by Crypt::Bcrypt and the package is useful if you want a small Perl-based CLI for generating bcrypt hashes or integrating bcrypt into Mojolicious workflows. There is no heavy API to learn because the CPAN module itself is essentially a packaging shim rather than a full-featured library, so check Crypt::Bcrypt or Mojolicious::Plugin::Bcrypt if you need a programmatic interface. Recent maintenance updates refreshed the distribution metadata in 2024 and in 2026 the test suite was tightened to scrub the environment for more reliable test results.

Syntax::Infix::ConditionalSplice adds a lexically scoped infix operator "?|" so you can write "COND ?| LIST" to include LIST in a surrounding list only when COND is true, which makes code that builds argument or option lists much cleaner than using the ternary with an empty-list branch. The operator short‑circuits so the right side is not evaluated unless the condition holds, and it is context aware so in list context it flattens into the outer list while in scalar context it yields the list's last value, mirroring standard ternary behavior. It binds tighter than the comma operator but looser than comparisons and logicals, so conditions usually need no extra parentheses, and it is implemented to be lexically scoped and safe for real-world use. Requires Perl 5.38 or newer.

Syntax::Infix::OptionalChain provides a lexically scoped safe-navigation infix operator ?-> that makes it easy to step into objects, hashes or arrays without repeatedly checking for undef. At runtime the bareword on the right becomes a method call if the left is a blessed object with that method, a hash key for HASH refs or an array index for ARRAY refs, and chains short-circuit to undef at the first missing value so you can write expressions like $cfg?->servers?->0?->port // 8080 without autovivification or "can't use an undefined value" failures. A blessed object that lacks the method falls through to structural access so blessed hashrefs behave like hashes, and attempting to navigate a defined value that is not navigable will croak rather than be silently swallowed. The operator is lexically scoped, requires Perl 5.38 or newer, and has the limitation that the right-hand side must be a compile-time bareword literal so you cannot pass arguments, use computed keys or negative indices.

Infix::Custom lets you add your own binary infix operators to Perl so expressions like a custom glyph between two operands are parsed at compile time and lowered into ordinary operations. You declare a glyph and choose how it lowers so the operator can call a Perl sub, map directly to a native binary operator for zero-call overhead, or act as a method-style operator that captures a bareword name for safe navigation. Declarations are lexically scoped and can be rebound or removed with no Infix::Custom, and you specify precedence to place the new operator into Perl's operator hierarchy. XS authors also get a low-level hook to supply a C-level build_op for custom optree construction when needed. The module requires Perl 5.38 or newer because it depends on a core parsing hook introduced in that release.

YAML::As::Parsed is a small, drop-in style alternative to YAML::Tiny that reads and writes YAML while preserving the order of mapping keys, so you get predictable key iteration and output instead of Perl's usual unordered hash behavior. It is aimed at people who need to load or emit YAML configuration or data files and keep the original key order for readability, diffs, or downstream processing. The module exposes the familiar YAML::Tiny API so existing code can switch with minimal changes. Recent updates replace the underlying implementation with Tie::OrderedHash to ensure stable ordering and the module requires a modern Perl runtime.