CPANscan

File::Rotate::Simple is a lightweight, no-frills Perl utility for rotating files by renaming them with numeric suffixes so you keep a simple set of backups. It can increment existing rotation numbers, limit kept files by count or by age in days, and is usable via an object interface, a legacy method call, or an exported function for quick scripts. You can customize the starting number, apply timestamped extensions using strftime with a special %# placeholder for the rotation number, replace or append extensions to preserve original suffixes, and optionally touch the file after rotation. The time attribute accepts Time::Piece and, since v0.4.0, DateTime::Lite and DateTime::Tiny objects. The module intentionally keeps behavior simple and does not track or fill gaps in rotation sequences. Recent changes include enhanced time object support and a security fix to avoid touching destinations of dangling symlinks when rotating (CVE-2026-17435). Note that current releases require Perl 5.14 or later and older Perl users should use the v0.2.x series.

Params::Get provides a single helper, get_params, that turns whatever a Perl caller might hand your subroutine into a consistent hash reference so you can write one simple normalisation call at the top of each public method instead of reimplementing argument parsing over and over. It understands the common Perl styles including a lone hashref, named key/value pairs, a single scalar tied to a default key, an arrayref shorthand or \@_, scalarrefs, CODE refs or blessed objects, and an arrayref of positional key names, and it pairs nicely with Params::Validate::Strict and Return::Set to enforce input and output contracts. The function returns a hashref on success or undef in the documented empty case and will croak or confess on misuse so bugs are reported from the caller frame. Be aware of a few documented limitations such as the fast-path that treats a single hashref as the hash rather than as a value for a default key, ambiguity when a caller passes a single empty arrayref, silent overwriting of duplicate keys in flat lists, and the lack of a way to mark a scalar default as optional. The current 0.16 release tightens edge-case handling, removes some redundant checks, improves performance of common paths, and adds extended security and unit tests.

Perl::Tidy is a module that brings the perltidy formatter into your Perl programs so you can parse, beautify, and analyze Perl source from code rather than the command line. You can feed it files, strings, arrays or stream objects and capture output, errors and logs, pass command-line style options or a perltidyrc, and hook in prefilters, postfilters or a formatter callback to inspect tokenized lines for custom processing. It is useful for editors, linters, automated formatting in build and CI systems, or any tool that needs to rewrite or report on Perl code while preserving control over encoding and error handling. The distribution is mature and actively maintained and the 20260808 release fixes a rare tokenization instability around an eval/map pattern and improves here-doc handling and related warnings, making the formatter more robust for tricky edge cases. The module is distributed under the GNU General Public License.

Imager::Font::W32 brings Windows GDI font rendering to the Imager image library so Perl programs on Win32 can draw text using native Windows fonts. You obtain a font with Imager::Font->new specifying type => "w32" and then pass that font to Imager methods like string to render text onto images. It is intended for Windows-only use when you want native font appearance and metrics in generated images. Note that the module was renamed after older Imager releases could mistakenly report Win32 font support when an unrelated Win32.pm was present.

Imager::Font::FT2 is the FreeType 2 based font backend for the Imager image library that lets you load TrueType and other FreeType-supported fonts and draw text into images via Imager::Font (for example, Imager::Font->new(file => "foo.ttf", type => "ft2")). It is intended for anyone using Imager who needs reliable font rendering, including anti-aliased and non-aliased text, glyph names and related font queries, and relies on the system FreeType 2 library at build and runtime. The module has had a few packaging and build fixes to improve compatibility with newer FreeType releases and toolchains and to clean up warnings and memory-test issues, and there is a historical caveat that older Imager releases used a different module name which could confuse probe logic on systems without FreeType installed. If you use Imager and need robust font support from the system FreeType implementation, this module is the appropriate backend to choose.

Imager::File::TIFF integrates libtiff support into the Imager framework so Perl programs can read and write TIFF images, typically by calling Imager->read or Imager->write; it also provides class methods to list available TIFF compression codecs with their numeric ids and names and to report the libtiff build date, build version and runtime library version, which helps when choosing compression options or diagnosing compatibility.

Imager::File::PNG provides PNG image read and write support for the Imager toolkit, letting you load and save PNG files (including paletted, interlaced and 16‑bit/sample images) through Imager in a straightforward way. It exposes low level class methods to read and write PNG data from Imager::IO objects, which are useful for related formats that encapsulate PNG such as APNG or ICO and for other advanced embedding scenarios. The module also supports metadata handling and lets you control things like zlib compression level when writing files. Recent updates cleaned up build warnings and refreshed the bundled Devel::CheckLib helper to improve compatibility and compilation robustness.

Imager::File::JPEG is the Imager extension that adds robust JPEG read and write support to the Imager image toolkit, letting Perl programs load, save and control JPEG images from within Imager. It exposes high-level controls for common JPEG features such as progressive output, optimization, subsampling, smoothing and restart markers and it also surfaces more advanced libjpeg-specific knobs including arithmetic coding, JFIF header control and mozjpeg tuning and compression profile settings. The module reports which libjpeg variant it was built against and its version, and provides helpers to detect libjpeg-turbo or mozjpeg and whether encoding or decoding of arithmetic coding is supported so you can adapt behavior to the available library. It integrates EXIF and IPTC handling via Imager and the recent releases include security and stability fixes, including patched EXIF parsing issues and a memory-leak fix, making it suitable for projects that need reliable, configurable JPEG handling in Perl.

Imager::File::GIF is the GIF reader and writer plugin for the Imager Perl image library, letting Perl scripts load and save GIF images through the Imager object model. It plugs into Imager so you can use familiar Imager methods to handle GIF files, and detailed options and behavior are documented in Imager::Files. Use this module when you need simple, integrated GIF input/output support within Imager-based image processing.

Imager is a mature Perl image library for creating, manipulating and saving full color images in a wide range of formats. It makes common tasks easy from simple scripts such as resizing or thumbnailing to more advanced work like drawing primitives and text, alpha blending, color conversion, filtering and matrix transforms, and it can read and write PNG, JPEG, GIF, TIFF, ICO/CUR and many other formats via optional format handlers. You work with image objects created by Imager->new, call methods such as scale, crop, filter, paste and string, and then write the result to disk, so it is a good fit for web backends, batch image processing and small graphics tools where you want direct control from Perl. The project is actively maintained and recent releases include important security and robustness fixes to EXIF/JPEG/GIF/TIFF handling, so upgrading to the latest version is recommended.

Search::Trigram is a compact, in-memory trigram inverted-index for Perl that makes it easy to add UTF-8 documents and run fast fuzzy or substring-style searches. You add texts and get back numeric ids, then search with a query string to receive a ranked list of matches scored by the Dice coefficient over shared trigrams, with case-insensitive matching at the byte level and a default result limit of 10. The module supports marking documents deleted and reclaiming space with an optimize call, clearing the whole index, and querying counts of live documents and distinct trigrams. For extension authors there is a documented C ABI so other XS code can drive the same index without a Perl frame, and the ABI is designed to avoid cross-module memory and ownership pitfalls by keeping object lifetime in Perl and returning borrowed text pointers that are invalidated on mutation.

Catalyst::View::ChromePDF is a Catalyst view that renders HTML or Template‑Toolkit output to PDF by driving Chrome or a Chrome‑compatible browser through WWW::Mechanize::Chrome, making it a modern replacement for Catalyst::View::Wkhtmltopdf. You configure it in your app and stash a pdf hash with either a template or raw HTML and options like page size, orientation, download disposition and filename, or you can pass an existing mechanize instance or chrome launch arguments. It intentionally mirrors familiar wkhtmltopdf settings where possible while noting some differences such as lowercase orientation and the need to supply Chrome launch executable via chrome_args, and it currently does not support margins, DPI, or image quality options. Be aware that temporary HTML and PDF files are written to tmpdir and may remain after failures or when returning filehandles so you should arrange periodic cleanup for sensitive data. The module requires Perl 5.24 or newer and the source and issue tracker are on GitHub.

Sidef is a modern, multi-paradigm programming language packaged as a Perl module so you can embed, compile, optimize, and execute Sidef code from Perl and reuse the entire CPAN ecosystem. It blends object-oriented and functional features with a rich numeric type system that includes arbitrary-precision integers, rationals, floats and complex numbers, and it offers conveniences like pattern matching, lazy evaluation, multiple dispatch, a REPL, AST-level parsing and transformation, and the ability to compile Sidef to readable Perl for inspection or high-performance deployment. The module supports multi-level optimization and optional DBM-backed caching to speed repeated runs and can use GMP/MPFR/MPC or optional Math::GMP* libraries and a PARI/GP backend for heavy numeric workloads. If you embed Sidef expect some operational details to consider such as required native math libraries for best performance, the DBM cache not being thread-safe without external coordination, and Unicode behavior relying on Perl itself. Note in the recent 26.08 release there is a breaking change: the regex union operator now performs alternation rather than concatenation, so patterns using the old behavior may need updating.

DBIx::Loop provides a non-blocking wrapper around DBI so you can run database work without stalling an event loop. It exposes a future-based API where query and do return futures that integrate with your event loop via a small adapter for IO::Async, Mojo::IOLoop, AnyEvent and others. At connect time it chooses one of two backends: a universal worker pool that runs blocking DBD calls in separate worker processes and works with any DBD including SQLite, or a native file-descriptor async path for DBD::Pg that drives libpq directly and avoids worker serialization. Results come back as simple structures so query yields rows as arrayrefs plus a columns list and do yields rows_affected and an optional insert_id. Transactions are supported and pinned to a single connection so you can run BEGIN and COMMIT safely inside the async model. DBIx::Loop is not an event loop itself so you must supply an adapter, and its goal is latency isolation and concurrency rather than raw per-query speed. If you run an event-driven server and need a straightforward future-based way to use DBI without blocking, this module is likely a good fit.

CPAN::MetaCurator is a maintenance toolkit for the cpan.metacurator.sqlite database that helps you curate and publish CPAN metadata and Perl wiki content. It bundles utilities to prepare wiki content, export Perl.Wiki.html, convert those exports into a jsTree-friendly structure for web presentation, rebuild the Perl Wiki tree, patch an index.html and upload the results, and it converts Changes into a machine-readable Changelog.ini via Module::Metadata::Changes. The distribution follows a simple versioning rule where versions below 1.00 are development and 1.00 and up are production, and it is maintained by Ron Savage with source and issues tracked on GitHub and RT. The code is released under the Perl 5 license and is intended for anyone who needs a practical, open source way to manage CPAN metadata and publish Perl wiki content.

Getopt::Guided is a POSIX-compliant option parser for Perl that provides an iterator-style getopts implementation and a small toolkit to map parsed options into useful program state. Use getopts to parse @ARGV (or a supplied argument array) into a hash containing flags, single-value options, multi-value lists, and name=value maps, with support for negatable flags and incrementable flags like verbosity counters. Use processopts to attach scalar, array, hash, or callback destinations so your options are applied in a defined semantic order and to handle actions like printing version info. readopts can prepend defaults from a per-user rc file located via XDG_CONFIG_HOME with a sensible fallback and print_version_info follows GNU-style recommendations when you want a -V option. The module exports its functions and a few constants on request and recent releases added map-style options with HASH destinations for key=value collections and improved behavior when XDG_CONFIG_HOME is not set.

Markdown::Simple is a compact, compiled Perl extension that converts Markdown into HTML with GitHub Flavored Markdown enabled by default while letting you opt into strict CommonMark or toggle individual features like tables, strikethrough, task lists, autolinks, raw HTML handling, and hard line breaks. It exposes a simple functional API for one-off conversions and an object interface that reuses an internal parser arena to avoid repeated allocations when rendering many documents, and it also provides strip_markdown to produce plain text. Optional extras include fenced-code syntax highlighting via Eshu and runtime SIMD acceleration for faster parsing, and you can disable individual Markdown constructs if you need literal passthrough. Note that it is an XS module so it builds native code during installation and may require a C toolchain. The recent 0.19 release fixes memory leaks discovered during rendering and scanning.

Version::Semantic is a Perl class for representing immutable Semantic Versioning (SemVer 2.0.0) numbers as objects so you can parse, print, compare and increment real semver strings including optional "v" prefixes, pre-release tags and build metadata. You create objects with parse() or new(), inspect attributes like major, minor, patch, prefix, pre_release and build, stringify versions for output, and use the built-in comparison behavior to order versions according to SemVer precedence. It also exposes the regular expression used for parsing via semver_re() and provides an increment() method that supports major, minor, patch and an experimental "trial" strategy for TRIAL pre-releases. Note that as of v2.0.0 parse() now returns undef for unparsable strings by default and only throws an error if you request a fatal parse, so code that relied on earlier behavior should be updated. This module is a good fit when you need accurate, comparable SemVer objects in Perl scripts or release tooling.

SDL3 is a Perl binding for the SDL 3.0 library that gives Perl programs cross-platform access to low-level multimedia and input features such as windowing, 2D rendering, GPU compute, audio, keyboard, mouse, gamepads, timers, threads and more. It exposes the full SDL API through selectable import tags so you can pull in only the subsystems you need or use the :all tag for everything. The module supports SDL's callback-based application entry points and maps the hundreds of SDL types and functions to Perl, with the usual caution about using low-level atomics unless you are experienced in lockless concurrency. Documentation links to the upstream SDL3 wiki for detailed behavior and function reference. Recent releases (v0.0.5) bundled a large set of working example programs and demos into the distribution to make it much easier to learn by example, so this is a practical choice if you want to write games, multimedia tools, or platform-agnostic GUI and hardware-access code in Perl.

Class::Simple::Cached is a small, transparent wrapper that adds a read cache to any Class::Simple‑style get/set object so repeated getter calls avoid expensive recomputation or remote round trips. You give it a cache backend either as a CHI-compatible object or a plain hashref and a target object to wrap, and the wrapper proxies all method calls so zero‑argument calls are served from the cache when present while setters always write through to the wrapped object and update the cache. Cache coherency is not automatic so you must invalidate entries yourself if the inner object can change by other means. The module is handy for speeding up read-heavy access patterns but has a few documented limitations: setter arguments are not part of the cache key so different setter calls can overwrite each other, falsy scalars like 0 or the empty string are not cached, a special sentinel string represents cached undef (so that literal string can collide), DESTROY may purge a shared CHI cache globally, and it does not work with Memoize. The recent 0.07 release tightened security around constructor argument injection and sentinel comparisons for overloaded values and also delivers several performance improvements and expanded tests.

HTML::Defang is a Perl library for safely cleaning HTML and CSS by removing executable content and neutralising XSS vectors while keeping safe markup intact. It uses a whitelist approach and a custom parser designed to handle real world, messy HTML the way browsers do, and it can strip or comment out scripts, embedded objects, dangerous attributes, URLs and CSS declarations. The module is highly customizable through callbacks that let you inspect or modify tags, attributes, URLs, style rules and plain content, and attribute values are passed as references so you can alter output in place. Options let you fix mismatched tags, return body-only content, delete defanged fragments instead of commenting them out, and control how already-defanged names are handled. Typical uses are sanitising user-supplied HTML in web apps, email rendering or any system that must accept rich content safely. A recent and important fix makes title, textarea, noembed and noframes content be treated as opaque raw text, closing an XSS bypass where a literal end tag plus active markup could be smuggled inside what previously looked like a harmless comment.

DBIx::QuickDB lets you spin up throwaway database servers quickly for testing and local development, supporting PostgreSQL, MySQL/MariaDB, SQLite and more via pluggable drivers. You can create named databases at compile-time as convenient constants or build them at runtime and get DBI-ready handles, control startup/teardown, point to an existing data directory or let QDB create and clean temporary ones, and preload schema SQL per driver. The API is simple: DBIx::QuickDB->build_db(...) creates or returns an instance and check_driver helps you probe available backends, while environment variables such as QDB_TMPDIR and DB_VERBOSE let you tune temp paths and server logging. Recent releases have hardened pooling and cloning, sanitizing and PID-tagging instance directories to avoid cross-process collisions, improved watcher behavior so servers are reaped cleanly and errors report clearer diagnostics, and added retries and safer teardown on Windows and slow hosts, making ephemeral databases far more reliable in parallel or forked test runs. If you need reliable, configurable ephemeral databases for tests or development, DBIx::QuickDB is a lightweight, production-hardened choice.

Mojolicious::Plugin::Fondation::OpenAPI is a plugin for Fondation-based Mojolicious apps that produces an OpenAPI 3.0.3 spec from DBIx::Class metadata and enforces it at runtime. It adds the openapi generate command to create share/openapi.json and a client validators.js file, supports backend selection and per-column schema overrides in your config, and integrates the generated spec with Mojolicious::Plugin::OpenAPI so requests are validated and Swagger UI is available in development. You can disable client-side validators with no_validator_js and hide internal tables via openapi_exclude in a plugin's fondation_meta. The module depends on Fondation::Model::DBIx::Async and Mojolicious::Plugin::OpenAPI and notes a known compatibility issue on Perl 5.40 caused by Net::IDN::Encode which may require a prebuilt package on some systems. Run openapi generate before building assets so the spec and validators are committed with your application.

Mojolicious::Plugin::Fondation::Menu is a plugin for Mojolicious applications that provides declarative, database-backed menu management with support for navbars and breadcrumbs, letting you ship menu definitions from each plugin via share/menus.json and synchronize them into a central menu table with a simple "menu sync" command. It stores menu entries with titles, links, icons, grouping, nesting, ordering and optional visibility conditions such as group or permission checks, and exposes helpers to fetch and render menus or breadcrumbs and to evaluate menu visibility, along with an auto-generated REST API and fine-grained menu permissions. If you need consistent, reusable menus across a modular Mojolicious app this module handles storage, rendering and access control for you, and the recent 0.03 release simplifies error handling and standardizes problem reporting for cleaner failure responses.

Mojolicious::Plugin::Fondation::Workflow is a Fondation plugin that makes it easy to use the Workflow state‑machine framework inside Mojolicious applications by exposing a simple controller helper to create and fetch workflow instances and by wrapping raw Workflow objects in a friendly proxy with convenience methods for state, actions, execution and history. It supports both database persistence via Workflow::Persister::DBI and file‑based persistence for wizard‑style workflows, lets you declare workflows in YAML with extra Fondation UI metadata for a Bootstrap renderer, and integrates with other Fondation plugins so workflow history can link to a user record when Fondation::User is present. The plugin is tolerant of missing database configuration so file-backed flows still work, and recent changes in 0.02 added a Workflow action, updated tests and dependencies, and moved result rows onto a common base to simplify models. If you need workflow/state machine behavior with built‑in persistence options, UI metadata and tight integration into the Fondation stack this plugin is likely a good fit.

Mojolicious::Plugin::Fondation::User is a plug-and-play user management module for Mojolicious apps built on the Fondation stack. It supplies a DBIx::Class users table with schema, Result and ResultSet classes, automatic password hashing via Crypt::Passphrase using Argon2 in the async DB worker so the event loop stays free, and a REST controller with OpenAPI-generated routes to list, create, read, update and delete users at /api/user and /api/user/:id. The password field is never returned in API responses. Convenient ResultSet helpers include active, created_today and latest, and a with('groups') option will prefetch many-to-many group relationships in one query and embed full group objects in JSON output. A Bootstrap-based HTML UI is provided by Fondation::User::UI::Bootstrap and translations for API notifications are included in English and French. This module is a good fit if you want a ready-made, secure user model and API that integrates with Fondation::Model::DBIx::Async and Fondation::OpenAPI.

Mojolicious::Plugin::Fondation::Perm is a small Mojolicious plugin that provides permission management for applications built on the Fondation stack, letting you centralize access rules and enforce them from controllers and templates. It integrates with Fondation’s schema layer and exposes helpers to perform common permission checks and produce consistent error responses so you can keep authorization logic out of application code. Recent updates simplified error handling by replacing the internal _render_error with unified calls to $c->problem() and refreshed dependencies for smoother integration.

Mojolicious::Plugin::Fondation::Auth::Token provides simple personal access token support for Fondation-based Mojolicious applications by adding an opt-in route condition fondation.bearer that lets API routes accept Bearer tokens. Tokens are random strings whose SHA-256 hashes are stored in an api_tokens table and are meant to be created outside HTTP flows via CLI or fixtures. When a route uses fondation.bearer it will accept a valid Bearer token or a normal cookie session, return 403 for invalid tokens and 401 for unauthenticated requests, and routes that do not opt in will reject any Bearer header with 403. The plugin integrates with Fondation::Auth and the DBIx async model component and works alongside Fondation permission and group checks so you can stack authorization conditions as needed. This is the initial 0.01 release.

Mojolicious::Plugin::Fondation::Model::DBIx::Async is a Fondation plugin that integrates DBIx::Class::Async with Mojolicious so your DBIC queries run in a background worker pool instead of blocking the event loop. It provides simple helpers like schema_class, schema and model so controllers can obtain native DBIx::Class::Async ResultSets and get Future-based results from operations such as search, create and find. You declare named backends and models in your app config, the plugin auto-discovers Result and ResultSet classes from Fondation plugins, and each backend gets its own lazy-forked worker pool that is cleanly shut down on process exit. This makes it easy to keep web requests responsive while running parallel database work, though you should remember to retain Future chains to avoid premature garbage collection. Recent updates improve many_to_many prefetch handling and upgrade integration with async many-to-many relationship support.

Mojolicious::Plugin::Fondation::MigrationDBIx adds a simple db command set to Mojolicious apps that use DBIx::Class via Fondation::Model::DBIx::Async, letting you generate migration SQL from your schema, apply and roll back migrations, and load fixture data shipped by plugins. It provides commands to bootstrap a Schema class, prepare migration files and copy fixture directories, install or step upgrades and downgrades, show status, and populate data sets. The plugin detects the database driver from your DSN, integrates with DBIx::Class::DeploymentHandler to generate upgrade and downgrade SQL on the fly, and discovers fixtures by copying share/fixtures from loaded plugins into the application for versioned fixture loading. A schema_drift helper reports differences between prepared migration files and the live schema and logs a warning without stopping the app. Recent updates improved fixture handling by resolving belongs_to dependencies between fixture sets and expanded testing to cover MySQL and PostgreSQL for more robust cross-database behavior.