CPANscan

Perl::Critic::PJCJ is a Perl module that provides a set of policies designed to enforce consistent coding practices within Perl codebases. By integrating these policies into your development workflow, either through a configuration file or command line, you can ensure adherence to best practices such as consistent string quoting and manageable line lengths, which enhance code readability and maintainability. The module includes specific rules for optimal quoting and a configurable maximum line length, helping developers produce cleaner, more uniform code.

The WebServer::DirIndex Perl module is designed to facilitate the creation of directory index pages for web servers by reading the contents of a specified filesystem directory. By instantiating a WebServer::DirIndex object with the directory path and corresponding URL, users can easily retrieve a list of file entries, including details such as URLs, names, sizes, MIME types, and modification times. Additionally, the module can generate a complete HTML directory index page, optionally enhanced with CSS for improved aesthetics, making it a valuable tool for developers looking to display directory contents on their web applications efficiently.

The Resque Perl module is a Redis-backed library designed for creating and managing background jobs, allowing developers to place tasks on multiple queues and process them asynchronously. It serves as a Perl port of the original Ruby Resque library, enabling seamless integration with Ruby's resque-server web application for monitoring job status. With features such as persistent queues, atomic operations, and support for distributed workers, Resque provides a robust solution for handling background processing in Perl applications. Recent updates in version 0.44 include enhancements to the job removal process to prevent orphaned markers on failure, ensuring greater reliability in job management.

The Data::FSM module provides a robust framework for creating and managing finite state machines (FSM) in Perl. It allows developers to define states and transitions between those states, encapsulating the logic of state management within a dedicated object. With methods to retrieve the FSM's ID, states, and transitions, users can easily interact with and manipulate the state machine. The module ensures that transitions are valid by checking that the involved states are defined within the FSM, thus preventing errors during execution. This module is particularly useful for applications requiring complex state management, such as workflow engines or game development. The initial release of Data::FSM was on February 21, 2026, marking its introduction to the Perl ecosystem.

The `Mo::utils::common` Perl module provides a set of common subroutines for the Mo::utils framework, with a primary focus on object validation. Its key function, `check_object`, allows developers to verify whether a given value is an instance of a specified class. If the check fails, it generates an error message based on a customizable template and parameters, facilitating error handling in applications. This module is particularly useful for ensuring type safety and improving code robustness by providing clear feedback when object type mismatches occur. With dependencies on modules like `Error::Pure` and `Scalar::Util`, it integrates seamlessly into existing Perl projects, making it a valuable tool for developers seeking to enhance their object-oriented programming practices.

"Dist::Build" is a modern Perl module builder designed to facilitate the creation and management of Perl distributions. Unlike its predecessors, it offers extensibility through a build graph, allowing users to easily combine various customizations by adding scripts in the "planner/" directory. Key features include support for compiling XS modules, managing shared directories, and dynamically evaluating dependencies, all through a range of plugins such as "Dist::Build::XS" and "Dist::Build::ShareDir." The latest version, 0.026, introduces improvements like enhanced cleanup during testing and refined delegate handling, making it a robust choice for developers looking to streamline their module building process.

ExtUtils::Builder is a Perl module designed to simplify the creation and management of build processes for software extensions across various platforms and build systems. By abstracting the steps involved in these processes into reusable components, it allows developers to define executable descriptions of work that are independent of the underlying build tools. The module introduces key concepts such as Actions, Nodes, Plans, and Planners, enabling users to create a structured workflow where dependencies are managed efficiently, and tasks are executed in a topological order similar to that of a Makefile. Additionally, it supports serialization to JSON-compatible formats and can be integrated with ExtUtils::MakeMaker, making it a versatile choice for developers looking to streamline their build processes.

The App::Greple::tee module is designed to enhance text processing by allowing users to replace matched text with the output of an external command. This functionality is particularly useful for transforming text in a flexible manner, as it can send matched portions of input to a specified filter command and replace them with the command's result. Users can invoke the module with various options, such as `--discrete` to process each match individually or `--bulkmode` for batch processing. Recent updates in version 1.05 include the introduction of a nofork+raw mode for code reference calls, improving performance when executing Perl functions directly instead of external commands. This module is ideal for users looking to leverage external processing tools within their text manipulation workflows, particularly in document processing scenarios.

Plack::App::DirectoryIndex is a PSGI application designed to serve static files from a specified document root while providing an index file feature similar to Apache's mod_autoindex. It allows developers to easily configure a default index file, such as "index.html," to be served when a directory is requested, enhancing user experience by avoiding plain directory listings. Additionally, users can customize the index file name or opt for a more visually appealing directory listing by enabling a pretty CSS stylesheet. This module is particularly useful for web applications that require straightforward static file serving with the convenience of default index file handling.

App::Netdisco is an open-source, web-based network management tool tailored for network administrators, enabling efficient monitoring and management of network devices. It collects data via SNMP and stores it in a PostgreSQL database, allowing users to locate devices by MAC or IP address, manage switch ports, and maintain an inventory of network hardware. With a built-in web server and backend daemon, Netdisco facilitates interactive requests such as changing port settings and provides visual representations of network topology. The module is designed for ease of installation and configuration, making it a valuable resource for managing complex network environments.

The Command::Run Perl module provides a straightforward interface for executing external commands or Perl code references while capturing their output. It allows users to run commands with various configurations, such as merging or capturing standard error output, providing input data via standard input, and accessing output through file descriptor paths. Notably, the recent version 0.9903 introduced a nofork option for executing code references without forking, significantly improving performance by eliminating the overhead associated with process duplication. Additionally, it added a raw option to avoid encoding overhead, enhancing efficiency further. This module is designed for simplicity and minimal dependencies, making it an excellent choice for lightweight command execution in Perl applications.

The SPVM::Resource::SQLite module is a resource class designed for integrating SQLite, a widely-used database engine, into SPVM (Simple Perl Virtual Machine) applications. It provides the necessary header and source code files for SQLite, enabling developers to leverage SQLite's functionalities directly within their SPVM projects. By configuring the module, users can include SQLite's capabilities, such as multi-threading support and various extensions for enhanced database operations, in their C code. This module simplifies the process of utilizing SQLite, making it easier for developers to manage and query databases efficiently within the SPVM environment.

Term::TablePrint is a Perl module designed for printing tables to the terminal in an interactive manner, allowing users to browse through the data easily. It supports various navigation keys for scrolling through the table, and users can expand rows to view detailed information about each entry. The module automatically handles terminal width adjustments and offers options for customizing the display, such as enabling color, filtering rows based on search patterns, and managing column visibility. Recent updates in version 0.176 include the reintroduction of the 'choose_columns' feature, a new option for expanded line spacing, and renaming of certain parameters for clarity, enhancing the overall usability of the module.

Yote::SQLObjectStore is a Perl module designed to facilitate the management of a rooted tree-based object store using SQL databases such as MariaDB or SQLite. It allows developers to define object structures through package-level column definitions, enabling the creation and manipulation of complex data hierarchies. With features like automatic table creation, path-based data retrieval, and runtime type checking, Yote::SQLObjectStore simplifies the process of storing and accessing objects in a relational database. Users can easily define their data models, instantiate objects, and save or fetch data using intuitive path-based queries, making it an effective solution for applications that require structured data storage and retrieval.

Plack::Handler::H2 is a high-performance HTTP/2 server handler designed for PSGI applications, utilizing native C++ code with Perl XS bindings to deliver efficient, asynchronous request handling. It supports full HTTP/2 protocol features, including header compression, stream multiplexing, and server push capabilities, while ensuring secure connections through TLS/SSL with OpenSSL. Ideal for production environments, Plack::Handler::H2 can be easily run using the plackup command, which allows for custom SSL configurations or auto-generates self-signed certificates for development. This module is fully compliant with the PSGI specification, making it compatible with various PSGI frameworks and applications, and it excels in performance through its event-driven architecture and optimized memory management for handling large request bodies.

Tree::STR is a Perl module designed for creating a Sort-Tile-Recursive (STR) tree, which serves as a read-only R-Tree optimized for efficient construction and spatial querying. It allows users to input data as an array of bounding box coordinates, each followed by an associated item, or as objects with a bbox method. With methods for querying points and rectangles, Tree::STR facilitates quick retrieval of items that intersect with specified spatial areas, making it ideal for applications in geographic information systems and spatial data analysis.

Module::CoreList is a Perl module that provides comprehensive information about which core and dual-life modules are included with various versions of Perl. It offers a functional programming API that allows developers to query details such as the first release of a module, whether a module is part of the core, and the changes between different Perl versions. The module also includes a command-line utility called `corelist` for convenient access to this information. Recent updates have ensured compatibility with the latest Perl versions, including the latest update for v5.43.8, enhancing its utility for developers working with the most current Perl distributions.

The CPAN::Perl::Releases module provides a convenient way to map Perl releases available on CPAN to their corresponding tarball locations. By utilizing the `perl_tarballs` function, users can input a specific Perl version and receive a hash reference containing the paths to the gzipped and bzip2-compressed tar files, facilitating easy access to the source code for different Perl versions. Additionally, the module offers functions to retrieve a list of all supported Perl versions and the PAUSE IDs of Perl pumpkins, making it a valuable resource for developers and maintainers working with Perl distributions.

DBIx::Class::Storage::DBI::MariaDB is a Perl module designed to integrate MariaDB support into the DBIx::Class Object-Relational Mapper (ORM). It functions similarly to the existing DBIx::Class::Storage::DBI::mysql module, allowing developers to utilize MariaDB-specific features while maintaining compatibility with the same parameters. To use this module, simply load it within your schema and specify MariaDB in your Data Source Name (DSN) when establishing a database connection. This module is ideal for developers looking to leverage the capabilities of MariaDB within their Perl applications seamlessly.

The `Business::ISBN::Data` module serves as a data pack for the `Business::ISBN` module, providing essential information derived from the RangeMessage.xml file supplied by the ISBN Agency. Typically, users do not need to load this module directly, as it is automatically loaded by `Business::ISBN` when required. This module is designed to work with `Business::ISBN` version 3.005 or later, due to changes in the data structure that address a bug related to ISBN-13 prefixes. Users can customize their data source by setting the `ISBN_RANGE_MESSAGE` environment variable to point to an alternative RangeMessage.xml file, allowing for the use of the most current or historical data without needing to update the module itself. If the specified data file is unavailable, the module defaults to older data included in `Data.pm` or searches the current directory for the file. The data is stored in the `%Business::ISBN::country_data` hash, which provides a historical context for the information.

Dist::Zilla::Plugin::AuthorSignatureTest is a Perl module designed to enhance the Dist::Zilla build system by providing a test for the presence and validity of a SIGNATURE file in author distributions. It extends the functionality of Dist::Zilla::Plugin::InlineFile by including a standard Test::Signature test located in xt/author/signature.t. This test checks the integrity of the SIGNATURE file, ensuring that it is correctly implemented and that the necessary dependencies, such as the Module::Signature package, are available. Users can configure the module to enforce stricter testing conditions by setting the 'force' attribute to true, which will cause the test to fail if the SIGNATURE file is missing or if there are issues connecting to the key server. This module is particularly useful for authors who want to ensure the authenticity and integrity of their distributions.

Plack::Middleware::DirListing is a Perl module designed to enhance web applications by providing a clean HTML directory listing for specified directories. It functions similarly to Plack::App::Directory but is specifically tailored to serve directory listings only, without attempting to serve individual files. This middleware aims for a user interface that resembles a polished version of the Apache web server's output, making it visually appealing and user-friendly. The module requires a configuration of the document root directory, defaulting to the current directory, and can be combined with other middleware for additional functionality. A noteworthy recent update in version 1.01 includes improved tests and the implementation of a trailing slash feature, enhancing its robustness and usability.

Test2::Harness is a robust test harness designed to enhance the testing experience in Perl by providing improved integration with the Test2 framework. While users typically interact with the more user-friendly App::Yath, Test2::Harness serves as the underlying engine that executes and manages test runs. It offers features such as better resource management, enhanced output handling, and the ability to run tests in parallel, making it suitable for complex testing scenarios. Notably, the recent version 1.000162, released on February 20, 2026, includes various bug fixes and improvements, such as addressing issues with preserving exit status and enhancing the handling of filesystem changes, further solidifying its reliability for developers.

SNMP::Info is a robust Perl module that provides an object-oriented interface for retrieving and managing information from network devices using the Simple Network Management Protocol (SNMP). Designed primarily for network devices, it abstracts the complexities of vendor-specific implementations by offering a unified interface to access various Management Information Base (MIB) data. Users can easily discover device types, retrieve interface statistics, and manage configurations through a consistent API. Recent enhancements in version 3.975000 include support for Cambium devices, showcasing the module's ongoing development and adaptability to new technologies. With its extensive support for a wide range of devices and MIBs, SNMP::Info is an essential tool for network administrators and developers looking to streamline network management tasks.

The CPAN::Meta module provides a structured way to handle distribution metadata for Perl modules published on CPAN, utilizing either META.json or the older META.yml format. It allows developers to load, validate, and manipulate metadata, including dependencies and features, through a variety of methods such as `load_file`, `effective_prereqs`, and `save`. This module is essential for managing the metadata associated with Perl distributions, ensuring compatibility and ease of use when dealing with module dependencies. A noteworthy recent change in version 2.150013 addresses an incompatibility with newer versions of CPAN::Meta::Requirements, enhancing its reliability for developers.

LTSV::LINQ is a Perl module that provides a LINQ-style query interface specifically designed for processing Labeled Tab-Separated Values (LTSV) files. With its fluent and chainable API, users can easily filter, transform, and aggregate data from LTSV files using a variety of methods, including lazy evaluation for efficient memory usage. The module supports both code reference and Domain Specific Language (DSL) syntax for filtering, allowing for straightforward queries that can handle complex data manipulations. Key features include comprehensive query capabilities with 54 methods, compatibility with Perl versions 5.005 and above, and the ability to work seamlessly with large datasets without consuming excessive memory. LTSV::LINQ is particularly useful for log analysis and data processing tasks, making it a powerful tool for developers working with structured log data.

Data::Smile::XS is a Perl module that provides a high-performance XS implementation for encoding and decoding Smile data, a binary serialization format. It offers four primary functions: `encode_smile`, which converts Perl data structures into Smile byte strings; `decode_smile`, which transforms Smile bytes back into Perl data; `dump_smile`, which encodes data and writes it to a specified file; and `load_smile`, which reads Smile data from a file and decodes it. The module supports various options for customization, such as including headers, enabling shared references, and controlling boolean decoding. Released in February 2026, this module is designed for efficiency and ease of use, making it an excellent choice for developers needing to work with Smile serialization in Perl applications.

Data::Smile is a Perl module designed for encoding and decoding Smile data, a binary format that efficiently represents JSON-like data structures. It provides four primary functions: `encode_smile` for converting Perl data structures into Smile byte strings, `decode_smile` for transforming Smile bytes back into Perl data, `dump_smile` for writing encoded data to a file, and `load_smile` for reading and decoding data from a file. The module intelligently utilizes either a pure Perl implementation or an XS (C-based) implementation for performance, depending on availability. With options for customizing encoding behavior, such as including headers and handling shared names and values, Data::Smile offers flexibility for various use cases. The initial release of this module was on February 20, 2026, marking its entry into the Perl ecosystem.

DBIx::Class::Async is an experimental Perl module that provides a non-blocking, multi-worker asynchronous wrapper for the popular DBIx::Class ORM, enabling developers to perform database operations without freezing the main application loop. By utilizing a worker-pool architecture, it allows multiple database queries to be executed in parallel, significantly improving responsiveness in applications that require high concurrency. The module integrates seamlessly with various event loops, including IO::Async and Mojolicious, and supports modern asynchronous programming patterns such as Futures and async/await. Notably, version 0.58 introduced a bug fix that ensures scalar-ref values targeting primary key columns are correctly handled, preventing silent errors during IPC serialization. This module is ideal for developers looking to enhance the performance of their database interactions in Perl applications.

Text::Amuse::Compile is a Perl module designed to compile documents written in the Muse markup language into various output formats, including PDF, HTML, EPUB, and LaTeX. With a flexible constructor, users can specify options such as font selection, output type, and compilation settings, allowing for tailored document generation. The module supports recursive compilation of directories, making it efficient for processing multiple files while managing auxiliary files and logging errors. Notably, version 1.91 has removed the xeCJK usage to avoid conflicts with babel options, enhancing compatibility for users working with multilingual documents. This module is particularly useful for authors and publishers looking to convert Muse documents into polished, professional formats.