CPANscan

The `Business::ISBN::Data` Perl 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. This module is typically loaded automatically by `Business::ISBN`, and it requires version 3.005 or later due to structural changes aimed at resolving issues with 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. The module includes a fallback mechanism to older data if the specified file is unavailable. Recent updates include a data refresh on December 5, 2025, ensuring users have access to the latest ISBN information.

The App::Test::Generator Perl module is designed to automate the creation of fuzz and corpus-driven test harnesses, enhancing the testing process for routines and methods by generating comprehensive black-box tests. By utilizing formal input/output specifications defined in YAML or Perl, this module produces test cases that incorporate random fuzzing, deterministic edge cases, and static corpus tests, effectively probing both expected and unexpected inputs. It supports various input types and configurations, allowing users to specify edge cases, transformations, and properties for property-based testing. The generated test scripts can be executed with "prove," making it easier to identify boundary errors, invalid data handling, and regressions without the need for extensive manual test case writing.

Log::Report is a versatile Perl module designed to streamline the process of reporting messages to users and logs, integrating logging, exception handling, and translation capabilities into a single framework. It allows developers to generate messages with varying severity levels—such as errors, warnings, and informational notices—while also supporting message translation through a syntax inspired by gettext. The module provides a flexible dispatcher system that can route messages to different outputs, including standard output, syslog, or custom log files, and it enables the use of interpolated variables within messages for enhanced clarity. Recent updates in version 1.43 include improvements to documentation and the addition of a bug tracker, reflecting the module's ongoing development and commitment to user support.

Data::TOON is a Perl module that provides a complete implementation of the Token-Oriented Object Notation (TOON), a human-friendly, line-oriented data serialization format. It allows users to easily encode and decode Perl data structures into a readable format that is particularly useful for configuration files and data interchange. The module supports various features such as flexible delimiters (comma, tab, pipe), multiple array formats (tabular, explicit list, inline), and security measures like depth limits and circular reference detection. Recent updates have improved the serialization of nested hash references within array elements, enhancing the module's capability to handle complex data structures. With its focus on readability and compliance with the TOON specification, Data::TOON is an excellent choice for developers looking to work with structured data in a clear and efficient manner.

Lib::Pepper is a Perl module that provides bindings for the Pepper payment terminal library, enabling communication with EFT/POS payment terminals using the ZVT (Zentraler Kreditausschuss Terminal) protocol. It offers both low-level XS bindings to the C API and high-level object-oriented interfaces, making it suitable for various user needs. Key features include support for different terminal types, asynchronous callback operations, comprehensive API coverage for initialization, configuration, transactions, and settlements, as well as robust error handling. Recent updates include a version bump to 0.4 and improvements in documentation and testing, ensuring better usability and reliability for developers integrating payment solutions.

Sisimai is a Perl library designed for analyzing bounce emails, providing a structured way to decode complex delivery failure messages. It extracts essential information such as the recipient's email address, the reason for the bounce, and the delivery status, outputting the results in a Perl hash reference or JSON format. The library supports various methods for processing bounce emails, including reading from mailbox files or standard input, and it features a callback mechanism for custom processing. Notably, version 5.5.0 introduced significant enhancements, including a shift to UTF-8 encoding, updates to SMTP reply codes, and the addition of new error message patterns, further improving its robustness in handling diverse email bounce scenarios.

The Image::ThumbHash Perl module provides a compact representation of image placeholders using the ThumbHash algorithm, originally developed by Evan Wallace. This module allows developers to efficiently generate small, lossy approximations of images, which can significantly reduce loading times for web image galleries. By converting images into thumb hashes, users can create lightweight placeholders that load instantly while the full images are fetched asynchronously. The module offers various functions to convert images to and from thumb hashes, including encoding RGBA images to thumb hashes, decoding thumb hashes back to RGBA format, and generating PNG data URLs. This functionality makes it an essential tool for optimizing image loading in web applications.

Template::Nest is a Perl module designed for manipulating generic template structures using a simple hash-based approach, emphasizing a clear separation between control logic and presentation. Unlike many templating systems that embed processing within templates, Template::Nest treats templates as static text with placeholders, allowing for greater flexibility and language independence. This module enables developers to create standalone HTML templates that can be rendered without additional processing logic, making it easier to maintain and understand. Recent updates in version 0.13 introduced a new option for specifying file encoding, enhancing the module's usability across different character sets. With features like preloading default values, maintaining indentation in nested templates, and customizable token delimiters, Template::Nest offers a straightforward and efficient solution for template rendering in Perl applications.

App::dnsq is a versatile DNS query tool written in Perl, designed to serve as a modern alternative to the traditional dig command. It offers a range of features including support for both TCP and UDP protocols, customizable DNS server settings, and various output formats such as JSON and short answer summaries. Users can perform single queries, batch process multiple queries from a file, or engage in an interactive shell mode, all while benefiting from smart caching, DNSSEC support, and comprehensive input validation. With its ability to trace DNS delegation paths and configurable timeout and retry settings, App::dnsq is an essential tool for anyone needing detailed and efficient DNS query capabilities.

Time::Moment is a Perl module designed to represent a specific date and time with nanosecond precision, including an offset from UTC, adhering to the ISO 8601 standard. It allows users to create instances of time using various constructors, such as specifying year, month, day, hour, minute, second, and nanosecond, or by converting from epoch time, strings, or other date objects. The module provides a comprehensive set of methods for retrieving and manipulating date and time components, performing arithmetic operations, and formatting output. With support for various calendar systems and time zones, Time::Moment is ideal for applications requiring precise and flexible date-time handling.

The `Params::Validate::Strict` Perl module provides a robust framework for validating input parameters against a defined schema, ensuring that data adheres to specified types and constraints. With features such as type coercion, custom validation rules, and support for nested structures, it allows developers to enforce strict data integrity in their applications. The module supports various data types, including strings, integers, and arrays, and offers advanced capabilities like cross-field validation and transformation of input values before validation. A noteworthy recent change in version 0.25 ensures that string length comparisons are now based on character counts rather than bytes, enhancing the accuracy of validations. This module is particularly useful for applications requiring rigorous input validation, such as web applications and APIs, where data integrity is paramount.

App::cpm is a high-performance CPAN module installer designed to significantly speed up the installation process of Perl modules. By caching builds of distributions in the user's home directory, cpm can reuse these prebuilt versions, eliminating the need for repeated builds and achieving installation speeds up to three times faster than traditional tools like cpanm. The module is particularly beneficial for projects with extensive CPAN dependencies, allowing for quick installations with simple commands like `cpm install Module`. Recent updates include the embedding of Test-Harness to streamline testing processes, reflecting the module's ongoing evolution and commitment to improving user experience.

Sys::Cmd is a versatile Perl module designed for executing system commands and managing processes with ease. It enhances Perl's built-in process handling capabilities by allowing users to run commands, capture their output, and interact with processes asynchronously through standard input, output, and error streams. With features like command lookup via File::Which, efficient process spawning using Proc::FastSpawn, and the ability to handle errors gracefully, Sys::Cmd simplifies the execution of system commands. It also supports template functions for repeated command calls, making it ideal for scenarios where similar commands need to be executed with slight variations. The latest version, v0.986.0, includes improvements to ensure tests pass on non-UTF-8 locales, enhancing its robustness across different environments.

Data::MessagePack::Stream is a Perl module designed for streaming deserialization of MessagePack data, providing an efficient alternative to the traditional Data::MessagePack::Unpacker. This module allows developers to handle streaming data seamlessly by maintaining an internal buffer, enabling the processing of incoming data in chunks. With methods to create a new unpacker, feed data into it, and retrieve parsed Perl objects, it simplifies the handling of MessagePack packets in real-time applications. Notably, the recent update to version 1.06 includes a fix for compatibility with newer CMake versions, ensuring smoother integration and functionality.

App::HTTPThis is a Perl module designed to facilitate the export of the current directory over HTTP, acting as a lightweight wrapper around Plack::App::DirectoryIndex. It provides a simple interface for starting an HTTP server that serves directory listings, making it easy to share files over a network. The module includes methods for creating an instance and running the server, and it has seen recent enhancements, including the addition of a `--host` option in version 0.010, which allows users to specify the host for the server. Other notable features include support for configuration files and improved directory listing aesthetics with the `--pretty` option.

Mojo::Collection::XS is a high-performance subclass of Mojo::Collection, designed to enhance the efficiency of operations on large lists by implementing critical methods in XS (eXternal Subroutine). This module provides a suite of fast iteration and transformation methods, such as `while_fast`, `map_fast`, and `grep_fast`, which allow developers to process collections with improved speed while maintaining a familiar interface. Callbacks must be provided as code references, ensuring a streamlined and efficient execution. The initial release of Mojo::Collection::XS introduces these XS-backed helpers, making it an excellent choice for Perl developers seeking to optimize their collection handling in performance-sensitive applications.

Crypt::Sodium::XS is a Perl module that provides XS bindings for the libsodium cryptographic library, enabling developers to perform a wide range of cryptographic operations such as authenticated symmetric and asymmetric encryption, password hashing, and more. This module offers both procedural and object-oriented interfaces, allowing for flexibility in usage while ensuring memory safety through the use of protected memory handling. With features like key generation, nonce management, and various encryption algorithms, Crypt::Sodium::XS is designed to facilitate secure data handling in applications. Notably, recent updates have improved the MemVault functionality, enhancing file and terminal I/O operations and allowing for subclassing, which reflects the module's ongoing development and commitment to security best practices. However, it is important to note that this module is still considered experimental and may not be suitable for production use.

Crypt::NaCl::Tweet is a Perl module that provides XS bindings to the TweetNaCl cryptographic library, which is a compact and auditable implementation of the NaCl cryptographic library. This module allows developers to easily incorporate a variety of cryptographic functions into their Perl applications, including public-key encryption, hashing, digital signatures, and authenticated encryption. With a straightforward interface that simplifies function names for ease of use, Crypt::NaCl::Tweet supports essential operations such as message encryption and decryption, key generation, and data integrity verification. While still in its early stages, the module aims to facilitate secure communication and data protection in Perl applications.

MetaCPAN::Client is a robust and feature-rich Perl module designed to interact seamlessly with the MetaCPAN API, providing a user-friendly interface for accessing various resources such as authors, distributions, modules, and more. With its DWIM (Do What I Mean) capabilities, it simplifies complex queries and enhances usability by allowing users to search using both simple identifiers and detailed search specifications. The module supports advanced features like caching for improved performance and offers a comprehensive set of methods for retrieving data, including recent releases, ratings, and reverse dependencies. Notably, the recent version 2.034000 introduced the addition of the distribution field to the DownloadURL response, enhancing the module's functionality and keeping it aligned with the evolving MetaCPAN API.

SimpleFlow is a straightforward workflow manager and logger implemented in Perl, designed to facilitate the execution and management of tasks in a manner akin to tools like snakeMake or NextFlow. It allows users to define tasks with minimal setup, primarily requiring a command to execute, while also offering additional options such as logging, input file checks, and output file management. Each task returns a comprehensive hash containing essential information such as the exit code, working directory, standard error, and standard output, making it easy to track the execution status and results. With features like customizable logging and the ability to handle file dependencies, SimpleFlow streamlines the process of managing complex workflows in Perl.

Aion::Annotation is a Perl module designed to streamline the processing of annotations within Perl modules by scanning the specified codebase and extracting relevant comments and annotations. It organizes this information into structured files located in a designated directory, allowing developers to easily track module updates, remarks, and TODO items. With configurable paths for both the source code and output files, Aion::Annotation enhances code documentation and maintenance by automatically generating files that detail the last modification times, comments on routines and properties, and parameter annotations. This module is particularly useful for developers looking to maintain clear and organized documentation within their Perl projects.

The `Hash::Merge::Simple` Perl module provides a straightforward way to recursively merge two or more hashes, returning a new hash reference that combines their contents. When merging, the values from the rightmost hash take precedence, effectively overriding any conflicting keys from the left hashes. This module is particularly useful for scenarios where nested hashes need to be merged, as it will also handle subordinate hashes appropriately. Additionally, it offers methods like `clone_merge` and `dclone_merge` to create merged results without side effects, ensuring that modifications to the original hashes do not affect the merged output. This module is derived from code in `Catalyst::Utils`, making it a reliable choice for developers needing efficient hash merging capabilities in their Perl applications.

Trickster is a modern micro-framework designed for building web applications in Perl, offering a simple and efficient way to create robust web services. It is PSGI compatible, ensuring seamless integration with existing Perl web technologies, and is built with production readiness in mind. With Trickster, developers can easily define routes for various HTTP methods, including GET, POST, PUT, PATCH, and DELETE, while also allowing for the addition of middleware and custom error handling. This framework respects CPAN traditions, making it a reliable choice for Perl developers looking to create scalable web applications with minimal overhead.

The `String::Print` Perl module offers a powerful alternative to the traditional `printf` and `sprintf` functions, enabling developers to easily insert values into format strings using both functional and object-oriented interfaces. It supports named parameters for interpolation, allowing for clearer and more maintainable code, especially in contexts involving translations. The module also features pluggable serializers and modifiers, which enhance its flexibility by allowing custom formatting and handling of various data types, including arrays and hashes. Additionally, `String::Print` ensures proper handling of Unicode and provides automatic output encoding for HTML, making it an ideal choice for modern Perl applications that require robust string formatting capabilities.

The Aion::Run module is a Perl role designed to facilitate the handling of command line arguments for console commands, enabling developers to easily define and manage script parameters. By utilizing this module, developers can create script objects that automatically parse command line options, allowing for both named and ordinal parameters. The module supports various argument types, including shortcuts for named parameters and the ability to handle unnamed parameters as arrays. This makes it particularly useful for building command line applications that require flexible input handling, such as mathematical operations or other calculations, as demonstrated in the provided example. With Aion::Run, developers can streamline the process of argument management, enhancing the usability and functionality of their scripts.

Mojolicious::Plugin::OpenAPI::Modern is a powerful plugin for the Mojolicious web framework that facilitates the integration of OpenAPI specifications into your application. It provides access to an OpenAPI document and a parser, allowing developers to validate incoming requests and outgoing responses against defined API schemas. With flexible configuration options, users can specify OpenAPI documents via file paths, URIs, or directly as Perl data structures. The plugin enhances API development by enabling automatic validation and logging of request and response data, ensuring compliance with the OpenAPI standard. This module is particularly useful for developers looking to streamline API design and improve the reliability of their web applications.

SPVM is a statically typed programming language that features a Perl-like syntax, designed to enhance performance and type safety in programming. Although it has not yet reached a stable release, SPVM allows developers to execute programs, generate executable files, and utilize both Ahead-of-Time (AOT) and Just-in-Time (JIT) compilation techniques. It supports native threads, static types, and type inference, making it suitable for high-performance applications. With the ability to call SPVM methods from Perl and integrate with C/C++ libraries, SPVM provides a versatile environment for developers looking to leverage the strengths of both Perl and compiled languages.

The IO::K8s Perl module provides a set of objects and methods for interacting with the Kubernetes API, facilitating the serialization and deserialization of Kubernetes structures. It allows users to convert JSON data into corresponding Perl objects and vice versa, ensuring that the data types conform to the strict requirements of the Kubernetes API. This module is particularly useful for developers working with Kubernetes, as it helps manage the complexities of data formatting and type validation. Recent updates include the addition of a convenient `to_json` method for all objects, enhancing usability for developers.

The `Data::Roundtrip` Perl module provides a versatile set of utilities for converting between Perl data structures, JSON, and YAML, while ensuring proper handling of Unicode content. With functions for transforming JSON to YAML and vice versa, as well as converting Perl variables to their string representations, this module facilitates seamless data interchange in various formats. It supports options for pretty-printing and Unicode escaping, making it suitable for both human-readable output and machine processing. Additionally, `Data::Roundtrip` includes file handling capabilities, allowing users to read from and write to files directly, enhancing its usability in data manipulation tasks. This module is particularly useful for developers needing to work with different data formats in a consistent and efficient manner.

The `Android::ElectricSheep::Automator` Perl module provides a powerful interface for controlling Android devices directly from a desktop environment, leveraging the capabilities of the Android Debug Bridge (ADB). Designed for developers and testers, this module allows users to perform a variety of actions on connected Android devices, including navigating the user interface, opening and closing applications, simulating touch events, and managing files. With features such as screen capture, geolocation manipulation, and process management, it serves as a comprehensive tool for automating interactions with both physical and emulated Android devices. Notably, it operates without installing any software on the device itself, ensuring a non-intrusive approach to device management. However, users should be aware that the module is currently in an alpha stage, and its API may undergo changes.