CPANscan

DBD::MariaDB is a Perl5 Database Interface driver designed for seamless interaction with MariaDB and MySQL databases. It provides a robust object-oriented interface that allows developers to connect to multiple database servers, execute SQL queries, and retrieve results efficiently. With support for most functions of the MariaDB/MySQL API, DBD::MariaDB facilitates operations such as inserting, updating, and querying data using prepared statements and handles. Recent updates in version 1.24 include improved handling of large BLOB parameters, enhanced support for the Embedded server, and various fixes for compatibility with new MySQL features, ensuring that developers can leverage the latest advancements in database technology while maintaining a stable and efficient connection to their databases.

The `Monitoring::Sneck` Perl module is designed to facilitate the execution of Nagios-style checks in a LibreNMS environment by providing a JSON-style SNMP extension. It allows users to define checks and environment variables in a configuration file, which the module parses to execute the specified commands and return results in a structured format. While not intended for direct library use, it supports scripts that require monitoring capabilities. The module handles various configurations, including error reporting and debugging options, making it a robust tool for system monitoring and alerting. Users can easily integrate it with SNMP and cron jobs to automate health checks and receive timely notifications about system status.

App::Test::Generator is a Perl module designed to automate the creation of fuzz and corpus-driven test harnesses for routines and methods, enhancing the robustness of test suites. By utilizing a formal input/output specification, it generates comprehensive black-box tests that include random fuzzing based on input types, deterministic edge cases, and static corpus tests defined in Perl or YAML. This module simplifies the testing process by automatically producing a Test::Most-based test script that probes both expected and unexpected inputs, effectively identifying boundary errors and invalid data handling. Recent updates in version 0.07 have improved the module's functionality by allowing real configuration files to be read, validating configurations, and demonstrating how to schedule random tests automatically, making it an essential tool for developers seeking to enhance their testing strategies.

Lingua::EN::PluralToSingular is a Perl module designed to convert English plural nouns into their singular forms, making it a valuable tool for text processing and linguistic applications. With functions like `to_singular`, which transforms a plural word into its singular counterpart, and `is_plural`, which checks if a word is plural, users can easily manipulate and analyze English nouns. The module handles a variety of pluralization rules and exceptions, although it assumes the input is a noun and does not address capitalized words or pronouns. Recent updates in version 0.21 have expanded the module's capabilities by adding more "men" words and refining the documentation, enhancing its usability for developers and linguists alike.

Cucumber::TagExpressions is a Perl module designed for parsing tag expressions used in Cucumber's Gherkin scenarios, allowing users to filter which scenarios to execute based on specified tags. By utilizing the `parse` method, users can create an evaluator object that checks if the tags associated with a scenario match the defined expression. This module is particularly useful for developers looking to streamline their testing processes by selectively running scenarios based on tags. Notably, in the recent 8.0.0 update, the module addressed issues related to building release artifacts, ensuring smoother deployment and maintenance.

Log::Dispatchouli is a lightweight Perl module that serves as a simple wrapper around Log::Dispatch, designed to streamline the logging process in applications. It allows developers to easily configure logging to various outputs such as syslog, standard output, standard error, or even in-memory arrays for testing purposes, without the complexity of managing categories and levels. The module utilizes String::Flogger for flexible message formatting, enabling straightforward logging of strings, data structures, and formatted messages. Recent updates in version 3.012 include a significant change to the logfmt grammar specification, enhancing how log messages are encoded, particularly with respect to control characters and quoting behavior. This makes Log::Dispatchouli an efficient choice for developers seeking a straightforward logging solution in their Perl 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 language independence and easier maintenance. This module enables developers to create modular templates that can be rendered with various data structures, making it particularly useful for generating HTML or other text formats. Recent updates in version 0.13 introduced a new option for specifying file encoding, enhancing the module's versatility in handling different character sets. Additionally, the module supports features like preloading default values, maintaining indentation in nested templates, and inspecting template parameters, making it a robust choice for developers seeking a straightforward and efficient templating solution.

The Graphics::Penplotters::GcodeXY Perl module is designed to facilitate the generation of G-code files specifically for pen plotters, allowing users to create intricate designs using various geometric shapes and paths. With support for multiple units (inches, millimeters, etc.), this module provides a range of graphics primitives, including lines, boxes, polygons, and arcs, which can be easily manipulated and outputted to a G-code file. Users can also import SVG files and generate Postscript output, making it versatile for different graphic needs. Recent updates, such as bug fixes and enhancements to SVG handling, ensure improved functionality and reliability, making GcodeXY a robust choice for anyone looking to automate pen plotting tasks in Perl.

App::DBBrowser is a Perl module designed for interactive browsing of SQLite, MySQL, and PostgreSQL databases and their tables. With version 2.434, this tool allows users to explore database structures and data in a user-friendly manner, making it easier to manage and analyze database content. Authored by Matthäus Kiem, App::DBBrowser is provided as free software under the same terms as Perl 5.10.0, ensuring flexibility for redistribution and modification.

App::rdapper is a command-line client for the Registration Data Access Protocol (RDAP), designed to retrieve and display information about internet resources such as domain names, IP addresses, and autonomous systems in a user-friendly format. Users can query various types of objects, including forward and reverse domain names, IP addresses, and registrar details, using a range of options to customize their requests. Recent updates include the transition to using Net::IDN::PP to resolve build issues on certain platforms and the addition of Spanish translation support, enhancing accessibility for a broader audience. With its robust functionality and internationalization features, App::rdapper serves as a valuable tool for network administrators and developers needing quick access to RDAP data.

Mojolicious is a powerful real-time web framework for Perl that simplifies the development of web applications with features like RESTful routing, session management, and a built-in testing framework. It supports various functionalities such as content negotiation, form validation, and first-class Unicode support, making it versatile for modern web development. The framework allows developers to define routes and controllers easily, and it includes a comprehensive set of hooks for extending application behavior. Recent updates in version 9.42 have removed the experimental status from several features, including encrypted session cookies and top-level await support, enhancing stability and security. With its extensive documentation and active community, Mojolicious is an excellent choice for developers looking to build robust web applications in Perl.

The JOAP Perl module provides an implementation of the Jabber Object Access Protocol, enabling developers to access object attributes and methods over the Jabber network in a seamless and Perl-friendly manner. This module serves as the entry point for JOAP programming, allowing users to define their own JOAP servers and classes while also facilitating the use of remote servers and classes. It includes essential data marshalling services to convert between Perl and JOAP data formats, making it easier to work with various data types, including complex structures. Although still in an experimental phase, JOAP offers a powerful framework for building applications that leverage the capabilities of the Jabber network, with a focus on flexibility and ease of use for Perl developers.

App::cpm is a high-performance CPAN module installer designed to expedite the installation process of Perl modules by leveraging parallel processing through Menlo. By storing builds of distributions in the user's home directory, cpm can reuse these prebuilt modules, significantly reducing installation time—demonstrated to be up to three times faster than cpanm. This module is particularly beneficial for projects with extensive CPAN dependencies, as it minimizes the need for repeated builds. Recent updates include the default use of the `--depth=1` option for git cloning, enhancing efficiency in fetching module sources. For users looking to streamline their Perl development, App::cpm offers a robust solution for managing CPAN modules swiftly and effectively.

Perl::Types is a Perl module that introduces a robust data type system, allowing developers to explicitly define and manage core data types and nested compound reference types using the "::" scope resolution operator. This module facilitates the declaration of typed scalars, arrays, and hashes, enhancing code clarity and preemptively optimizing Perl source code for future compiler improvements. With support for various scalar types such as boolean, integer, number, character, and string, as well as complex structures like array and hash references, Perl::Types empowers developers to write more structured and type-safe code. The module is available in multiple usage styles—pragma, class, and object-oriented—catering to different coding preferences, and is currently in beta, deemed stable for monitored use in production environments.

QRCode::Encoder is a Perl module designed for generating QR Codes purely in Perl, providing a flexible interface for encoding messages with various options such as error correction levels and encoding modes. The primary function, `qr_encode`, allows users to encode a message into a structured hash reference that includes details like the QR Code's version, error correction level, and a matrix representation of the code. Notably, the output is compatible with the Text::QRCode module, making it easy to visualize the QR Code in a text format. The module is currently at version 0.003, marking its initial release, and is built to support Perl versions 5.24 and above.

The `WWW::Mechanize` Perl module provides a powerful and convenient way to automate web browsing tasks, allowing users to fetch web pages, follow links, and submit forms programmatically. It simplifies the process of interacting with web content by handling HTTP requests and responses, managing cookies, and parsing HTML to extract links and forms without requiring manual HTML parsing. With features like SSL support, custom HTTP headers, and automatic redirection handling, `WWW::Mechanize` is particularly useful for web scraping and testing web applications. Recent enhancements in version 2.19 include minor documentation fixes and a change from "base" to "parent" in the code, reflecting ongoing improvements to maintain clarity and functionality.

The `Dist::Zilla::PluginBundle::Author::ETHER` module is a comprehensive plugin bundle designed for Perl distributions authored by Karen Etheridge. It streamlines the configuration and management of various Dist::Zilla plugins, facilitating tasks such as file gathering, metadata generation, testing, and release processes. By including a wide array of plugins for tasks like compiling tests, checking for stale dependencies, and managing versioning, this bundle enhances the development workflow for Perl authors. Notably, the recent version 0.169 introduced a "GIVING THANKS" section in the woven pod, reflecting a commitment to community engagement and acknowledgment. This module is particularly useful for developers looking to maintain high-quality Perl distributions with minimal configuration overhead.

Path::AttrRouter is a Perl module designed for routing URLs in web applications by utilizing method attributes for defining routes. It allows developers to create controllers with methods annotated to specify their routing behavior, such as path matching and argument handling. The module simplifies method dispatching by enabling the use of a base package namespace for controllers, making it easier to manage and organize routing logic. With features like action caching and the ability to generate dispatching tables, Path::AttrRouter is particularly useful in CGI or development environments. Notably, the module has seen updates since its initial release, including enhancements to support specific controller namespaces, which improve its flexibility and usability in various application structures.

Path::Class is a Perl module designed for cross-platform manipulation of file and directory paths, providing an object-oriented interface that simplifies path handling across various operating systems, including Unix, Windows, and Mac. By wrapping the complexities of the underlying File::Spec module, Path::Class allows developers to create and manage file and directory objects intuitively, enabling operations like checking if a path is absolute or retrieving parent directories with ease. The module also supports foreign path formats, making it versatile for applications that need to interact with different file systems. Notably, version 0.37 introduced documentation updates and fixes for the "contains" method, enhancing its reliability when dealing with relative paths.

Class::Data::Inheritable is a Perl module designed to facilitate the creation and management of inheritable class data, allowing developers to define class-level attributes that can be shared and overridden by subclasses. By using the `mk_classdata` method, developers can easily set up accessors for class data, enabling them to store and retrieve information relevant to the class as a whole rather than individual objects. This module supports inheritance, meaning that subclasses can inherit class data from their parent classes, and if needed, they can override this data to maintain their own unique values. This functionality is particularly useful for maintaining consistent configurations across a class hierarchy while still allowing for customization at different levels.

Mojo::AsyncAwait is a Perl module that provides an implementation of the async/await programming pattern specifically for the Mojolicious web framework. This module allows developers to write nonblocking asynchronous code in a more straightforward, synchronous style, enhancing code readability and maintainability. By utilizing the `async` and `await` keywords, users can easily manage asynchronous operations, such as HTTP requests, while handling promises seamlessly. Designed to integrate with Mojolicious applications, Mojo::AsyncAwait simplifies the development of async controller actions and encourages interoperability with other promise-based systems. It serves as both a practical tool for Mojolicious users and a testbed for advancing async/await capabilities within the Perl 5 ecosystem.

Mojo::Debugbar is a powerful debugging tool designed for developers using the Mojolicious framework, enabling them to collect and visualize metrics from their applications. By integrating various monitors—such as those for requests, database interactions, templates, and validation—Mojo::Debugbar provides a comprehensive overview of application performance. The module allows developers to easily start and stop monitoring, inject necessary JavaScript for functionality, and render collected metrics as HTML. Notably, in the recent update (version 0.1.1), the module was enhanced to inject monitors even when there is no body tag present, improving its usability in diverse scenarios.

Mojo::TypeModel is a lightweight model system designed for use with Mojolicious applications, leveraging the capabilities of Mojo::Base. It allows developers to create models that can interact with one another and share data, such as database connections, facilitating a structured approach to application architecture. The module includes the Mojolicious::Plugin::TypeModel, which aids in building helper methods for models, enhancing the overall functionality. With features like the ability to define types and manage attribute propagation between model instances, Mojo::TypeModel streamlines the process of creating and managing complex data interactions within web applications.

The Mercury module serves as the primary broker application class for managing message brokering in Perl applications. With a straightforward command-line interface, users can easily start the broker using the command "mercury broker" and access help documentation through "mercury help broker." This module is designed for those looking to implement message brokering functionality, and it also provides guidance for creating custom message brokers that can incorporate features like authentication and logging through the Mojolicious::Plugin::Mercury. Developed by Doug Bell, Mercury is open-source software, allowing for redistribution and modification under the same terms as Perl itself.

Mojolicious::Plugin::JavaScript::Console is a Perl module designed to facilitate debugging in Mojolicious applications by enabling developers to send output directly to the JavaScript console. By integrating this plugin, users can easily log messages, warnings, and structured data from their server-side code to the client-side console, enhancing the debugging process. The module allows for customizable output formatting and supports UTF-8 character encoding, making it a versatile tool for web developers looking to streamline their debugging workflow. With simple usage in both Mojolicious and Mojolicious::Lite applications, it provides a straightforward way to access console functionalities, ultimately improving the development experience.

Mojolicious::Plugin::ExceptionSentry is a powerful plugin designed for the Mojolicious web framework that facilitates seamless integration with Sentry, a popular error tracking service. By automatically sending all exceptions encountered in a Mojolicious application to Sentry, this module helps developers monitor and resolve issues efficiently. Configuration is straightforward, requiring only a Sentry DSN for setup, with an optional timeout setting to control the maximum wait time for sending events. This plugin is particularly useful for developers looking to enhance their application's error handling capabilities and maintain high reliability. The module has seen recent updates, including improvements to documentation and test handling, ensuring a smoother user experience.

Mojolicious::Plugin::Authentication is a powerful plugin designed to simplify user authentication in Mojolicious applications. It allows developers to easily implement user login functionality by providing methods for user loading and validation, session management, and user state checks. With both synchronous and asynchronous options available, developers can choose how to handle authentication processes, including the ability to pass additional data during authentication. The plugin also supports routing conditions to restrict access to certain routes based on user authentication status. Recent updates have reinstated support for Perl versions below 5.20, ensuring broader compatibility. This module is ideal for developers looking to streamline authentication in their web applications while maintaining flexibility and control over user management.

Mojolicious::Plugin::Notifications is a versatile Perl module designed to facilitate frontend event notifications within Mojolicious applications. By allowing developers to register multiple notification engines, such as HTML, JSON, and Humane.js, this plugin enables the seamless display of messages to users in response to various events, such as warnings or errors. Notifications can persist across redirects and are adaptable to different response types, ensuring a consistent user experience. The module provides helper methods for adding notifications in controllers and rendering them in templates or JSON responses, while also supporting custom notification engines. With hooks for logging and an asset management feature for integrating notification scripts and styles, Mojolicious::Plugin::Notifications enhances the interactivity and responsiveness of web applications.

Mojolicious::Plugin::DOCRenderer is a powerful plugin for Mojolicious applications that enables the generation and browsing of POD (Plain Old Documentation) documentation directly from your source code. This plugin allows developers to easily access and display their application's documentation online, typically at the */doc* URL, which can be customized. It is particularly useful in development mode, where it can be activated to provide immediate access to documentation for the application being developed. The plugin is a modification of Mojolicious::Plugin::PODRenderer and supports various options such as specifying the module to display, customizing the handler name, and setting a preprocessing handler. Notably, the recent update in version 5.02 ensures compatibility with Mojolicious 9.17, enhancing its functionality and stability.

Mojolicious::Plugin::EventSource is a Perl module designed to simplify the integration of Server-Sent Events (SSE) within Mojolicious applications. By providing an easy-to-use plugin, it allows developers to create real-time web applications that can push updates from the server to the client without requiring the client to request new data. The module facilitates the registration of event sources and the emission of events, enabling seamless communication between the server and the browser. With a straightforward syntax, developers can quickly set up event streams, making it ideal for applications that require live updates, such as gaming or live data feeds.