CPANscan

Sub::Conveyor is a Perl module designed for subroutine chaining with type enforcement, allowing developers to create a sequence of operations that can process data based on specified types. By utilizing the Types::Standard library, users can define a series of subroutines that transform input values according to their types, enabling flexible and type-safe data manipulation. The module provides methods to initialize a conveyor with type-subroutine pairs, add additional processing steps, and invoke the chain with input values. This facilitates a clean and organized approach to handling various data types, making it particularly useful for applications that require dynamic type handling and transformation.

Config::LNPath is a Perl module designed for reading and managing configuration settings from YAML files in a straightforward manner. With its simple interface, users can easily create a new configuration object by specifying one or more YAML files, and it offers options for merging configurations with unique hash and array handling. The module provides methods such as `find` to locate specific paths within the configuration and `section_find` to retrieve entire sections, making it an efficient tool for developers needing to manage application settings in a structured format.

Data::LNPath is a Perl module designed for efficient lookup of nested data structures using a path-based syntax. With the `lnpath` function, users can easily retrieve values from complex data hierarchies, including arrays and hashes, by specifying a path string. This module supports advanced features such as method calls on objects within the data structure, allowing for dynamic evaluations and calculations directly through the path. Recent updates have improved its functionality, including the ability to call object methods without parameters and enhanced error handling options. Data::LNPath is particularly useful for developers needing to navigate and manipulate deeply nested data in a concise and readable manner.

The `smallnum::XS` Perl module provides a faster and transparent implementation of "SmallNumber" support, enhancing numerical operations with improved performance. By utilizing this module, developers can seamlessly perform arithmetic operations on small floating-point numbers while benefiting from significant speed improvements compared to the original `smallnum` module. With its straightforward usage, simply including `use smallnum::XS;` allows for efficient calculations, making it an ideal choice for applications that require high-performance numerical processing. The module is designed for ease of integration and offers a simple interface for specifying precision, ensuring that developers can optimize their code without sacrificing accuracy.

The `smallnum` Perl module provides transparent support for "SmallNumber" arithmetic, allowing users to perform mathematical operations with controlled precision. By using `smallnum`, developers can specify the desired precision level, which affects the results of arithmetic operations. For instance, using `smallnum '0.1'` will round results to one decimal place, while `smallnum '1'` will round to the nearest whole number. This module is particularly useful for applications where precision in numerical calculations is critical, such as financial computations. The current version, 1.02, builds upon the initial release, enhancing its functionality for users seeking precise numerical operations in Perl.

Config::Abstraction is a versatile Perl module designed to simplify configuration management by providing a robust abstraction layer over various configuration file formats, including YAML, JSON, XML, and INI. It enables developers to create layered configurations that can be easily overridden at runtime through environment variables and command line arguments, facilitating dynamic adjustments without altering the original files. With features like intelligent merging of configuration layers, support for flattened key-value structures, and comprehensive error handling, Config::Abstraction streamlines the process of managing complex configurations, making it an essential tool for modern Perl applications.

YAOO (Yet Another Object Orientation) is a Perl module designed to simplify object-oriented programming by providing a flexible and intuitive framework for defining attributes and their behaviors. With YAOO, developers can easily declare attributes with various types, such as read-only or read-write, and specify constraints like required values and default settings. The module supports advanced features like lazy loading, coercion of values, and defining build order for attributes, allowing for greater control over object instantiation. Additionally, YAOO facilitates inheritance and the declaration of required attributes and methods in subclasses, making it a powerful tool for creating robust and maintainable object-oriented Perl applications.

The `Phone::Valid::International::Loose` Perl module provides a simple way to loosely validate international phone numbers using regular expressions. With a straightforward interface, users can create an instance of the module or utilize the exported `valid_phone` function to check the validity of phone numbers that include an area code prefix. This module is particularly useful for applications that require basic validation of international phone formats without the need for strict adherence to specific country rules. It is designed for ease of use, making it accessible for developers looking to incorporate phone number validation into their projects.

The ODS (Object Data Store) Perl module provides a structured way to manage and manipulate data in an object-oriented manner, making it ideal for applications that require a robust data storage solution. With ODS, developers can define tables, columns, and relationships easily, allowing for the creation of complex data models. The module supports various data types, automatic incrementing of IDs, and features like filtering and sorting, which enhance data retrieval and management. Recent updates have introduced directory storage, data generation capabilities, and improved file serialization, making it even more versatile for developers looking to implement custom data solutions. ODS is licensed under the Artistic License 2.0, ensuring it remains free and open for use and modification.

Struct::Match is a Perl module designed to facilitate exact matching of various data types, including scalars, hashes, and arrays. By using the `match` function, developers can easily compare two variables to determine if they are equal, returning a boolean value of 1 for a match and 0 otherwise. The module also allows for customization, enabling users to extend its functionality to include additional data types such as regular expressions and code references by modifying the `%STRUCT` variable. This flexibility makes Struct::Match a valuable tool for developers needing precise comparisons in their Perl applications. The module is currently at version 1.01, with its initial release marking the beginning of its journey in the Perl ecosystem.

Caller::Reverse is a Perl module designed to manipulate the caller stack by providing functions that reverse its order. With this module, developers can easily retrieve the first caller in the stack using the `caller_first` function, which returns the package name in scalar context and the full caller response in list context. Additionally, the `callr` function allows users to access caller information in reverse order, enhancing debugging and stack tracing capabilities. This module is particularly useful for developers looking to gain insights into the call hierarchy of their applications. The latest version, 1.01, continues to build on its initial release, ensuring improved functionality and usability.

The `Module::Runtime` Perl module provides a set of functions for handling Perl modules at runtime, allowing developers to load and manage modules dynamically rather than at compile time. It includes utilities for validating module names, generating notional filenames, and requiring or using modules with support for version checks. Notably, it addresses several historical bugs in Perl's core module loading mechanisms, ensuring that modules are loaded correctly and without interference from lexical state or erroneous caching of load results. Additionally, it offers features for composing module names from user-friendly specifications, making it easier to work with complex module structures. This module is particularly useful in low-level infrastructure where avoiding dependencies on other modules is crucial.

The `Compiled::Params::OO` Perl module provides an object-oriented approach to parameter validation through compiled parameter objects. It simplifies the process of validating method parameters by allowing developers to define expected types and default values in a structured manner using the `cpo` function. This function acts as a wrapper around `Type::Params`, enabling the creation of validation rules for named accessors, which can include both simple types and complex structures. With features like optional parameters and default values, `Compiled::Params::OO` enhances code readability and maintainability. The latest version, 1.01, continues to build on its foundational capabilities, making it a valuable tool for Perl developers seeking robust parameter validation solutions.

The `Math::Pari` module provides a Perl interface to the PARI library, which is renowned for its capabilities in numerical, scientific, and number-theoretic computations. This module allows users to seamlessly utilize PARI functions as Perl functions, facilitating the integration of PARI's powerful mathematical capabilities with Perl's flexibility. Users can create PARI objects from various data types, including integers, floats, and strings, and can construct matrices and vectors with ease. The module also supports advanced features like parsing GP (the PARI/GP calculator) expressions, enabling whitespace and comments for improved usability. Recent updates have enhanced the module's functionality, including the addition of new functions and improved error handling, making it a robust choice for mathematicians and developers working with complex calculations in Perl.

Class::ExtraAttributes is a Perl module designed to facilitate the addition of extra attributes to existing classes, particularly when subclassing standard classes. It allows developers to enhance their objects with new attributes without needing to modify the underlying class structure, ensuring that the original functionality remains intact. By utilizing the OOB module, Class::ExtraAttributes provides a seamless way to create accessor and mutator methods for these additional attributes. Furthermore, it supports custom persistence mechanisms, enabling users to implement their own update and retrieve methods for managing the extra attributes in persistent storage. This module is particularly useful for developers looking to extend the capabilities of existing classes while maintaining clean and manageable code.

The OOB module in Perl provides a flexible way to associate out-of-band data (attributes) with any Perl data structure, utilizing both an object-oriented and a functional interface. This module allows users to register and manage metadata attributes, enabling easy access and manipulation of additional information tied to scalars, arrays, hashes, and even blessed objects. With OOB, developers can define globally accessible attributes and ensure that they are properly namespaced to avoid conflicts across different modules. Recent updates have improved test coverage and enhanced internal storage efficiency, ensuring that values are more likely to be stored by namespace rather than by value. This makes OOB a powerful tool for managing metadata in complex Perl applications.

The "load" Perl pragma provides developers with enhanced control over when subroutines are loaded, allowing for optimization of memory and CPU usage in applications. By using "load," module developers can specify whether subroutines should be loaded on demand, immediately at compile time, or not at all until needed, thus offering flexibility in resource management. This pragma serves as a more versatile alternative to existing modules like AutoLoader and SelfLoader, enabling application developers to choose the loading strategy that best fits their needs. Recent updates have improved compatibility and functionality, including fixes for issues related to thread handling and the introduction of AutoLoader emulation mode, making it particularly useful in mod_perl environments.

Mac::OSA::Notification::Tiny is a Perl module designed to facilitate the creation of native macOS notifications from scripts. With a simple interface, users can trigger notifications by specifying a title, subtitle, message, and an optional sound effect from a selection of predefined noises, such as "Purr" or "Glass." This module is particularly useful for developers looking to enhance user engagement by providing timely alerts or information through pop-up notifications. The initial release of this module was in 2021, marking its entry into the Perl ecosystem, and it continues to be a valuable tool for macOS users seeking to integrate notification functionality into their applications.

Term::ProgressSpinner is a Perl module designed to create visually appealing terminal progress indicators, enhancing user experience during long-running tasks. With this module, developers can easily implement progress spinners and bars that provide real-time feedback on task completion. It supports multiple customizable spinner styles and progress bar formats, allowing for a tailored appearance to fit various applications. Users can specify colors, widths, and messages, as well as manage multiple spinners simultaneously. The module also includes features for precision timing and output customization. Notably, recent updates have introduced enhanced precision settings for time and duration displays, making it easier to present progress information clearly and accurately.

Log::JSON::Lines is a Perl module designed for logging messages in the JSON Lines format, which is ideal for structured data processing and works seamlessly with Unix-style text processing tools. This module allows developers to create a logger instance that writes log entries to a specified file, supporting various severity levels from emergency to debug. Users can log messages as simple strings or as structured data using hash references, making it versatile for different logging needs. With options for pretty-printing and canonical formatting, Log::JSON::Lines enhances the readability and usability of log files, making it a valuable tool for applications that require efficient logging and data interchange.

Game::HeroesVsAliens is a Perl module that implements a simple tower defense game using the SDL (Simple DirectMedia Layer) framework. Designed for both casual gamers and developers interested in game programming, this module allows users to engage in strategic gameplay where they can build defenses against waves of alien invaders. The current version, 1.01, builds upon the initial release, which introduced the core gameplay mechanics. With its straightforward setup and engaging mechanics, Game::HeroesVsAliens serves as an excellent introduction to game development in Perl. Users can report bugs or request features through the provided channels, ensuring ongoing support and improvement for the module.

The JSON::Lines Perl module provides a straightforward way to parse and generate JSON Lines format, which is ideal for handling structured data in a line-by-line manner. This module allows users to easily encode Perl data structures into JSON Lines strings or files and decode them back into Perl structures, making it particularly useful for processing log files or facilitating communication between processes. With features like customizable encoding options, support for UTF-8, and the ability to read data one line at a time, JSON::Lines is a versatile tool for developers looking to work with JSON data efficiently.

The Termux::API Perl module serves as a wrapper for the Termux API, enabling developers to interact with various hardware features of Android devices directly from a Perl environment. This module allows users to perform a wide range of operations, such as accessing battery status, managing notifications, controlling the device's camera, and utilizing sensors, among others. With simple method calls, developers can easily integrate Android functionalities into their Perl scripts, making it a powerful tool for creating mobile applications without the need for rooting or complex setups. Notably, recent updates have introduced additional functions like audio_info, elf_cleaner, and speech_to_text, enhancing the module's capabilities for audio processing and file management.

Mac::OSA::Dialog::Tiny is a Perl module designed to facilitate the creation of native dialog alerts on macOS, allowing developers to easily prompt users for responses through simple dialog windows. With a straightforward interface, the module enables the display of customizable messages, titles, icons, and button texts, making it ideal for applications that require user interaction. By using the `dialog` function, developers can enhance their scripts with native macOS dialog functionality, streamlining user engagement in a familiar format. This module is particularly useful for Perl developers looking to integrate user-friendly alerts into their macOS applications.

The Blessed::Merge Perl module provides a powerful solution for deeply merging multiple blessed references, allowing developers to combine complex objects while maintaining their unique properties. With options to control the merging behavior, such as ensuring unique keys in hashes and unique values in arrays, users can customize how data is integrated. The module's functionality includes the ability to instantiate a new merging object, specify whether to allow non-blessed references, and prevent merging of identical references. This makes it particularly useful for applications that require the consolidation of data from various sources while preserving the integrity of the original objects.

Moonshine::Bootstrap is a Perl module designed to facilitate the integration of Bootstrap, a popular front-end framework, into web applications. With this module, developers can easily create responsive and visually appealing web pages by leveraging Bootstrap's components, such as navigation tabs and jumbotrons. The module provides a straightforward interface for generating HTML templates and adding Bootstrap elements programmatically, allowing for dynamic content creation. As of version 0.05, the module continues to evolve, enhancing its functionality and usability for developers looking to streamline their web development process.

Moonshine::Template is a Perl module designed to facilitate the creation of HTML templates by providing a structured approach to building and rendering HTML elements. It allows developers to define a base HTML structure and customize it through subclassing, enabling the addition of various HTML components such as headers, titles, and body content. With methods like `build_html` and `base_element`, users can easily manage the hierarchy and attributes of HTML elements, making it suitable for applications that require dynamic HTML generation. The module supports configuration options for advanced users, while its straightforward syntax ensures that even those new to templating can quickly grasp its functionality.

The `Moonshine::Component` module serves as a foundational base for creating HTML components in Perl, enabling developers to build reusable and customizable UI elements with ease. With version 0.09, it allows for the definition of component-specific behaviors and properties, such as modifiers and rendering methods, exemplified by the `Moonshine::Component::Glyphicon` subclass that generates Bootstrap glyphicon elements. This module leverages utility functions for class management and argument handling, streamlining the process of component creation. Notably, recent updates have focused on improving dependencies and ensuring compatibility, enhancing the overall stability and functionality of the module.

Moonshine::Parser is a Perl module designed for parsing HTML content into structured elements, making it easier for developers to manipulate and analyze web data. With a simple interface, users can create a new parser instance and utilize the `parse` method to convert raw HTML into a more manageable format. This module is particularly useful for web scraping, data extraction, and any application that requires handling HTML documents efficiently. Developed by Robert Acock, Moonshine::Parser is open-source and available under the Artistic License (2.0), ensuring flexibility for modification and redistribution.

Moonshine::Util is a Perl module designed to provide a collection of utility functions for handling HTML and string manipulation tasks. With a focus on simplifying common operations, it includes methods for validating HTML5 tags and their attributes, as well as various string trimming functions to clean up whitespace. Additionally, it offers functionality for managing class attributes and truncating strings with ellipses. The module is easy to use, allowing developers to import specific functions as needed, enhancing code readability and maintainability. Notably, recent updates have expanded its capabilities, including the addition of the `elide` function for more sophisticated string truncation.