CPANscan

The `Net::Cloudflare::DNS` Perl module provides a straightforward interface for interacting with the Cloudflare DNS API v4, allowing users to manage DNS records programmatically. With this module, developers can create, update, retrieve, and delete DNS records for their domains hosted on Cloudflare, using either an email and API key combination or a bearer token for authentication. The module supports standard DNS record types such as A, TXT, MX, and CNAME, and includes options for setting TTL and proxying through Cloudflare. Notably, recent updates have introduced bearer token authentication, enhancing security and flexibility for users. This module is particularly useful for automating DNS management tasks in a Perl environment.

Data::Power::Inspection is a Perl module designed to facilitate the inspection and troubleshooting of power equipment faults. With version 0.07, it offers a suite of functions that allow users to retrieve inspection rules based on various criteria, such as device type, data sources, and priority levels. The module also provides access to fault criteria specific to different equipment, making it a valuable tool for maintenance and operational efficiency in power systems. Recent updates have focused on enhancing the module's documentation, ensuring users have clear guidance on its capabilities and usage. This module is particularly useful for professionals in the power industry looking to streamline their inspection processes and improve fault management.

Email::Send::YYClouds is a Perl module designed for sending simple text-based emails using any SMTP relay server, with localhost as the default option. It provides an easy-to-use interface for composing and dispatching emails, allowing users to specify recipients, sender information, subject lines, and message bodies, which can include UTF-8 characters. The module includes debugging capabilities and requires a properly configured SMTP relay server to function correctly. Recent updates have focused on enhancing documentation, ensuring users have clear guidance on its usage and features. This module is particularly useful for developers looking to integrate email functionality into their Perl applications without the complexity of managing SMTP connections directly.

The Perl module Test2::Require::ProgramInPath is designed to facilitate the skipping of tests unless a specified program is available in the system's PATH. By leveraging the File::Which module, it checks for the presence of the program and allows developers to conditionally execute tests based on its availability. This module is a subclass of Test2::Require and provides a straightforward way to ensure that tests only run when the necessary dependencies are met, enhancing the robustness of test suites. The initial version, released on June 23, 2025, marks the introduction of this functionality, making it a valuable tool for Perl developers who need to manage test dependencies effectively.

Data::SimpleKV is a Perl module that offers a straightforward key-value database solution, featuring both in-memory caching and disk persistence. Designed for ease of use, it allows developers to store and retrieve UTF-8 encoded data safely across multiple processes, ensuring data integrity through file locking mechanisms. With simple methods for setting, getting, deleting, and checking the existence of key-value pairs, as well as the ability to save data to disk, Data::SimpleKV is ideal for applications that require a lightweight and efficient data storage solution. The module also provides a clear file structure for data storage and is compatible with various operating systems, making it a versatile choice for developers looking to implement a reliable key-value store in their Perl applications.

The CPAN::Maker module is a utility designed to streamline the creation of CPAN distributions for Perl modules. It primarily operates by reading a YAML build specification file, which outlines the necessary details for packaging the distribution, including module dependencies, author information, and project structure. When invoked with the appropriate options, CPAN::Maker generates a Makefile.PL and can package project artifacts into a tarball for distribution. This tool is particularly useful for developers looking to automate the process of preparing their Perl modules for CPAN, ensuring that all dependencies are correctly identified and included. Additionally, it offers various command-line options for customization, debugging, and specifying paths for modules and tests, making it a versatile component of the Perl toolchain.

The `Amazon::API` module serves as a generic base class for interfacing with various AWS services, enabling developers to construct API calls in a streamlined manner. It can be utilized directly or as a parent class for more specific service implementations, allowing for the creation of tailored API classes using metadata from the Botocore project. This module simplifies the process of invoking AWS APIs by handling the necessary HTTP requests and responses, while also providing options for error handling, debugging, and response serialization. Users can either take a straightforward approach by directly invoking APIs or leverage the included utility to generate service-specific classes, making it a flexible choice for developers looking to interact with AWS services in Perl.

The `Data::Dumper::Interp` Perl module enhances the output of the standard `Data::Dumper` for better readability and human consumption by interpolating variable values directly into strings. It provides a variety of functions to format scalars, arrays, and hashes, while ensuring that complex data structures are displayed in a clear and concise manner. Key features include the ability to visualize references with abbreviated addresses, stringify objects, and handle Unicode characters appropriately. Recent updates include improved support for `threads::shared`, allowing for accurate representation of shared variables, and the introduction of new configuration methods like `set_defaults` and `reset_defaults` for easier management of output settings. This module is particularly useful for debugging and logging, making it easier to understand complex data structures at a glance.

Math::AnyNum is a Perl module designed for high-precision arithmetic, supporting arbitrary size integers, rationals, floating-point numbers, and complex numbers. It provides a user-friendly interface to underlying libraries like Math::GMPz, Math::GMPq, Math::MPFR, and Math::MPC, allowing seamless mathematical operations without the need for explicit type conversions. The module includes a wide array of functions for various mathematical computations, including factorials, binomial coefficients, and special functions like gamma and beta. Notably, version 0.41 introduced stricter validation for rational inputs in the `new` method, enhancing the robustness of the module. With its focus on performance and ease of use, Math::AnyNum serves as an efficient alternative to traditional big number libraries in Perl.

Alien::Bit is a Perl module designed to facilitate the installation and integration of the Bit library, which is essential for manipulating bitsets and their packed containers. With version 0.01, this module automates the process of downloading the Bit library from GitHub and building both static and dynamic versions for use in other Perl distributions available on CPAN. The Bit library itself is a high-performance, uncompressed implementation optimized for modern architectures, providing efficient methods for creating, manipulating, and querying bitsets, while also supporting advanced operations and GPU functionalities. This module is particularly useful for developers looking to leverage the capabilities of the Bit library within their Perl applications.

The DiaColloDB module serves as the top-level interface for managing a diachronic collocation database in Perl. It allows users to create, query, and manipulate a local database instance, facilitating the analysis of language data over time. With features for opening and closing databases, exporting and importing data, and profiling queries, DiaColloDB provides a comprehensive set of tools for linguistic research. Recent updates include enhancements to error handling and support for environment variables that allow users to customize compile-time options, improving the module's flexibility and usability.

Perl::Critic::Grape is an extension of the Perl::Critic framework that introduces additional policies aimed at enhancing code quality and maintainability. This module includes rules such as requiring parentheses with built-in function calls, prohibiting inline do blocks, and disallowing manual reference checks, all designed to promote best practices in Perl programming. Recent updates have added new policies, including the enforcement of parentheses with built-ins and the prohibition of inline do blocks, further refining the coding standards it advocates. With its focus on improving code clarity and consistency, Perl::Critic::Grape is an essential tool for developers looking to adhere to high coding standards in their Perl projects.

The `Filename::Type::Executable` Perl module provides a straightforward way to determine if a given filename suggests that it is an executable program or script. By using the `check_executable_filename` function, users can easily check filenames for executable characteristics, receiving detailed information such as the executable type and extension if applicable. The function supports both case-sensitive and case-insensitive checks, making it versatile for various filename conventions. This module is particularly useful for developers who need to validate file types in scripts or applications. Notably, version 0.002, released on December 20, 2024, included a renaming of the module and distribution for improved clarity.

Valiant is a Perl module designed for object validation, drawing inspiration from Ruby on Rails. It provides a domain-specific language (DSL) for defining validation rules and filters for Moo or Moose classes, allowing developers to enforce business logic constraints and validate user input effectively. With Valiant, you can specify various validation criteria, such as length, numericality, and custom validation methods, while also managing error messages in a structured way. This module is particularly useful for applications that require robust validation mechanisms, such as web forms, where user input may often be invalid but well-formed. Recent updates have improved memory management and introduced new features for form handling, making it a reliable choice for developers looking to streamline their validation processes.

Daje::Workflow::Config is a Perl module designed to facilitate the loading of workflow configurations from JSON files into a hash structure, making it easy to manage and access configuration parameters within your applications. By utilizing this module, developers can instantiate a configuration object by specifying the path to their JSON files, and subsequently retrieve specific configuration values using the provided methods. This streamlined approach enhances the organization and accessibility of workflow settings, ensuring that applications can efficiently adapt to varying configurations.

The Net::CIDR Perl module provides a comprehensive suite of functions for manipulating IPv4 and IPv6 netblocks expressed in CIDR notation. It allows users to validate IP addresses and CIDR notations, convert ranges of IP addresses to CIDR format, and vice versa, as well as perform operations such as adding CIDR blocks, looking up IP addresses within CIDR ranges, and generating lists of possible CIDR blocks for a given IP address. Recent updates include enhancements to the cidrvalidate() function, which now accepts IPv6 addresses with one uncompressed zero, improving its flexibility and usability. This module is essential for network administrators and developers who need to manage and manipulate IP address ranges efficiently.

Travel::Routing::DE::DBRIS is a Perl module designed to interface with the bahn.de itinerary service, allowing users to request and retrieve detailed travel connections between specified locations in Germany. By creating an instance of Travel::Routing::DE::DBRIS with mandatory origin and destination parameters, users can access various travel options, including transfer and walking segments, while also customizing requests with parameters such as travel date, language, and modes of transit. The module provides methods to handle errors and retrieve connection details, making it a valuable tool for developers looking to integrate German travel routing capabilities into their applications.

The `Alien::liburing` Perl module serves as a wrapper for the `liburing` C library, facilitating the building and detection of this library, which is essential for interacting with the io_uring Linux kernel subsystem. Specifically designed for Linux environments, this module requires a modern Linux kernel version, ideally 5.3 or newer, to ensure compatibility and functionality. It is particularly relevant for developers looking to implement asynchronous I/O operations in Perl through the upcoming `IO::Async::Loop::IOUring` module, which will necessitate a minimum kernel version of 5.4. Recent updates include the transition to `liburing` version 2.11, which addresses various compilation issues, particularly with musl, enhancing the module's stability and performance. For further details, users can refer to the official GitHub repository and kernel documentation linked within the module.

WWW::Noss is a Perl module designed as a backend for the noss RSS/Atom feed reader and aggregator, enabling users to efficiently manage and interact with their feeds. By utilizing the `init` method, users can initialize a WWW::Noss object with command-line arguments, followed by executing the `run` method to process those parameters. The module offers a variety of methods for common feed operations, including updating, reading, marking, and managing feeds and groups, as well as importing and exporting OPML files. This module is particularly useful for developers looking to integrate feed reading capabilities into their applications or for users seeking a customizable feed management solution. The initial release of WWW::Noss was made on June 20, 2025, marking the start of its journey in the Perl ecosystem.

The Mo::utils::Hash module provides utility functions for validating hash references in Perl, specifically through the `check_hash` subroutine. This function checks if a specified key in a given hash reference points to a valid hash; if not, it generates an error message indicating the issue. Designed for use in conjunction with the Mo object system, this module helps ensure that parameters are correctly defined as hash references, enhancing code robustness and error handling. With its straightforward implementation and reliance on the Error::Pure module for error reporting, Mo::utils::Hash is an essential tool for developers looking to maintain data integrity in their Perl applications.

The CGI::Info module is a Perl library that provides essential information about the CGI environment in which a script operates, aiming to enhance code readability and portability by eliminating hard-coded details. It offers a range of functionalities, including retrieving script names, paths, and parameters, as well as identifying the type of device accessing the script (mobile or desktop). Additionally, CGI::Info includes a basic web application firewall to help mitigate common security threats such as SQL injection and XSS attacks. With features for dynamic parameter validation and logging, this module is particularly useful for developers looking to create robust and secure CGI applications while simplifying debugging and configuration through runtime parameters and environment variables.

The `MARC::Field008` Perl module provides a robust framework for parsing and serializing MARC field 008 data, which is essential for handling bibliographic information in library systems. This module allows users to create an object with a required MARC leader string and offers methods to parse a MARC field 008 string into a structured data object and serialize that object back into a string format. It is designed to facilitate the manipulation of MARC data, making it easier for developers to work with bibliographic records. The initial release of this module, version 0.01, was made on June 20, 2025, marking its introduction to the Perl community.

Reactive::Core is a Perl module designed to facilitate reactive programming, allowing developers to create dynamic and responsive applications with ease. With version 0.10, it provides essential methods such as `initial_render` and `process_request`, enabling efficient handling of user interactions and updates. This module is particularly useful for those looking to implement reactive paradigms in their Perl applications, streamlining the process of rendering and managing state changes. The author, Robert Moore, encourages users to report bugs or feature requests, ensuring continuous improvement and support for the module.

Reactive::Mojo::Plugin is a Mojolicious plugin designed to integrate Reactive programming components seamlessly into your Mojolicious applications. By registering this plugin in the startup method of your app, you can specify an array of namespaces that the plugin will scan for Reactive components, allowing you to easily utilize these components within your templates. For instance, you can render a reactive component like a counter with initial state support, and include the necessary JavaScript with a simple template call. This module is particularly useful for developers looking to enhance their web applications with reactive features while leveraging the powerful capabilities of Mojolicious. The initial release marks the beginning of this module's journey, setting the stage for future enhancements and features.

The Reactive::Mojo::Plugin is a Mojolicious plugin designed to integrate Reactive programming components into your Mojolicious applications seamlessly. By registering this plugin in the startup method of your app, you can specify an array of namespaces to scan for Reactive components, allowing you to easily utilize these components within your templates. For instance, you can render a reactive component like a counter with initial state settings, and include the necessary JavaScript with a simple template call. This plugin enhances the interactivity of your web applications by leveraging the Reactive programming paradigm, making it easier to manage state and updates in a dynamic environment.

Net::Curl is a Perl module that provides an object-oriented interface to the libcurl library, enabling developers to easily perform network requests and manage data transfers. It includes functions to retrieve version information about the libcurl library and decode date strings, while also allowing the import of constants for checking libcurl features. Although it does not export functions by default, users can access its capabilities through fully qualified names or by importing specific constants. Designed to be robust and stable, Net::Curl aims to minimize the risk of crashes associated with libcurl, making it a reliable choice for Perl developers needing to integrate network functionality into their applications.

Iterator::Flex is a Perl module designed to provide flexible and advanced iterator functionalities, allowing developers to create iterators that can rewind, reset, serialize, and signal exhaustion in various ways. This module supports optional behaviors such as maintaining history through previous and current value tracking, and it can wrap existing iterators to standardize their exhaustion interfaces. With a collection of pre-made iterators available in Iterator::Flex::Common, users can easily implement these features in their applications. Recent updates include a significant enhancement in version 0.19, which allows the `icat` function to accept a list of iterables instead of just an array reference, improving usability and flexibility.

Specio is a Perl module designed for defining type constraints and coercions, providing a flexible framework for type checking and transformation in your applications. It allows developers to create custom types with specific constraints, enabling explicit validation of values against these types. Specio supports both simple and complex types, including parameterized types, and offers built-in types that mirror Perl's native types. The module facilitates the creation of coercions, which can automatically convert values from one type to another, enhancing code robustness and clarity. Notably, version 0.51 introduced the ability to force Specio to operate with pure Perl dependencies by setting the `SPECIO_IMPLEMENTATION` environment variable, catering to users who prefer a non-XS implementation. This feature enhances compatibility and simplifies deployment in environments where XS modules may pose challenges.

The `perlfaq` module serves as a comprehensive resource for frequently asked questions about Perl and Perl programming, organized into nine major sections covering topics from general questions and programming tools to data manipulation and web interaction. It is designed to assist both beginners and experienced developers by providing clear answers and guidance on a wide range of Perl-related queries. Users can access the latest version online or through the standard Perl distribution using the `perldoc` command. Recent updates include various typo fixes, modernized references to random number modules, and the addition of "phaser" to the glossary, reflecting the module's ongoing evolution and commitment to accuracy.

The `Text::Table::Read::RelationOn::Tiny` Perl module is designed to read and parse binary relations from a text-based table format, specifically a "two-valued cross table." This module allows users to define relationships between elements in a set, represented by "X" for related and an empty string for not related. It provides flexibility in handling table formats, including optional format checks and the ability to specify equivalent elements. The primary method, `get`, reads the table from various sources (files, strings, or arrays) and returns the incidence matrix, element names, and their corresponding indices. With version 3.0.0, this module continues to enhance its functionality, making it a valuable tool for those needing to manage and analyze binary relations in a structured manner.