CPANscan

The `Alien::gdal` Perl module provides a convenient way to compile and access the Geographic Data Abstraction Library (GDAL), which is essential for handling raster and vector geospatial data. By using this module, developers can easily integrate GDAL utilities into their Perl applications, allowing them to manipulate geographic data formats and perform operations such as data transformation with tools like `gdalwarp`. The module facilitates the inclusion of GDAL's binary and data directories into the environment, streamlining the process of working with geospatial data in Perl. Additionally, it encourages users to report any issues or feature requests, fostering community collaboration and improvement.

Dancer2 is a modern, lightweight web application framework for Perl, designed to simplify the process of building web applications. It is a complete rewrite of the original Dancer framework, leveraging Moo for improved performance and flexibility. Dancer2 supports optional XS modules for enhanced speed while remaining fatpackable, making deployment straightforward on environments without custom CPAN module support. The framework offers an intuitive DSL (Domain-Specific Language) for defining routes and handling requests, allowing developers to create applications quickly and efficiently. Recent enhancements in version 2.0.0 include a new extendable configuration system, improved logging capabilities, and the ability to scaffold multiple applications within the core framework, making it even more versatile for developers.

The `WWW::Mechanize` Perl module is a powerful tool for automating web browsing tasks, enabling users to programmatically interact with websites by fetching pages, following links, and submitting forms. It simplifies the process of web scraping and testing web applications by providing high-level methods for handling HTTP requests, managing cookies, and parsing HTML content without requiring manual HTML parsing. With features like SSL support, automatic redirection handling, and customizable HTTP headers, `WWW::Mechanize` is particularly useful for developers looking to automate repetitive web tasks or conduct web application testing. The latest version, 2.19, includes minor documentation fixes and enhancements, such as replacing "base" with "parent" in the code, ensuring the module remains up-to-date and user-friendly.

The HTML::Form module in Perl provides a robust class for representing and manipulating HTML form elements. It allows developers to parse HTML documents to extract form data, modify input values, and generate HTTP requests that can be sent using LWP::UserAgent. With methods for accessing and modifying form attributes, handling various input types, and managing form submissions, HTML::Form simplifies the process of working with web forms in Perl applications. The latest version, 6.13, includes compatibility fixes for HTTP::Message 7.01+, ensuring seamless integration with newer versions of related libraries. This module is essential for developers looking to automate form interactions or process form submissions in web scraping and web application development.

The LWP (Library for the World-Wide Web) module in Perl provides a comprehensive and user-friendly interface for creating web clients and handling HTTP-style communication. It allows developers to easily send requests and receive responses from various web servers using an object-oriented approach, encapsulating user agents, requests, and responses as objects. With support for multiple protocols including HTTP, HTTPS, FTP, and Gopher, as well as features like proxy handling, cookie management, and form parsing, LWP simplifies the process of web interaction. Additionally, it includes command-line tools for common tasks, making it a versatile choice for Perl developers looking to integrate web functionality into their applications.

The App::Test::Generator module is designed to automate the creation of fuzz and corpus-driven test harnesses for Perl routines and methods, enhancing the robustness of test suites by generating comprehensive black-box tests. By utilizing a configuration file that specifies input and output parameters, the module generates test cases that include random fuzzing, deterministic edge cases, and static corpus tests defined in Perl or YAML. This approach helps identify boundary errors and invalid data handling without the need for manual test case creation. Notably, in version 0.10, released on October 22, 2025, the module improved error handling by ensuring that incorrect data types trigger appropriate failures, thereby enhancing the reliability of the generated tests.

Const::Fast is a Perl module designed to facilitate the creation of read-only scalars, arrays, and hashes, enhancing code reliability by preventing unintended modifications. By using the `const` function, developers can easily define variables that are immutable after their initial assignment, ensuring that arrays and hashes are deeply read-only. This module addresses performance issues and subtle bugs associated with other readonly implementations, such as Readonly, by leveraging Perl's built-in readonly features without the complications of tied variables. Const::Fast is particularly useful for developers seeking a straightforward and efficient way to enforce immutability in their Perl applications.

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 and analysis of molecular graphs. The module also includes a writer that can generate SMILES strings from these graph representations. Recent updates, such as version 0.12.1, have improved the handling of ambiguous valences and disconnected molecular entities, enhancing the module's robustness and usability for chemists and researchers working with chemical data.

Plack::Middleware::ETag is a Perl module designed to enhance web applications by automatically adding ETag headers to HTTP responses, which helps with caching and content validation. This middleware can be easily integrated into a Plack application, allowing developers to specify which file attributes—such as inode, modified time, or size—should be used to generate the ETag. Additionally, it offers options to include Cache-Control headers for better cache management and can be configured to avoid adding an ETag if a Last-Modified header is already present. This module is particularly useful when combined with Plack::Middleware::ConditionalGET to optimize resource delivery and reduce unnecessary data transfer.

Test2::Plugin::SubtestFilter is a Perl module designed to enhance the Test2 testing framework by allowing developers to selectively run specific subtests based on their names. This functionality is particularly useful during development and debugging, enabling users to filter tests using environment variables. The module supports both substring and regular expression matching for subtest names, including nested subtests, where it intelligently executes parent tests when a child matches the filter. With the ability to run only relevant tests, developers can streamline their testing process and focus on specific areas of their code. The module is a valuable addition to any Test2-based testing suite, providing flexibility and efficiency in test execution.

Cwd::Guard is a Perl module designed to facilitate temporary changes to the current working directory (chdir) within a limited scope, ensuring that the original directory is restored automatically when the scope is exited. By using the `cwd_guard` function, developers can safely switch to a specified directory, and if the operation fails, it returns an undefined value while providing error messages through `$Cwd::Guard::Error`. This module is particularly useful for scripts that require directory changes without the risk of permanently altering the working environment, making it a reliable choice for managing directory contexts in Perl applications.

The `ansicolumn` Perl module is designed to facilitate the formatting of text output in a columnar layout while being aware of ANSI escape sequences, making it particularly useful for terminal applications that require color and style. This module allows users to customize the appearance of their output with various options, including border styles, alignment, and handling of whitespace. Recent updates, such as the change in the default value for `table_columns_limit` from 0 to -1 and improvements to whitespace regex handling, enhance its functionality and usability. With its rich feature set, `ansicolumn` is an excellent tool for developers looking to create visually appealing command-line interfaces.

Date::Find is a Perl module designed to extract year, month, and day information from filename strings, making it particularly useful for organizing and managing files with date-related naming conventions. With simple functions like `guess_ymd`, users can easily retrieve date components from filenames, whether they are formatted as 'YYYYMMDD' or 'DD.MM.YYYY'. The module also supports various modes, including a strict mode for more precise date extraction. Released recently, this module aims to streamline the process of date identification in filenames, enhancing file management workflows for developers and users alike.

The PAR::Packer module is a powerful tool for creating stand-alone executables, Perl scripts, and PAR files, effectively allowing developers to package their Perl applications for distribution without requiring end-users to have a Perl interpreter installed. This module implements the App::Packer::Backend interface and is primarily utilized through the command-line tool `pp`, which has been separated from the main PAR distribution to simplify the user experience. Recent updates, including version 1.064, have introduced enhancements such as a new troubleshooting module, improved compatibility with GCC 15, and stricter path handling for added files, ensuring a more robust and user-friendly packaging process. With its ability to streamline the deployment of Perl applications, PAR::Packer remains an essential resource for Perl developers looking to distribute their work efficiently.

The Image::WebP Perl module provides a convenient interface for working with Google's libwebp, enabling users to decode and encode WebP images efficiently. With its straightforward methods, users can easily retrieve image information, such as dimensions and alpha channel presence, and convert WebP-encoded data into various RGB formats. Additionally, the module allows for encoding raw RGB data back into WebP format with customizable options for quality and lossless compression. This makes Image::WebP an essential tool for developers looking to integrate WebP image handling into their Perl applications.

The `WWW::Suffit::Server` module is a powerful web server class designed for building applications using the Suffit API framework. It leverages the Mojolicious framework to provide a robust environment for developing web applications with features such as customizable routing, logging, and security options. The module allows developers to easily configure server parameters, including project name, version, directories for data and logs, and security settings like RSA key generation. With support for preforking, it can efficiently handle multiple concurrent connections, making it suitable for high-traffic applications. Additionally, it offers various initialization options for setting up admin and user routes, authentication databases, and more, enabling developers to create scalable and secure web services with minimal effort.

The `WWW::Suffit::API` module provides a comprehensive interface for interacting with the Suffit API, facilitating server communication through various HTTP methods such as GET, POST, PUT, PATCH, and DELETE. Designed to handle JSON data exchange, it requires specific headers for content type and accepts only a subset of UTF-8 characters. The module supports robust error handling with detailed JSON error responses and offers authentication via token or bearer schemes. Additionally, it includes methods for retrieving hints based on error codes, making it a valuable tool for developers looking to integrate with the Suffit API efficiently.

Markdown::Parser is an object-oriented Perl module designed for parsing and manipulating Markdown text, adhering to both strict and extended syntax modes. It allows users to create a new parser instance with customizable options, including case sensitivity for abbreviations and the ability to return tables as CSS grids instead of traditional HTML tables. The module provides methods to parse Markdown strings or files, generating a structured document object that represents the parsed content, which can then be converted back into Markdown, HTML, or POD formats. With features like callback functions for processing Markdown objects and detailed error handling, Markdown::Parser is a versatile tool for developers looking to integrate Markdown processing into their applications.

The `Business::ISBN::Data` module serves as a data pack for the `Business::ISBN` module, providing essential data derived from the ISBN Agency's `RangeMessage.xml` file. Typically, users do not need to load this module directly, as it is automatically loaded by `Business::ISBN`, which requires version 3.005 or later due to structural changes addressing ISBN-13 prefixes. The module allows for flexibility in data usage by enabling users to specify an alternate `RangeMessage.xml` file through the `ISBN_RANGE_MESSAGE` environment variable, ensuring access to the most current or historical data without needing to update the module itself. If the specified data file is unavailable, it defaults to older data included within the module. The data is stored in the `%Business::ISBN::country_data` hash, which provides insights into the source of the data. This module is particularly useful for developers working with ISBNs, ensuring they have access to accurate and up-to-date information for their applications.

The `Regexp::Common::Markdown` module provides a comprehensive set of regular expressions for parsing and recognizing various Markdown syntax elements, as defined by its original creator, John Gruber. This module allows developers to easily identify and extract components such as headers, bold text, links, images, lists, and more from Markdown-formatted text. It supports both standard and extended Markdown features, enabling the use of named captures for specific elements, which enhances the ease of processing and manipulation of Markdown content. By utilizing this module, Perl developers can efficiently integrate Markdown parsing capabilities into their applications, ensuring accurate handling of Markdown syntax while maintaining the flexibility to customize the parsing behavior through options like extended patterns.

The Genealogy::Obituary::Parser module is designed to extract structured family relationship information from freeform obituary text, making it a valuable tool for genealogical research. By utilizing the `parse_obituary` function, users can input a string containing obituary details, and the module will return a structured hash reference that categorizes family members into distinct groups such as spouse, children, and grandchildren. This functionality allows researchers and developers to easily organize and analyze familial connections from obituaries, enhancing the process of building family trees and understanding lineage.

The `MARC::Convert::Wikidata::Object` Perl module is designed to facilitate the conversion of bibliographic data from MARC records into structured Wikidata objects. It provides a comprehensive set of methods to manage various bibliographic attributes, including authors, editors, publishers, and publication details, allowing users to create and manipulate instances that represent books and their associated metadata. Recent updates in version 0.15 include the addition of a 'series_ordinal_raw' parameter and enhanced validation for the 'series_ordinal' parameter, reflecting ongoing improvements to the module's functionality and robustness. This module is particularly useful for developers working with bibliographic data who need to integrate or convert this information into the Wikidata format.

YAMLScript is a functional programming language that utilizes a stylized YAML syntax, allowing users to write programs and applications directly in YAML format. It serves multiple purposes, including enhancing standard YAML files with functional capabilities such as string interpolation and importing components from other YAML files. YAMLScript can be executed as a script or compiled into a binary executable, making it versatile for various programming needs. It seamlessly integrates with Perl, enabling users to load and manipulate YAMLScript files within Perl applications. The underlying architecture compiles YAMLScript to Clojure, which in turn compiles to a native shared library, ensuring compatibility with any programming language that supports shared libraries. This makes YAMLScript not only a powerful tool for YAML manipulation but also a potential drop-in replacement for traditional YAML loaders.

The `Alien::YAMLScript` Perl module serves as a bridge to locate or install the `libys` shared library, which is essential for working with YAMLScript. Although it is primarily intended for internal use, developers can utilize it to retrieve library paths and compiler flags necessary for integrating `libys` into their applications. As of the latest update, version 0.2.7, the module has been enhanced to include the latest version of `libys`, ensuring users have access to the most up-to-date features and fixes. This module is currently in its alpha stage, indicating that users should be prepared for potential changes in future releases.

The Quiq Perl module is a comprehensive class library designed for rapid application development, featuring 258 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 interactions, HTTP client operations, and various utilities for handling data structures, file management, and web development. With specialized classes for tasks such as generating HTML, managing configurations, and processing JSON, Quiq streamlines the development process, making it an invaluable resource for Perl developers looking to enhance productivity and efficiency in their projects.

JQ::Lite is a lightweight, pure-Perl JSON query engine that provides a simplified, jq-like syntax for extracting, traversing, and filtering JSON data directly within Perl, without the need for external binaries or XS modules. With features such as dot notation traversal, optional key access, array indexing, and a rich set of built-in functions for data manipulation, JQ::Lite allows users to perform complex queries and transformations on JSON structures efficiently. It supports interactive querying and offers a command-line interface for ease of use, making it an ideal tool for developers looking to work with JSON data in a flexible and powerful manner.

The Win32API::Process module is a Perl extension designed for managing processes using the Win32 API, providing essential functions for opening and terminating processes. It allows developers to interact with process handles, enabling operations such as retrieving process information, setting error codes, and terminating processes when necessary. The module exports functions like OpenProcess, CloseProcess, and TerminateProcess, which facilitate direct manipulation of process handles. It is particularly useful when combined with other modules like Win32API::ProcessStatus for enhanced process management capabilities. Notably, the module has evolved since its initial release, with recent updates enhancing its functionality and ensuring compatibility with the latest Win32 API standards.

Crypt::Fernet is a Perl module that implements the Fernet symmetric encryption scheme, providing a secure method for encrypting and decrypting messages using a shared secret key. It ensures that messages cannot be manipulated or read without the appropriate key, making it suitable for applications requiring authenticated cryptography. The module allows users to generate keys, encrypt plaintext, and verify or decrypt tokens, with support for time-to-live (TTL) parameters to enhance security. With its straightforward interface, Crypt::Fernet is an essential tool for developers looking to incorporate robust encryption into their Perl applications.

The `Archive::BagIt` Perl module provides a robust framework for creating, verifying, and managing BagIt bags, adhering to the specifications outlined in RFC 8493. This module supports UTF-8 encoding and allows for the creation and validation of bags with either MD5 or SHA512 fixity checks, depending on the version used. It features a variety of methods for interacting with bag contents, including loading existing bags, verifying their integrity, and storing modifications. Recent updates in version 0.101 include significant refactoring for improved performance and reduced complexity, as well as the removal of readme files generated on-the-fly, enhancing the module's usability and maintainability. This makes `Archive::BagIt` an essential tool for developers working with digital preservation and data management.