CPANscan

WWW::Pastebin::PastebinCa::Create is a small Perl helper for posting text to pastebin.ca directly from your code. You make an object, call paste(content, ...) and get back a URI object pointing to the new paste while errors are exposed via error(). The module posts anonymously through the site's API and automatically solves the Turnstile proof-of-work challenge so you do not need an account or API key. You can tune network behavior with a timeout or provide your own WWW::Mechanize instance. paste() accepts options like name, language (numeric codes for syntax highlighting), and expire, with anonymous pastes required to expire and any empty or over-90-day value capped at the 90-day maximum. The desc and tags arguments are accepted for backwards compatibility but the rebuilt site no longer uses them. The module also exposes helpers to list valid language codes and expire values, and notes that pastebin.ca enforces spam protection so avoid excessive automated pasting.

Mojolicious::Plugin::BarefootJS makes it easy to use the BarefootJS server runtime inside a Mojolicious app by registering a bf controller helper that lazily creates a per-request BarefootJS instance backed by BarefootJS::Backend::Mojo. The helper lets you render compiled marked templates as native Mojolicious templates so you can integrate BarefootJS rendering into your controllers and views with minimal configuration. This plugin is useful for Mojolicious developers who want to adopt BarefootJS templating and runtime behavior; projects running on other PSGI hosts can use BarefootJS::Backend::Xslate for a comparable integration without Mojolicious.

BarefootJS::Backend::Xslate is a rendering backend that lets the BarefootJS runtime render Kolon (.tx) templates using Text::Xslate, without tying you to any web framework. It can take a prebuilt Text::Xslate instance or build one from a list of template paths and options, and it configures Xslate for HTML auto-escaping while providing a mark_raw helper for emitting raw markup. Templates compiled by the companion @barefootjs/xslate adapter call runtime helpers as methods on a bound bf object, so the backend needs no special function map and works equally well inside PSGI/Plack apps or in standalone scripts. The module exposes a small set of runtime operations such as render_named, encode_json (customizable), materialize, and mark_raw, making it a lightweight bridge between BarefootJS templates and Text::Xslate rendering.

BarefootJS is a lightweight server-side runtime that supports templates compiled from JSX/TSX into BarefootJS "marked" templates and accompanying client JavaScript. It supplies the runtime helpers those compiled templates call at render time, for tasks like JSON marshalling, marking raw strings, materializing JSX children, spreading attributes, and invoking named sub-templates. The design deliberately avoids locking you into a specific template engine or web framework by delegating engine- and framework-specific behavior to pluggable backends such as BarefootJS::Backend::Xslate for Text::Xslate or Mojolicious::Plugin::BarefootJS for Mojolicious, so the core itself only pulls in Perl core modules unless a chosen backend requires more. If you need to render JSX-style templates from Perl in a PSGI/Plack or Mojolicious app and want a minimal, backend-agnostic runtime, BarefootJS is a good fit and it is actively maintained under the MIT license.

Email::Abuse::Investigator examines the raw source of spam and phishing messages to answer the practical questions an abuse investigator asks: where the message was injected, which web hosts and URLs are implicated, and which parties should receive abuse reports. It walks the Received header chain to find the originating IP and enriches it with rDNS and RDAP/WHOIS ownership, extracts HTTP/HTTPS links from plain and HTML parts and resolves their hosting networks, and collects contact domains from headers and mailto links to assemble registrar, hosting and nameserver intelligence. The module produces both a detailed analyst report and a compact abuse-report body, collates email and web-form complaint targets, runs heuristic risk scoring, and caches lookups to reduce redundant WHOIS and DNS queries. Optional modules such as Net::DNS, LWP::UserAgent, Domain::PublicSuffix, AnyEvent::DNS and CHI improve DNS resolution, redirect-following, accurate registrable-domain handling and cross-message caching when present. The recent 0.13 release tightens security around WHOIS and RDAP lookups to prevent protocol injection and to validate IPv6 zone identifiers, and it adds stricter CLI path validation. Note the documented limitations: bodies are not charset-decoded, the built-in MIME parser is a pragmatic rather than fully RFC-compliant implementation, WHOIS rate-limiting is not retried, IPv6 CIDR entries for trusted_relays are not matched, and the class is not thread-safe so you should create separate objects per thread.

Digest::xxHash is a Perl wrapper around the official C xxHash library that gives you extremely fast, non-cryptographic hashing for single-shot and streaming use. It exposes simple functional helpers for one-off 32- and 64-bit hashes and modern XXH3 64- and 128-bit hashes, plus a Digest-style object interface that matches Digest::MD5 and Digest::SHA so you can swap algorithms with minimal code changes. You can feed data incrementally, clone or reset contexts, get binary, hex, or base64 output, control seeding, and for XXH3 supply a high-entropy secret generated by the module. If you need high-performance checksums, deduplication fingerprints, or fast hash keys for large datasets, this module delivers a very fast, easy-to-use solution; do not use it where cryptographic security is required.

Mojolicious::Plugin::Fondation::MigrationDBIx is a Mojolicious plugin that adds a simple "db" command suite for managing DBIx::Class migrations and fixture data in applications that use Fondation::Model::DBIx::Async. It generates migration SQL from your schema classes using DBIx::Class::DeploymentHandler, detects the database driver from the DSN, copies fixture directories shipped by plugins into your app, and loads fixtures via DBIx::Class::Migration. Common commands include bootstrap-schema to create a minimal Schema class, prepare to generate SQL and gather fixtures, install/upgrade/downgrade/status to apply or roll back migrations, and populate to load fixture sets. A schema_drift helper reports differences between prepared migration files and the live schema and will log a startup warning if plugin Result classes change without breaking the app. The plugin is configurable for which DBIx::Async backend to target and where migration files live, making it a convenient choice if you want integrated migration and fixture management for DBIx::Class backends in a Fondation-based Mojolicious app.

CLI::Simple is a minimalist object oriented base class for building command line Perl programs that handles Getopt::Long-style option parsing, subcommands, and positional arguments while encouraging the modulino pattern so the same file can be used as a module and an executable. It auto-creates getter/setter accessors for options, integrates optional Log::Log4perl logging with per-command log levels, and offers configurable help, optional pager support, bash completion generation and a low dependency footprint. For larger projects it supports a role-based workflow driven by a YAML manifest and ships with built-in utilities to introspect a modulino, dump a spec, scaffold Role::Tiny role stubs and migrate to a role-based layout. Choose CLI::Simple when you want a lightweight, testable and extensible foundation for admin scripts and internal CLIs without adopting a heavyweight application framework.

Jacode4e::RoundTrip is a Perl module for converting Japanese character encodings with an emphasis on preserving JIS X 0213 characters so they can be round-trip transferred between legacy enterprise and mainframe encodings and modern UTF-8 variants. It exposes a simple API, Jacode4e::RoundTrip::convert, which updates a string in place and returns the character count, and accepts source and target encoding names such as cp932x, cp00930, keis78, keis83, keis90, jef, jipsj, jipse, letsj, utf8, utf8.1 and utf8jp along with options to declare input layout, enable output SI/SO shifting, set DBCS/MBCS space and geta fallback codes, and supply override mappings. The module automatically handles SI/SO kanji shift codes when present and lets you force SBCS/DBCS layout for enterprise encodings that rarely use shift codes. It was designed to help systems exchange and restore JIS X 0213 data by using user defined areas and special encodings like CP932X and UTF-8-SPUA-JP, but for reliable round-trip conversion you must use the same version of the software for both directions and be aware that older releases had some mapping errata that were corrected in later updates. If you need to interoperate with Japanese enterprise character sets while retaining JIS X 0213 fidelity this module is directly relevant and it runs on Perl 5.005_03 and newer.

Dist::Zilla::Plugin::TemplateXS is a small Dist::Zilla plugin that creates XS stub files when you run "dzil new" to start a new distribution. It renders a template using Text::Template and injects the module name, the Dist::Zilla object, and a style flag so you can control where the generated .xs ends up. The style option chooses layout conventions so "MakeMaker" writes Foo::Bar to Bar.xs while "ModuleBuild" places it at lib/Foo/Bar.xs. It also optionally adds the PROTOTYPES line required by ExtUtils::MakeMaker, with sensible defaults, and you can supply your own template or use the provided boilerplate that includes the usual XS headers and include handling. This lets you produce consistent XS skeletons as part of your Dist::Zilla workflow without handcrafting each file.

CPAN::Maker::Bootstrapper is a command line tool that scaffolds a complete, production-ready Perl distribution so you can go from idea to a buildable CPAN tarball with a single command. It creates a managed Makefile, a prefilled buildspec.yml, editable ".pm.in" and ".pl.in" sources, a minimal test, and an upgrade-safe .includes build system that runs dependency scanning, syntax checks, perltidy and perlcritic gates, and produces a distributable tarball via make. The tool can import existing projects into the scaffold, generate CLI stubs, install CI workflow helpers, and provides an extension point (project.mk) so your custom rules survive upgrades. It also includes optional AI-assisted workflows that use the Anthropic Claude API to run structured code and POD reviews, generate release notes, and support an annotate-and-resubmit review loop, with prompts and cost estimates to help manage token usage. Note the importer and stub options are mutually exclusive, imported files are copied as ".in" sources and not auto-tidied, and you may need to declare inter-module build dependencies in project.mk to avoid syntax-check ordering issues.

Win32::GUITaskAutomate is a Windows-only Perl helper for scripting and automating desktop GUI tasks by watching the screen for images and then running a sequence of mouse, keyboard and clipboard actions relative to where those images appear. You give it named screenshots to load, then tell it to wait for a picture and execute a compact "robot instruction" list that can click, double-click, drag, spin the mouse wheel, send key sequences, copy large text to the clipboard for fast pasting, or pause between steps. It is handy for automating repetitive GUI workflows, simple UI testing, bulk form entry or tooling that has no API, and it builds on existing modules like Win32::GUIRobot and Win32::Clipboard while using SendKeys-style key syntax. The interface is designed to let you write actions quickly but the author notes it was created to meet a short-term need and is not exhaustively polished.

WWW::WebDevout::BrowserSupportInfo is a lightweight Perl client for the WebDevout browser support API that lets scripts look up browser compatibility for CSS and HTML terms and receive the results as simple Perl data structures. You can choose which browsers to query, toggle between short codes and full browser names, supply LWP::UserAgent options like timeout and agent string, and then call fetch('display block') to get per‑browser support via methods such as browser_results, what and uri_info or by hash dereferencing the object. Errors are exposed via an error method so you can handle failures, and the module is intended for developers who want to programmatically check or display browser support information. Note that the underlying WebDevout database is beta and incomplete and the author warns that Safari and Konqueror data may be missing or incorrect. A recent maintenance update in 2026 verified the module still works with the service.

WWW::Pastebin::Base::Retrieve is a lightweight base class for writing Perl modules that fetch pastes from various pastebin sites. It wraps HTTP fetching with LWP::UserAgent and URI and provides a simple public API including new, retrieve, error, content, results, ua, uri and id so callers can request a paste, inspect the result, and get the raw text. Module authors implement two small methods, _make_uri_and_id to turn a user-supplied ID or URL into a URI and an ID, and _parse to extract metadata and the paste content, with an optional _get_was_successful hook for pastebins that need extra requests. The content accessor is overloaded so the object interpolates to the paste text for easy printing. The module is mature and recently received a maintenance update that verified it still works.

WWW::PAUSE::CleanUpHomeDir is a small utility for CPAN authors that helps you tidy your PAUSE home directory by logging in with your PAUSE ID and password, listing your files, spotting distributions that are old because newer versions exist, and removing those older archives along with their .meta and .readme files. It provides methods to fetch and inspect your file list, get just the scheduled-for-deletion or old distributions, perform a selective or bulk cleanup, and undelete files if you change your mind. The constructor lets you choose HTTPS (default) or plain HTTP and set a network timeout. The author notes the module was only lightly tested and does not include live deletion tests, so you should verify which files will be removed on initial runs.

WWW::HTMLTagAttributeCounter is a small Perl utility that fetches a webpage or accepts raw HTML and counts how many times specified HTML tags or element attributes appear. You instantiate it with an optional LWP::UserAgent, call count with a URL or a scalar reference plus a tag or attribute name or list, and it returns a hashref of counts, a human readable string form of the results, and exposes the last result and any error message. It is lightweight and easy to use for quick diagnostics, simple scraping or bot features, and it was originally written for an IRC bot so it focuses on straightforward counting rather than full-scale HTML analysis.

WWW::GetPageTitle is a tiny, no-nonsense Perl helper that fetches the HTML title from a web page, built originally for an IRC bot and aimed at simplicity and low overhead. You create an object, optionally supply a custom user agent (the default uses LWP::UserAgent with a Mozilla agent, 30s timeout and a 2KB max body), call get_title with a URL and then read the title, uri or error as needed; if you pass a bare host the module will prepend http:// for you. It is a good fit when you just need a lightweight way to show page titles without pulling in a heavier dependency. The author notes that URI::Title is more featureful and robust and recommends using that if it meets your needs, and warns this module may be removed in the future.

Test::WWW::Mechanize::MultiMech lets you group and manage multiple Test::WWW::Mechanize agents so you can run the same web tests across different user roles or target checks at a single role by name. You register named user aliases when creating the object and then call Test::WWW::Mechanize methods on the MultiMech instance to have them applied to every unignored user or use alias methods to call a method for just one user. All-user calls return a hashref mapping aliases to each user’s return value, there is a convenience login helper that injects per-user credentials into form fields, and you can add, remove, ignore, and unignore users at runtime while also using a special any alias to pick one user’s result. Calls are performed sequentially in the order you listed users so there is no built-in parallelism. The author warns the test output can be verbose and less pretty than ideal, but the module is a practical way to verify role-based differences in a multi-user web application.

Test::Mojo::Role::SubmitForm is a small Test::Mojo role that adds form submission support to your Mojolicious tests by providing a click_ok method. You can submit a form or click a specific submit button by CSS selector or Mojo::DOM object and optionally override any form control values by passing a hash where values may be scalars, arrayrefs for multiple values, coderefs that receive the current value, or undef to remove a parameter. It fits into normal Test::Mojo chains so you can do get_ok, click_ok and status_is in sequence, and you can set MOJO_SUBMITFORM_DEBUG to see the exact data being posted during a test run. Note that you cannot override the value of a button you click, so click the form itself if you need to change a button parameter. This module is useful for Mojolicious developers who want a simple, programmable way to exercise and test HTML form submissions.

Test::Mojo::Role::ElementCounter is a small Test::Mojo extension that makes it easy to assert exact or range-based counts of HTML elements when testing Mojolicious apps. It provides element_count_is for exact, "<n" and ">n" checks and a set of "dive" helpers that let you stash a selector prefix with dive_in and then trim or reset it with dive_out, dive_up, and dive_reset so you can write concise checks against deeply nested markup. You also get dived_text_is which behaves like Test::Mojo's text_is but automatically applies the stored selector prefix, and the module includes a whitespace-friendly text matching workaround for known Mojo DOM quirks. Note that newer Mojolicious/Test::Mojo versions already include an element_count_is method, so this role is most useful when you want the dive-prefix behavior or range-style checks for complex structures.

Test::Mojo::Role::Debug is a tiny role for Test::Mojo that makes it easy to inspect the HTML when a web test fails by dumping the current page markup or a specific element. It adds two chainable methods, d which dumps the entire DOM or a CSS-selected element only when preceding tests failed, and da which always dumps regardless of test outcome. Both accept an optional selector and an optional filename to write the output to, and the role recognizes Mojolicious error pages and prints the error text instead of the full DOM for clearer diagnostics. It returns its invocant so it fits naturally into Test::Mojo chains and is ideal for Mojolicious developers who want quick, readable failure context. Recent maintenance work verifies it still works with modern Mojolicious versions and earlier releases added file dumping and automated error-page parsing.

Test::Mojo::Role::DOMinizer is a small role for Test::Mojo that lets you examine and act on the current page DOM without breaking a method chain. It supplies an in_DOM method that takes a coderef and provides the current Mojo::DOM as $_ and the Test::Mojo object as a second argument so you can run DOM queries and drive further requests inline. If your coderef returns a Test::Mojo object that becomes the new chain value, otherwise the original test object is preserved so you can continue chaining as usual. This keeps tests tidy and avoids scattering temporary variables when page content determines subsequent checks, and it works alongside Test::Mojo and Mojo::DOM.

Test::GetVolatileData is a tiny Perl test helper that fetches frequently changing test data from a URL so you do not have to ship a new distro every time an API key or tracking number changes. It exports a get_data function that reads a newline separated text document and returns one or more randomly chosen lines. Call get_data('http://...') to get a single random entry or pass num => N to retrieve up to N entries, and on failure it returns undef or an empty list while populating $Test::GetVolatileData::ERROR so your test can skip or fall back to bundled values. This module is handy for injecting fresh volatile inputs into Test::More based suites without changing your released distribution.

Syntax::Highlight::CSS is a small, straightforward Perl module that converts a string of CSS into HTML with <span> wrappers tagged by class names so you can style and display highlighted CSS on the web. It recognizes selectors, comments, properties, values, pseudo-selectors and at-rules and emits classes such as ch-sel, ch-com, ch-p, ch-v, ch-ps and ch-at, and it can optionally wrap the output in a <pre class="css-code"> block and add line numbers. The author recommends trying Syntax::Highlight::Engine::Kate::CSS if you need finer-grained tokenization, and notes this module was tested only on common CSS and may not cover every corner of the spec. A recent maintenance update verified the module still works.

Spreadsheet::DataToExcel is a tiny, focused helper for turning a two‑dimensional Perl arrayref into a ready‑to‑open Excel .xls file without the friction of learning the full Spreadsheet::WriteExcel API. You give it a filename or filehandle and an arrayref of rows and it writes a spreadsheet with sensible defaults such as wrapped text for newline characters, automatic column widths (with a multiplier to tweak sizing) and optional centering of the first row for headings. The interface is minimal and easy to use so you can quickly dump tabular data with new() and dump() and check error() if something goes wrong. If you need deep formatting or formula support use Spreadsheet::WriteExcel directly. A maintenance update in 2026 verifies the module remains functional.

Spreadsheet::DataFromExcel is a small, user-friendly Perl helper that loads a single Excel sheet into a plain arrayref of arrayrefs so each inner array is a row and each element is a cell value, with empty cells represented as undef. You give it a filename and optionally a sheet name or index and zero-based start and end row numbers, and it returns the data or an error string via error() if something goes wrong. It is deliberately lightweight and aimed at simple, tabular Excel data rather than complex spreadsheets, so if you need fine-grained control or advanced features you should use Spreadsheet::ParseExcel or Spreadsheet::Read instead. The module is maintained on GitHub and received a recent maintenance update in 2026 confirming it still works.

Package::Localize makes it easy to treat modules that rely on package globals as if they were instanced objects by creating localized copies of a package so you can have multiple independent sets of package variables. You give it the package name and get back an object that forwards calls to the original package functions while keeping state in a separate, localized namespace, so legacy code that uses globals can be used in isolation or tested concurrently. A name method exposes the localized package name if you need to inspect variables directly. Note that it works for function-based modules and does not provide special support for object oriented modules.

POE::Component::WWW::XKCD::AsText is a non-blocking POE component that wraps WWW::XKCD::AsText to fetch xkcd comic transcriptions asynchronously. You add it to your POE kernel with spawn and can customize alias, timeout or supply your own LWP::UserAgent to control retrieval. Call retrieve with an event name and comic id and the component will post a hashref to your session containing text and uri or an error message if a transcription is missing, and it preserves any user-supplied arguments that begin with an underscore. It is ideal for bots, archival tools and any event-driven Perl programs that need comic text without blocking the event loop. A 2026 maintenance update verified the module is still working.

POE::Component::WWW::OhNoRobotCom::Search is a non-blocking POE component that wraps WWW::OhNoRobotCom::Search to let Perl programs perform asynchronous searches on ohnorobot.com for webcomic text and metadata. You spawn the component in a POE session, call search with a hashref containing a search term and optional parameters such as comic_id, which parts to include, max_results, or the "lucky" option, and the component posts back an event carrying a results hashref mapping comic URLs to titles or an error message. It supports routing results to other sessions, passing through user data keys that begin with an underscore, and basic debug and session configuration. Note that comic selection uses numeric IDs from the site rather than names and requesting large max_results can cause multiple requests because the site paginates and results may repeat.

POE::Component::NonBlockingWrapper::Base is a lightweight base class for turning blocking libraries or operations into POE-friendly, non-blocking components by running the blocking work inside a single POE::Wheel::Run child process. You subclass it, declare which public methods map to POE events with _methods_define, implement _process_request to do the blocking work in the child, and optionally provide argument checks and per-child setup with _check_args and _prepare_wheel, while the base class creates the component session, delivers results back to a caller-specified event, and handles shutdown for you. It is a good fit when you want an easy way to expose blocking functionality to an event loop without rewriting code to be asynchronous, but note that all requests are serialized through one child process so parallelism is limited and certain keys like event and sender are reserved and arguments are lowercased.