CPANscan

Spreadsheet::Edit is a Perl tool for loading, inspecting, transforming and saving tabular data from CSV files or common spreadsheet formats with a friendly, scriptable API. It gives you a sheet object and a functional interface where each row behaves like both an array and a hash so you can refer to columns by index, letter, title or user-created alias. Typical uses include scanning or applying a block to every data row, random access, inserting, deleting, moving or splitting columns, sorting rows, transposing tables, and writing back to CSV or spreadsheet files. For convenience it can tie package variables to columns so you can write mail‑merge or row-oriented code that reads and writes column variables directly. The module also auto-detects title rows, CSV encodings and column formats and recent improvements focus on safer CSV handling and format detection so values like leading-zero zip codes survive round trips to spreadsheet formats. One practical caveat is that reading non-CSV spreadsheets relies on external tools and can fail if LibreOffice/OpenOffice is running, so CSV input is the most robust option.

Test::Mockingbird is a Perl testing utility that makes it simple to replace and observe parts of your code so you can write focused unit tests. It provides mocking to swap in custom implementations, spies that record every call and its arguments, dependency injection to substitute collaborators, and scoped guards that automatically restore mocks when they go out of scope. Handy helpers let you make a method always return a value, throw an exception, yield a sequence of values, or act only once, and there are unmock, restore, and restore_all routines to clean up test state. Non‑intrusive diagnostics give a readable and structured view of active mock layers and where they were installed to help debug complex test setups. In the recent 0.09 release mock_scoped was fixed so it no longer creates duplicate diagnostic entries and now supports multi‑method guards that restore several mocks atomically, making scoped mocking more reliable and convenient.

IRI is a Perl module that implements Internationalized Resource Identifiers (IRIs) as defined by RFC 3987 and makes it easy to parse, serialize, inspect and resolve IRIs in your code. It gives you an object you can query for scheme, host, port, user, path, query and fragment, resolve relative IRIs against a base, obtain or set query form data, and produce absolute or relative string forms. The module can defer parsing until a component is actually accessed to save work on simple use cases, and it includes helpers like query_form and set_query_param for manipulating query data and rel to compute a relative IRI. Use IRI when you need robust handling of non-ASCII URLs, link resolution, or IRI normalization in web applications or tools. Recent maintenance updates fixed a trailing-newline parsing bug and corrected packaging metadata, and earlier releases added lazy parsing and relative-IRI support.

Graphics::Framebuffer is a Perl library for drawing directly to a Linux console framebuffer, giving you pixel plotting, lines, shapes, gradients, image blitting, TrueType text and simple animation without the overhead of X. Its methods take hashref parameters and cover everything from single-pixel plotting and clipping to filled polygons, rotated and scaled blits, color conversions and basic mouse polling, while optional Imager and Inline::C acceleration speed up heavy operations. The module runs in exclusive graphics mode on framebuffer devices and will fall back to an emulated in-memory screen for development, but it will not work inside X/Wayland and prefers open source drivers such as Nouveau rather than proprietary DRM drivers. It is CPU bound in pure Perl so 24/32 bit modes and enabling acceleration improve performance, and the author documents caveats for functions like flood fill and TTF rendering. If you need simple, low-level console graphics for embedded Linux, media players or kiosks, this module is a practical, well documented choice.

Router::Ragel is a high-performance URL router that compiles route patterns into a single Ragel-generated finite state machine and emits C via Inline::C so matching is a fixed-cost DFA walk rather than a per-route regex scan. It supports static segments, named placeholders, typed constraints and inline placeholders inside segments, and you can use a function form of match to minimize call overhead. You must call compile to build and dlopen the generated machine before matching, and for best deployment behavior you should compile in the parent process or warm the Inline::C cache to avoid per-worker compilation. The router matches byte strings exactly and requires patterns to start with "/", it treats UTF-8 strings as bytes, adding routes after compile invalidates the compiled matcher and requires recompilation, and pattern validation is strict. Recent 0.02 adds typed and inline placeholders and tighter compile-time validation.

Attean is a Perl Semantic Web framework that provides a unified API for parsing, storing, querying, and serializing RDF and SPARQL data. It is plugin driven so you can pick different store, parser, and serializer implementations by name, filename extension, or media type, and it includes a ready-to-use in-memory store and temporary models for quick work. The library handles streaming iterators of triples and quads, can attach graph names to triples, and evaluates SPARQL algebra against models to return bindings or result sets. For web services it can negotiate content types with HTTP::Negotiate and produce Accept header strings that reflect available parsers. Developers can also register global SPARQL functions, functional forms, aggregates, and datatype roles to extend evaluation behavior. If you need to work with RDF data in Perl, convert between formats, store quads, or run SPARQL queries, Attean gives a cohesive and extensible toolkit.

CPAN::Maker is a command-line tool that automates turning a Perl project into a CPAN distribution using a YAML "buildspec" file. It can scan your code for module dependencies, generate a Makefile.PL with META information and dependency lists, collect modules, scripts, tests and extra files into a tarball, and call a provided bash helper to complete the build, while offering options to include or omit core modules, add version constraints, and preserve the generated Makefile or skip tests via environment variables. The tool includes a validate command that checks buildspec.yml against a JSON schema so you can catch errors early in CI and a write-makefile path that emits Makefile.PL when you want to inspect or modify it manually. Recent 1.9.0 improvements refactor autoconf handling into a CPAN::Maker::Bootstrapper, add a formal buildspec schema and polish CLI behavior to make automated, repeatable builds and validation more reliable.

File::Process is a small Perl utility that removes the repetitive open/read/close boilerplate when you need to read and transform text files. It provides a single exported function process_file that accepts a filename or filehandle and a set of options and runs a sequence of customizable hooks — pre, next_line, filter, process and post — so you can chomp, trim, skip blank or commented lines, merge lines, or inject custom per-line logic without reimplementing file-handling each time. The function returns the accumulated lines (or a merged scalar) plus any metadata collected during processing and includes convenience support and examples for common tasks such as CSV or JSON handling with Text::CSV_XS and decode_json. It is aimed at moderately sized files because it typically accumulates lines in memory and the hook-based approach is not as fast as raw slurping for very large data sets. This package ships as the initial 1.0.0 release and includes a companion File::Process::Utils module plus basic tests and build files.

File::Raw::Base64 is a compact plugin for File::Raw that registers two filters, "base64" and "base64url", so you can encode or decode Base64 directly when using file_slurp and file_spew. It supports common options such as wrap width and end-of-line style, URL-safe alphabet and optional padding, and a PEM mode that strips or emits BEGIN/END markers with a configurable label. Decoders tolerate missing padding by default and can be made strict to reject unexpected bytes, and the module performs in-memory, per-call conversions rather than streaming, which matches the typical single-call file I/O use case. Use it when you want convenient, configurable Base64 handling integrated with File::Raw, including PEM and JWT-style variants.

File::Raw::Separated is a compact, high-performance CSV and TSV parser that plugs into the File::Raw I/O layer to give you both simple in-memory parsing and a streaming API for files larger than RAM. It exports parse_buf/parse_buf_each/parse_stream (and dialect-pinned csv_* and tsv_* variants) as file_<name> functions when imported, and also registers "csv" and "tsv" plugins so you can call file_slurp with plugin => 'csv' or 'tsv' to get an array of rows or an array of hashes when header mode is enabled. You can control separators, quoting, backslash escapes, line ending handling, trimming, empty-field semantics, strictness on malformed input, and a per-field max byte length, and the stream reader reads in fixed-size chunks so memory use is bounded by the read buffer plus the largest field. Callback-based APIs reuse a single arrayref per row for efficiency so copy rows if you need to keep them, and strict mode will croak with a helpful byte-offset on malformed input. The module is a first release and currently only implements the read side and File::Raw plugin registration while write/record phases are planned for future versions.

RTIR-Extension-MISP is a plugin for RTIR that connects your incident response system to a MISP threat‑intelligence instance so you can ingest events, view event details on incident pages, and create or update MISP events directly from RTIR tickets. After configuring the MISP URL and API key it adds a MISP feed to the External Feeds page, a MISP Event Details portlet on incidents when a MISP ID is present, and Actions to create or update events so incident data and indicators can be pushed to or pulled from MISP. The extension supports custom field groupings for showing MISP IDs and includes Mason callbacks to let you tailor what data is sent and how results are handled. It is written for RTIR 5.0 and requires the usual plugin installation and configuration in RT_SiteConfig.pm. A recent release added BeforeMISPSync and AfterMISPSync callbacks to make customization of the create/update sync easier without modifying the extension code.

File::Raw is a performance-focused Perl module that replaces many common file and directory operations with direct system calls to make reading, writing, copying and metadata queries much faster than PerlIO. It exposes convenient functions like file_slurp/file_spew and file_append, memory-efficient line operations including a fast callback-based each_line and a lines iterator, zero-copy reads via file_mmap_open, atomic_spew for safe writes, and native-optimized copy/move operations. The module also provides stat with an internal cache to avoid repeated syscalls, a full suite of file tests and path helpers, directory utilities and recursive mkpath/rm_rf, plus hooks so you can transform data on read or write and an XS API so other C extensions can register hooks without Perl callback overhead. Functions are imported with a file_ prefix for low-overhead calls. If you need faster IO on large files, streaming line processing, memory mapping, atomic updates or C-level integration, File::Raw is directly relevant, and recent releases improved portability and added path and recursive directory helpers while fixing build issues on Solaris and Windows; remember to call clear_stat_cache when external processes may have modified files.

Music::ScaleNote is a small utility for moving a note around within a musical scale and returning the resulting note as a Music::Note object. You give it a scale start, a named scale and a starting note and it computes the note a given number of scale steps away with get_offset or a given number of chromatic half steps with step. It understands common note formats such as ISO names and MIDI numbers and can be told to prefer flats or sharps. This makes it handy for tasks like programmatic transposition, algorithmic composition, or generating scale-based melodies without dealing with interval math yourself.

Mojolicious is a modern real-time web framework for Perl that provides a batteries-included toolkit for building web apps and APIs quickly. It offers a simple RESTful router, a built-in nonblocking web server and user agent, a Perl-friendly templating system, content negotiation, session and cookie handling, form validation, static file serving, hooks and helpers for extending behavior, and a plugin and command system for reusable features. The framework includes testing support, strong Unicode handling, and thorough guides to help you prototype or scale production applications. Be aware that the default secret passphrase is intentionally weak and should be replaced for secure signed cookies and sessions. If you develop web software in Perl and want a full-featured, extensible framework with real-time capabilities, Mojolicious is a good fit.

HTTP::Tinyish is a lightweight compatibility wrapper that gives you the HTTP::Tiny API while transparently using whatever HTTP client is available on the system—LWP, HTTP::Tiny, curl or wget—so your code can perform get, post, put, delete, patch, request and mirror operations even in restrictive environments. It auto-selects backends and detects HTTPS support, translates common options like timeouts, redirects, headers and user agent, and is especially handy for tooling that must fetch CPAN modules or other resources on machines where the built-in Perl HTTP stack lacks SSL or where only command-line clients are present. The module documents backend-specific caveats such as LWP needing LWP::Protocol::https for HTTPS and older wget versions not supporting custom methods, and it translates backend behavior into HTTP::Tiny-style responses. Recent updates fixed mirror() for the curl and wget backends so failed downloads no longer leave local files and HTTP error codes are reported correctly.

Rose::DB::Object is a mature, high-performance object-relational mapper for Perl that maps individual database rows to rich Perl objects and gives you metadata-driven control over tables, columns, keys and relationships. You can declare classes manually or let it auto-discover schema information, work with one-to-one, one-to-many and many-to-many relationships, lazy-load columns, inflate and deflate values into convenient Perl types, and use the companion Manager to build complex queries, iterate results efficiently, count, update and delete matching rows. It supports multiple databases through Rose::DB but requires tables to have non-null primary keys, and it is designed to be extensible so you can add custom column types, triggers and primary key generators when needed. The distribution also includes a Loader to auto-generate classes from an existing schema and helpers for cascaded saves and deletes across related objects, all within configurable transactions. Recent updates improve compatibility with newer DBD::Pg behavior and MySQL ONLY_FULL_GROUP_BY settings and modernize internals such as replacing List::MoreUtils with List::Util. If you need a powerful, well-documented ORM with fine-grained metadata control and strong cross-database behavior, Rose::DB::Object is worth evaluating and you can start with Rose::DB::Object::Tutorial for a quick introduction.

Rose::DB is a practical wrapper around DBI that gives you a higher-level way to define and use logical data sources instead of raw DSNs, manage DBI handles, and handle database-specific value parsing and formatting. You register named data sources (by domain and type) or load them from small config files, then instantiate a Rose::DB object to get a driver-specific subclass and a connected DBI handle when you need it. It provides handle lifecycle management with retain/release semantics, simple transaction helpers including a do_transaction block, and vendor-aware conversions for dates, times, booleans, bitfields, intervals, and related types. The module supports common drivers such as PostgreSQL, MySQL/MariaDB, SQLite, Informix, and Oracle and is designed to be subclassed for custom behavior. It is not an ORM, so if you want object-relational mapping use Rose::DB::Object, and be aware of a serialization caveat that requires preloading registered data sources before thawing objects across processes.

RT::Extension::ToggleTheme is a lightweight plugin for Request Tracker 6 that adds a simple light/dark theme toggle to the web interface so users can switch to dark mode for easier nighttime use. The button is shown only to users who have the ModifySelf right and appears in both the main and self-service navigation areas. It performs instant client-side switching by toggling data-bs-theme on the html element and relies on RT 6's native dark-mode styling and icons for a clean, integrated experience. Installation is done via the RT plugin mechanism and requires adding the plugin and refreshing the Mason cache or restarting the webserver. Recent updates include a rewrite to support RT 6 and Bootstrap 5 plus a small fix to avoid a keyboard-shortcuts.js error.

Net::Silverpeak::Orchestrator is a Perl client library for talking to the Silverpeak Orchestrator REST API that makes it easy to script common tasks such as authenticating with an API key or user/password, listing and managing template groups, appliances and appliance groups, address and service groups, domain and application groups, VRF configurations and security policies, BGP and IP SLA data, backups and other Orchestrator resources. The module exposes straightforward create, read, update and delete methods plus helpers for appliance-specific REST calls and handles API endpoint changes introduced in Orchestrator 9.3 while recent updates add appliance REST passthrough methods and compatibility fixes for newer Orchestrator releases. It also includes convenience features like explicit login/logout and automatic logout when the object is destroyed. Be aware of a known Orchestrator server issue on versions before 9.0.4 where API key authentication can return HTTP 500 unless the key has an expiration date set.

Geo::Leaflet is a Perl helper that builds complete Leaflet JavaScript map pages from Perl code, so you can programmatically produce interactive maps without handcrafting the HTML and JS. You create a map object, set its id, center, zoom and dimensions, and then add common map pieces like a tile layer (defaults to OpenStreetMap), markers, custom icons including Font Awesome divIcons, polylines, polygons, rectangles and circles. The module exposes simple constructors that mirror the Leaflet API and then emits the finished HTML and scripts via an html method you can print or embed. It includes sensible defaults for center, zoom and sizing, and uses HTML::Tiny and JSON::XS internally to generate clean output. Use Geo::Leaflet when you need to generate web-ready interactive maps from Perl quickly and with minimal JavaScript knowledge.

File::Unpack2 is a Perl library and command line tool that detects and recursively unpacks a wide range of archive and packed file formats by analyzing MIME types instead of trusting file extensions. It supports tar, zip, gz, bz2, lzma, 7z, rar, rpm, deb, cab, cpio, iso, pdf, ODF and many more, can descend into nested or multiply wrapped archives to expose all payload files, and lets you add external shell-script helpers to handle new mime types. The module combines libmagic and shared-mime-info to provide multi-level MIME recognition so common cases like tar+gzip are handled efficiently, and it produces a JSON logfile that records every unpacked item and related metadata. You can control destination directory, file size limits, symlink behavior, file permissions and other safety guards, and the recent 1.1 release fixed cleanup of temporary archives created during unpacking. The author notes the MIME-detection code is somewhat complex and the built-in helper set is not exhaustive, but overall File::Unpack2 is a robust solution when you need content-aware, recursive extraction rather than simple suffix-based unpacking.

Business::ISBN::Data is a data-only companion for Business::ISBN that supplies the official ISBN range information used to validate and decode group and publisher ranges. You normally do not load it yourself because Business::ISBN will auto-load it, and it requires Business::ISBN 3.005 or later to accommodate fixes for ISBN-13 prefixes. The module ships a copy of the ISBN RangeMessage.xml and also contains embedded fallback data if that file is missing, and you can point the module at an alternate RangeMessage.xml by setting the ISBN_RANGE_MESSAGE environment variable or by placing the file in the current working directory so bundled apps can find it. If you need newer ranges you can include an updated RangeMessage.xml in your installation or regenerate the default data with the provided script, and the code and data are maintained on GitHub for contributions and updates.

Minima is a lightweight PSGI web framework that uses Perl's new native class system to give you a minimal, fast foundation for web applications. It follows an MVC-like approach without enforcing one, so controllers can use Plack request and response objects directly and you can pick any view system, with built-in support for Template Toolkit if you want it. Routes are defined in a simple routes.map file and the distribution includes a command line helper to create and manage projects and an easy init entry point for Plack. Recent updates in v0.8.0 add convenient route-level redirect commands, session-backed flash messages for one-time notices, and an API to access the configured not_found route, making common tasks like redirects and transient user messages simpler to implement. Minima is best for developers who want a modern, unobtrusive Perl framework that provides the essentials without getting in the way.

MARC::Validator is a small Perl utility for developers and library technologists that discovers and lists installed MARC validation plugins so you can build or run checks on MARC bibliographic records. It uses Module::Pluggable to find modules named MARC::Validator::Plugin::* and exposes a single plugins method that returns the available plugin module names, making it easy to assemble a modular validation workflow or to display which rule sets are present in an environment. If you work with MARC records and want a lightweight, pluggable way to manage field-level validators this module is directly relevant.

DateTime::Lite is a lightweight, low-dependency drop-in replacement for DateTime that gives you the same familiar API for creating, formatting, comparing, and doing calendar arithmetic with datetimes while using less memory and loading faster in short-lived scripts. It provides accurate IANA timezone handling by reading TZif binaries compiled with the official zic tool and ships a compact SQLite timezone database with options for coordinate-based lookup and BCP47 -u-tz- locale inference, full Unicode CLDR locale support via DateTime::Locale::FromCLDR, and XS-accelerated math for the hot calendar paths. The module aims to behave like DateTime so existing code usually works unchanged, avoids dying on normal error paths by returning exception objects, and includes a pure-Perl fallback for environments without a C compiler. If you need fast startup, modern timezone rules, flexible locale-driven time zone selection, or a smaller dependency footprint for command line tools and batch jobs, DateTime::Lite is likely relevant. The recent v0.6.6 release tightened the XSLoader fallback and fixed several issues in the pure-Perl fallback so the module now degrades cleanly on platforms with older compilers and the pure-Perl path is more complete and robust.

Sys::GetRandom::PP is a pure-Perl wrapper around the kernel getrandom(2) call that lets Perl code obtain random bytes directly from the kernel RNG without opening /dev/urandom or loading a C extension. It exports getrandom, which fills a scalar with up to a requested number of bytes and returns the number generated or undef on error, and random_bytes, which returns a string of 0 to 256 random bytes, along with the GRND_RANDOM and GRND_NONBLOCK flags to select /dev/random or nonblocking behavior. By default it behaves like reading /dev/urandom and may block until the kernel RNG is initialized, larger reads can be interrupted by signals, and the wrapper enforces the 256 byte limit for the convenience function. It mirrors the interface of the XS Sys::GetRandom module but is implemented in pure Perl for easier installation and works on Linux and FreeBSD.

Params::SomeUtil is a compact toolkit of importable functions for robustly validating arguments and data in Perl programs, aimed at the edges of your API where untrusted input arrives. You pick the small checks you need, such as _SCALAR, _ARRAY, _HASH, _INSTANCE, _CLASS, _NUMBER, _CODELIKE, _REGEX, _HANDLE and _DRIVER, and each returns the validated value on success or undef on failure so you can fail fast and clearly. The checks are conservative, well documented and heavily tested so they behave predictably with odd or malicious inputs. This distribution is a maintained fork of Params::Util that fixes several long-standing bugs and preserves the original XS behaviour, so nothing is exported by default and you must explicitly request symbols. Note that the XS components are unchanged from the upstream release which can mean a C compiler is needed to install on some systems.

XS::JIT is a lightweight runtime JIT compiler for embedding C/XS code into Perl programs that need to generate and load C code on the fly. It takes your C source that uses the Perl C API, compiles it with a direct compiler invocation, and installs the resulting functions into Perl namespaces with optional caching to avoid recompilation. Compared with Inline::C it avoids heavy parsing and xsubpp, which makes initial compilation and subsequent loads faster, and it provides a C API and helper methods so other XS modules or build systems can integrate with it. The module supports both simple SV* wrapper-style functions and XS-native functions for maximum performance, supplies convenience macros and Inline::C compatibility shims, and returns the necessary include and linker flags for Makefile.PL. Use XS::JIT when you want fast, minimal-overhead runtime compilation of generated C code; if you need the broader feature set of Inline::C you may prefer that more feature-rich alternative.

Game::HexDescribe is a Mojolicious::Lite web application that turns hex maps into coherent, table-driven descriptions by applying recursive random tables that respect neighboring tiles so features like rivers and forests can span multiple hexes. It integrates with Text Mapper to generate or render maps and can accept built-in or external rule tables, pasted table text, or a pure text input mode for use as a general random text generator. The app is configurable via a hex-describe.conf file, exposes simple URLs for editing, generating random maps, rendering descriptions as HTML or Markdown, and running without a map, and it can optionally include or omit images and embedded SVG links so map tiles and descriptions stay linked. Command line usage is supported for automated workflows and the distribution includes several ready-made table sets such as Schroeder, Seckler, Strom, Johnston, and Traveller. Recent changes add a "closest" keyword, tweak the behavior of the "same" rule, extend arithmetic operators, and provide an option to hide the map in output, making it more flexible for game designers and worldbuilders who want automated, spatially consistent prose rather than isolated random entries.

Game::TextMapper turns a simple, human-readable text description of a hex grid into a fully editable SVG map, making it easy to design landscapes, settlements, roads, rivers, and decorative shapes for role playing or worldbuilding. You define hex types, SVG attributes, labels, icons or arbitrary SVG fragments and even closed paths for large areas, and the tool supports includes, reusable libraries, transparency, URL-linked labels, and multiple map-generation algorithms and style libraries so you can generate random maps or import curated icon sets. It works from the web or the command line and produces SVG you can view in a browser or refine in Inkscape, with configuration options for libraries and logging. Recent updates added Gazetteer icons and improved parsing of Traveller UWP data, making it handier for genre-specific map types.