CPANscan

Acme::KMX::Test is a Perl module designed as a testing package, although it lacks specific functionality details or a synopsis in its documentation. It is intended for developers looking to incorporate testing capabilities into their Perl applications, and it is released under the same terms as Perl itself, allowing for free redistribution and modification.

Dancer2::Plugin::OIDC is a Perl module designed to facilitate the integration of the OpenID Connect (OIDC) protocol into Dancer2 applications. By leveraging the OIDC-Client distribution, this plugin streamlines the process of managing OIDC authentication, allowing developers to easily create and configure OIDC clients, handle user authentication, and manage security tokens. The module provides methods for creating OIDC client instances, verifying tokens, and checking user roles and scopes, making it a comprehensive solution for applications requiring secure user authentication. With its initial release in December 2025, Dancer2::Plugin::OIDC is positioned as a robust tool for developers looking to implement OIDC in their web applications efficiently.

Data::MoneyCurrency is a Perl module designed to provide detailed information about various currencies. It allows users to retrieve currency data by either specifying a currency code (such as 'usd') or a country code (like 'fr') through its primary function, `get_currency`, which returns a reference to a hash containing relevant currency details. Additionally, the module offers the `get_currencies_for_country` function, enabling users to obtain a list of currency codes associated with a specific country. This module is self-contained, utilizing data sourced from the Ruby library Money, and is particularly useful for applications that require currency information without external dependencies.

The OIDC::Client module serves as a robust client for implementing OpenID Connect and OAuth 2.0 protocols in Perl applications. It allows developers to easily create an OpenID Connect client by configuring essential parameters such as provider details, client ID, and secret. With methods for generating authorization URLs, obtaining tokens, verifying JWT tokens, and retrieving user information, OIDC::Client simplifies the process of authenticating users and managing access tokens. It is designed for use in both standalone scripts and web applications, with additional support through framework plugins for Mojolicious, Catalyst, and Dancer2, making it a versatile choice for integrating secure authentication in Perl-based projects.

Class::XSConstructor is a Perl module designed to create high-performance constructors for classes using XS (eXternal Subroutine) code, enhancing the capabilities of standard constructors. It allows for flexible initialization of class attributes from both hash references and key-value pairs, supports required attributes, and provides features such as default values, builders, type constraints, and coercions. The module is compatible with Moose and Moo, offering strict constructor options and the ability to define custom constructor names. While it optimizes for speed, certain features like builders and type checks may slow down performance, making it ideal for developers who need efficient object construction while still requiring advanced attribute management.

File::Find::Mason is a Perl module designed to facilitate the identification and retrieval of files containing Mason components, which are often used in web applications for templating. By leveraging the familiar interface of File::Find, this module allows users to search specified directories for files that meet certain criteria indicative of Mason templates, such as the presence of specific component calls or modelines. It provides options to customize the search behavior, including the ability to ignore files with shebang lines or to enable verbose error reporting. The latest version, 0.0.6, includes a backport to Perl 5.16.3, ensuring compatibility with older Perl environments. This module is particularly useful for developers working with Mason who need to efficiently locate and manage their template files.

Data::TagMap is a Perl module designed for efficiently managing mappings between host-defined tag identifiers and their corresponding tags. It provides a variety of methods for adding individual entries, ranges, and colors to the mapping, as well as retrieving and reverse-retrieving identifiers. The module supports advanced features such as finding the next available identifier within a specified range and adding meta ranges for various identifier types. Recent updates in version 0.03 include enhancements to its inheritance structure and improved documentation for the reverse_get() method, making it a robust choice for developers needing to handle complex tag mapping scenarios.

Getopt::Long::Bash is a powerful Bash option parsing module designed to simplify the handling of command-line options in Bash scripts, offering a user-friendly alternative to the traditional "getopts" method. It allows developers to define options in a single associative array, supporting both long and short options, automatic validation of input types, and the ability to generate help messages effortlessly. With features like option bundling, rich data types (including arrays and hashes), and built-in callbacks, Getopt::Long::Bash enhances script flexibility and usability, making it ideal for creating robust command-line interfaces. This module is particularly useful for wrapper scripts and supports subcommand parsing, streamlining the process of managing complex command-line arguments.

Convert::Pheno is a Perl module designed to facilitate the interconversion of various standard data models for phenotypic data, making it easier for researchers and developers to work with different formats. By providing a straightforward interface, users can easily convert data between models such as PXF and BFF, enhancing data interoperability in biomedical informatics. The module allows users to create an object with their phenotypic data and apply conversion methods seamlessly, streamlining the process of data integration and analysis in the field of genetics and phenomics.

App::Transpierce is a Perl module designed to facilitate the backup and modification of critical files in a controlled environment. It allows users to create a structured workspace for managing file changes, ensuring that original files are preserved while modifications are made on local copies. The module generates a set of shell scripts to handle file restoration and deployment, enabling users to easily revert changes or apply updates without directly altering live files. With a configuration file to specify target files and directories, App::Transpierce streamlines the process of managing file modifications, making it particularly useful for debugging or hotfix scenarios in Unix-based systems. Its portability and self-contained nature mean it can be easily deployed on remote servers without requiring additional dependencies.

Pry is a Perl module designed to facilitate debugging and code inspection by providing an interactive Read-Eval-Print Loop (REPL) that can be invoked at any point in your code. By simply calling the `pry` function, developers can pause execution and enter a REPL environment where they can inspect and modify lexical variables, call functions, and explore the current state of the program. Utilizing the powerful Reply REPL as its foundation, Pry enhances the debugging experience with features like variable and function name auto-completion. Additionally, Pry allows for the selective dumping of variable values and offers utility functions for accessing lexical variables and stack traces. While it is a valuable tool for single-threaded applications, users should be cautious of its limitations in multi-threaded or multi-process scenarios.

The Z Perl module serves as a convenient collection of essential modules designed to streamline rapid application development in Perl. By simply using `use Z;`, developers can automatically load a variety of broadly useful modules, including those for strict programming, warnings, modern features, and various types, without the need for repetitive imports. Z supports both modern and compatibility modes, allowing it to function seamlessly with Perl versions 5.8.8 and above, while also providing additional utility functions upon request. This makes Z an ideal choice for developers looking to enhance productivity and maintain clean, efficient code in their Perl applications.

Term::ANSIEncode is a Perl module designed to facilitate the generation of ANSI text for terminal applications, enabling developers to create visually appealing command-line interfaces. By utilizing a markup language, it allows for the encoding of various text attributes such as colors, cursor movements, and screen clearing commands, making it easy to manipulate text display in terminals that support UTF-8. With a range of tokens for formatting, including options for bold, italic, and underlined text, as well as the ability to draw frames and horizontal rules, Term::ANSIEncode enhances the user experience by providing a rich set of features for terminal output customization.

The Quiq Perl module is a comprehensive class library designed for rapid application development, featuring 259 application-independent classes that adhere to consistent design principles. This continuously evolving library provides a wide array of functionalities, including text formatting with ANSI color codes, database operations, HTTP client capabilities, and tools for generating HTML, JSON, and LaTeX code. Quiq also supports various data structures, file handling, and inter-process communication, making it a versatile toolkit for developers looking to streamline their coding processes and enhance productivity across diverse projects.

The Gherkin Perl module serves as a parser and compiler for the Gherkin language, which is integral to the Cucumber testing framework. This module allows developers to read and process Gherkin feature files, generating structured output in the form of Abstract Syntax Trees (AST) and executable scenarios known as Pickles. By utilizing the Gherkin module, users can easily integrate Gherkin parsing capabilities into their Perl applications, facilitating the development of behavior-driven development (BDD) tools. The module supports various options for output customization, including the inclusion of source text and AST in the generated messages, and it operates within a pipeline that produces protobuf messages formatted in ndjson.

The Aion::Fs Perl module provides a straightforward and efficient set of utilities for file system operations, including reading, writing, searching, and replacing files. Designed with simplicity in mind, it adheres to the KISS (Keep It Simple, Stupid) principle, making it accessible for users who may find other modules like File::Path or File::Find overly complex. Aion::Fs supports functional programming paradigms and offers a variety of functions such as `cat` for reading files, `lay` for writing content, and `find` for recursively searching directories with customizable filters. Additionally, it includes features for modifying file contents, managing paths across different operating systems, and handling errors gracefully, making it a versatile tool for developers working with file systems in Perl.

Dist::Build is a modern Perl module builder designed to facilitate the creation and management of Perl distributions with enhanced extensibility and customization options. Unlike traditional builders, it employs an internal build graph that simplifies the integration of various extensions, allowing developers to easily add functionalities through custom scripts. Key features include support for compiling XS modules, managing shared directories, and dynamically evaluating dependencies, making it a versatile tool for developers looking to streamline their build processes. With its modular architecture, Dist::Build empowers users to tailor their build environments to meet specific project needs while maintaining compatibility with existing Perl tools.

File::ValueFile is a Perl module designed for reading and writing ValueFile files, providing essential global functionality for managing these file formats. It serves as a foundation for more specialized operations through its associated classes, File::ValueFile::Simple::Reader and File::ValueFile::Simple::Writer, which handle the actual reading and writing processes. The module includes methods for retrieving well-known tags and adding UTF-8 markers to facilitate encoding and decoding. The latest version, v0.09, introduces code cleanups and a new style option 'comment_column' in the writer class, enhancing the module's usability and flexibility. This module is particularly useful for developers working with structured data files that require specific formatting and encoding considerations.

OODoc is a Perl module designed for the object-oriented production of software documentation, enabling developers to create high-quality manual pages in both HTML and Perl's POD format. By utilizing OODoc, users can efficiently manage and generate documentation for their software distributions, integrating documentation directly with code while enhancing the standard POD syntax with logical markup through its Markov parser. The module facilitates the extraction of documentation from source files, organizes it into a structured object tree, and allows for the generation of formatted output through various formatters. OODoc can be used directly or via the accompanying "oodist" script, which streamlines the release process for Perl modules, making it an invaluable tool for developers looking to improve their documentation practices.

Log::Report is a versatile Perl module designed to streamline the process of reporting problems through a unified interface that combines logging, exception handling, and translation capabilities. It allows developers to generate messages for users and logs with varying severity levels, such as errors, warnings, and informational messages, while also supporting language translations using a syntax similar to gettext. The module provides a range of functions for reporting messages, managing dispatchers for output, and handling exceptions in a structured manner. Notably, recent updates in version 1.44 have renamed exception "classes" to "tags" for better clarity, while also enhancing documentation and fixing various issues. This makes Log::Report a powerful tool for developers looking to implement robust logging and error handling in their Perl applications.

ExtUtils::Builder::Compiler is a Perl module designed to provide a unified interface for interacting with various compilers, streamlining the process of compiling source code. While it is typically not used directly, it serves as a foundational component for higher-level portability layers, such as ExtUtils::Builder::Autodetect::C. The module offers methods to add include directories and define macros, as well as to compile source files into target binaries, making it a valuable tool for developers looking to manage compilation tasks in a consistent manner across different environments.

The CPAN::Tarball::Patch module provides a mechanism for patching CPAN tarballs using the CPAN::Distroprefs framework, allowing developers to customize and modify distributions before installation. With a straightforward interface, users can create a patcher instance by specifying the paths to their preferences and patches directories, and then apply patches to specific tarballs by providing the appropriate file name format. However, it is important to note that the module's internal functionality and API are still in development, and users are advised to proceed with caution as it may not be stable for production use.

The `SPVM::Sys` module provides a comprehensive interface for making system calls related to file I/O, sockets, time, process management, signals, and user manipulation in the SPVM (Simple Perl Virtual Machine) environment. It allows developers to perform operations such as opening files, creating directories, managing processes, and handling sockets, all while ensuring compatibility across different operating systems, including automatic handling of UTF-16LE encoding for Windows file names. Recent updates include the addition of the `Sys::Process#setsid` method, enhancing process management capabilities. This module is essential for developers looking to leverage low-level system functionalities within SPVM applications.

The App::Test::Generator module is designed to automate the generation of fuzz and corpus-driven test harnesses for Perl routines, enhancing the robustness of test suites by creating comprehensive black-box tests. By utilizing formal input/output specifications defined in YAML or Perl, it generates test cases that include random fuzzing, deterministic edge cases, and static corpus tests, thereby effectively probing both expected and unexpected inputs. The module supports various input types and configurations, allowing for detailed testing of edge cases and constraints. Notably, in version 0.22, significant improvements were made to the API for generating tests, including enhanced parameter relationship detection and better default value extraction, which streamline the process of creating reliable test cases. This module is particularly useful for developers looking to ensure their code handles a wide range of inputs and edge cases without the need for extensive manual test writing.

The `optex` Perl module serves as a command module directory designed to facilitate the execution of commands with enhanced options and functionalities. It allows users to invoke commands with the `optex` command syntax, including the ability to load additional modules dynamically using the `-M` option. Recent updates in version 1.04, released on December 22, 2025, introduced significant enhancements such as the addition of `--yf/--ysub` options for merging STDERR into STDOUT, support for file redirection, and improved handling of duplicated output streams. This module is particularly useful for developers looking to streamline command execution and output management in their Perl applications. For more information, users can refer to the module's documentation available on its GitHub page.

The Monero::Keys module is designed for generating cryptocurrency-compatible keys specifically for Monero, utilizing a unique public key generation algorithm that differs from the standard Ed25519. By providing a cryptographically secure 32-byte seed, users can invoke the `generate_keys` function to produce a set of keys, including both spend and view private and public keys. The module ensures that the generated private keys adhere to Monero's specific constraints, returning undefined if the seed does not meet the criteria. This functionality is essential for developers working with Monero, enabling secure key generation for transactions and wallet management.

The Solana::SPLAddress Perl module provides a straightforward way to create and manage deterministic token addresses on the Solana blockchain. It offers two primary methods: `create_address`, which generates an address based on a given seed, program ID, and bump value, allowing for the recovery of previously generated addresses; and `find_address`, which retrieves an address using a set of seeds and a program ID, returning both the address and the bump value. This module is essential for developers working with Solana's token standards, enabling efficient address management in their applications.

The Finance::Quote Perl module provides a robust interface for retrieving stock and mutual fund quotes from various global exchanges. By creating a quoter object and utilizing the fetch method, users can easily obtain financial data, which is returned as a two-dimensional hash, allowing access to a wide range of information such as price, market capitalization, and trading volume. The module supports multiple data sources and offers customizable options for fetching quotes, including the ability to specify required labels and currency conversion. With its comprehensive features and straightforward usage, Finance::Quote is an essential tool for developers looking to integrate financial data into their applications.

The `sealed` Perl module provides a subroutine attribute that enables compile-time method lookups for typed lexicals, enhancing performance in specific scenarios. By using `sealed`, developers can optimize method calls in their applications, particularly when working with typed lexicals in subroutines. The module offers various import options for debugging and verification, allowing users to tailor its behavior to their needs. Notably, as of version 8.5.0, the module automatically activates the Perl Type System, streamlining its integration. However, it is essential to note that `sealed` is best suited for end applications rather than reusable OO modules, as the overhead of its op-tree processing can negate performance benefits in nontrivial methods implemented in pure Perl.

The SIRTX::Datecode module is designed for efficient interaction with SIRTX datecodes, which encode dates from 1582 to 2440 into a compact 16-bit format, allowing for variable precision and numeric ordering. With this module, users can easily create datecode objects from various input types, including ISO-8601 strings, epoch values, and existing datecode objects. Key functionalities include converting datecodes to ISO-8601 format, comparing datecodes for equality or ordering, and retrieving individual date components such as year, month, and day. Recent updates in version 0.06 have improved documentation and introduced inheritance from Data::Identifier::Interface::Subobjects, enhancing the module's capabilities for more complex operations.