CPANscan

Text::Names::Abbreviate provides a small, easy way to turn full personal names into common abbreviated forms such as initials, compact strings, or initials plus the full last name, and supports both "First Middle Last" and "Last, First Middle" input styles with options for output order, format and the separator between initials. Single-word names are returned unchanged and initials are derived verbatim from each component so punctuation or digits are preserved. The module validates input and croaks on missing or invalid parameters, and warns that formats like "compact" or "initials" are lossy so feeding their output back in will not recover the original structure. The recent 0.02 release improved robustness and testing by adopting Params::Get, adding fuzz testing in GitHub Actions, fixing edge cases including a bug where abbreviate('0') failed, and expanding the documentation and test suite.

DBIx::Class::MockData is a utility for quickly populating DBIx::Class schemas with realistic, randomized test data so you can exercise queries, relationships and fixtures without handcrafting rows. You give it a connected schema and the module introspects your result sources, figures out foreign key insertion order, and inserts values matched to each column's declared data_type while salting unique keys to avoid collisions. It supports targeted generation via only or exclude lists, per-table row counts, custom column generators, a dry-run mode for previewing output, and safe operations to deploy or truncate tables with an explicit wipe option for destructive resets. A command line tool is included for one-off runs and recent releases focused on speed and usability, adding bulk insert mode for up to 10x faster population and a truncate operation for fast refreshes, making it a practical choice whenever you need dependable test data for DBIx::Class-based applications.

POE::Component::Server::JSONUnix is a lightweight, event-driven JSON-over-Unix-socket server built on POE that provides a simple RPC-style interface for local control and interprocess communication. Clients send newline-delimited JSON objects containing a command, optional args, and an optional id, and handlers return JSON envelopes with status and results or errors, so malformed requests and handler failures are reported without disturbing other clients. You add commands at startup via a commands hash, at runtime with register, or by subclassing cmd_* methods, and handlers may reply synchronously or keep a context object to respond asynchronously later. The server includes handy built-ins like ping and commands, removes stale socket files but will not clobber an active listener, lets you set socket permissions, and defaults to line-based framing while allowing POE::Filter::JSON for pretty-printed input. It depends on POE and JSON::MaybeXS and is aimed at daemons, command-line tools, and other local processes that need a simple, extensible control or RPC endpoint.

oEdtk is the main module of an open source toolkit for industrial printing processing that provides a simple, documented framework to parse fixed-width record files and build formatted outputs. It opens and closes job filehandles, lets you declare record templates that map fixed-length fields into a global data array, and lets you attach user callbacks to run before, during, and after record extraction. You can also define sprintf-style output templates, and dynamically erase or redefine record types at runtime, so it is useful for automating batch jobs that transform legacy or production print/data streams into composed documents. The module is presented primarily as the documented entry point for the oEdtk toolkit and is distributed under the GNU GPL with no warranty.

HTTP::Request::FromCurl converts curl command lines into Perl HTTP::Request objects so you can turn examples copied from documentation or browser developer tools into code for LWP, HTTP::Tiny or similar clients. You pass a curl-style command or argv array and the module returns one or more HTTP::Request::CurlParameters objects that encapsulate the request parameters and can produce an HTTP::Request for your user agent. It recognizes many common curl options, supports multiple URL expansion and optional inlining of file contents, and can regenerate curl or other client snippets for round‑tripping. There are some limitations to be aware of such as incompatible curl cookie file formats, file uploads and body files being slurped into memory, certain curl features like --next being unsupported and a small set of options intentionally ignored, but these are documented. The latest release fixes handling of empty passwords in Authorization headers and adds support for the commonly used --follow option.

DesktopWorkspaceRoles::Standard provides a ready-made collection of roles for use with the DesktopWorkspace framework, offering common behaviors and interfaces you can compose into workspace objects so you do not have to recreate basic functionality. It is aimed at developers building or extending DesktopWorkspace-based applications or plugins who want consistent, tested building blocks to speed development and reduce boilerplate. The module is lightweight, maintained on GitHub, and welcomes contributions and bug reports.

YAML::LibYAML is the Perl binding (distributed as YAML-LibYAML and better known as YAML::XS) that gives you fast, robust YAML parsing and generation by wrapping the libyaml C library with XS. It provides familiar Load and Dump routines and file helpers so Perl programs can read and write YAML efficiently while handling anchors, aliases, tags, regexps, tied variables, Unicode, and various Perl types including blessed references when explicitly allowed. The module is actively maintained with security-conscious defaults such as disabling automatic loading of blessed objects and recent fixes for YAML 1.2 compatibility, boolean handling, and several memory and parsing bugs. Use it when you need a high-performance, well-tested way to serialize or parse YAML from Perl and when you want explicit control over object loading and the latest libyaml behavior.

Weasel::Driver::Selenium4 is a lightweight adapter that lets the Weasel browser-automation framework drive real browsers via Selenium WebDriver 4 by wrapping Selenium::Client, providing the standard Weasel driver operations like navigating pages, finding elements, clicking, double-clicking, typing, executing scripts, taking screenshots and waiting for conditions. It exposes simple configuration for Selenium capabilities, window_size and a millisecond wait_timeout and includes helpers to update the timeout and window size on a running session, while capability changes take effect after restarting the session. Use this module when you are working with the Weasel test framework and need a ready-made Selenium 4 backend for browser-based tests.

Syntax::Infix::ConditionalSplice provides a lexically scoped infix operator ?| that makes it trivial to conditionally splice elements into a list, so you can write things like $verbose ?| '--verbose' inside an argument list instead of the noisier COND ? LIST : (). The operator short-circuits so the right-hand expression is only evaluated when the condition is true, and it is context-aware so in list context it flattens the supplied list into the surrounding list while in scalar context it returns the list's last value or undef when false. The operator has sensible precedence relative to commas and logical operators and you can parenthesize the right side to include multiple elements. Note that it relies on Perl 5.38 or newer and will not install on older Perl releases.

Syntax::Infix::OptionalChain provides a lexically scoped infix operator "?->" that implements safe navigation in Perl so you can walk into objects, hashes and arrays and get undef instead of a fatal error when a link in the chain is missing. The right-hand bareword is resolved at runtime so if the left value is a blessed object with that method it calls the method, if it is a HASH reference it performs a key lookup, and if it is an ARRAY reference it treats the bareword as a numeric index; an undef left-hand operand causes an immediate undef result and no autovivification happens. Blessed hashrefs or arrayrefs fall through to structural access when the method does not exist, defined but non-navigable values croak, and the operator pairs naturally with // for defaults. Note that the right-hand side must be a compile-time bareword so you cannot pass arguments, compute keys, or use negative indices. The module is implemented on top of Infix::Custom with an XS navigator, requires Perl 5.38 or newer, and this release is the initial 0.01.

Infix::Custom lets you declare your own binary infix operators in Perl so expressions like "a OP b" can be made to call a Perl sub, act as a native binary operator, or be handled by a C-level builder, and those operators are recognized and lowered at compile time so there is no added runtime parsing cost beyond the work of the operation itself. You register a glyph and choose a lowering mode: call mode maps the infix to a Perl sub, method mode treats the right hand side as a bareword to enable natural looking safe-navigation like "?->", and binop mode maps directly to a built-in operator for zero call overhead. Declarations are lexical so operators only apply where imported and can be rebound or removed in nested scopes. There is also an escape hatch for XS authors to build custom optrees at C level. This requires Perl 5.38 or newer because it relies on the core infix plugin hook, so use it when you want readable, compile-time custom operators with predictable performance.

Perl::Critic::Policy::ControlStructures::LoopsRequireLabels is a Perl::Critic policy that enforces explicit labels on loops and on loop-control keywords like next, last, and redo so the target of a break is always obvious and less likely to break during refactoring. It offers three modes: always, which requires labeled loops and labeled break keywords everywhere; nested, the default, which requires labels for loops that are nested or whose body exceeds a configurable max_lines threshold; and max_lines, which only enforces labels when a loop body is longer than the configured line count. The policy also treats continue blocks as part of their loop and flags bare breaks when any ancestor loop carries a label to avoid ambiguous targets. Configure it in your perlcriticrc to tighten control-flow clarity in codebases where nested loops or long loop bodies make break targets hard to track.

Gherkin is the Perl implementation of the Gherkin language parser and compiler used by the Cucumber project. It reads feature files (including support for Markdown-based Gherkin in recent releases), parses them according to the official grammar, and emits a stream of Cucumber::Messages protobuf objects encoded as NDJSON so other tooling in the Cucumber pipeline can consume them. The module exposes streaming APIs such as from_paths and from_source that accept a user-supplied id generator and a sink callback to receive Envelope messages, and you can choose whether to include the original source, the parsed AST, or the compiled "pickles" in the output. It handles source encodings, is intended for building higher-level Cucumber tools in Perl, and since version 22 it emits Cucumber::Messages objects instead of plain hashes. The project is actively maintained, ships under the MIT license, and is a good fit if you need robust, language-compliant Gherkin parsing in Perl.

Cucumber::Messages is a Perl library that implements the Cucumber messaging protocol and makes it easy for Perl programs to produce and consume the NDJSON event stream used across the Cucumber ecosystem. It provides in-memory classes for every message type—envelope, source, gherkin AST, pickles, test cases, step results, attachments and more—plus simple serialization and parsing helpers so you can call methods like to_json on objects or Envelope->from_json on NDJSON lines. Use it when you need to integrate Perl tools with Cucumber formatters, test runners or CI pipelines, or when you want structured access to attachments, timestamps and other test metadata; the library also supports externalized attachments to avoid embedding large binaries and is released under the MIT license.

Algorithm::QuadTree::XS is a high-performance XS (C) backend for the Algorithm::QuadTree family that gives you a drop-in, compatible replacement for the pure-Perl implementation and is used automatically when available. It provides the same quadtree API so you can index and query 2D shapes like rectangles and circles without changing your code, while delivering much faster insert and search operations and dramatically reduced tree-clearing time in recent releases. If your application needs spatial indexing or collision-style queries and the pure-Perl version feels slow, this module provides a straightforward way to get a significant speedup with minimal fuss.

Algorithm::QuadTree is a pure-Perl spatial index that stores rectangular and circular objects in a hierarchical quadtree so you can rapidly find everything that intersects a given rectangular or circular region. You create the tree by giving map bounds and depth, add objects (as rectangles or circles) with add, and then use getEnclosedObjects to retrieve items that overlap a query area; objects can be removed or the whole tree cleared and you can set a window and scale to support zoomed views. The module uses a pure-Perl backend by default but will use an optional XS backend if installed for better performance. It is handy for fast region queries and simple collision detection in canvases or map-like data, and note that you are responsible for providing unique object identifiers if you need them to be distinct.

App::CommonPrefixUtils provides small command line tools and supporting functions for finding and manipulating common prefixes in lists of strings, including the utilities common-prefix, majority-prefix, remove-common-prefix and strip-common-prefix. It is useful when you need to detect the longest shared starting substring across many labels or filenames or to derive a prefix that is shared by the majority of items and then optionally remove or strip that prefix. The included library functions common_prefix and majority_prefix return an enveloped result designed for programmatic use, using an HTTP-like status code, a human-readable reason, an optional payload with the computed prefix, and optional metadata. The 0.002 release added the common-prefix and majority-prefix CLI wrappers to make these operations directly available from the command line.

Switch::Declare provides a compile-time, lexically-scoped switch/case keyword for Perl that lowers the whole construct to ordinary Perl ops so there is no runtime parser overhead. You write switch (EXPR) { case ... { ... } default { ... } } and the scrutinee is evaluated exactly once, the first matching case wins, and there is no fallthrough. Cases support a compact, predictable pattern grammar including numeric and string literals, regexes, ranges and lists, predicate subs, ref/reftype and isa checks, named constants, runtime comparisons and runtime regexes, and you can destructure the matched value into fresh lexicals with -> PATTERN for convenient per-arm bindings. The implementation is undef and type safe so non-matching or undef inputs do not warn or miscompare, and common string-only switches are automatically lowered to a static hash lookup for fast dispatch. Performance is close to hand-written if/elsif chains for most patterns, with numeric comparisons paying a small extra cost for safety, and the compile-time lowering keeps the generated code tight and efficient. If you want a readable, safe, and performant switch construct that integrates with Perl scoping and offers destructuring it is likely a good fit.

Graphics::Toolkit::Color is a high‑level Perl API for creating, converting and manipulating colors and color sets aimed at colors for screen output. You build lightweight, read‑only color objects from names, hex, CSS strings, numeric tuples or many named formats, then convert them between dozens of color spaces, format their values for output, check gamut validity and look up or approximate human‑readable color names. It also provides practical color operations such as mix, invert, add_value/set_value and a suite of convenience modifiers to lighten, darken, saturate, desaturate, tint, shade and tone, plus generators for gradients, complements, analogous palettes and clusters of similar colors. The module emphasizes perceptual correctness by using RGB as the I/O format while performing many calculations in perceptually uniform spaces like OKLAB or OKHSL, supports many RGB profiles and modern spaces, offers multiple output formats and an is_in_gamut helper, and ships with no runtime dependencies. The recent 2.20 release is a notable feature bump that added the HSL‑family OKHSL/OKHSV/OKHWB spaces, the new lighten/darken/saturate/desaturate/tint/shade/tone methods, improved docs and more flexible error handling, making it easier to produce visually consistent color manipulations.

Destructure::Declare installs a compile-time, lexically scoped let keyword that makes it easy to unpack arrays, hashes and lists into real my variables using simple pattern syntax. Array patterns [ ... ] treat the right-hand side as an arrayref, hash patterns { ... } treat it as a hashref and ( ... ) destructures a list in list context. The module supports nested patterns, per-slot defaults that use // and are evaluated lazily, holes to skip slots, and trailing slurpy captures like @rest and %rest for remaining elements or keys. The right-hand side is evaluated exactly once and the entire pattern is parsed at compile time and lowered to ordinary lexical declarations so runtime overhead is minimal, and flat patterns can lower to a single native list assignment for hand-written assignment speed. The distribution also publishes its compile-time engine for reuse by other modules. This is the initial 0.01 release implementing these features.

JSON::Schema::Modern is a Perl evaluator and validator for JSON Schema that implements the official specification up to Draft 2020-12, letting you validate either Perl data structures or JSON strings and get back a rich Result object describing success, errors, annotations and defaults. It supports multiple schema versions, configurable behavior such as short-circuiting, default population, optional string-to-number and scalarref-boolean handling, format and content-schema validation, and extensibility via custom format validators, media types, encodings, vocabularies and callbacks, plus utilities to add and cache schemas or traverse and validate schemas themselves. The module is suitable for integrating strict JSON Schema validation into Perl applications and works well with tools like OpenAPI::Modern, but it does not automatically fetch schemas from disk or the network, some format checks require optional CPAN modules, and you should avoid running untrusted schemas because pattern evaluation and certain numeric operations can pose security risks.

JSON::Schema::Tiny is a compact Perl validator that checks Perl data structures against JSON Schema rules, offering both a simple functional interface and an object-oriented API. It covers the most commonly used keywords and returns either a boolean pass/fail or a detailed result with standard JSON Schema error locations, making it handy for quick validation right after decoding JSON. You can tweak behavior with globals or constructor options such as short-circuiting, allowing numeric strings, and limiting traversal depth to avoid accidental recursion. It intentionally omits some advanced JSON Schema features and external $ref resolution to stay small and fast, so very complex schemas or cross-document references are not supported. Be aware that schema regular expressions are used as-is, so do not run schemas from untrusted sources. If you need full specification compliance, consider a heavier implementation such as JSON::Schema::Modern.

Hypersonic is a Perl micro HTTP server that JIT‑compiles C code so the hot path runs in native code for extreme throughput. You define routes in Perl, call compile() to generate and compile the C event loop and baked responses, then run() the server; static handlers execute once at compile time and are embedded as C constants while dynamic routes still run Perl per request and can be augmented with custom JITed C handlers. It provides optional TLS, gzip compression, streaming and SSE, full WebSocket support including broadcast rooms, sessions, middleware, and a JIT async thread pool, making it a good fit for high‑performance APIs, static asset delivery, and low‑latency real‑time services. Because it relies on XS::JIT and native libraries such as zlib and OpenSSL and requires a compile step, it is most useful when your routes and behavior are known ahead of time and you are willing to accept native code generation rather than a purely interpreted runtime.

DBIx::Class::Relationship::ManyToMany::Async provides asynchronous many-to-many accessors for DBIx::Class by generating Future-returning methods that work with DBIx::Class::Async worker pools. You declare the usual has_many pivot and belongs_to target relationships and then call many_to_many_async to create an accessor like groups plus helper methods add_to_groups, remove_from_groups and set_groups. The read accessor returns a Future that resolves to an arrayref of target objects and the mutators return Futures that resolve when the pivot rows have been created, removed or replaced. The module assumes the target table has a primary key named id and may need proper SQL quoting if your relationship name is an SQL reserved word. This is an experimental initial release extracted from a Mojolicious plugin so the API may change, but it is useful if you need nonblocking many-to-many helpers for DBIx::Class::Async.

Plerd is a minimalist static-blog generator that turns Markdown files stored in a Dropbox-synced directory into a ready-to-serve website. It uses Template Toolkit templates to render posts, generates syndication feeds, and maintains a small index so post ordering, recent-post lists, tag pages, and prev/next links are correct. The tool can republish the entire site or run incrementally so changes to a single file are handled efficiently, and recent updates write files atomically to avoid serving half-written pages. Plerd also includes features for tags, social-media metadata, JSON Feed and RSS, optional webmention support, and MultiMarkdown compatibility. If you want a simple, file-based blogging workflow without a database or heavy CMS, Plerd makes it easy to author posts in Markdown and publish them via a Dropbox-backed directory.

Mojolicious::Plugin::BarefootJS integrates the BarefootJS server runtime into a Mojolicious application by registering a "bf" controller helper that provides a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. It lets you render compiled BarefootJS marked templates as normal Mojolicious templates and installs the supporting hooks so rendering happens smoothly within each request. If you prefer a framework-free setup, the same runtime can be driven with BarefootJS::Backend::Xslate and Text::Xslate. The plugin is lightweight, focused on wiring the runtime into Mojolicious, and is available under the MIT license.

BarefootJS::Backend::Xslate provides a simple bridge that lets the BarefootJS runtime render Kolon-style Text::Xslate templates. It can take an existing Text::Xslate object or build one from a list of template paths, binds the runtime into templates as the bf variable so helpers are invoked naturally, and configures Xslate for HTML auto-escaping while offering a mark_raw mechanism for helper-produced markup. You can override the JSON encoder if needed and call render_named to render a named .tx template with variables. Because it has no web-framework dependency it runs under PSGI/Plack or in standalone scripts and pairs cleanly with the @barefootjs/xslate compile-time adapter that emits templates expecting the bf runtime.

BarefootJS is a lightweight server runtime for rendering BarefootJS templates that were compiled from JSX/TSX into marked templates and accompanying client JavaScript. It intentionally stays framework and engine agnostic and delegates framework-specific tasks like JSON marshalling, raw-string marking, children handling, and named-template rendering to pluggable backends so the same runtime can drive different Perl rendering stacks. Out of the box it has backends for Text::Xslate and Mojolicious and it only pulls in noncore template or web framework code when a backend requires it, keeping the core minimal and easy to embed in PSGI/Plack or Mojolicious applications. If you need to render BarefootJS templates from Perl across multiple frameworks or want a backend-driven, low-dependency approach, this module provides that and is actively maintained with releases through 2026.

WWW::Gitea is a lightweight Perl client for the Gitea REST API that makes it easy to script and automate common operations on a self hosted Gitea instance. Built with Moo, it exposes resource controllers for repositories, issues, pull requests, labels, milestones, releases, organizations and users so you can do things like create a repo, open or comment on an issue, create and merge a pull request, or publish a release with simple method calls. Authentication works with a personal access token or basic auth and the client will derive the API base URL from the instance root you provide or from environment variables like GITEA_URL and GITEA_TOKEN. Calls return small entity objects wrapping the decoded JSON while keeping the raw data available, and internal operation tables are precomputed so there is no OpenAPI parsing at runtime. If you need a straightforward programmatic interface to manage Gitea resources from Perl, WWW::Gitea provides an intuitive, minimal layer over the API.

Dist::Zilla::PluginBundle::Author::GETTY is a ready-made Dist::Zilla configuration that encodes the packaging, metadata, versioning and release practices used by the CPAN author GETTY, so you can build and release Perl distributions with a consistent, automated workflow. It wires together common plugins to generate META and POD, manage versions and changelogs, run pre and post build or release commands, and integrate with GitHub or self-hosted Gitea for repository metadata and release creation. The bundle also supports XS and Alien-based C libraries, optional Docker image builds, control over what files are shipped, and flags to skip CPAN uploads or other steps, while exposing many attributes for fine-grained customization. A companion GitHub Action and CI guidance make it easy to reproduce the same authoring and test environment across projects, which makes this bundle a good fit for Perl authors who want a well-tested, configurable release pipeline without hand-crafting every Dist::Zilla plugin.