CPANscan

Perl::Download::FTP is a Perl module designed to facilitate the identification and downloading of Perl releases via FTP. It provides a straightforward interface for users to connect to FTP servers, list available Perl releases, classify them by type (production, development, or release candidate), and download the latest or specific versions in various compression formats (gz, bz2, xz). The module's constructor allows customization of the FTP host and directory, while its methods enable users to retrieve comprehensive lists of releases and manage downloads efficiently. A noteworthy recent change in version 0.06, released in November 2025, involved updates to the lists of Perl releases used in testing, ensuring the module remains current and functional.

Plack::Middleware::ConsoleLogger is a Perl module designed to enhance the logging capabilities of PSGI applications by capturing logs and making them accessible in the JavaScript console for Firebug and Webkit Inspector. By simply enabling this middleware, developers can easily monitor and debug their applications in real-time, improving the development workflow and facilitating the identification of issues. With the option to configure log groups, Plack::Middleware::ConsoleLogger provides a flexible solution for integrating console logging into web applications.

Plack::Middleware::ReverseProxy is a Perl module designed to facilitate the operation of a web application as a reverse proxy backend. It achieves this by resetting certain HTTP headers that may have been altered by the reverse proxy, ensuring that the application receives accurate request information. The module allows developers to specify the reverse proxy address and implement security measures to prevent fake requests using the 'enable_if' directive in their app.psgi configuration. A noteworthy recent change in version 0.16, released on February 19, 2019, involved updating the packaging process to utilize Milla, enhancing the module's maintainability. This middleware is particularly useful for applications that need to handle requests from a reverse proxy while maintaining the integrity of the original request data.

Plack::Middleware::Debug is a powerful debugging tool for Plack applications that provides detailed insights into the current request and response cycle. By enabling this middleware, developers can display a configurable set of panels containing information such as environment variables, response details, memory usage, and database interactions, all embedded directly into the HTML response sent to the browser. The middleware is designed to be easily extensible, allowing users to create custom debug panels tailored to their specific needs. Recent updates have improved functionality, including the ability to load debug middleware from outside the Plack::Middleware::Debug namespace, enhancing flexibility for developers. This module is particularly useful for debugging web applications, ensuring that developers have the necessary tools to monitor and optimize their applications effectively.

The `abbreviation` Perl module is a pragma designed to simplify the use of lengthy class names by allowing developers to create abbreviated versions. By using this module, you can easily define shorter aliases for long class names, making your code cleaner and more manageable. For instance, instead of repeatedly typing `Very::Long::ClassName::Here`, you can simply use `V::L::CN::Here` to instantiate objects. This module employs symbol table aliasing for dynamic package name aliasing, which enhances its functionality while maintaining simplicity. Although the module has been stable since its initial release, it continues to be a valuable tool for Perl developers looking to streamline their code.

The `import` Perl module is a pragma designed to simplify the process of importing multiple modules that share a common package prefix, effectively allowing developers to avoid repetitive 'use' statements. By utilizing `import`, users can load all modules within a specified package prefix, automatically aliasing their fully qualified names to a shorter, more convenient form. This functionality is particularly beneficial for those transitioning from Java, where similar import capabilities exist. The module enhances code readability and reduces the need for prior knowledge of all module names, making it a valuable tool for Perl programmers seeking to streamline their code.

The `namespace` Perl module provides a pragma that facilitates the aliasing of namespaces, similar to C++ namespace aliasing, enhancing code reusability and organization. By using the `use namespace` directive, developers can create an alias for a package, allowing for cleaner and more manageable code when importing functions or constants from that package. This module supports importing specific items or entire subpackages, and it also allows for the removal of the alias with `no namespace`. A noteworthy feature is the ability to expand the alias to the caller's namespace when prefixed with '::', making it versatile for various coding contexts. Overall, `namespace` is a valuable tool for Perl developers looking to streamline their code structure and improve maintainability.

The "Syntax::Keyword::MultiSub" Perl module introduces a powerful new keyword, "multi," that allows developers to define multiple subroutine bodies with varying parameter signatures, enabling multiple dispatch based on the number of arguments provided. This feature enhances code readability and maintainability by allowing distinct implementations of a function to coexist under the same name, with the appropriate version being invoked based on the arguments passed. Designed for Perl version 5.26 and above, this module requires the independent activation of the "signatures" feature and currently supports dispatching solely based on argument count. It is particularly useful for scenarios where functions need to handle different types or numbers of inputs gracefully, making it a valuable addition for developers looking to streamline their code.

"Syntax::Keyword::Match" is a Perl module that introduces a "match/case" control-flow syntax, allowing developers to execute blocks of code based on the value of a controlling expression, similar to the "switch/case" constructs found in languages like C. This module enables the use of various comparison operators, including string and numerical comparisons, as well as type checks with the `isa` operator. It supports multiple case labels for a single block and introduces a new `case if` syntax for more complex conditions. As of version 0.15, recent updates include bug fixes and improvements to the module's internal handling, ensuring better compatibility and functionality. This module is still considered experimental, with ongoing development aimed at enhancing its features and stability.

Lexical::Persistence is a Perl module designed to facilitate the management of persistent lexical variable values across multiple subroutine calls. By creating a Lexical::Persistence object, developers can store and retrieve variable states seamlessly, allowing for the preservation of data between function invocations. The module supports multiple contexts, enabling the organization of variables with prefixes, and provides methods for calling subroutines with named arguments that are accessible as lexical variables. Additionally, Lexical::Persistence allows for the execution of Perl code strings within a persistent lexical environment, making it a versatile tool for maintaining state in complex applications. This module is particularly useful for scenarios where variable values need to be retained across different function calls without resorting to global variables.

Term::ANSIEncode is a Perl module designed to facilitate the generation of ANSI text markup for terminal applications, enabling developers to create visually rich command-line interfaces. It provides a variety of tokens for cursor movement, text formatting (such as bold, italic, and underlined text), screen clearing, and color manipulation, allowing for enhanced user interaction in terminals that support UTF-8 and ANSI standards. Recent updates have significantly improved token handling and expanded the range of available symbols and colors, making it easier to create complex visual layouts. The module is particularly useful for developers looking to enhance the aesthetic and functional aspects of terminal output in their Perl applications.

The App::perlimports module provides a command line interface (CLI) designed to enhance the management of Perl import statements by making implicit imports explicit. This tool automates the cleanup and maintenance of import statements in Perl code, helping developers maintain cleaner and more understandable codebases. The latest version, 0.000058, introduced a fix that allows the recognition of function references (e.g., `\&Module::func`) as valid module usage, improving the module's functionality and usability. With its focus on simplifying the import process, App::perlimports is an essential tool for Perl developers looking to streamline their code.

Test::Fatal is a Perl module designed to simplify the process of testing code that may throw exceptions. It provides a straightforward interface, primarily through the `exception` function, which executes a block of code and returns any exception thrown, or `undef` if no exception occurs. Unlike other testing modules, Test::Fatal does not manipulate the call stack, allowing for greater flexibility and avoiding potential false positives in tests. It also includes additional functions like `success`, `dies_ok`, and `lives_ok` for enhanced testing capabilities, making it a valuable tool for developers looking to ensure robust error handling in their code.

The Import::Into Perl module simplifies the process of importing packages into other packages, addressing the inconsistencies found in various exporting mechanisms. By providing a global method, `import::into`, it allows developers to easily import modules into a specified target package or caller level, while also supporting additional options like filename, line number, and version checks. This module is particularly useful for those who want to re-export modules without modifying their original import methods, making it compatible with any exporter or pragma. A noteworthy recent change in version 1.002003 allows for module loading during the import process, eliminating the need to load modules beforehand, thereby streamlining the usage of Import::Into in complex scenarios.

The `Keyword::Declare` Perl module allows developers to create new keywords in Perl with ease, enabling the definition of custom syntax that can enhance code readability and functionality. By using the `keyword` directive, users can specify the name of the new keyword along with its parameters and the corresponding replacement source code, which the module handles automatically. This eliminates the need for complex parsing and manual code substitution typically required in other approaches. The module supports various parameter types, including regex and named types, and allows for advanced features like optional parameters, multiple keyword definitions, and the ability to maintain whitespace in specific contexts. With `Keyword::Declare`, developers can create expressive and intuitive constructs that integrate seamlessly into their Perl code, making it a powerful tool for extending the language's capabilities.

Eval::Context is a Perl module designed to evaluate Perl code within a specified context, allowing for enhanced control over the execution environment. It enables users to prepend and append code, define variables and subroutines, and even run code in a safe compartment to mitigate security risks. The module supports evaluating code from both strings and files, and it offers mechanisms for sharing and persisting variables between the caller and the evaluated code. Notably, recent updates have improved the module's functionality and documentation, ensuring better usability and clarity for developers. This makes Eval::Context a powerful tool for scenarios where code execution needs to be tightly controlled and monitored.

The Safe Perl module provides a mechanism for creating compartments that allow the execution of Perl code in a controlled and restricted environment. By establishing a new namespace and an operator mask, Safe ensures that code evaluated within a compartment cannot access variables or execute operations outside its defined boundaries, thus enhancing security and stability. Users can permit or deny specific operators and share variables with the compartment, allowing for flexible yet safe code execution. Recent updates include the localization of signal handling within Safe compartments and improved checks for method calls on Safe objects, enhancing its reliability and security features. This module is particularly useful for applications that require executing untrusted code while minimizing risks associated with code execution.

Daje::Plugin::Apploader is a Perl module designed to facilitate the dynamic loading of plugins and routes within a web application framework. It allows developers to define various loadable components, including plugins, routes, and helpers, through a structured configuration. By utilizing this module, developers can easily register and manage their application's extensions, enhancing modularity and maintainability. The module requires Mojo::Loader and is compatible with Perl version 5.40 or higher, making it a versatile choice for modern Perl applications.

Business::CAMT is a Perl module designed for managing ISO20022 Cash Management (CAMT) messages, commonly used in banking to represent account transactions. This module allows users to read and write CAMT XML message files, ensuring they are validated and predictable. It provides methods for creating new messages, converting them to Perl data structures or JSON, and writing them to files. Recent updates in version 0.13 include the ability to combine set and version arguments in the create() method, enhancements to the read() function to accept file handles and strings, and improvements in handling long tag names for better readability. This module is particularly useful for developers working with financial data who need to interact with CAMT messages efficiently.

HTML::Defang is a Perl module designed to sanitize HTML and CSS by removing executable content, such as scripts and embedded objects, thereby neutralizing potential XSS (Cross-Site Scripting) attacks. It employs a whitelist approach, allowing only safe HTML elements through while providing a robust custom HTML tag parser that can handle complex and malformed HTML structures. The module supports various callback functions, enabling users to customize how specific tags, attributes, and URLs are processed during sanitization. Recent updates include a fix for a defang bug related to `<script>` tags and mangled comment data, enhancing its reliability in handling real-world HTML scenarios. This makes HTML::Defang an essential tool for developers looking to secure web applications against XSS vulnerabilities while maintaining control over the HTML content they process.

Liveman is a Perl module designed to streamline the process of compiling Markdown documentation into test scripts and documentation files, effectively bridging the gap between documentation and testing in modern projects. With Liveman, users can transform Markdown files into corresponding test files and embed documentation directly into Perl modules, ensuring that examples remain accurate and up-to-date. The module supports various testing methods and allows for translation of documentation using the Trans utility, making it versatile for multilingual projects. Notably, version 3.4 introduced a fix for translation bugs and improved handling of documentation files, ensuring that if a Perl module is not present, a POD file will be created instead. This makes Liveman an essential tool for developers looking to maintain high-quality documentation and testing practices.

The `IRC::Utils` Perl module provides a comprehensive set of utilities designed to simplify various tasks associated with Internet Relay Chat (IRC). It includes functions for manipulating nicknames and channel names, parsing mode lines, normalizing ban masks, and handling message encoding and formatting. Key features include converting strings to IRC-compliant uppercase and lowercase, comparing nicknames with case sensitivity options, and parsing user information from IRC messages. Additionally, it offers functionality to detect and strip color and formatting codes from messages, as well as to decode raw IRC messages for proper text handling. A noteworthy recent change in version 0.12 includes an enhancement to the `strip_formatting()` function, which now only removes cancellation codes if no color codes are present in the string, improving its utility in mixed-format scenarios. This module is essential for developers working with IRC bots or applications, providing the necessary tools to manage IRC-specific data effectively.

TOML::Tiny is a minimal, pure Perl module designed for parsing and serializing TOML (Tom's Obvious, Minimal Language) data format, adhering to TOML v1.0 specifications with some exceptions. It provides a straightforward interface for decoding TOML strings into Perl data structures and encoding Perl hashes back into TOML format. The module exports functions like `from_toml` for parsing and `to_toml` for generating TOML strings, while also offering an object-oriented API for more advanced usage. Recent updates in version 0.20 include fixes for parsing and writing quoted keys, ensuring better handling of inline table keys, and improvements to error handling when encoding non-hash references, enhancing the module's robustness and usability.

Path::Iterator::Rule is a powerful Perl module designed for iterative and recursive file searching based on user-defined criteria. It allows developers to create complex rules for matching files and directories, leveraging a flexible API that supports both lazy iteration and flattened list outputs. With features such as custom rule callbacks, breadth-first or depth-first searching, and options for handling symlinks and directory loops, this module provides a robust solution for file management tasks. Recent updates include a fix for Windows directory handling, ensuring that directories that are readable but cannot be opened are properly skipped, enhancing the module's reliability across different operating systems.

Crypt::Argon2 is a Perl module that provides an interface to the Argon2 key derivation functions, which are designed for securely converting passwords into cryptographic keys. This module is particularly useful for password storage and can also derive encryption keys from passwords, offering customizable parameters for time and memory costs as well as output size. With functions like `argon2id_pass` and `argon2_verify`, users can easily hash passwords with a specified salt and verify them later, ensuring robust security practices. Additionally, the module includes tools for checking if a password needs rehashing based on changing security requirements, making it a versatile choice for developers looking to implement secure password management in their applications.

Data::Password::zxcvbn is a Perl module that implements Dropbox's password strength estimation logic, providing developers with a robust tool for assessing the security of user passwords. By utilizing the `password_strength` function, users can analyze a password and receive detailed feedback, including an estimated number of guesses required to crack it, a score indicating its strength, and suggestions for improvement if the password is deemed weak. The module has been optimized for performance and accuracy, with pre-computed dictionaries and a structure that enhances usability. Notably, version 1.1.3 introduced a new `--input` option for the `zxcvbn-password-strength` command, further enhancing its functionality. This module is essential for applications that prioritize user security by encouraging the use of strong passwords.

The Term::ANSIColor module provides a straightforward way to add color to terminal output using ANSI escape sequences in Perl. It allows developers to easily format text with various colors and attributes, such as bold or underlined, by using functions like `color()` and `colored()`, or by importing constants for a more concise syntax. The module supports a wide range of color options, including standard, bright, 256-color, and true color formats, making it versatile for different terminal capabilities. Additionally, it includes utility functions for validating colors, stripping color codes, and creating aliases for color attributes, enhancing usability in scripts that require colored output. Overall, Term::ANSIColor is an essential tool for Perl developers looking to improve the visual appeal of their command-line applications.

The `Term::ReadLine::Gnu` Perl module provides an interface to the GNU Readline and History Library, enabling advanced command-line input features such as line editing, history management, and customizable key bindings. It is designed to be used through the `Term::ReadLine` interface, allowing developers to create interactive applications that can read user input with support for features like auto-completion and history navigation. The module includes a comprehensive set of methods that mirror the functionality of the GNU Readline library, along with additional features specific to this Perl implementation. Notably, version 1.47 introduced support for readline-8.3, adding new functions and variables, enhancing the module's capabilities for handling command-line input.

The Neo4j::Client Perl module provides a convenient interface for building and utilizing the libneo4j-omni library, which facilitates communication with Neo4j servers using the Bolt protocol. This module simplifies the installation process by leveraging GNU autotools to compile the necessary API components on your machine, ensuring compatibility with Neo4j versions up to 5.x. While it does not include the interactive shell or documentation of the library, it guarantees that OpenSSL support is integrated, thanks to the Alien::Build framework. Ideal for developers looking to interact with Neo4j databases, Neo4j::Client streamlines the setup and configuration of the underlying C library, making it easier to incorporate Neo4j functionality into Perl applications.

The `Test::JSON::Schema::Acceptance` Perl module facilitates acceptance testing for JSON Schema validators by allowing developers to run the official JSON Schema Test Suite directly within Perl. This module is particularly useful for those creating or maintaining Perl modules that implement the JSON Schema specification, as it automates the process of verifying compliance with various drafts of the schema without the need for manual conversion of test cases. By leveraging this module, developers can ensure their implementations are interoperable with other libraries across different programming languages, thereby enhancing the reliability and consistency of JSON data validation. The module supports multiple schema drafts and provides a flexible interface for defining test parameters, making it an essential tool for developers focused on JSON Schema compliance.