CPANscan

Mojo::SAML is an experimental Perl module designed to provide a SAML2 toolkit built on the Mojo framework, allowing developers to implement basic SAML interactions with proper configuration. While it is still in the early stages of development and considered unstable, it offers a range of document constructors for SAML entities, such as AuthnRequest and EntityDescriptor, and relies on Crypt::OpenSSL::RSA and Crypt::OpenSSL::X509 for cryptographic operations. Recent updates include a fix for compatibility with Mojolicious versions greater than 8.42, enhancing its usability within the Mojolicious ecosystem. Users should be aware of its limitations and the potential for API changes as the module evolves.

SReview is a Perl-based system designed for the efficient review and transcoding of conference videos. By allowing users to input timestamped videos along with a schedule, SReview automates the creation of initial video cuts. It features a web interface for reviewers to finalize the start and end times of talks, ensuring precise editing. Once the timings are confirmed, SReview enhances the videos by adding opening and closing credits, transcodes them to a high-quality archive format, and facilitates their publication, making it an essential tool for managing conference video content. For further details, visit <https://yoe.github.io/sreview>.

Media::Convert is a Moose-based Perl library designed for managing and manipulating media assets, enabling users to inspect, edit, convert, and transcode media files with ease. By leveraging the powerful capabilities of ffmpeg and ffprobe, Media::Convert allows developers to create and execute command lines for various media operations seamlessly. Originally part of the SReview web-based video review tool, this module has been developed into a standalone solution, making it a valuable resource for anyone working with media files in Perl. With its structured approach and adherence to semantic versioning, Media::Convert provides a robust framework for media processing tasks.

The VKontakte::API module is designed to facilitate interaction with the VKontakte social networking platform by enabling users to log in and send API requests. With this module, developers can easily create an instance using their application's API ID and secret key, and then utilize the `sendRequest` method to access various API functionalities, such as retrieving user profiles. The module supports traditional authentication as well as OAuth 2.0, providing flexibility for different use cases. Notably, version 0.04 includes improvements to the documentation, ensuring that users have clear guidance on how to implement the module effectively.

Mojo::File::ChangeNotify is a Perl module designed to monitor file changes in specified directories and convert those changes into Mojo events, facilitating real-time responses to file modifications. By allowing users to instantiate a watcher with customizable parameters such as directory paths and file filters, it enables the execution of callback functions whenever changes occur. This module is particularly useful for applications that require immediate updates based on file alterations, such as configuration management or live reloading in development environments. It operates by creating a subprocess that handles blocking waits or polling, ensuring efficient communication of file change events back to the main process.

The IO::Uring Perl module provides a low-level interface to Linux's io_uring, an advanced asynchronous I/O framework designed to minimize system calls and enhance performance. By utilizing a proactor model, this module allows developers to schedule asynchronous operations and receive notifications via callbacks upon their completion. With methods that closely mirror system calls, IO::Uring supports a variety of I/O operations, including reading, writing, and socket management, while also enabling features like chaining actions and handling timeouts. Although still in an experimental phase, this module offers a powerful toolset for developers looking to leverage the efficiency of asynchronous I/O in their Perl applications.

Linux::FD::Mem is a Perl module designed for creating memory file descriptors that reside entirely in RAM, providing a volatile storage solution without any filesystem representation. It allows users to create anonymous files that can be modified, truncated, and memory-mapped, mimicking the behavior of regular files while utilizing anonymous memory for backing storage. The module supports optional flags for enhanced functionality, such as allowing seals to restrict modifications to the filehandle and enabling support for larger page sizes. A noteworthy recent update in version 0.002 introduced additional flags to the constructor and enhanced capabilities for managing seals, making it easier to control file behavior in memory. This module is particularly useful for applications requiring fast, temporary storage without the overhead of disk I/O.

The Linux::FD::Pid module provides a convenient way to manage process ID (PID) file descriptors in Perl, allowing developers to await the termination of processes without relying on traditional signal handling like "SIGCHLD". By creating a pidfd filehandle, users can leverage non-blocking I/O operations with select, poll, and epoll, enhancing the efficiency of process management. Key methods include `new` for instantiating a filehandle for a specified PID, `send` for signaling the process, and `wait` for retrieving the process's exit status. Notably, version 0.007 introduced improvements to ensure that Linux::FD::Pid behaves as an IO::Handle and refined the return value of the `wait` method to provide a proper wait status. This module is particularly useful for applications that require robust and responsive process control in a Linux environment.

Linux::FD is a Perl module designed to provide Linux-specific special filehandles that facilitate event-driven programming. It offers three primary types of filehandles: event filehandles for monitoring events, signal filehandles for handling signals, and timer filehandles for managing timers. By utilizing these filehandles, developers can implement conventional polling mechanisms to efficiently wait for a wide range of events in their applications. The module includes functions such as eventfd, signalfd, and timerfd, each tailored to create the respective filehandles, making it a valuable tool for Perl developers working in Linux environments.

Acme::Hospital::Bed is a whimsical Perl module that offers a command-line question-and-answer game centered around managing hospital patients. In this game, players are tasked with determining whether to check patients into beds based on their randomly assigned 'illness' levels, which range from 1 to 10. Players must make strategic decisions, balancing their limited lives against the patients' health statuses, as they navigate through various phrases associated with each level of illness. The module allows customization of the total number of beds, lives, patient names, and phrases, making it adaptable for different gameplay experiences. With version 0.06, Acme::Hospital::Bed continues to evolve, providing a light-hearted yet engaging way to test decision-making skills in a playful hospital setting.

Git::Server is a Perl module designed to serve as a secure Git server, offering enhanced capabilities for server hooks and access control lists (ACLs) compared to standard Git servers. It allows administrators to set up granular permissions and automated deployment configurations, making it a powerful alternative for managing Git repositories. The module is straightforward to install and configure, enabling users to create bare repositories and manage access through SSH keys. Notably, in the recent version 0.037, support for SCP-style proxy URLs was added, along with a git-verify configuration sanity checker, enhancing the module's functionality and security. This makes Git::Server an excellent choice for developers seeking a robust and flexible Git hosting solution.

The `Params::Filter` Perl module is designed for efficient field filtering in parameter construction, allowing developers to define strict rules for incoming data from various sources such as web forms, APIs, or command-line interfaces. It enables the specification of required, accepted, and excluded fields, ensuring that only the necessary data is processed while sensitive information is kept secure. The module offers multiple interfaces, including functional, object-oriented, and a high-performance closure interface, catering to different use cases and performance needs. By separating field filtering from value validation, `Params::Filter` enhances data consistency, security, and compliance with regulations like GDPR and PCI-DSS, making it an essential tool for applications that handle user input and sensitive data.

Affix is a high-performance Foreign Function Interface (FFI) for Perl that enables seamless interaction with dynamic libraries (DLLs and shared objects) without the need for XS code or C compiler configuration. By utilizing a custom lightweight Just-In-Time (JIT) engine, Affix generates efficient machine code at runtime for function calls, significantly reducing overhead compared to traditional FFI solutions. It provides a user-friendly API for loading libraries, binding functions, and managing memory, allowing developers to easily allocate raw memory, perform pointer arithmetic, and inspect memory contents. With support for complex data types, including structs, arrays, and enums, as well as the ability to handle callbacks and variadic functions, Affix empowers Perl developers to leverage native C functionality with minimal friction.

Progress::Any::SIGHandler is a Perl module designed to facilitate the output of progress updates to the terminal in response to Unix signals, primarily USR1 by default. By integrating this module into your Perl scripts, you can easily track and report the progress of long-running tasks. It allows for customization of the signal used and the format of the progress message through import arguments, enhancing the user experience during execution. With a straightforward implementation, developers can utilize this module to provide real-time feedback on task completion, making it an invaluable tool for any Perl application that requires progress monitoring.

Perl::Version::Bumper is a Perl module designed to facilitate the updating of Perl code to declare a more recent version of the Perl language using the "use VERSION" directive. It simplifies the process by removing unnecessary feature and experimental warnings, ensuring that compatibility modules are only retained when needed, and managing the version bumping process safely. The module provides methods to bump the version in PPI::Documents, strings of code, or files, with options for safe version bumping that guarantees the updated code will compile. Recent updates have included enhancements to documentation, test cases, and the ability to record unfeatures for future use, reflecting the module's ongoing development and commitment to improving Perl code compatibility.

Linux::Event is a specialized Perl module designed to provide a robust event loop ecosystem tailored for Linux systems. It leverages Linux-specific primitives such as epoll for I/O readiness, timerfd for timers, signalfd for signal handling, eventfd for wakeups, and pidfd for process exit notifications. With its stable API introduced in version 0.004, Linux::Event allows developers to create efficient event-driven applications by utilizing features like mutable watcher handles, integrated signal handling, and a deadline scheduler. Recent enhancements include the addition of eventfd-based wakeups and pidfd integration for process notifications, ensuring a streamlined and effective event management experience. This module is ideal for developers looking to harness the power of Linux's event-driven capabilities in their Perl applications.

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 the use of custom `RangeMessage.xml` files by setting the `ISBN_RANGE_MESSAGE` environment variable, enabling users to access 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 in the module. The data is accessible through 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, ensuring they have accurate and up-to-date information for their applications.

CLI::Simple is a minimalist object-oriented base class designed for creating command-line interface (CLI) applications in Perl. It simplifies the process of building scripts that handle options, commands, and arguments, allowing developers to focus on functionality rather than boilerplate code. With features like automatic logging, command argument parsing, and customizable help output, CLI::Simple provides a flexible framework without imposing a rigid structure. Recent updates in version 1.0.12 introduced new package variables, `$AUTO_HELP` and `$AUTO_DEFAULT`, which enhance control over default behaviors when no command is specified, allowing for a more tailored user experience. This module is ideal for internal tools, admin scripts, and scenarios where a lightweight CLI solution is preferred.

SimpleFlow is a Perl-based workflow manager designed to streamline the execution and debugging of complex shell command workflows, similar to tools like snakeMake or NextFlow. It allows users to define tasks with a simple interface, where each task is represented by a command and can include optional parameters such as input and output file checks, logging options, and error handling. Upon execution, each task returns a comprehensive hash containing details like exit codes, working directories, and standard output/error, making it easy to track the progress and results of each step in a workflow. This module is particularly useful for managing intricate pipelines where meticulous file handling and error checking are crucial, thereby enhancing the reliability and clarity of command execution in Perl scripts.

App::fsql is a versatile Perl module designed to execute SQL queries on various file formats, including CSV, TSV, LTSV, JSON, and YAML, as well as TableData modules. With its command-line interface, fsql, users can easily manipulate and query data stored in these formats without needing a traditional database setup. The latest version, 0.233, released on December 29, 2023, includes updated documentation that provides examples for selecting data from TableData modules, enhancing usability for developers working with structured data. This module is particularly useful for data analysis and processing tasks where lightweight data handling is required.

App::GhostWork is a Perl module designed for logging barcode data into structured log files in CSV, LTSV, and JSON5 formats. It captures essential information such as the time and location of the scan, the identity of the scanner, the barcode scanned, its resulting status, and the time taken to create the record. Users can run the module via batch files for English or Japanese, with the option to specify a constant reason for the scan to streamline data entry. Recent updates have expanded its functionality to support Perl scripts, enhancing its versatility for developers. This module is particularly useful for applications requiring detailed tracking and analysis of barcode interactions.

App::CSVUtils is a comprehensive command-line interface (CLI) utility suite designed for handling CSV (Comma-Separated Values) files in Perl. With a wide array of functionalities, it includes tools for adding fields, calculating averages, checking cell values, comparing files, concatenating data, and converting CSV to various formats, among others. The module allows users to generate custom CSV utilities with hooks for processing input and output, making it highly flexible for different use cases. Notably, version 1.036 introduced new options for skipping lines and patterns during input processing, enhancing its usability for complex CSV manipulations. This module is ideal for developers and data analysts looking to streamline their CSV data handling tasks efficiently.

App::LTSVUtils is a Perl module that provides a set of command-line interface (CLI) utilities for working with Labeled Tab-Separated Values (LTSV) data format. It includes functions to convert LTSV to CSV and TSV formats, as well as to dump LTSV data into a structured array of hashes. Each utility function accepts a filename as input, allowing for reading from standard input if needed, and returns a structured response that includes an HTTP status code, a message, and optional payload and metadata. The module is designed to facilitate data manipulation and conversion tasks for users dealing with LTSV files. A noteworthy recent change in version 0.002 addressed a bug related to parsing date columns, ensuring that they are correctly identified.

Log::Log4perl::Layout::LTSV is a Perl module that provides a layout for logging in the Labeled Tab-Separated Values (LTSV) format within the Log4perl logging framework. This module allows developers to configure their logging output to be structured and easily parsable, making it ideal for applications that require log data to be sent over a network or processed by other systems. With its straightforward configuration, users can define loggers and appenders, specifying details such as the logging level, destination, and custom facilities. The module supports most options available in Log::Log4perl::Layout::PatternLayout, enabling flexible log formatting while ensuring that log entries are rendered in the LTSV format for enhanced readability and utility.

Devel::KYTProf is a Perl module designed for profiling code to analyze I/O blocking times, making it particularly useful for developers working with database interactions and web requests. By integrating this profiler into your code, you can easily track the execution time of specific methods, such as those from DBI and LWP, and receive detailed output that highlights performance bottlenecks. The module allows for flexible configuration, enabling users to add profiling to individual methods or entire modules, adjust settings like logging and thresholds, and even customize the profiling behavior through regex filters. With its straightforward implementation and experimental features, Devel::KYTProf is an invaluable tool for optimizing Perl applications.

Log::ger::Layout::LTSV is a Perl module designed to format log messages in the Labeled Tab-Separated Values (LTSV) format, allowing for structured logging that is easy to parse. This module integrates seamlessly with Log::ger, enabling users to customize log output by adding or deleting fields, including special fields such as timestamps and hostnames. It supports both hash references for direct logging and standard message formatting, ensuring flexibility in how log data is presented. The latest version, 0.006, released on March 11, 2020, updated the module to comply with Log::ger version 0.037, enhancing its compatibility with recent changes in the logging framework. For more information, visit the project's homepage on MetaCPAN.

Log::LTSV::Instance is a Perl module designed for logging in the Labeled Tab-Separated Values (LTSV) format, which is particularly useful for structured logging. It allows developers to create a logger instance that can output log messages at various severity levels, including critical, error, warning, info, and debug. The module provides a flexible interface where users can define a custom logging function and specify the desired log level. Additionally, it supports attaching metadata to log entries, such as the file and line number from which the log was generated, enhancing traceability and debugging capabilities. This makes Log::LTSV::Instance an excellent choice for applications that require organized and easily parsable log output.

Text::Table::LTSV is a Perl module designed to facilitate the generation of Labeled Tab-Separated Values (LTSV) format from a two-dimensional array of data. With its straightforward interface, similar to that of Text::Table::Tiny, it allows users to easily format and output data in a structured manner. The primary function, `table`, accepts an array reference containing rows of data, where each row is itself an array reference, and returns a formatted string that represents the data in LTSV format. This module is particularly useful for applications that require a simple and efficient way to produce LTSV output, making it a valuable tool for developers working with data serialization in Perl. The initial release of this module was on June 30, 2018.

Text::LTSV::Liner is a Perl module designed for filtering Labeled Tab-separated Values (LTSV) text based on specified keys, making it easier to work with this data format. By utilizing the module, users can create a new instance with desired keys and process input lines to produce filtered output directly to STDOUT or parse lines for further manipulation within their code. Recent updates include the addition of a '--no-buffer' option, enhancing the module's functionality by allowing for immediate output without buffering, which can be particularly useful in real-time data processing scenarios. This module is ideal for developers looking to streamline their handling of LTSV data in Perl applications.

LTSV::LINQ is a Perl module that provides a LINQ-style query interface specifically designed for working with Labeled Tab-Separated Values (LTSV) files. It enables users to perform complex data manipulations such as filtering, transforming, and aggregating LTSV data through a fluent and chainable API. With features like lazy evaluation for efficient memory usage, a Domain Specific Language (DSL) for simple filtering, and over 30 LINQ methods for comprehensive querying capabilities, LTSV::LINQ allows for both straightforward and advanced data analysis tasks. This pure Perl implementation is compatible with Perl versions 5.005 and above, making it accessible for a wide range of environments without requiring additional dependencies.