CPANscan

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.

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.

Test2::Harness is a robust Perl module designed to serve as a backend for running and processing tests, offering enhanced integration with the Test2 framework. While users typically interact with it indirectly through the App::Yath user interface, Test2::Harness provides essential functionalities for managing test execution and reporting. Recent updates include the removal of an unintended dependency on Test::Exception and improvements in preserving the exit status across various scenarios, ensuring more reliable test outcomes. This module is particularly valuable for developers looking to streamline their testing processes and enhance the reliability of their test suites.

Mooish::Base is a Perl module designed to simplify the creation of classes and roles within the Moose family of object-oriented programming frameworks. By using Mooish::Base, developers can easily import essential components such as Moo, Mooish::AttributeBuilder, and Types::Common, streamlining the setup process for their classes and roles. The module also supports a "-role" flag to import Moo::Role instead of Moo, catering to different development needs. Additionally, it allows customization through environmental variables to modify the underlying class and role systems, ensuring compatibility with various Moose flavors like Moose, Mouse, and Moo. This module is particularly beneficial for module authors, as it provides a solid foundation while maintaining flexibility and performance enhancements through optional modules.

Crypt::SecretBuffer is a Perl module designed to securely manage sensitive data, such as passwords, by preventing accidental exposure or copying in memory. It provides a specialized buffer that ensures secrets are wiped from memory when no longer needed, thereby reducing the risk of leaks in long-running applications. The module allows for secure input from the console without echoing characters, and it can interact with external commands without exposing the secret in Perl's memory. Recent updates in version 0.010 include bug fixes, new methods for manipulating the buffer, and enhancements to the C API, making it easier to integrate with C code while maintaining security practices. This module is particularly useful for developers looking to handle sensitive information safely within their Perl applications.

The Sys::Async::Virt Perl module provides an asynchronous interface for interacting with LibVirt services via its remote protocol, enabling clients to manage virtualization environments effectively. Built on the IO::Async framework, this module allows users to connect to a LibVirt server, execute various commands such as listing domains, and handle events asynchronously. It offers a user-friendly object-oriented API that maps closely to the underlying C API of LibVirt, while also accommodating differences in data types and argument handling. Notably, version 0.1.10 introduces updates to the LibVirt library, enhancing functionality with new constants related to storage and event management, ensuring that users can leverage the latest features available in the virtualization ecosystem.

The `Protocol::Sys::Virt` Perl module provides an abstract implementation of the LibVirt protocol, enabling the development of client and server components that interact with virtualization technologies. Designed to facilitate a truly asynchronous interface to LibVirt, this module addresses the limitations of the existing `Sys::Virt` module, which operates with blocking API calls. Unlike Python's threading model, which allows for shared variables across threads, Perl's threading is discouraged and creates isolated interpreters, making `Protocol::Sys::Virt` a valuable solution for developers seeking non-blocking interactions with LibVirt. This module is particularly useful for those looking to leverage the asynchronous capabilities of LibVirt in their Perl applications.

MooX::TypeTiny is a Perl module designed to enhance the performance of type checks in Moo classes when used in conjunction with Type::Tiny. By optimizing the way type checks and coercions are applied, this module allows for faster execution of attribute setters, achieving speeds comparable to those found in Moose. It achieves this by inlining type checks specifically for Type::Tiny, rather than relying on Moo's general mechanism. While it currently serves as a performance booster, there is an expectation that future developments may render this module unnecessary by automating the type inlining process.

SQL::Shell is a versatile command interpreter designed for creating database shells and executing batch scripts using the DBI framework in Perl. It provides a user-friendly command-line interface with features akin to popular database clients like mysql and sql*plus, but operates independently of any specific database, making it adaptable for various DBI-compatible databases. Key functionalities include executing SQL commands, managing command history, displaying database schemas, and importing/exporting data from delimited files. Users can customize commands and output formats, enhancing the shell's flexibility. The latest version, 1.18, introduces the use of File::Temp for improved handling of temporary files, further streamlining its operation.

The Win32::Console::DotNet module provides a .NET-compatible interface for managing Windows console applications in Perl, building upon the existing Win32::Console functionality. This module simplifies console input and output operations, allowing developers to easily read keyboard inputs, write text to the console, and manipulate console properties such as title, cursor position, and colors. It abstracts complex low-level Windows console functions and structures, making it easier to create robust console applications. Recent updates have included bug fixes for various methods and enhancements to support encoding and console key information, ensuring improved reliability and functionality for developers working with console applications in Perl.

The IO::Uring module provides a low-level interface to Linux's io_uring, enabling efficient asynchronous I/O operations in Perl. By drastically reducing the number of system calls required for I/O tasks, it allows developers to schedule actions and receive notifications via callbacks when those actions complete. The module's methods closely mirror system calls, with additional parameters for submission flags and callbacks, facilitating advanced features like chaining actions and handling timeouts. Designed for performance and flexibility, IO::Uring is ideal for applications that require high concurrency and low latency, although it is still considered experimental and may undergo changes in future releases.

Test::Unit is a Perl module that provides a unit testing framework inspired by the JUnit framework for Java, designed to facilitate unit testing in an object-oriented programming environment. It supports inheritance of tests and offers both object-oriented and procedural interfaces, making it versatile for various coding styles. The module includes essential components such as Test::Unit::TestCase and Test::Unit::TestSuite for structuring tests, while also allowing for procedural testing through Test::Unit::Procedural. Recent updates include version 0.28, which involved code formatting improvements without functional changes, and previous updates that enhanced hash comparison during tests to prevent randomization issues. This framework is particularly useful for developers looking to implement robust testing practices in their Perl applications.

WebDyne is a dynamic Perl web application framework designed for high performance and modularity, enabling seamless integration of Perl code within HTML files through template compilation and caching. It supports both CGI and persistent environments like mod_perl and PSGI, allowing developers to render .psp templates into HTML using the `html` and `html_sr` functions. With features such as block rendering, custom handlers, and caching, WebDyne is built for flexibility and efficiency, making it suitable for a variety of web applications. Recent updates include enhancements to the `html` function, allowing for alternative outputs, and improvements in error handling, ensuring a more robust development experience. Comprehensive documentation is available to guide users through its features and usage.

Print::Format is a Perl module designed to facilitate the creation of responsive text formats for output, particularly useful for generating structured reports such as bug reports. By defining a format template using a simple syntax, users can easily control the alignment and layout of various fields, ensuring that the output is both readable and well-organized. The module allows for dynamic data insertion, enabling developers to print formatted tables and detailed information with minimal effort. As of its initial release in version 0.01, Print::Format provides a straightforward approach to formatting output, making it a valuable tool for Perl developers looking to enhance the presentation of their data.