CPANscan

MooX::Cmd is a Perl module designed to simplify the creation of command-line interface (CLI) applications using the Moo object system. It allows developers to organize commands and subcommands in a hierarchical structure, mirroring the package structure of the application. Each command is defined as a class with an `execute` method that receives parameters for the command instance, the arguments passed to it, and the chain of commands leading to it. This structure enables the easy handling of complex command trees, where only the most specific command's `execute` method is invoked, while also providing access to attributes and options defined at higher levels in the command hierarchy. With MooX::Cmd, developers can efficiently build modular and organized CLI applications that are easy to maintain and extend.

Travel::Status::DE::VRR is an unofficial Perl module designed to interface with the VRR departure monitor, allowing users to retrieve real-time departure information for public transport in the VRR region, such as Essen. By creating a new instance of the module with specified parameters like location and stop name, users can easily access and display upcoming departures, including details such as time, platform, line, and destination. This module relies on several dependencies, including Class::Accessor and DateTime, and serves as a convenient tool for developers looking to integrate transport status functionality into their applications.

The `Config::Model::TkUI` module provides a graphical user interface (GUI) for editing configuration data using the Config::Model framework. It allows users to interactively modify configuration files, such as `/etc/X11/xorg.conf`, through a tree structure that displays configuration elements. Users can easily navigate, edit, and save changes to their configurations, with features like a search function, customizable font sizes, and a wizard for guided editing. Recent updates include the addition of a history menu and navigation buttons for improved user experience, alongside various bug fixes to enhance stability and functionality. This module is particularly useful for those who prefer a visual approach to configuration management in Perl applications.

Test::Expander is a Perl module designed to enhance testing capabilities by automating the determination of the class/module and method/subroutine being tested, thereby reducing boilerplate code and improving test readability. It integrates with Test2::V0 and offers features such as automatic creation of temporary directories and files, environment variable management through .env files, and subtest selection by name or number. Recent updates include improved support for colorization of exported variables and the ability to handle different file path delimiters across operating systems, making it a versatile tool for developers looking to streamline their testing processes.

The `JSON::Schema::Validate` Perl module is a lightweight and recursion-safe validator for JSON Schema, specifically designed to comply with the Draft 2020-12 specification. It provides a straightforward API for validating JSON data against defined schemas, supporting features such as dynamic references, annotations, and built-in format validators for common data types like dates and emails. The module allows for optional compilation of schemas for improved performance, and it can generate client-side JavaScript validators to facilitate form validation in web applications. Recent updates in version 0.8.0 have removed unnecessary dependencies and enhanced the validation of duration formats, ensuring stricter compliance with ISO 8601 standards. This makes `JSON::Schema::Validate` a robust choice for developers needing reliable JSON validation in Perl applications.

MetaCPAN::Client is a robust Perl module designed to provide a comprehensive and user-friendly interface to the MetaCPAN API, enabling developers to easily access and manipulate data related to Perl distributions, authors, modules, and more. With features that include searching for authors and distributions, retrieving recent releases, and fetching POD documentation, this module supports both simple and complex queries through a flexible hash-based search specification. Recent updates have enhanced its functionality by adding support for scrolling through more types of data and fixing issues related to fetching CVE information. This makes MetaCPAN::Client an essential tool for Perl developers looking to integrate MetaCPAN data into their applications efficiently.

DBD::Mock::Session::GenerateFixtures is a Perl module designed to facilitate the generation of mock database fixtures for testing purposes using the DBD::Mock::Session framework. It allows developers to create a mocked database handle by either providing a real DBI database handle, reading from a fixture file, or using an array of mock data. The module supports various database interactions, including transaction management with methods for beginning, committing, and rolling back transactions. Recent updates have enhanced compatibility with MySQL and Rose::DB, ensuring broader usability in different database environments. This module is particularly useful for developers looking to streamline their testing processes by simulating database interactions without the need for a live database connection.

The `Graphics::Penplotters::GcodeXY` Perl module is designed to facilitate the creation of G-code files specifically for pen plotters, allowing users to generate intricate designs directly from Perl scripts. With a range of graphics primitives such as lines, boxes, polygons, and arcs, users can easily define shapes and paths in various units (inches, millimeters, etc.). The module supports advanced features like font rendering, SVG file import, and Postscript output, making it versatile for different plotting needs. Users can customize their G-code output with options for paper size, margins, and movement commands, while also benefiting from built-in optimizations for efficient pen travel. This module is ideal for artists, engineers, and hobbyists looking to automate their pen plotting tasks with precision and flexibility.

Bundle::Maintainer::MHASCH is a Perl module that serves as a convenient collection of CPAN modules maintained by Martin Becker (MHASCH). This bundle simplifies the installation process by allowing users to install all the listed modules at once using a single command through CPAN. It includes various mathematical modules such as Date::Gregorian and several polynomial-related modules, making it particularly useful for developers who require these specific functionalities. While bundles like this one provide an easy way to gather related modules, they are less flexible than modern meta-modules, which can handle complex dependencies. Nonetheless, Bundle::Maintainer::MHASCH is an excellent resource for anyone looking to quickly set up a development environment with the essential tools maintained by Becker.

The Date::Holidays::AU Perl module provides a straightforward way to determine public holidays in Australia, utilizing the interface defined by Date::Holidays::Abstract. With its primary functions, `is_holiday` and `holidays`, users can easily check if a specific date is a holiday in a given Australian state or retrieve a list of holidays for that year. The module supports various states, including Victoria, Queensland, and New South Wales, and allows for customization through parameters specific to each state. Ideal for developers needing to incorporate holiday data into their applications, Date::Holidays::AU simplifies the process of holiday management across Australia.

App::GitKtti is a Perl module designed to enhance Git branch management by providing a suite of command-line tools that facilitate safe and efficient use of the Git flow methodology. With features such as safe branch operations, colorized output for improved readability, and support for various workflows including feature, hotfix, and release, App::GitKtti streamlines the process of managing branches. It also includes automatic branch cleanup and management, making it an essential tool for developers looking to maintain a clean and organized Git repository.

The CPANSA::DB module provides a Perl data structure containing the CPAN Security Advisory (CPANSA) reports, primarily intended for use with the CPAN::Audit module. By calling the `db` subroutine, users can access a hash reference of all CPANSA reports, which are crucial for ensuring the integrity and security of Perl modules. Each release of this module is accompanied by a GPG signature for verification, and users can also utilize GitHub Attestations to confirm the authenticity of the downloaded files. This module is available on GitHub, where it includes detailed release information and attestation capabilities, making it a vital tool for developers concerned with the security of their Perl applications.

Math::GMPz is a Perl module that provides an interface to the GNU Multiple Precision Arithmetic Library (GMP), specifically for handling large integers (mpz). This module wraps nearly all integer functions available in the GMP library, allowing users to perform arithmetic operations, comparisons, and conversions on arbitrarily large integers with ease. It supports various initialization methods for creating bignum objects, automatic memory management, and includes functions for random number generation, formatted input/output, and number-theoretic calculations. With its extensive functionality and reliance on the efficient GMP library, Math::GMPz is ideal for applications requiring high-performance arithmetic on large integers.

Net::Async::Kubernetes is an asynchronous client for interacting with Kubernetes clusters, designed to work seamlessly with the IO::Async framework. This module simplifies Kubernetes operations by providing non-blocking CRUD (Create, Read, Update, Delete) methods that return Future objects, allowing for efficient handling of asynchronous tasks. Users can easily configure the client using a kubeconfig file, in-cluster service account tokens, or explicit server and credential parameters. The module also features a robust watcher mechanism that supports auto-reconnection and event streaming, enabling real-time monitoring of Kubernetes resources with customizable callbacks for added, modified, and deleted events. Notably, version 0.004 introduced enhancements for automatic detection of kubeconfig and in-cluster service accounts, streamlining the client setup process.

Kubernetes::REST is a Perl module that serves as a REST client for interacting with the Kubernetes API, providing a simplified interface for managing Kubernetes resources. With this module, users can easily perform operations such as listing, creating, updating, patching, and deleting resources like Pods and Namespaces, all while leveraging the automatic URL building capabilities of IO::K8s resource classes. The module supports dynamic loading of resource maps from the cluster's OpenAPI specification, ensuring compatibility with various Kubernetes versions. Notably, the recent version 1.003 introduced automatic detection of in-cluster service account tokens, allowing seamless operation within Kubernetes pods without requiring a kubeconfig file. This enhancement significantly simplifies authentication for applications running in Kubernetes environments.

The `IO::K8s` Perl module provides a comprehensive interface for interacting with Kubernetes API objects, enabling users to easily create, manipulate, and serialize Kubernetes resources. With features such as loading and validating YAML manifests, programmatically creating objects, and inflating JSON data into typed Perl objects, `IO::K8s` streamlines the process of working with Kubernetes configurations. The module supports both built-in Kubernetes types and custom resource definitions (CRDs), allowing for flexible integration with various Kubernetes setups. Recent updates have improved JSON deserialization by fixing issues with recognizing sanitized field names, enhancing the module's robustness when handling complex Kubernetes structures. This makes `IO::K8s` an essential tool for developers looking to automate and manage Kubernetes resources effectively.

The TimeDate Perl module provides a comprehensive suite of date and time handling functionalities, including parsing, formatting, and timezone management. With its core components—Date::Parse for converting various date string formats into Unix timestamps, Date::Format for formatting timestamps into human-readable strings, and Date::Language for multi-language support—TimeDate is versatile for international applications. The module also includes Time::Zone for timezone offset lookups. Recent updates in version 2.34 have enhanced documentation coverage, fixed language data bugs, and introduced support for the boost C++ timestamp format, making it even more robust for developers needing precise date and time manipulation in their Perl applications.

The "Future::IO::Impl::Tickit" module provides an implementation of the Future::IO interface using the Tickit framework, enabling asynchronous I/O operations within a Tickit application. To utilize this module, developers must first create a Tickit instance and set it using the `set_tickit` method, ensuring that the Future::IO functionalities can operate correctly. Recent updates include enhancements to support the latest Future::IO features, such as the addition of the `->poll` method and improved test compatibility, while also addressing limitations regarding the POLLPRI constant, which is not currently supported by libtickit. This module is particularly useful for developers looking to integrate asynchronous I/O capabilities into their Tickit-based applications.

"Future::IO::Impl::Glib" is a Perl module that serves as an implementation of the Future::IO framework using Glib, making it an ideal choice for integrating asynchronous I/O operations within Glib or Gtk applications. By simply loading this module alongside Future::IO, developers can leverage its functionality to handle non-blocking I/O tasks seamlessly, enhancing the responsiveness of their applications without the need for additional methods. This module is particularly useful for those looking to utilize the capabilities of Glib in a straightforward manner, allowing for efficient event-driven programming in Perl.

The Net::Correios Perl module provides a convenient interface for accessing the Brazilian Postal Service's REST API, enabling developers to perform various operations such as querying postal codes (CEPs), calculating shipping prices and delivery times, and tracking packages. Designed primarily for Brazilian developers, this module requires an active commercial contract with Correios and an API key for authentication. With methods to retrieve information about shipping costs, delivery deadlines, and tracking status, Net::Correios simplifies the integration of postal services into applications, making it an essential tool for businesses and developers working with logistics in Brazil.

The `Time::ParseDate` Perl module is designed for parsing both relative and absolute date and time strings into seconds since January 1, 1970. It supports a wide variety of date formats, including common styles like "dd/mm/yyyy" and "yyyy-mm-dd," as well as relative formats such as "next Tuesday" or "3 days ago." The module offers numerous options to customize parsing behavior, such as handling time zones, requiring complete date strings, and allowing for fuzzy matching of input. A notable recent update in February 2026 added support for trailing "Z" or "z" to denote UTC in ISO 8601 timestamps, enhancing its compatibility with modern date formats. This module is particularly useful for applications that need to interpret and manipulate date and time information flexibly and accurately.

The "Test::Future::IO::Impl" Perl module provides a suite of acceptance tests designed for implementations of the "Future::IO" framework. It allows developers to ensure that their custom implementations adhere to the expected behavior of various I/O methods, such as `accept`, `connect`, `poll`, `recv`, `send`, and others. By utilizing the `run_tests` function, users can execute specific test suites against their implementation, ensuring compatibility and correctness. Recent updates, including version 0.20, have improved testing related to `POLLHUP`, enhancing the reliability of the tests across different operating systems. This module is essential for developers looking to validate their I/O implementations within the Future::IO ecosystem.

The Curses module provides a Perl interface to the system's curses library, enabling terminal screen handling and optimization for text-based user interfaces. It simplifies the usage of various curses functions by unifying multiple variants into single, more flexible functions that accept optional window and coordinate parameters, making it easier for Perl developers to create interactive applications. The module also includes wide-character-aware functions for better handling of multi-byte character encodings, enhancing compatibility with modern text formats. Recent updates include the addition of BUTTON5 constants in version 1.46, which expands the module's capabilities for handling mouse events. Overall, Curses is an essential tool for Perl developers looking to build robust terminal applications with advanced screen management features.

The "Tickit" module is a high-level toolkit designed for creating interactive, full-screen terminal applications in Perl. It provides a structured way to build user interfaces using a tree of widget objects, allowing developers to define layouts and behaviors abstractly. Tickit supports advanced terminal features such as rich text rendering, mouse interactions, and asynchronous input handling, making it suitable for modern terminal applications. With its ability to manage multiple instances and non-blocking operations, Tickit simplifies the development of complex terminal interfaces, enabling developers to focus on functionality rather than low-level terminal management.

Class::Enumeration is an abstract parent class designed for creating enumeration classes in Perl, providing a structured way to define immutable enum objects with associated names and ordinal values. It offers essential methods such as `name()` and `ordinal()` for accessing the properties of enum objects, as well as class methods like `names()` and `values()` for retrieving lists of enum names and objects, respectively. While this class should not be used directly, it serves as a foundation for more specific enum implementations via the Class::Enumeration::Builder module. Recent updates in version 1.3.0 introduced a 'to_json' builder option, enhancing the module's functionality for JSON serialization.

"Future::IO::Impl::KQueue" is a Perl module that implements the Future::IO interface using the kqueue(2) and kevents(2) system calls, leveraging the IO::KQueue functionality. This module does not introduce any new methods; instead, it seamlessly integrates with Future::IO, allowing developers to utilize asynchronous I/O operations in their applications. By simply loading this module alongside Future::IO, users can easily manage future events and asynchronous tasks, making it a valuable tool for building efficient, non-blocking I/O applications in Perl.

The `nup` Perl module is a versatile tool designed for generating multi-column paged output from files or commands, enhancing readability and organization. It automatically determines whether to display a file or execute a command based on the input, with options to customize the layout, such as setting the number of columns and rows, adjusting pane width, and selecting various border and line styles. Users can also enable features like parallel view mode, document mode, and folding mode for a more streamlined output experience. With support for color mapping and predefined display themes, `nup` is ideal for users looking to improve the presentation of command-line outputs or file contents in a visually appealing manner.

Test::PostgreSQL::v2 is a modern Perl module designed to facilitate the creation and management of isolated PostgreSQL instances for testing purposes. This module serves as a robust replacement for the older Test::PostgreSQL, addressing contemporary Linux environment challenges by isolating socket directories and ensuring compatibility with modern PostgreSQL binaries. With its straightforward interface, users can easily start a temporary PostgreSQL instance, connect via DBI, and execute SQL commands, all while benefiting from automatic cleanup when the instance goes out of scope. Notably, version 2.03 includes improvements to the documentation, while earlier updates introduced significant features such as enhanced error handling, automatic port selection, and better process management, making it an essential tool for developers utilizing Test::DBIx::Class for ORM-based testing.

Geo::Location::TimeZoneFinder is a Perl module designed to map geographic coordinates to their corresponding time zone names, such as "Asia/Shanghai". Utilizing database files from the Timezone Boundary Builder project, this module allows users to easily retrieve time zone information based on latitude and longitude inputs. With methods for creating a new finder object and querying time zones, it ensures accurate results while handling various edge cases, such as disputed areas with multiple time zones. A noteworthy recent update in version 1.002, released on February 25, 2026, enhances the module by converting coordinates passed as strings into numeric values, improving usability and robustness.

The Perl module Number::ZipCode::JP provides a straightforward way to validate Japanese zip codes according to the regulations set by Japan Post Holdings Co., Ltd. It allows users to create instances of zip codes, set their values, and check their validity based on specified categories, such as area-specific or company-specific zip codes. The module supports various input formats, including those with non-numeric characters, and can be easily integrated into applications that require zip code validation. Recent updates have focused on refining the underlying table classes used for validation, ensuring that the module remains accurate and reliable for users.