CPANscan

GDPR::IAB::TCFv2 is a Perl parser for IAB TCF version 2 consent strings that decodes a base64url encoded Transparency & Consent string into an easy to use, immutable object so you can read who gave consent, when and for what. Use Parse to validate and load a TC string and then call methods to fetch metadata like version, creation and update timestamps, CMP id and version, consent language and vendor list version. The object exposes checks for purpose consent and legitimate interest, vendor consent and legitimate interest, special feature opt ins, purpose one treatment, publisher country and publisher restrictions, and it can decode a Publisher TC section when present. Parse supports a strict mode for format validation, a prefetch option to help with range-based vendor sections and a configurable TO_JSON output to produce compact or verbose JSON with customizable date and boolean formats. The module will die on invalid input but otherwise gives a convenient API for integrating TCFv2 checks into applications that need to respect consent signals. Recent releases added a unified subcommand CLI and fixed a CLI parameter bug along with improvements to the CLI help and overall quality checks.

File::Raw::Gzip is a lightweight plugin that adds transparent gzip/zlib/raw-deflate support to File::Raw, letting you read compressed files as regular strings and write compressed files with a single option. Once loaded it registers the "gzip" plugin so file_slurp/file_spew and similar File::Raw helpers will automatically inflate on read or deflate on write, with configurable compression level, mode (gzip, zlib, raw or auto for decoding), chunk size and advanced tuning like strategy and memory level. It also supports streaming each_line over compressed files without slurping the whole file and composes cleanly with other File::Raw plugins for slurp/spew chains, although per-record dispatching is not applicable to gzip streams. The module is a thin binding to libz so you need the system zlib development package to build, and version 0.01 is the initial release.

Test::SPDX::Coverage is a small test-harness helper for Perl projects that scans the files listed in your MANIFEST and checks that each matched source file contains a SPDX-License-Identifier comment and that the identifier is valid according to the License::SPDX database. You drop it into your test suite and call spdx_coverage_ok(), and it will read your MANIFEST for files matching a pattern (by default .pm, .pl, .cgi), look for a line like "# SPDX-License-Identifier: MIT" within the first N lines, and validate the declared license string via License::SPDX. The exported spdx_coverage_ok function accepts options such as which manifest to use, the filename match regex, how many lines to scan, and a diagnostic level. This module is useful for projects that want automated, CI-friendly checks that source files carry proper SPDX metadata and is distributed under the MIT license.

Geo::Address::Parser::Country is a Perl module that normalizes the last comma-separated component of a place string into a canonical country name. It is built to tolerate messy, abbreviated, or historical place names often found in genealogy data and poor-quality imports. Resolution starts with a direct lookup of common variants and historical names, then checks US states, Canadian provinces in English and French, and Australian states via Locale::US, Locale::CA and Locale::AU, and finally falls back to Locale::Object::Country and optionally Geo::GeoNames if you supply one. You construct the resolver with prebuilt locale objects and resolve() returns a hashref containing the resolved country, the possibly amended place string, an array of warnings, and an unknown flag instead of emitting errors. Note two documented caveats: the direct lookup maps "NL" to Netherlands which can conflict with the Canadian province code for Newfoundland and Labrador, and Geo::GeoNames uses AUTOLOAD which may cause simple constructor validation to reject a real Geo::GeoNames object unless you wrap or subclass it.

Graphics::Toolkit::Color (GTC) is a high-level Perl API for creating, converting and composing colors and palettes as immutable objects. It accepts many input forms including CSS and named colors, hex codes, numeric tuples and custom ranged or raw values, and it can output values in multiple formats or canonical names. You can measure perceptual distance, check if a color is in gamut, convert between spaces, and produce related colors such as mixes, gradients, complements and clusters for palette generation. The module defaults to RGB for screen work but supports many perceptual and wide-gamut spaces, and the recent 2.1 release added a large set of professional color spaces plus improved gamut checking and raw value handling for advanced workflows. Lightweight helpers color and is_in_gamut are exportable for quick scripting and optional external color-name modules extend available naming schemes.

CGI.pm is a long‑standing, full‑featured Perl module for building classic web scripts that need to parse form input, handle file uploads, read and write cookies, emit HTTP headers and redirects, build and preserve query strings, and inspect common request environment variables. It works in plain CGI as well as under mod_perl and FastCGI, is battle‑tested on thousands of sites, and offers both object and function styles so you can fetch params, generate headers, and save or restore script state with simple calls. The distribution has been removed from the Perl core so you must install it separately, and its built‑in HTML generation helpers are no longer maintained so template engines are recommended for page rendering. CGI.pm still provides useful protections and hooks for upload handling, POST limits, and debugging, making it a solid choice for maintaining legacy CGI apps or writing simple server scripts, while newer web frameworks are generally preferred for modern, scalable application development.

DBIx::Lite is a lightweight, chainable ORM for Perl that lets you build SQL and work with database rows using simple method chains without requiring a full schema upfront. It can run disconnected to just generate SQL or connect to a database via DBI/DBIx::Connector and supports lazy SQL generation, joins, relationships, automatic column accessors, paging with Data::Page and SQL::Abstract style conditions. You can provide a DBI handle or connection info, and optionally declare primary keys and relationships in a small schema to enable convenience methods like find and insert_related. The module aims to give most of the useful ergonomics of a full ORM while staying minimal and easy to adopt for scripts and applications that want expressive query construction without the overhead of heavier systems.

Crypt::SecretBuffer gives you a SecretBuffer object for holding sensitive byte data outside Perl's normal scalar heap so passwords and keys are less likely to be copied into logs, temporary buffers, or long-lived memory. The buffer lives in XS memory that Perl does not normally inspect, is wiped before being freed or reallocated, and is engineered to let you read from TTYs with echo disabled, feed secrets to external commands via pipes without creating Perl scalars, and hand raw bytes directly to XS code via unmasking helpers or a C API. It also provides convenient and safe-ish operations for manipulating secrets such as splice, substr, length-prefixed encoding, file IO, a memcmp that runs in constant time relative to the shortest input, and Span objects for parsing, while stringification is masked by default to avoid accidental exposure. The module is explicit that this reduces accidental leakage rather than making Perl the ideal environment for long-lived secret management, and recent 0.024 changes add timeout, resumable state, and utf8 support to append_console_line, add a len alias for length, and expand scan character class parsing while noting a semi-breaking C API signature change for callers that compiled against the headers.

Plack is a lightweight Perl toolkit that implements the PSGI specification and acts as the glue between web applications, frameworks and web servers. It gives you server adapters so the same app can run under CGI, FastCGI, Apache or standalone servers, a loader and plackup command to run .psgi application files, a middleware system and a small builder DSL to stack common features like logging, static file serving and compression, and convenient Request and Response wrappers to work with the PSGI environment. Plack also includes testing helpers to exercise applications with real HTTP requests without starting external servers which makes development and debugging easier. If you build or deploy Perl web apps or frameworks Plack lets you mix and match servers and middleware and standardizes how apps are run and tested. Note that the project recently deprecated Plack::Middleware::XSendfile due to security design concerns so check the changelog for migration guidance.

Win32::EventLog lets Perl programs interact with Windows Event Logs so you can open, read, back up, clear and write event records from scripts. It exposes an EventLog object with methods to connect to local or remote logs, read entries sequentially or by offset, back up or clear a log and report new events, and it provides a helper to format an entry's message text. The module understands Windows concepts like event type, category, event ID, raw data and insertion strings and exports useful constants to simplify code. It is a practical tool for Windows system administrators and developers who need to automate log collection, auditing or alerting with Perl. Recent fixes improved read reliability by correcting a skipped-record bug in sequential reads and by refactoring read caching for seek mode.

Win32::NetAdmin is a Perl module for administering Windows network accounts and groups from scripts, letting you create, delete and modify users and groups, check membership, change passwords, and enumerate domain controllers, servers, transports, logged-on users and local drives. Most functions accept an optional server name so you can target the local machine or a remote host, and they return false on failure with Win32::NetAdmin::GetError() available to retrieve the Windows error code. This module is useful for automating Windows account and group management but many operations require administrative privileges on the target machine. The project is actively maintained and the latest release fixes a memory leak and improves build and test reliability on Windows Server.

Win32 is the standard Perl interface to many Windows API routines, giving Perl scripts easy access to Windows-specific functionality without writing C or XS code. It wraps common tasks such as creating and copying files and directories, converting and querying path names (long, short, ANSI and Unicode), getting OS and filesystem details, reading process and thread IDs, inspecting privileges and administrative status, working with console code pages and system metrics, generating GUIDs, initiating shutdowns, showing message boxes and even a simple HTTP file downloader. The module is useful whenever you need to query or control aspects of the host Windows environment from Perl, and it includes some higher-level helpers like GetOSName/GetOSDisplayName and GetFolderPath. Be aware that path-related functions may return Unicode or ANSI names and that short (8.3) path support is system- and volume-dependent so results can vary on modern Windows, and a few legacy entry points are deprecated. Recent updates modernize packaging and documentation and improve detection of newer Windows releases and CPU architectures.

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.

CLI::Simple is a lightweight, object-oriented base class for building Perl command-line tools that need a simple, predictable lifecycle for option parsing, subcommand dispatch, and positional arguments. It embraces the modulino pattern so the same module can be used as a library or executed as a script, automatically creates getter/setter accessors for options, integrates with Log::Log4perl including per-command log levels, and exposes a simple init hook for startup validation. For larger projects it supplies an optional role-based workflow driven by a YAML manifest and includes migration and scaffolding helpers such as -dump-spec to generate a manifest, -scaffold to produce role stubs and a project tarball, and -generate-completion to emit a bash completion script. You define Getopt::Long-style option specs, add aliases for options and commands, and extend internal commands as needed, making it a good fit for small admin tools and bootstrapped CLIs that want structure without a heavy framework. The 2.0.1 release primarily tightens build tooling and reduces dependencies by switching manifest loading to YAML::Tiny while keeping the role and scaffolding features intact.

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.