CPANscan

Doubly::Linked::PP is a Perl module designed for creating and manipulating doubly linked lists, providing a straightforward interface for adding, accessing, and traversing list elements. With features such as bulk addition of elements and methods to navigate to the start and end of the list, it allows for efficient data management. The module is particularly useful for developers needing to implement linked list structures in their applications, offering a performance benchmark against similar modules like Doubly and Doubly::Linked. Despite being slower than its counterparts, it serves as a valuable tool for those looking to work with linked lists in Perl.

The Hades Perl module is designed to simplify the generation of Perl classes and their associated test files through a concise and expressive syntax. With Hades, developers can define classes, accessors, and methods using a structured format that emphasizes clarity and reduces boilerplate code. The module supports features such as type checking, default values, and required parameters, while also allowing for the inclusion of macros for reusable code snippets. Additionally, Hades can automatically generate comprehensive test files, ensuring that the created classes are thoroughly tested and maintain high code quality. This module is particularly useful for developers looking to streamline their Perl development process while adhering to best practices in object-oriented programming and testing.

The `Net::Fortinet::FortiManager` module is a Perl client library designed for interacting with the Fortinet FortiManager REST API, specifically tailored for managing FortiGate devices through a JSONRPC-like interface. This module facilitates various operations such as logging in, managing ADOMs (Administrative Domains), and executing a wide range of API actions including creating, updating, and deleting firewall addresses, policies, and services. With version 0.004001, recent enhancements include improved handling of tests against FortiManager with invalid certificates, the addition of a method to check for UDP-Lite support, and fixes for compatibility with FortiManager versions 7.6 and above. This makes it a robust tool for network administrators looking to automate and streamline their firewall management tasks.

Melian is a Perl client designed for interacting with the Melian cache server, facilitating efficient data retrieval through a binary protocol. It allows developers to connect to the server using either UNIX or TCP sockets and provides methods for fetching data by table and index identifiers, including support for JSON decoding. The client can be configured with various schema specifications, enabling flexible data handling, and includes features for connecting and disconnecting from the server as well as fetching raw or structured data. With its initial release in November 2025, Melian aims to streamline the integration of caching mechanisms in Perl applications, making it easier for developers to manage data efficiently.

Getopt::EX is a powerful Perl module that enhances the capabilities of Getopt::Long by allowing users to define custom option aliases and create dynamic extension modules that integrate seamlessly with scripts through an option interface. With its two primary interfaces, Getopt::EX::Long offers a straightforward way to implement option aliases via a user-defined startup configuration file, while Getopt::EX::Loader provides more advanced functionality for loading and processing command-line options. Additionally, the module supports colored text output on ANSI terminals through Getopt::EX::Colormap, enabling users to customize terminal color schemes easily. Overall, Getopt::EX is ideal for developers looking to create flexible and user-friendly command-line applications in Perl.

The `App::optex::rpn` module is designed for use with the optex command, enabling users to perform calculations using Reverse Polish Notation (RPN) directly from the command line. It automatically detects RPN expressions in the provided arguments and computes their results, simplifying complex calculations. Users can customize its behavior with options such as enabling or disabling automatic processing of all arguments and specifying individual RPN expressions. The module supports a wide range of operators, including arithmetic, trigonometric, and logical operations, making it versatile for various mathematical tasks. A noteworthy recent update in version 1.02 addresses an infinite loop issue and introduces support for `Getopt::EX::Config`, enhancing the module's functionality and reliability.

The optex module serves as a command module directory for the optex command, allowing users to execute various commands with the option to specify additional modules using the -M flag. This module is designed to facilitate the integration and management of command-line functionalities within the optex framework, with comprehensive documentation included directly in the script for user guidance. For further information and resources, users can refer to the project's GitHub page. The module is licensed under the same terms as Perl itself, ensuring flexibility for redistribution and modification.

Daje::Plugin::workflow is a Mojolicious plugin designed to integrate with Daje::Workflow, facilitating the management and execution of workflows within Mojolicious applications. It requires several components, including Daje::Workflow and its associated loaders and database modules, ensuring a robust framework for workflow handling. The plugin's configuration allows users to specify the path and type of workflows, streamlining the process of workflow execution. Notably, in the recent 0.10 release, the plugin introduced a new URL endpoint for executing workflows and enhanced logging and documentation, making it easier for developers to implement and troubleshoot workflows in their applications.

The `xform` module is a data transformation filter designed for use with the `optex` command, enabling users to manipulate standard input (STDIN) data into various formats while ensuring that the transformed data retains the original order. It offers several transformation options, including converting ANSI terminal sequences into printable strings, encoding multibyte non-ASCII characters into single-byte sequences, and transforming non-printable binary characters into printable formats. Additionally, users can customize the character set used for transformation through the `--xform-visible` option, which allows for greater flexibility in handling different types of data. Notably, version 1.05 introduced the `--xform-bin` option for binary data transformation and the `--xform-visible` option to customize the visible parameter of `Text::Conceal`, enhancing the module's functionality for diverse data manipulation tasks.

OpenAPI::Modern is a Perl module designed to validate HTTP requests and responses against OpenAPI v3.1 and v3.2 specifications, ensuring compliance with defined API contracts. It provides a robust framework for working with OpenAPI documents, allowing developers to create, validate, and manage API interactions seamlessly. The module supports various HTTP request and response types, including those from Mojolicious, Plack, and Catalyst, and offers detailed error reporting for validation failures. Recent updates include the addition of support for OpenAPI 3.0 schemas, enhancing its utility for developers working with multiple API versions. With its comprehensive features and ongoing improvements, OpenAPI::Modern is an essential tool for maintaining API integrity and compliance in Perl applications.

The OpenTelemetry Perl module provides a comprehensive implementation of the OpenTelemetry standard, enabling developers to instrument their Perl applications for performance monitoring and observability. It offers a backend-agnostic API that allows users to create and manage traces and spans, facilitating the collection of telemetry data about application behavior. The module supports both class method and functional interfaces for ease of use, allowing for global configuration of logging, tracing, and error handling components. Recent updates include enhancements to instrumentation tests and the introduction of new features in the OpenTelemetry::Instrumentation namespace, which now supports options as array references for better control over instrumentation behavior. This module is essential for developers looking to integrate observability into their Perl applications effectively.

Daje::Plugin::Tools is a versatile plugin designed for use with the Mojolicious web framework, enabling developers to enhance their applications with additional functionalities. Built on the foundation of Mojolicious::Plugin, it provides a straightforward way to integrate tools into both Mojolicious and Mojolicious::Lite applications. By simply invoking the `plugin 'Tools'` method, users can easily register the plugin and leverage its capabilities, streamlining the development process and improving application performance. This plugin is ideal for developers looking to extend their Mojolicious applications with minimal effort while adhering to the latest Perl standards.

The `WWW::Noss` module serves as a backend for the noss RSS/Atom feed reader and aggregator, enabling users to manage and interact with their feeds through a command-line interface. It provides a variety of methods for initializing the application, running commands, and managing feeds, including updating, reloading, reading, and posting content. Recent updates in version 2.01 introduced a new "discover" command to find feed URLs associated with web pages, enhanced error messaging with color coding, and improved handling of HTTP responses, such as respecting the "Retry-After" header and following redirections. This module is particularly useful for users looking to streamline their feed management and access content efficiently.

The "meta" Perl module provides a powerful metaprogramming API that allows developers to inspect and manipulate the structure of their own Perl programs. By utilizing "meta"-objects, users can access various parts of the Perl interpreter, enabling them to create, modify, or remove symbols and other elements within packages dynamically. This module serves as a more user-friendly alternative to traditional metaprogramming techniques, such as using "no strict 'refs'", and aims to offer a consistent interface for enhancing Perl's capabilities. With methods for retrieving package information, adding new symbols, and managing subroutines, "meta" is designed for those looking to leverage advanced programming techniques, although it is currently considered experimental and subject to change.

Number::ZipCode::JP is a Perl module designed to validate Japanese zip codes according to the regulations set by Japan Post Holdings Co., Ltd. It allows users to create an instance of a zip code, set its value, and check its validity based on specified categories, such as area-specific or company-specific zip codes. The module provides methods for constructing zip code instances, importing validation categories, setting zip code values, and verifying their correctness. This makes it a useful tool for applications that require accurate handling of Japanese postal codes, ensuring compliance with official formatting standards.

Liveman is a Perl module designed to streamline the process of generating tests and documentation from Markdown files, effectively bridging the gap between documentation and testing in modern projects. By transforming Markdown files located in the `lib` directory into test files in the `t` directory, Liveman ensures that examples in the documentation remain functional and up-to-date with the code. It also integrates documentation into the `__END__` section of Perl modules, allowing for seamless access to both code and documentation. Recent updates in version 3.8 include enhancements to test definitions, specifically checking for defined values and equality without referencing equal objects, which improves the reliability of test outcomes. Liveman supports multilingual documentation through translation utilities and provides various testing capabilities, making it a versatile tool for Perl developers looking to maintain high-quality documentation and testing practices.

MARC::Validator is a Perl module designed to facilitate the validation of MARC (Machine-Readable Cataloging) records through a flexible plugin architecture. By utilizing the `plugins` method, users can retrieve a list of available validation plugins, each tailored to check specific aspects of MARC records, such as fields and formats. This modular approach allows for easy extension and customization, making it an essential tool for developers and librarians who need to ensure the integrity and compliance of their MARC data. With its straightforward implementation and reliance on the Module::Pluggable framework, MARC::Validator streamlines the process of MARC validation, enhancing data quality in library systems.

Graph::MoreUtils is a Perl module designed for detecting subgraph isomorphisms using the VF2 algorithm within undirected graphs. It allows users to identify all occurrences of a smaller graph within a larger one by utilizing the `matches` method, which returns an array of vertex correspondences for each match found. This module is particularly useful for applications in graph theory and network analysis, where understanding the relationships and structures within data is crucial. The initial release of this module was on November 28, 2025, marking its entry into the Perl ecosystem.

Chemistry::OpenSMILES is a Perl module designed for reading and writing chemical structures in the OpenSMILES format, adhering to the OpenSMILES v1.0 specification. It provides a parser that converts SMILES strings into arrays of Graph::Undirected objects, where atoms are represented as vertices and bonds as edges, allowing for detailed manipulation of molecular graphs. The module also includes a writer that can generate SMILES strings from these graph representations. Recent updates include the introduction of a 'write_atom_sub' option in version 0.12.3, enhancing the flexibility of the SMILES writing process. This module is particularly useful for chemists and researchers working with chemical informatics, enabling efficient parsing and generation of molecular representations.

Test::Which is a Perl module designed to enhance testing by allowing developers to skip tests if specific external programs are not available in the system's PATH, while also checking for version constraints. By using the `which_ok` function, developers can easily verify the presence and version of required executables, ensuring that tests only run when the necessary tools are available and meet specified version requirements. This module is particularly useful for projects that depend on external utilities, as it helps maintain test integrity and provides clear feedback on environment setup. The initial release of Test::Which was made in November 2025, marking its introduction to the Perl testing ecosystem.

Dist::Build::DynamicPrereqs is a Perl module designed to enhance the Dist::Build system by enabling support for dynamic prerequisites that are evaluated at configure time. This extension allows developers to specify dependencies that may change based on the environment or other conditions, ensuring that the necessary modules are included in the build process. With the key functions `evaluate_dynamic_prereqs()` and `add_prereq()`, users can effectively manage their project's prerequisites, including specifying phases and relations for each dependency. Notably, version 0.022, released on November 27, 2025, marks a significant update as it separates this functionality into its own module from the Dist::Build framework, streamlining its use and integration.

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 its predecessors, it employs an internal build graph that allows developers to easily combine various customizations through the addition of scripts in a "planner/" directory. With support for plugins such as Dist::Build::XS for compiling XS modules and Dist::Build::ShareDir for managing shared directories, it provides a robust framework for building complex distributions. The module also includes built-in delegates for managing metadata and configuration, making it a versatile tool for Perl developers looking to streamline their build processes.

ExtUtils::Builder is a Perl module that provides a framework for building and managing actions within various build tools, such as ExtUtils::MakeMaker and Module::Build. It abstracts the complexities of build processes into reusable components, allowing developers to define actions, nodes, and plans that can operate independently of the underlying build system. Actions serve as the fundamental units of work, which can be executed, converted to commands or code, and organized into composite structures called nodes. These nodes represent build steps with specified targets and dependencies, while plans group multiple nodes together, facilitating a topological sort to determine the necessary build order. This modular approach simplifies the creation of platform-agnostic build scripts, making it easier to manage and execute complex build tasks.

Beam::Minion is a powerful distributed task runner designed for use with Beam::Wire containers, enabling efficient execution of tasks across multiple workers. With a straightforward command-line interface and a flexible Perl API, users can easily configure the system via environment variables or configuration files, specifying the backend database for task coordination. The module allows for the enqueuing of tasks defined as Beam::Runnable objects, with options for retries, delays, and priority management. Ideal for applications requiring asynchronous job processing, Beam::Minion facilitates seamless task execution and management, making it a valuable tool for developers looking to enhance their Perl applications with distributed processing capabilities.

The `List::Gen` Perl module is a powerful tool designed for generating and manipulating lists through a variety of higher-order functions, list comprehensions, and lazy evaluation techniques. It allows users to create generators and iterators that produce values on demand, enabling efficient handling of potentially infinite sequences without the need for pre-computation. With features like custom step sizes for list traversal, lazy ranges, and a rich set of utility functions, `List::Gen` simplifies complex list operations such as zipping, filtering, and mapping. The module also integrates seamlessly with existing Perl functions from `List::Util`, making it a versatile addition for developers looking to enhance their list processing capabilities in Perl.

The Mail::Box module in Perl provides a robust framework for managing mailboxes, allowing users to interact with various types of mail folders in a consistent manner. It serves as a base class for different folder types, such as Mail::Box::Dir, Mail::Box::File, and Mail::Box::Net, each of which handles message storage differently—whether in a single file or across multiple files in a directory. With Mail::Box, users can easily open folders, retrieve messages, delete or add messages, and iterate through all messages using a unified API. The module also supports advanced features like message filtering, lazy loading of message bodies, and folder locking, making it suitable for both simple and complex email management tasks. Overall, Mail::Box simplifies the handling of email data, providing a powerful tool for developers working with email systems in Perl.

The `Text::PO` Perl module provides a comprehensive solution for reading, writing, and manipulating GNU Portable Object (PO) and Portable Object Template (POT) files, which are commonly used for localization in software applications. With this module, developers can easily parse PO files, edit localized text, and output the results back into the PO format or convert them into JSON for use in JavaScript applications. It supports various functionalities such as adding and removing translation elements, synchronizing data with existing files, and exporting data in different formats, all while managing metadata associated with the translations. This module eliminates the need for external tools like `msgfmt` or `msginit`, making it a convenient choice for developers looking to streamline their localization workflows.

Daje::Workflow is a straightforward workflow engine designed to manage processes through a series of states and transitions, allowing developers to model complex workflows in a clear and organized manner. By defining states that represent object properties and transitions triggered by events, users can navigate through various actions within a workflow. The module initializes with a default 'INITIAL' state and facilitates the execution of actions that lead to new states, making it easy to track the progression of tasks. With dependencies on several other Daje modules for database interaction and error handling, Daje::Workflow provides a robust framework for implementing and managing workflows in Perl applications.