CPANscan

Sys::Monitor::Lite is a lightweight system monitoring toolkit designed for easy automation and integration, providing structured output in JSON or YAML formats. It offers functions to collect various system metrics, including CPU and memory usage, and allows users to retrieve all available metrics or a specified subset. The module also includes serialization capabilities, enabling users to convert collected data into JSON or YAML strings for further processing with tools like jq-lite or yq. A noteworthy recent addition in version 0.03 is the support for YAML output, enhancing its versatility for users who prefer this format. With its minimalistic approach, Sys::Monitor::Lite is ideal for developers looking to implement straightforward system monitoring solutions.

SimpleFlow is a straightforward workflow manager and logger implemented in Perl, designed to facilitate the execution of tasks in a structured and error-checked manner, similar to tools like snakeMake or NextFlow. It allows users to define tasks with a command to execute, along with optional parameters such as input and output file checks, logging options, and error handling. Each task returns a comprehensive hash containing details like exit codes, working directories, and standard output/error, making it easy to track the execution of complex pipelines. SimpleFlow is particularly useful for automating workflows in scientific computing, where precision and clarity are paramount, ensuring that each step is validated and logged for easy debugging and analysis.

The Affix module provides a Foreign Function Interface (FFI) for Perl, allowing developers to seamlessly call functions and access variables from libraries written in other languages such as C, C++, and Rust without the need for XS. With a straightforward API, Affix enables users to bind exported functions and values to Perl subroutines, wrap them in code references, and define argument and return types using a signature system. It supports various features like memory management functions, type definitions, and ABI hints for handling name mangling in advanced languages. The module also includes a convenient ":Native" attribute for declaring native functions, making it easier to integrate external libraries into Perl applications. Overall, Affix is a powerful tool for Perl developers looking to leverage existing native code efficiently.

Net::Stripe is a Perl module that serves as a comprehensive API client for Stripe.com, enabling developers to easily integrate payment processing capabilities into their applications. With version 0.43, this module provides a robust interface for managing various Stripe resources such as charges, customers, subscriptions, and invoices, all while adhering to the structure of the Stripe API. The module employs Moose objects for API responses, ensuring a clean and object-oriented approach to handling data. Recent updates include improvements to form field serialization and the addition of a tax_id subkey for billing details, enhancing compatibility with the latest Stripe API features. This makes Net::Stripe an essential tool for developers looking to implement Stripe's payment solutions efficiently and effectively.

The Dev::Util module is a comprehensive toolkit designed to streamline the development of Perl programs by providing a standardized set of utilities. It encompasses various sub-modules that facilitate essential functionalities such as consistent feature setup, OS identification, file and directory management, user input prompts, and backup operations. With features like automatic inclusion of strict and warnings pragmas, named constants, and semaphore locking, Dev::Util enhances code maintainability and efficiency. This module is particularly useful for developers looking to simplify common tasks and ensure best practices across their Perl applications.

The `WWW::SnipeIT` Perl module provides a straightforward interface for accessing the Snipe-IT API, a popular asset inventory management system that can be deployed either on-premises or in the cloud. By utilizing this module, developers can easily interact with various aspects of asset management, such as retrieving hardware details by asset tag, updating asset information, and searching for hardware based on specific criteria. With its simple syntax and comprehensive functionality, `WWW::SnipeIT` streamlines the integration of Snipe-IT's capabilities into Perl applications, making it an essential tool for managing IT assets efficiently.

The JSON::Schema::Modern Perl module provides a robust and compliant way to validate data against JSON schemas, specifically targeting the latest Draft 2020-12 version of the JSON Schema specification. With its straightforward interface, users can create a new schema evaluator, configure various options such as output format and validation depth, and evaluate instance data against defined schemas. The module supports a range of features including custom format validations, early evaluation short-circuiting, and the ability to handle complex schemas with nested structures. It also allows for the registration of custom media types and encodings, making it a versatile tool for developers working with JSON data validation in Perl applications.

Marlin is a high-performance class builder for Perl that combines the features of Moose and Moo with a unique syntax, offering a fast and efficient way to create object-oriented classes. It leverages Class::XSAccessor, Class::XSConstructor, and Type::Tiny::XS for enhanced speed, particularly when using simple attributes. Marlin supports a wide range of features, including attribute declaration, type constraints, method delegation, and various accessors, while maintaining compatibility with older Perl versions as far back as 5.8.8. It allows for compile-time class construction without polluting the namespace with keywords, making it an excellent choice for developers looking for a lightweight yet powerful alternative to traditional object systems in Perl.

Lexical::Accessor is a Perl module designed to create truly private attributes for Moose, Moo, and Mouse object systems, ensuring that these attributes remain inaccessible from outside the class, including subclasses. By utilizing the `lexical_has` function, developers can define private attributes that are stored inside-out, allowing for complete encapsulation and preventing naming conflicts with attributes in subclasses. This module supports various options similar to Moose's `has`, such as defining read/write accessors, type constraints, and default values, while also offering performance benefits—being significantly faster than alternatives like MooX::PrivateAttributes and MooseX::Privacy. A noteworthy recent change in version 1.000000 includes optimizations to the Sub::Accessor::Small component, enhancing code efficiency, particularly for method delegations.

Alien::SDL3 is a Perl module designed to facilitate the building and installation of SDL3, a popular multimedia library used for game development and other graphical applications. While it provides a method to retrieve dynamic library files, it is not intended for direct use by developers; instead, it serves as a backend dependency management tool. Users should ensure that the necessary development libraries, such as X11 or Wayland, are present on their systems, particularly for Linux and BSD platforms. This module is maintained by Sanko Robinson and is distributed under the Artistic License 2.

DBIx::Class::DeploymentHandler is a powerful and flexible tool designed for deploying and upgrading databases in applications that utilize DBIx::Class. Unlike its predecessor, DBIx::Class::Schema::Versioned, this module offers enhanced capabilities such as support for downgrades, the ability to manage multiple SQL files for each upgrade or downgrade, and the option to use Perl scripts for database operations. It streamlines the deployment process by requiring only a single set of files for upgrades, significantly simplifying version management. Built on Moose and utilizing a modular architecture, DBIx::Class::DeploymentHandler allows developers to easily customize and extend its functionality while providing robust logging features to track operations. This makes it an essential tool for developers looking to maintain and evolve their database schemas efficiently.

The App::TimeTracker::Command::Jira module is a plugin for the App::TimeTracker application that facilitates integration with Atlassian Jira, enabling users to manage their tasks more efficiently. With this plugin, users can automatically set task descriptions and tags based on Jira ticket data, assign ticket ownership, and update work logs directly from the command line. Additionally, if used alongside the Git plugin, it can generate branch names that reflect Jira ticket information. Recent updates include the introduction of token-based authentication for enhanced security, allowing users to connect to Jira without exposing their passwords. This module is particularly useful for developers and teams who rely on Jira for project management and want to streamline their workflow.

File::XDG is a Perl module that implements the XDG base directory specification, which is designed to standardize the locations for user-specific configuration, data, and cache files across different applications. With version 1.03, it allows developers to easily access directories such as user configuration, data, and cache homes, as well as system-wide configuration and data directories. The module supports various path classes, including Path::Tiny and Path::Class, and offers methods for looking up configuration and data files based on the application name. Notably, the recent update in version 1.03 included an update to the license text, ensuring compliance and clarity for users. This module is particularly useful for developers looking to adhere to the XDG specification while managing application file paths in a consistent manner.

The User::Identity Perl module is designed to manage and maintain information about individual users, encapsulating various attributes such as names, birthdates, and gender in a flexible object-oriented structure. It allows developers to create user identity objects with a range of customizable fields, providing defaults and smart handling of data to ensure ease of use. The module supports stringification, enabling seamless integration into output contexts by automatically converting user objects to their full names. While it does not implement any storage mechanisms, it offers the flexibility to store user data using various Perl data serialization methods or databases. This makes User::Identity a versatile choice for applications requiring user information management without being tied to a specific data format.

The `Object::Realize::Later` Perl module facilitates the delayed creation of objects, allowing for on-demand realization of object data to enhance performance and reduce resource consumption. By implementing a lazy loading mechanism, this module enables developers to defer the instantiation of an object until its data is actually needed, which can significantly improve the startup time of applications. It provides a flexible interface for defining how and when an object should be realized, including options for handling method calls and warnings during the realization process. This makes it particularly useful for larger projects where efficiency is critical, as it allows for the management of object states without unnecessary overhead.

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 sourcing; users can specify an alternate `RangeMessage.xml` file via 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 organized 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, enabling them to manage and utilize ISBN-related data effectively.

The Perl module Module::Release is designed to automate the software release process, streamlining tasks such as version control, testing, and uploading to repositories like PAUSE (CPAN) and SourceForge. Originally developed as a script, it has evolved into a comprehensive tool that integrates with various build systems, including Makefile.PL and Module::Build, and supports multiple version control systems like CVS, SVN, and Git through mixins. The module provides a series of methods that check conditions (e.g., ensuring all tests pass) before proceeding with the release, ensuring that errors are caught early in the process. Recent updates include enhancements to the handling of GitHub metadata and improvements in the release process, making it easier for developers to manage their distributions effectively. With its flexible configuration options and robust functionality, Module::Release is an essential tool for Perl developers looking to streamline their release workflows.

Daje::Workflow is a straightforward workflow engine designed to manage processes as a series of states and transitions triggered by events. It allows developers to define workflows with various activities, each leading to a resulting state, making it easy to model complex processes in a clear and organized manner. The module requires several components, including database models and error handling, to function effectively. Recent updates in version 0.24 include bug fixes, the merging of the Daje::Workflow::Loader and Daje::Workflow::Config modules, and the addition of pre and post activity checks, enhancing its robustness and usability for developers looking to implement workflow management in their applications.

Daje::Plugin::Workflow is a Mojolicious plugin designed to integrate with Daje::Workflow, enabling developers to manage and execute workflows within their applications seamlessly. By utilizing this plugin, users can easily configure workflow loaders, specifying paths and types for their workflow files, thus streamlining the process of workflow management. It requires several components, including Daje::Workflow and its associated loaders and database modules, ensuring a robust framework for workflow operations. This plugin is ideal for developers looking to enhance their Mojolicious applications with powerful workflow capabilities.

Daje::Plugin::Tools is a Mojolicious plugin designed to enhance the functionality of Mojolicious applications by providing a suite of tools and database models essential for managing various aspects of application data. It requires several database helpers and models, ensuring a robust integration with the Daje framework. The plugin can be easily registered within a Mojolicious application or used in Mojolicious::Lite, making it versatile for different development environments. Recent updates in version 0.25 include critical bug fixes, the relocation of migrations to Daje::Database::Tools, and corrections to dependencies and tests, ensuring improved stability and performance for developers utilizing this plugin.

The SPVM::Regex module provides a powerful interface for working with regular expressions in Perl, leveraging the Google RE2 engine for efficient pattern matching and string manipulation. It offers methods for matching patterns, replacing substrings, and splitting strings based on regex patterns, all while supporting UTF-8 and various regex features. Users can create Regex objects with custom patterns and flags, perform matches with optional offsets and lengths, and utilize both simple and callback-based replacements. Recent updates include bug fixes that enhance pattern matching capabilities, particularly for edge cases involving anchors like `\A` and `\z`, ensuring more reliable behavior in string processing tasks. This module is ideal for developers looking to integrate robust regex functionality into their SPVM applications.

Schema::Validator is a Perl module designed to facilitate the validation and loading of Schema.org vocabulary definitions, enabling developers to work effectively with structured data. It provides functions for validating datetime formats and dynamically loading Schema.org class and property definitions from the official JSON-LD vocabulary file. The module includes a command-line tool that scans HTML files for embedded JSON-LD and validates them against local schema definitions, offering detailed diagnostics and integration with GitHub Code Scanning through SARIF output. Additionally, it supports dynamic validation by downloading the latest Schema.org vocabulary, caching it for improved performance. This module is particularly useful for ensuring compliance with structured data standards in web applications.

Bitcoin::Crypto is a Perl module designed for cryptographic operations related to Bitcoin, facilitating the manipulation of keys, transactions, and encodings. It provides essential functions for generating mnemonics, deriving keys using BIP44 standards, and handling both private and public keys for signatures and addresses. With its straightforward interface, users can easily perform common Bitcoin tasks such as creating wallets and managing transactions. The module also offers shortcut functions for loading various key and transaction-related packages, making it a versatile tool for developers working with Bitcoin in Perl.

Data::Dumper::Interp is a Perl module designed to enhance the output of Data::Dumper for better readability and human consumption. It allows for the interpolation of variable values into strings, making it easier to visualize complex data structures. The module provides various functions to format scalars, arrays, and hashes, while also offering options to control the display of objects and references. Notably, it can handle Unicode characters gracefully and avoids common pitfalls associated with debugging. Recent updates include the reversion of a change related to the $Carp::RefArgFormatter setting, ensuring that the module maintains its intended functionality without unintended side effects. This makes Data::Dumper::Interp a valuable tool for developers looking to debug and present data in a clear and concise manner.

File::HomeDir is a versatile Perl module designed to locate user-specific directories across various platforms, ensuring consistent access to essential folders like home, desktop, documents, music, pictures, and videos. By providing a unified API, it simplifies the development of cross-platform Perl applications that require user directory information. The module features methods for retrieving paths for both the current user and other users, while also handling cases where directories may not exist. Recent updates have improved compatibility with modern toolchains and addressed specific issues reported by users, enhancing its reliability and functionality.

The Mail::Transport Perl module provides a framework for interacting with various Mail Transfer Agents (MTAs) to facilitate the sending and receiving of email messages using different protocols. It serves as a base class that can be extended by other modules, such as Mail::Transport::Send for sending emails via protocols like SMTP, and Mail::Transport::Receive for receiving emails through protocols like POP3. With configurable options for executable paths, hostnames, authentication, and connection parameters, Mail::Transport allows developers to easily implement email functionality in their applications while managing error handling and connection retries. This module is particularly useful for those looking to integrate email capabilities into Perl applications with flexibility and ease.

Mail::Box::Parser::C is a Perl module designed for efficient parsing of email messages using ANSI C routines through Perl's XS extension facility. It serves as an optional parser for the MailBox framework, automatically utilized when messages are provided via file handles, while defaulting to the Perl-based parser in other scenarios. This module enhances performance and introduces a new attribute, `boxnr`, for better management of mail folder access. Notably, version 4.00 has transitioned to using the Mail::Box 4 exception model with Log::Report, marking a significant update in error handling. Users upgrading from earlier versions should be aware of compatibility changes, particularly in exception handling.

The Mail::Box::POP3 module provides a robust interface for managing email folders stored on a remote server using the POP3 protocol. It allows Perl applications to interact with POP3 email accounts, enabling users to retrieve and handle messages efficiently. This module abstracts the complexities of the underlying POP3 communication through the Mail::Transport::POP3 class, focusing on message management within a POP3 folder. Users can authenticate using various methods, including LOGIN and APOP, and can specify options such as server details and message types. However, it's important to note that due to the limitations of the POP3 protocol, users cannot create sub-folders or write messages back to the server, making this module primarily suitable for reading and organizing emails. With its comprehensive error handling and support for SSL connections, Mail::Box::POP3 is an essential tool for developers looking to integrate POP3 email functionality into their Perl applications.

The `Mail::Box::IMAP4` Perl module provides a robust interface for managing IMAP4 email folders, allowing users to interact with messages stored on remote servers using the IMAP4 protocol. It simplifies the process of opening, reading, and manipulating email folders by encapsulating the complexities of network communication and message handling. With support for multiple folders over a single connection, this module enables efficient email management, including features like caching options for message bodies and headers, as well as customizable access modes. Designed for flexibility, it allows developers to specify various options during folder creation and supports both read and write operations, making it an essential tool for applications that require email functionality.

The Mail::Box module provides a robust framework for managing mailboxes, allowing users to interact with various types of mail folders in a consistent manner. It serves as a base class for different folder types, such as Mail::Box::Dir, Mail::Box::File, and Mail::Box::Net, each of which handles message storage differently—either in a single file or across multiple files in a directory. With Mail::Box, users can easily open, read, and manipulate messages, including adding, deleting, and iterating through them, all while benefiting from a unified API that abstracts the underlying complexities of different mailbox formats. The module also supports advanced features like message filtering, lazy loading of message bodies, and folder locking, making it a powerful tool for email management in Perl applications.