List::Unique::DeterministicOrder Store and access a list of keys using a deterministic order based on the sequence of insertions and deletions
Discussion section from the POD is below.
Any suggestions for a better name are appreciated.
The algorithm used is from https://stackoverflow.com/questions/5682218/data-structure-insert-remove-contains-get-random-element-all-at-o1/5684892#5684892
The algorithm used inserts keys at the end, but swaps keys around on deletion. Hence it is deterministic and repeatable, but only if the sequence of insertions and deletions is replicated exactly.
So why would one use this in the first place? The motivating use-case was a randomisation process where keys would be selected from a pool of keys, and sometimes inserted. e.g. the process might select and remove the 10th key, then the 257th, then insert a new key, followed by more selections and removals. The randomisations needed to produce the same results same for the same given PRNG sequence for reproducibility purposes.
Using a hash to store the data provides rapid access,
but getting the nth key requires the key list be generated
each time, and Perl's hashes do not provide their
keys in a deterministic
order across all versions and platforms.
Binary searches over sorted lists proved very effective for a while, but bottlenecks started to manifest when the data sets became much larger and the number of lists became both abundant and lengthy.
Since the order itself does not matter, only the ability to replicate it, this module was written.
One could also use Hash::Ordered, but it has the overhead of storing values, which are not needed here. I also wrote this module before I benchmarked against Hash::Ordered. Regardless, this module is faster for the example use-case described above - see the benchmarking results in bench.pl (which is part of this distribution). That said, some of the implementation details have been adapted/borrowed from Hash::Ordered.
WebService::HMRC Interact with the UK HMRC tax authority Making Tax Digital API
This is a base set of modules used for interacting with the HMRC Making Tax Digital (MTD) and Making Tax Digital for Business (MTDfB) APIs.
HMRC is the UK government tax authority. Their APIs provide a means to submit and query information relating to personal and business tax and customs affairs.
WebService::HMRC module is a stub bundling the following modules which encapsulate the minimum functionality needed to interact with the HMRC API:
These base modules will normally not be used directly by an application. Instead, applications will generally use a higher-level module which inherits from these classes.
I have written and intend to release separately the following modules which use the base functionality:
Further APIs exist for different aspects of personal and company taxation. It is hoped that this base distribution makes it easier to contribute modules for these.
More information on the HMRC APIs here: https://developer.service.hmrc.gov.uk/api-documentation/docs/api
HEXONET::Apiconnector Connector Library for the insanely fast HEXONET Backend API
This module allows to query the HEXONET Backend API and to deal with different response formats (list, list_hash, hash). It provides a short hand method (HEXONET::Apiconnector::connect) to instantiate API clients.
A helper utility module is also included for tasks like date handling and string encoding.
Benchmark::Parametric Measure code performance by passing an iteration count argument
Instead of iterating the same subroutine over and over again, this module passes an iteration counter to code under test, thus allowing to time precisely the iterated snippet.
It also allows to prepare complex test data and/or check the validity of results by providing "setup" and "teardown" functions.
Password::Policy::Rule::Pwned Plug matches against api.pwnedpasswords.com into Password::Policy
Password::Policy::Rule::Pwned is a Password::Policy::Rule to match against the pwned password service at https://api.pwnedpasswords.com/range/ as specified at https://haveibeenpwned.com/API/v2#PwnedPasswords
A password found in the list throws an exception as usual. A password not in the list returns itself also as usual.
Following discussions with the author of Password::Policy, it has been decided to throw a separate, distinct, testable error to deal with the 3rd possibility which is a failure in the API call for whatever reason.
LDF::Schema Classes that implement Linked Data e.g. schema.org
I am working on some Perl classes that are auto-generated from http://schema.org class definitions, and can then be used to output json-ld metadata appropriate to the classes (e.g. for embedding in a web page to help search engines index the content).
Eventually I hope to add classes for other data schemes (e.g. "dc", "foaf" etc.) and allow them to be combined.
In the mean time, I am unsure what to call the module. I chose the "LDF::" namespace since it relates to linked data fragments, but I'm not happy with that. I am open to suggestions.
HTML5::DOM Make html parsing fast again
Stop using libxml for parsing html!
HTML5::DOM - is a fast HTML5 parser with DOM and CSS4 selectors. It really fast, as rocket. With threads!
At the same time, it is achieved fully conformant with the HTML5 specification.
Module has simple classic DOM-like API, it's easily to use. Try and enjoy!
Why this module so fast?
Apache::Arrow Perl bindings for Arrow data structures, IPC and computation kernels
Apache Arrow https://en.wikipedia.org/wiki/Draft:Apache_Arrow already has C bindings via GLib https://github.com/apache/arrow/tree/master/c_glib and Perl already has GLib bindings via https://metacpan.org/pod/Glib.
Given this, does it make sense to implement Arrow bindings for perl as its own module? Or are the existing GLib bindings sufficient for any practical task?
If I were to implement Apache::Arrow[::*] it would likely be little more than a convenience wrapper around the GLib interface.
Amazon::Credentials read AWS credentials from file, instance metadata, container, env
While PAWS is a wonderful project, it has a lot of dependencies. I've found myself trying to use slimmer Perl modules for interacting with AWS...along the way a need arises to provide the AWS credentials tuple, hence Amazon::Credentials which attempts to find those in the various places they should be found.
Might be a module somebody needs, might not. So, some questions for the community:
- Do folks want a slimmer set of AWS APIs or is alignment with boto3 more important?
- Does anyone still use some of the AWS CPAN modules or is all development being down with PAWS?
- Any feedback on the module in any event would be appreciated.
Web::Mention An implementation of the Webmention protocol, as defined by the W3C and the IndieWeb community.
Webmention provides a standard way for one website to inform another that someone, somewhere on the web, has published a reference to a URL under the receiver's domain. This notification travels through very short and simple HTTP POST messages that merely identify the two URLs involved: the source of the mention, and its target. The receiver of a webmention can, at its own leisure, request the HTML document found at the source URL in order to verify the mention, and also to learn more about its author and content via any Microformats2 metadata it may contain. The receiver may then proceed to do something interesting with this fetched and parsed data, such as display hyperlinked information about the mention and its author underneath its own, original content.
For example, a response published on Blog A to an article on Magazine B could result in A sending a webmention to B. (There is implied consent here, since the article on B has a <link> tag in its HTML that explicitly invites webmentions, providing an endpoint URI for them.) It would then become B's responsibility to confirm that the webpage at A really does mention the URL of B's aticle. B may then wish to represent the mention on its own site, however it deems appropriate.
About these modules
An object of the main Web::Mention class represents a single webmention instance, probably created from an incoming HTTP request, as shown in the synopsis. The object's
verify() method (and, indeed, its
is_verified attribute) will do the hard work of fetching the source URL's document, verifying the presence of the target URL, and parsing any Microformats2 metdata it finds in order to infer author information. The latter goes into a Web::Mention::Author object, and taken all together this should give the receiver enough information to react in some appropriate way to the mention.
This module requires Web::Microformats2, another proposed CPAN module of mine with its own PrePAN page.
Near-future versions of this module will assist with creating and sending webmentions. But receiving is the harder part (and arguably the more rewarding part as well) so I wanted to get it done first. This ended up being a depth-first adventure that resulted in my creating all of Web::Microformats2 before I could come back and finish this module, and so here we are.
Regarding the name
I'd like to hear opinions on the name. Giving it a top-level namespace of "Web" seemed natural, for the same arguments I made in Web::Microformats2's case, and then following up the way I did seemed inevitable. But is splitting the word up this way too "cute"? Or, more to the point, will it make it harder to find in CPAN searches?
Certainly "Web::Webmention" is too ugly to live, but I could be talked into e.g. "Net::Webmention" or "HTTP::Webmention" or something. Absent any argument to the contrary, I do like both the directness and the subtle humor of "Web::Mention" the best.