testilo 24.3.1 → 25.0.1

package/README.md

@@ -33,21 +33,16 @@ Environment variables for Testilo can be specified in a `.env` file. An example:
 
 ```bash
 FUNCTIONDIR=./procs
+SPECDIR=../testdir/specs
 JOBDIR=../testdir/jobs
 REPORTDIR=../testdir/reports
-REQUESTER=a11ymgr@a11yorg.com
-SPECDIR=../testdir/specs
+SCORED_REPORT_URL=../scored/__id__.json
+DIGEST_URL=../digested/__id__.html
 ```
 
-The `FUNCTIONDIR` environment variable typically references the `procs` directory, but it could reference a different directory in the filesystem where Testilo resides, if you wanted to customize the procs that Testilo uses.
-
-`JOBDIR` references a directory in the filesystem where jobs created by the `merge` proc are to be saved.
-
-`REPORTDIR` references a directory in the filesystem where reports are saved.
-
-`REQUESTER` is an email address that will be used as a job property if no other email address is specified for the `sources.requester` property of the job.
+The first four variables above tell Testilo where to find or save files when a user invokes a function. This decreases the count of arguments that the user would otherwise need to specify.
 
-`SPECDIR` references a directory in the filesystem where tanrget lists, batches, and scripts can be found. Those are raw materials from which Testaro creates jobs.
+The other two variables specify the destinations of links to scored reports and digests. Digests produced by Testilo digesters link to scored reports, and difgests produced by Testilo difgesters link to digests. The URLs can be absolute, or, if digests and difgests will be opened from a local filesystem, they can be relative to the linking document, as shown. They include the substring `__id__`. A function that needs the URL of a scored report or digest is expected to substitute the ID of that document for `__id__` to produce the URL. Since the `.env` file is excluded from the repository, importing modules that will use `digest()` need a `SCORED_REPORT_URL` environment variable, and importing modules that will use `difgest()` need a `DIGEST_URL` environment variable.
 
 ## Job preparation
 
@@ -195,7 +190,7 @@ As shown in this example, when a browser is launched by placeholder substitution
 
 ### Target list to batch
 
-If you have a target list, the `batch` module of Testilo can convert it to a batch. The batch will contain, for each target, one array of acts named `main`, containing a `launch` act (depending on the script to specify the browser type and the target to specify the URL).
+If you have a target list, the `batch` module of Testilo can convert it to a simple batch. The batch will contain, for each target, only one array of acts, named `main`, containing only a `launch` act (depending on the script to specify the browser type and the target to specify the URL).
 
 #### Invocation
 
@@ -203,41 +198,45 @@ There are two ways to use the `batch` module.
 
 ##### By a module
 
-A module can invoke `batch` in this way:
+A module can invoke `batch()` in this way:
 
 ```javaScript
 const {batch} = require('testilo/batch');
+const id = 'divns';
+const what = 'divisions';
+const targets = [
+  ['Energy', 'https://abc.com/energy'],
+  ['Water', 'https://abc.com/water']
+];
 const batchObj = batch(id, what, targets);
 ```
 
-This invocation references `id`, `what`, and `targets` variables that the module must have already defined. The `id` variable is a unique identifier for the target list. The `what` variable describes the target list. The `targets` variable is an array of arrays, with each array containing the 2 items (description and URL) defining one target.
+The `id` argument to `batch()` is a unique identifier for the target list. The `what` variable describes the target list. The `targets` variable is an array of arrays, with each array containing the 2 items (description and URL) defining one target.
 
-The `batch()` function of the `batch` module generates a batch and returns it as an object. The invoking module can further dispose of the batch as needed.
+The `batch()` function of the `batch` module generates a batch and returns it as an object. Within the batch, each target is given a sequential (base-62 alphanumeric) string as an ID.
 
-The ID assigned to each target by the `batch()` function is a sequential (base-62 alphanumeric) string, rather than a mnemonic like the one (`'acme'`) in the above example.
+The invoking module can further dispose of the batch as needed.
 
 ##### By a user
 
-A user can invoke `batch` in this way:
+A user can invoke `batch()` in this way:
 
 - Create a target list and save it as a text file (with tab-delimited items in newline-delimited lines) in the `targetLists` subdirectory of the `SPECDIR` directory. Name the file `x.tsv`, where `x` is the list ID.
 - In the Testilo project directory, execute the statement `node call batch id what`.
 
-In this statement, replace `id` with the list ID and `what` with a string describing the batch.
+In this statement, replace `id` with the list ID and `what` with a string describing the batch. Example: `node call batch divns 'ABC company divisions'`.
 
 The `call` module will retrieve the named target list.
 The `batch` module will convert the target list to a batch.
-The `call` module will save the batch as a JSON file in the `batches` subdirectory of the `SPECDIR` directory.
+The `call` module will save the batch as a JSON file named `x.json` (replacing `x` with the list ID) in the `batches` subdirectory of the `SPECDIR` directory.
 
 ### Issues to script
 
-Testilo contains a classification of tool rules into _issues_. It is located in the `procs/score` directory and has a file name starting with `tic` (Testilo issue classification). You can create custom classifications and save them in a `score` subdirectory of the `FUNCTIONDIR` directory.
+You can use the `script()` function of the `script` module to simplify the creation of scripts.
 
-For example, one of the issues in the `tic40.js` file is `mainNot1`. Four rules are classified as belonging to that issue: rule `main_element_only_one` of `aslint` and 3 more rules defined by 3 other tools.
+In its simplest form, `script()` requires only one argument, a string that will serve as the ID of the script. Called in this way, `script()` produces a script that tells Testaro to perform all of the tests defined by all of the tools integrated by Testaro.
 
-If you want Testaro to test targets for only particular issues, you can use the `script` module to create a script. Jobs created from that script will make Testaro test for only the issues you specify to the `script` module.
-
-If you want Testaro to test targets for **all** the rules of all the available tools, you can use the `script` module to create a script that does not impose any issue restrictions.
+If you want a more focused script, you can add additional arguments to `script()`. First you must add the ID of a Testilo issue classification (such as `tic99`). After that, you must add one or more arguments giving the IDs of issues in that classification. The latest Testilo issue classification classifies about a thousand rules of the 10 Testaro tools into about 300 _issues_. The classification is found in a file whose name begins with `tic` in the `procs/score` directory. For example, one issue in the `tic40.js` file is `mainNot1`. Four rules are classified as belonging to that issue: rule `main_element_only_one` of the `aslint` tool and 3 more rules defined by 3 other tools. You can also create custom classifications and save them in a `score` subdirectory of the `FUNCTIONDIR` directory.
 
 #### Invocation
 
@@ -249,55 +248,103 @@ A module can invoke `script` in this way:
 
 ```javaScript
 const {script} = require('testilo/script');
-const scriptObj = script(scriptID, issues, issueID0, issueID1, …);
+const {issues} = require('testilo/procs/score/tic99');
+const scriptObj = script('monthly', issues, 'regionNoText', 'mainNot1');
 ```
 
-This invocation references `scriptID`, `issues`, and `issueID` variables.
-- The `scriptID` variable specifies the ID that the script will have.
-- The `issues` variable (if present) is an object that classifies issues, such as the `issues` object in a `tic` file.
-- The `issueID` variables (if any) are strings, such as `'regionNoText'`, that name issues, i.e. properties of the `issues` object, that you want jobs from the script to test for.
-
-The `script()` function of the `script` module generates a script and returns it as an object. The invoking module can further modify and use the script as needed.
+In this example, the script will have `'monthly'` as its ID. It will tell Testaro to test for all, and only, the rules that are classified into either the `regionNoText` or the `mainNot1` issue.
 
-To create a script **without** issue restrictions, a module can use this invocation:
+The invoking module can further modify and use the script (`scriptObj`) as needed.
 
-```javaScript
-const {script} = require('testilo/script');
-const scriptObj = script(scriptID);
-```
+To create a script **without** issue restrictions, a module can call `script()` with only the first (ID) argument.
 
 ##### By a user
 
-A user can invoke `script` in this way: In the Testilo project directory, execute the statement `node call script id ticnn issuea issueb …`.
+A user can invoke `script()` by executing one of these statements in the Testilo project directory:
 
-In this statement:
-- Replace `id` with an ID for the script, such as `headings`.
+```javascript
+node call script id ticnn issuea issueb …
+node call script id
+```
+
+In this statement, replace `id` with an ID for the script, such as `headings`.
+
+If specifying issues:
 - Replace `ticnn` with the base, such as `tic99`, of the name of an issue classification file in the `score` subdirectory of the `FUNCTIONDIR` directory.
 - Replace the remaining arguments (`issuea` etc.) with issue names from that classification file.
 
-The `call` module will retrieve the named classification.
+The `call` module will retrieve the named classification, if any.
 The `script` module will create a script.
 The `call` module will save the script as a JSON file in the `scripts` subdirectory of the `SPECDIR` directory.
 
-To create a script without any issue restrictions, a user can execute the statement `node call script id`.
-
 #### Options
 
 The `script` module will use the value of the `SEND_REPORT_TO` environment variable as the value of the `sendReportTo` property of the script, if that variable exists, and otherwise will leave that property with an empty-string value.
 
-When the `script` module creates a script for you, it does not ask you for all of the options that the script may require. Instead, it chooses default options. After you invoke `script`, you can edit the script that it creates to revise options.
+When the `script` module creates a script for you, it does not ask you for all of the options that the script may require. Instead, it chooses default options. For example, it sets the values of `isolate` and `strict` to `true`. After you invoke `script`, you can edit the script that it creates to revise options.
 
 ### Merge
 
-Testilo merges batches with scripts, producing jobs, by means of the `merge` module.
+Testilo merges batches with scripts, producing Testaro jobs, by means of the `merge` module.
+
+#### Invocation
+
+There are two ways to use the `merge` module.
+
+##### By a module
+
+A module can invoke `merge` in this way:
+
+```javaScript
+const {merge} = require('testilo/merge');
+const script = …;
+const batch = …;
+const standard = 'only';
+const observe = false;
+const requester = 'me@mydomain.tld';
+const timeStamp = '241215T1200';
+const jobs = merge(script, batch, standard, observe, requester, timeStamp);
+```
+
+The first two arguments are a script and a batch obtained from files or from prior calls to `script()` and `batch()`.
+
+The `standard` argument specifies how to handle standardization. If `also`, jobs will tell Testaro to include in its reports both the original results of the tests of tools and the Testaro-standardized results. If `only`, reports are to include only the standardized test results. If `no`, reports are to include only the original results, without standardization.
+
+The `observe` argument tells Testaro whether the jobs should allow granular observation. If `false`, Testaro will not report job progress, but will only send reports to the server when the reports are completed. It is generally user-friendly to allow granular observation, and for user applications to implement it, if they make users wait while jobs are assigned and performed, since that process typically takes a few minutes.
+
+The `timeStamp` argument specifies the earliest UTC date and time when the jobs may be assigned, or it may be an empty string if now.
+
+The `merge()` function returns the jobs in an array. The invoking module can further dispose of the jobs as needed.
+
+##### By a user
+
+A user can invoke `merge()` in this way:
+
+- Create a script and save it as a JSON file in the `scripts` subdirectory of the `SPECDIR` directory.
+- Create a batch and save it as a JSON file in the `batches` subdirectory of the `SPECDIR` directory.
+- In the Testilo project directory, execute the statement:
+
+```javascript
+node call merge scriptID batchID standard observe requester timeStamp todoDir
+```
+
+In this statement, replace:
+- `scriptID` with the ID (which is also the base of the file name) of the script.
+- `batchID` with the ID (which is also the base of the file name) of the batch.
+- `standard`, `observe`, `requester`, and `timeStamp` as described above.
+- `todoDir`: `true` if the jobs are to be saved in the `todo` subdirectory, or `false` if they are to be saved in the `pending` subdirectory, of the `JOBDIR` directory.
+
+The `call` module will retrieve the named script and batch from their respective directories.
+The `merge` module will create an array of jobs.
+The `call` module will save the jobs as JSON files in the `todo` or `pending` subdirectory of the `JOBDIR` directory.
 
 #### Output
 
-Suppose you ask for a merger of the above batch and script. Then the first job produced by `merge` will look like this:
+A Testaro job produced by `merge` may look like this:
 
 ```javaScript
 {
-  id: '240115T1200-4Rw-acme',
+  id: '240115T1200-4R-0',
   what: 'aside mislocation',
   strict: true,
   timeLimit: 60,
@@ -308,29 +355,9 @@ Suppose you ask for a merger of the above batch and script. Then the first job p
   acts: [
     {
       type: 'launch',
-      which: 'chromium',
-      what: 'Acme Clothes login page',
-      url: 'https://acmeclothes.com/login.html'
-    },
-    {
-      type: 'text',
-      which: 'User Name',
-      what: 'tester34'
-    },
-    {
-      type: 'text',
-      which: 'Password',
-      what: '34SecretTester'
-    },
-    {
-      type: 'button',
-      which: 'Submit',
-      what: 'submit the login form'
-    },
-    {
-      type: 'wait',
-      which: 'title',
-      what: 'account'
+      which: 'webkit',
+      what: 'Acme Clothes',
+      url: 'https://acmeclothes.com/'
     },
     {
       type: 'test',
@@ -341,29 +368,9 @@ Suppose you ask for a merger of the above batch and script. Then the first job p
     },
     {
       type: 'launch',
-      which: 'chromium',
-      what: 'Acme Clothes login page',
-      url: 'https://acmeclothes.com/login.html'
-    },
-    {
-      type: 'text',
-      which: 'User Name',
-      what: 'tester34'
-    },
-    {
-      type: 'text',
-      which: 'Password',
-      what: '34SecretTester'
-    },
-    {
-      type: 'button',
-      which: 'Submit',
-      what: 'submit the login form'
-    },
-    {
-      type: 'wait',
-      which: 'title',
-      what: 'account'
+      which: 'webkit',
+      what: 'Acme Clothes',
+      url: 'https://acmeclothes.com/'
     },
     {
       type: 'test',
@@ -376,77 +383,22 @@ Suppose you ask for a merger of the above batch and script. Then the first job p
   sources: {
     script: 'ts99',
     batch: 'clothing-stores',
+    lastTarget: false,
     target: {
       id: 'acme',
       what: 'Acme Clothes'
     },
     requester: 'you@yourdomain.tld'
   },
-  creationTime: '241120T1550'
+  creationTimeStamp: '241120T1550'
 }
 ```
 
-Testilo has substituted the `private` acts from the `acme` target of the batch for the placeholder when creating the job. Testilo also has:
-- inserted a copy of those same acts after the `axe` test act, because `axe` is a target-modifying tool.
-- let the script determine the browser type of the `launch` act.
-- given the job an ID that combines the time stamp with a differentiator and the batch ID.
-- inserted a `sources` property into the job, recording facts about the script, the batch, the target, the requester, and the report URL.
-- added a time stamp describing the creation time to the job.
-
-This is a valid Testaro job.
-
-#### Invocation
-
-There are two ways to use the `merge` module.
-
-##### By a module
-
-A module can invoke `merge` in this way:
-
-```javaScript
-const {merge} = require('testilo/merge');
-const jobs = merge(script, batch, standard, observe, requester, timeStamp);
-```
-
-The `merge` module uses these 4 arguments to create jobs from a script and a batch.
-
-The arguments are:
-- `script`: a script.
-- `batch`: a batch.
-- `standard`: how to handle standardization. If `also`, jobs will tell Testaro to include in its reports both the original results of the tests of tools and the Testaro-standardized results. If `only`, reports are to include only the standardized test results. If `no`, reports are to include only the original results, without standardization.
-- `observe`: whether to allow granular observation. If `true`, jobs will tell Testaro to permit granular observation of job progress. If `false`, jobs will tell Testaro not to permit granular observation, but only to send the report to the server when the report is completed. It is generally user-friendly to allow granular observation, and for user applications to implement it, if they make users wait while jobs are assigned and performed, since that process typically takes about 3 minutes.
-- `requester`: an email address.
-- `timeStamp`: the earliest UTC date and time when the jobs may be assigned (format `240415T1230`), or an empty string if now.
-
-The `merge()` function of the `merge` module generates jobs and returns them in an array. The invoking module can further dispose of the jobs as needed.
-
-##### By a user
-
-A user can invoke `merge` in this way:
-
-- Create a script and save it as a JSON file in the `scripts` subdirectory of the `SPECDIR` directory.
-- Create a batch and save it as a JSON file in the `batches` subdirectory of the `SPECDIR` directory.
-- In the Testilo project directory, execute the statement:
-
-```javascript
-node call merge scriptID batchID standard observe requester timeStamp todoDir
-```
-
-In this statement, replace:
-- `scriptID` with the ID (which is also the base of the file name) of the script.
-- `batchID` with the ID (which is also the base of the file name) of the batch.
-- `standard`, `observe`, `requester`, and `timeStamp` as described above.
-- `todoDir`: `true` if the jobs are to be saved in the `todo` subdirectory, or `false` if they are to be saved in the `pending` subdirectory, of the `JOBDIR` directory.
-
-The `call` module will retrieve the named script and batch from their respective directories.
-The `merge` module will create an array of jobs.
-The `call` module will save the jobs as JSON files in the `todo` or `pending` subdirectory of the `JOBDIR` directory.
-
 #### Validation
 
 To test the `merge` module, in the project directory you can execute the statement `node validation/merge/validate`. If `merge` is valid, all logging statements will begin with “Success” and none will begin with “ERROR”.
 
-## Report scoring
+## Report enhancement
 
 ### Introduction
 
@@ -459,16 +411,22 @@ Thus, a report produced by Testaro contains these properties:
 - `what`
 - `strict`
 - `timeLimit`
+- `standard`
+- `observe`
+- `sendReportTo`
+- `timeStamp`
 - `acts`
 - `sources`
-- `creationTime`
-- `timeStamp`
+- `creationTimeStamp`
 - `jobData`
 
-Testilo can enhance such a report in three ways:
+Testilo can enhance such a report by:
 - adding scores
 - creating digests
-- creating comprisons
+- creating difgests
+- creating comparisons
+
+## Scoring
 
 To add scores to reports, the `score` module of Testilo performs computations on the test results and adds a `score` property to each report.
 
@@ -480,7 +438,7 @@ A scoring function defines scoring rules. The Testilo package contains a `procs/
 
 ### Scorers
 
-The built-in scoring functions are named `scorer` and are exported by files whose names begin with `tsp` (for Testilo scoring proc). Those functions make use of `issues` objects defined in files whose names begin with `tic`. An `issues` object defines an issue classification: a body of data about rules of tools and the tool-agnostic issues that those rules are deemed to belong to.
+The built-in scoring functions are named `scorer()` and are exported by files whose names begin with `tsp` (for Testilo scoring proc). Those functions make use of `issues` objects defined in files whose names begin with `tic`. An `issues` object defines an issue classification: a body of data about rules of tools and the tool-agnostic issues that those rules are deemed to belong to.
 
 The properties of an `issues` object are issue objects: objects containing data about issues. Here is an example from `tic40.js`:
 
@@ -530,31 +488,36 @@ There are two ways to invoke the `score` module.
 
 #### By a module
 
-A module can invoke `score` in this way:
+A module can invoke `score()` in this way:
 
 ```javaScript
 const {score} = require('testilo/score');
 const {scorer} = require('testilo/procs/score/tsp99');
+const reports = …;
 score(scorer, reports);
 ```
 
-The first argument to `score()` is a scoring function. In this example, it has been obtained from a module in the Testilo package, but it could be a custom function. The second argument to `score()` is an array of report objects. The invoking module can further dispose of the scored reports as needed.
+The first argument to `score()` is a scoring function. In this example, it has been obtained from a module in the Testilo package, but it could be a custom function.
+
+The second argument to `score()` is an array of report objects. They may have been read from JSON   files and parsed, or the array may contain a single report object parsed from the body of a `POST` request received from a Testaro agent.
+
+The invoking module can further dispose of the scored reports as needed.
 
 #### By a user
 
-A user can invoke `score` in this way:
+A user can invoke `score()` in this way:
 
 ```bash
 node call score tsp99
 node call score tsp99 75m
 ```
 
-When a user invokes `score` in this example, the `call` module:
-- gets the scoring module `tsp99` from its JSON file `tsp99.json` in the `score` subdirectory of the `process.env.FUNCTIONDIR` directory.
-- gets the reports from the `raw` subdirectory of the `process.env.REPORTDIR` directory.
-- writes the scored reports in JSON format to the `scored` subdirectory of the `process.env.REPORTDIR` directory.
+When a user invokes `score()` in this example, the `call` module:
+- gets the scoring module `tsp99` from its JSON file `tsp99.json` in the `score` subdirectory of the `FUNCTIONDIR` directory.
+- gets the reports from the `raw` subdirectory of the `REPORTDIR` directory.
+- writes the scored reports in JSON format to the `scored` subdirectory of the `REPORTDIR` directory.
 
-The optional third argument to call (`75m` in this example) is a report selector. Without the argument, `call` gets all the reports in the `raw` subdirectory. With the argument, `call` gets only those reports whose names begin with the argument string.
+The optional third argument to `call()` (`75m` in this example) is a report selector. Without the argument, `call()` gets all the reports in the `raw` subdirectory. With the argument, `call()` gets only those reports whose names begin with the argument string.
 
 ### Validation
 
@@ -564,16 +527,16 @@ To test the `score` module, in the project directory you can execute the stateme
 
 ### Introduction
 
-Reports from Testaro are JavaScript objects. When represented as JSON, they are human-readable, but not human-friendly. They are basically designed for machine tractability. Testilo can _digest_ a scored report, converting it to a human-oriented HTML document, or _digest_.
+Reports from Testaro are JavaScript objects. When represented as JSON, they are human-readable, but not human-friendly. They are basically designed for machine tractability. This is equally true for reports that have been scored by Testilo. But Testilo can _digest_ a scored report, converting it to a human-oriented HTML document, or _digest_.
 
 The `digest` module digests a scored report. Its `digest()` function takes three arguments:
-- a digest template
 - a digesting function
 - an array of scored report objects
+- the URL of a directory containing the scored reports
 
-The digest template is an HTML document containing placeholders. A copy of the template, with its placeholders replaced by computed values, becomes the digest. The digesting function defines the rules for replacing the placeholders with values. The Testilo package contains a `procs/digest` directory, in which there are subdirectories, each containing a template and a modules that exports a digesting function. You can use one of those template-module pairs, or you can create your own.
+The digesting function populates an HTML digest template. A copy of the template, with its placeholders replaced by computed values, becomes the digest. The digesting function defines the rules for replacing the placeholders with values. The Testilo package contains a `procs/digest` directory, in which there are subdirectories, each containing a template and a module that exports a digesting function. You can use one of those modules, or you can create your own.
 
-The included template-module pairs format placeholders with leading and trailing underscore pairs (such as `__issueCount__`).
+The included templates format placeholders with leading and trailing underscore pairs (such as `__issueCount__`).
 
 ### Invocation
 
@@ -581,35 +544,103 @@ There are two ways to use the `digest` module.
 
 #### By a module
 
-A module can invoke `digest` in this way:
+A module can invoke `digest()` in this way:
 
 ```javaScript
 const {digest} = require('testilo/digest');
 const digesterDir = `${process.env.FUNCTIONDIR}/digest/tdp99a`;
 const {digester} = require(`${digesterDir}/index`);
-digest(digester, scoredReports)
+const scoredReports = …;
+const reportDirURL = 'https://xyz.org/a11yTesting/reports';
+digest(digester, scoredReports, reportDirURL)
 .then(digestedReports => {…});
 ```
 
-The first argument to `digest()` is a digesting function. In this example, it has been obtained from a files in the Testilo package, but it could be custom-made. The second argument to `digest()` is an array of scored report objects. The `digest()` function returns an array of digested reports. The invoking module can further dispose of the digested reports as needed.
+The first argument to `digest()` is a digesting function. In this example, it has been obtained from a file in the Testilo package, but it could be custom-made.
+
+The second argument to `digest()` is an array of scored report objects. They may have been read from JSON files and parsed, or the array may contain a single scored report output by `score()`.
+
+The third argument is the absolute or relative URL of a directory where the reports being digested are located. The `digest()` function needs that URL because a digest includes a link to the full report. The link concatenates the directory URL with the report ID and a `.json` suffix.
+
+The `digest()` function returns an array of digested reports. The invoking module can further dispose of the digested reports as needed.
 
 #### By a user
 
-A user can invoke `digest` in this way:
+A user can invoke `digest()` in this way:
 
 ```bash
 node call digest tdp99
 node call digest tdp99 75m
 ```
 
-When a user invokes `digest` in this example, the `call` module:
-- gets the template and the digesting module from subdirectory `tdp99` in the `digest` subdirectory of the `process.env.FUNCTIONDIR` directory.
-- gets the reports from the `scored` subdirectory of the `process.env.REPORTDIR` directory.
-- writes the digested reports to the `digested` subdirectory of the `process.env.REPORTDIR` directory.
+When a user invokes `digest()` in this example, the `call` module:
+- gets the template and the digesting module from subdirectory `tdp99` in the `digest` subdirectory of the `FUNCTIONDIR` directory.
+- gets the reports from the `scored` subdirectory of the `REPORTDIR` directory.
+- writes the digested reports to the `digested` subdirectory of the `REPORTDIR` directory.
+- includes in each digest a link to the scored report, with the link destination being based on `DIGEST_URL`.
+
+The third argument to `call()` can be an absolute URL, as shown, or a URL that is relative to the URL of the digest. For example, if it is known that the scored reports and the digests will inhabit the same directory and be retrievable with identical URLs except for the file extensions, then the third argument can be `./`.
+
+The optional fourth argument to `call()` (`75m` in this example) is a report selector. Without the argument, `call` gets all the reports in the `scored` subdirectory of the `REPORTDIR` directory. With the argument, `call` gets only those reports whose names begin with the argument string.
+
+The digests created by `digest()` are HTML files, and they expect a `style.css` file to exist in their directory. The `reports/digested/style.css` file in Testilo is an appropriate stylesheet to be copied into the directory where digested reports are written.
+
+## Report difgesting
+
+### Introduction
+
+A _difgest_ is a digest that compares two reports. They can be reports of different targets, or reports of the same target from two different times or under two different conditions.
+
+The `difgest` module difgests two scored reports. Its `difgest()` function takes five arguments:
+- a difgest template
+- a difgesting function
+- a scored report object
+- another scored report object
+- the URL of the digest of the first scored report
+- the URL of the digest of the second scored report
+
+The difgest template and module operate like the digest ones.
+
+### Invocation
+
+There are two ways to use the `difgest` module.
+
+#### By a module
+
+A module can invoke `difgest()` in this way:
+
+```javaScript
+const {difgest} = require('testilo/difgest');
+const difgesterDir = `${process.env.FUNCTIONDIR}/difgest/tdp99a`;
+const {difgester} = require(`${difgesterDir}/index`);
+const scoredReportA = …;
+const scoredReportB = …;
+const digestAURL = 'https://abc.com/testing/reports/digested/241022T1458-0.html';
+const digestBURL = 'https://abc.com/testing/reports/digested/241029T1458-0.html';
+difgest(difgester, scoredReportA, scoredReportB, digestAURL, digestBURL)
+.then(difgestedReport => {…});
+```
+
+The difgest will include links to the two digests, which, in turn, contain links to the full reports.
 
-The optional third argument to `call` (`75m` in this example) is a report selector. Without the argument, `call` gets all the reports in the `scored` subdirectory of the `process.env.REPORTDIR` directory. With the argument, `call` gets only those reports whose names begin with the argument string.
+`difgest()` returns a difgest. The invoking module can further dispose of the difgest as needed.
 
-The digests created by `digest` are HTML files, and they expect a `style.css` file to exist in their directory. The `reports/digested/style.css` file in Testilo is an appropriate stylesheet to be copied into the directory where digested reports are written.
+#### By a user
+
+A user can invoke `difgest` in this way:
+
+```bash
+node call difgest tfp99 20141215T1200-x7-3 20141215T1200-x7-4
+```
+
+When a user invokes `difgest` in this example, the `call` module:
+- gets the template and the difgesting module from subdirectory `tfp99` in the `difgest` subdirectory of the `FUNCTIONDIR` directory.
+- gets reports `20141215T1200-x7-3` and `20141215T1200-x7-4` from the `scored` subdirectory of the `REPORTDIR` directory.
+- writes the difgested report to the `difgested` subdirectory of the `REPORTDIR` directory.
+
+Difgests include links to the digests of the two reports. The destinations of those links are obtained from the `DIFGEST_URL` environment variable.
+
+Difgests expect a `style.css` file to exist in their directory, as digests do.
 
 ### Validation
 
@@ -648,15 +679,14 @@ The first argument to `compare()` is a comparison function. In this example, it
 A user can invoke `compare` in this way:
 
 ```bash
+node call compare tcp99 legislators
 node call compare tcp99 legislators 23pl
 ```
 
 When a user invokes `compare` in this example, the `call` module:
-- gets the comparison module from subdirectory `tcp99` of the subdirectory `compare` in the `process.env.FUNCTIONDIR` directory.
-- gets all the reports in the `scored` subdirectory of the `process.env.REPORTDIR` directory whose file names begin with `23pl`.
-- writes the comparative report as an HTML file named `legislators.html` to the `comparative` subdirectory of the `process.env.REPORTDIR` directory.
-
-The fourth argument to `call` (`23pl` in this example) is optional. If it is omitted, `call` will get and `comparer` will compare all the reports in the `scored` directory.
+- gets the comparison module from subdirectory `tcp99` of the subdirectory `compare` in the `FUNCTIONDIR` directory.
+- gets all the reports in the `scored` subdirectory of the `REPORTDIR` directory, or, if there is a fourth argument, whose file names begin with `23pl`.
+- writes the comparative report as an HTML file named `legislators.html` to the `comparative` subdirectory of the `REPORTDIR` directory.
 
 The comparative report created by `compare` is an HTML file, and it expects a `style.css` file to exist in its directory. The `reports/comparative/style.css` file in Testilo is an appropriate stylesheet to be copied into the directory where comparative reports are written.
 
@@ -699,8 +729,8 @@ node call credit legislators 23pl
 ```
 
 When a user invokes `credit` in this example, the `call` module:
-- gets all the reports in the `scored` subdirectory of the `process.env.REPORTDIR` directory whose file names begin with `23pl`.
-- writes the credit report as a JSON file named `legislators.json` to the `credit` subdirectory of the `process.env.REPORTDIR` directory.
+- gets all the reports in the `scored` subdirectory of the `REPORTDIR` directory whose file names begin with `23pl`.
+- writes the credit report as a JSON file named `legislators.json` to the `credit` subdirectory of the `REPORTDIR` directory.
 
 The third argument to `call` (`23pl` in this example) is optional. If it is omitted, `call` will get and `credit()` will tabulate all the reports in the `scored` directory.
 

package/call.js

@@ -16,6 +16,8 @@
 
 // Module to keep secrets.
 require('dotenv').config();
+// Module to perform common operations.
+const {getNowStamp, getRandomString} = require('./procs/util');
 // Function to process files.
 const fs = require('fs/promises');
 // Function to process a list-to-batch conversion.
@@ -28,6 +30,8 @@ const {merge} = require('./merge');
 const {score} = require('./score');
 // Function to digest reports.
 const {digest} = require('./digest');
+// Function to difgest reports.
+const {difgest} = require('./difgest');
 // Function to compare scores.
 const {compare} = require('./compare');
 
@@ -124,6 +128,7 @@ const callScore = async (scorerID, selector = '') => {
     // Score the reports.
     score(scorer, reports);
     const scoredReportDir = `${reportDir}/scored`;
+    await fs.mkdir(scoredReportDir, {recursive: true});
     // For each scored report:
     for (const report of reports) {
       // Save it.
@@ -151,6 +156,7 @@ const callDigest = async (digesterID, selector = '') => {
     // Digest the reports.
     const digestedReports = await digest(digester, reports);
     const digestedReportDir = `${reportDir}/digested`;
+    await fs.mkdir(digestedReportDir, {recursive: true});
     // For each digested report:
     for (const reportID of Object.keys(digestedReports)) {
       // Save it.
@@ -164,6 +170,34 @@ const callDigest = async (digesterID, selector = '') => {
     console.log('ERROR: No scored reports to be digested');
   }
 };
+// Fulfills a digesting request.
+const callDifgest = async (difgesterID, reportAID, reportBID) => {
+  // Get the scored reports to be difgested.
+  const reportAArray = await getReports('scored', reportAID);
+  const reportBArray = await getReports('scored', reportBID);
+  const reportA = reportAArray[0];
+  const reportB = reportBArray[0];
+  // If both exist:
+  if (reportAID && reportBID) {
+    // Get the difgester.
+    const difgesterDir = `${functionDir}/difgest/${difgesterID}`;
+    const {difgester} = require(`${difgesterDir}/index`);
+    // Difgest the reports.
+    const difgestedReport = await difgest(difgester, reportA, reportB);
+    const difgestedReportDir = `${reportDir}/difgested`;
+    await fs.mkdir(difgestedReportDir, {recursive: true});
+    // Save the difgested report.
+    const difgestID = `${getNowStamp()}-${getRandomString(2)}-0`;
+    const difgestPath = `${difgestedReportDir}/${difgestID}.html`;
+    await fs.writeFile(difgestPath, difgestedReport);
+    console.log(`Reports ${reportAID} and ${reportBID} difgested and saved as ${difgestPath}`);
+  }
+  // Otherwise, i.e. if no scored reports are to be digested:
+  else {
+    // Report this.
+    console.log('ERROR: No pair of scored reports to be digested');
+  }
+};
 // Fulfills a comparison request.
 // Get the scored reports to be scored.
 const callCompare = async (compareProcID, comparisonNameBase, selector = '') => {
@@ -177,6 +211,7 @@ const callCompare = async (compareProcID, comparisonNameBase, selector = '') =>
     const comparison = await compare(comparer, reports);
     // Save the comparison.
     const comparisonDir = `${reportDir}/comparative`;
+    await fs.mkdir(comparisonDir, {recursive: true}); 
     await fs.writeFile(`${comparisonDir}/${comparisonNameBase}.html`, comparison);
     console.log(`Comparison completed and saved in ${comparisonDir}`);
   }
@@ -192,8 +227,10 @@ const callCredit = async (tallyID, selector = '') => {
     // Tally the reports.
     const tally = credit(reports);
     // Save the tally.
-    await fs.writeFile(`${reportDir}/credit/${tallyID}.json`, JSON.stringify(tally, null, 2));
-    console.log(`Reports tallied and credit report saved in ${reportDir}/credit`);
+    const creditDir = `${reportDir}/credit`;
+    await fs.mkdir(creditDir, {recursive: true}); 
+    await fs.writeFile(`${creditDir}/${tallyID}.json`, JSON.stringify(tally, null, 2));
+    console.log(`Reports tallied and credit report saved in ${creditDir}`);
   }
   // Otherwise, i.e. if no scored reports are to be tallied:
   else {
@@ -217,7 +254,7 @@ else if (fn === 'batch' && fnArgs.length === 2) {
     console.log('Execution completed');
   });
 }
-else if (fn === 'script' && fnArgs.length) {
+else if (fn === 'script' && (fnArgs.length === 1 || fnArgs.length > 2)) {
   callScript(... fnArgs)
   .then(() => {
     console.log('Execution completed');
@@ -241,14 +278,14 @@ else if (fn === 'multiScore' && fnArgs.length === 1) {
     console.log('Execution completed');
   });
 }
-else if (fn === 'digest' && fnArgs.length > 0 && fnArgs.length < 3) {
+else if (fn === 'digest' && fnArgs.length && fnArgs.length < 3) {
   callDigest(... fnArgs)
   .then(() => {
     console.log('Execution completed');
   });
 }
-else if (fn === 'multiDigest' && fnArgs.length === 1) {
-  callMultiDigest(... fnArgs)
+else if (fn === 'difgest' && fnArgs.length === 3) {
+  callDifgest(... fnArgs)
   .then(() => {
     console.log('Execution completed');
   });

package/difgest.js

@@ -0,0 +1,17 @@
+/*
+  difgest.js
+  Creates difgests from scored reports.
+  Arguments:
+    0. Difgesting function.
+    1. Array of 2 scored reports.
+*/
+
+// ########## FUNCTIONS
+
+// Difgests the scored reports and returns a difgest.
+exports.difgest = async (difgester, reportA, reportB) => {
+  const difgestedReport = await difgester(reportA, reportB);
+  console.log(`Reports ${reportA.id} and ${reportB.id} difgested`);
+  // Return the difgest.
+  return difgestedReport;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "testilo",
-  "version": "24.3.1",
+  "version": "25.0.1",
   "description": "Prepares and processes Testaro reports",
   "main": "aim.js",
   "scripts": {

package/procs/compare/cpA11yMessage/index.js

@@ -12,14 +12,14 @@ const fs = require('fs/promises');
 
 // ########## CONSTANTS
 
-const reportDirScored = process.env.REPORTDIR_SCORED || 'reports/scored';
+const reportDir = process.env.REPORTDIR;
 const query = {};
 
 // ########## FUNCTIONS
 
 // Returns data on the hosts in the report directory.
 const getData = async () => {
-  const reportDirAbs = `${__dirname}/../../../${reportDirScored}`;
+  const reportDirAbs = `${__dirname}/../../../${reportDir}/scored`;
   const reportFileNamesAll = await fs.readdir(reportDirAbs);
   const reportFileNamesSource = reportFileNamesAll.filter(fileName => fileName.endsWith('.json'));
   const pageCount = reportFileNamesSource.length;

package/procs/compare/cpProductPrice/index.js

@@ -12,14 +12,14 @@ const fs = require('fs/promises');
 
 // ########## CONSTANTS
 
-const reportDirScored = process.env.REPORTDIR_SCORED || 'reports/scored';
+const reportDir = process.env.REPORTDIR;
 const query = {};
 
 // ########## FUNCTIONS
 
 // Returns data on the hosts in the report directory.
 const getData = async () => {
-  const reportDirAbs = `${__dirname}/../../../${reportDirScored}`;
+  const reportDirAbs = `${__dirname}/../../../${reportDir}/scored`;
   const reportFileNamesAll = await fs.readdir(reportDirAbs);
   const reportFileNamesSource = reportFileNamesAll.filter(fileName => fileName.endsWith('.json'));
   const pageCount = reportFileNamesSource.length;

package/procs/compare/{tcp39 → tcp40}/index.html

@@ -10,7 +10,7 @@
     <meta name="keywords" content="accessibility a11y web testing">
     <title>Accessibility score comparison</title>
     <link rel="icon" href="favicon.ico">
-    <link rel="stylesheet" href="/scores/style.css">
+    <link rel="stylesheet" href="style.css">
   </head>
   <body>
     <main>
@@ -19,7 +19,7 @@
       </header>
       <h2>Introduction</h2>
       <p>The table below compares __pageCount__ web pages on <a href="https://www.w3.org/WAI/fundamentals/accessibility-intro/">accessibility</a>. The page names are links to the pages on the web. The scores are links to digests that explain in detail how the scores were computed.</p>
-      <p>The pages were tested by <a href="https://www.npmjs.com/package/testaro">Testaro</a>. Testaro used nine tools (Alfa, ASLint, Axe, Equal Access, HTML CodeSniffer, Nu Html Checker, Testaro, and WAVE) to perform about 900 automated accessibility tests.</p>
+      <p>The pages were tested by <a href="https://www.npmjs.com/package/testaro">Testaro</a>. Testaro used ten tools (Alfa, ASLint, Axe, Editoria11y, Equal Access, HTML CodeSniffer, Nu Html Checker, QualWeb, Testaro, and WAVE) to perform about 900 automated accessibility tests.</p>
       <p><a href="https://www.npmjs.com/package/testilo">Testilo</a> classified the problems found by these tests into <dfn>issues</dfn> and assigned a <dfn>score</dfn> to each page. A perfect score would be 0. Higher scores indicate more issues, more instances of them, more serious issues, and more of the tools reporting instances of issues.</p>
       <h2>Comparison</h2>
       <table class="allBorder">

package/procs/compare/{tcp39 → tcp40}/index.js

@@ -7,14 +7,13 @@
 
 // Module to access files.
 const fs = require('fs/promises');
+const {getBarCell} = require('../../util');
 
 // CONSTANTS
 
 // Comparer ID.
 const id = 'tcp39';
 // Newlines with indentations.
-const joiner = '\n      ';
-const innerJoiner = '\n        ';
 const innestJoiner = '\n          ';
 
 // ########## FUNCTIONS
@@ -53,9 +52,7 @@ const getTableBody = async bodyData => {
     const pageCell = `<th scope="row"><a href="${url}">${org}</a></th>`;
     const numCell = `<td><a href="testu/digest?jobID=${id}">${score}</a></td>`;
     // Make the bar width proportional.
-    const barWidth = 100 * score / maxScore;
-    const bar = `<rect height="100%" width="${barWidth}%" fill="red"></rect>`;
-    const barCell = `<td aria-hidden="true"><svg width="100%" height="0.7em">${bar}</svg></td>`;
+    const barCell = getBarCell(score, maxScore);
     const row = `<tr>${pageCell}${numCell}${barCell}</tr>`;
     return row;
   });

package/procs/difgest/tfp40/index.html

@@ -0,0 +1,56 @@
+<!DOCTYPE HTML>
+<html lang="en-US">
+  <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta name="author" content="Testilo">
+    <meta name="creator" content="Testilo">
+    <meta name="publisher" name="Testilo">
+    <meta name="description" content="report of accessibility testing of a web page">
+    <meta name="keywords" content="accessibility a11y web testing">
+    <title>Accessibility difgest</title>
+    <link rel="icon" href="favicon.ico">
+    <link rel="stylesheet" href="style.css">
+  </head>
+  <body>
+    <main>
+      <header>
+        <h1>Accessibility difgest</h1>
+        <h2>Synopsis</h2>
+        <p>Difgested by: Testilo, proc __fp__</p>
+        <table class="allBorder">
+          <caption>Audit A</caption>
+          <tr><th>Page</th><td>__orgA__</td></tr>
+          <tr><th>URL</th><td>__urlA__</td></tr>
+          <tr><th>Test date</th><td>__dateSlashA__</td></tr>
+          <tr><th>Score</th><td>__totalA__</td></tr>
+          <tr><th>Digest</th><td><a href="__digestAURL__">__digestAURL__</a></td></tr>
+        </table>
+        <table class="allBorder">
+          <caption>Audit B</caption>
+          <tr><th>Page</th><td>__orgB__</td></tr>
+          <tr><th>URL</th><td>__urlB__</td></tr>
+          <tr><th>Test date</th><td>__dateSlashB__</td></tr>
+          <tr><th>Score</th><td>__totalB__</td></tr>
+          <tr><th>Digest</th><td><a href="__digestBURL__">__digestBURL__</a></td></tr>
+        </table>
+      </header>
+      <h2>Introduction</h2>
+      <p>This <q>difgest</q> summarizes the differences between the scores from the two accessibility audits referenced in the synopsis above. A perfect score would be 0.</p>
+      <h2>Issue summary</h2>
+      <p>Issues are ordered from the one on which B was most superior to the one on which A was most superior.</p>
+      <table class="allBorder">
+        <caption>Differences in issue scores</caption>
+        <thead>
+          <tr><th>Issue</th><th>WCAG</th><th>Score A</th><th>Score B</th><th>A &minus; B</th><th>A superiority</th><th>B superiority</th></tr>
+        </thead>
+        <tbody class="headersLeft">
+          __issueRows__
+        </tbody>
+      </table>
+      <footer>
+        <p class="date">Produced <time itemprop="datePublished" datetime="__dateISO__">__dateSlash__</time></p>
+      </footer>
+    </main>
+  </body>
+</html>

package/procs/difgest/tfp40/index.js

@@ -0,0 +1,109 @@
+// index: difgester for scoring procedure tsp40.
+
+// IMPORTS
+
+// Module to keep secrets.
+require('dotenv').config();
+// Module to classify tool rules into issues
+const {issues} = require('../../score/tic40');
+// Module to process files.
+const fs = require('fs/promises');
+// Utility module.
+const {getBarCell} = require('../../util');
+
+// CONSTANTS
+
+// Difgester ID.
+const id = 'tfp40';
+// Newline with indentations.
+const innerJoiner = '\n          ';
+
+// FUNCTIONS
+
+// Gets a row of the issue-score-summary table.
+const getIssueScoreRow = (summary, wcag, scoreA, scoreB, bSuperiorityMax, aSuperiorityMax) => {
+  const bSuperiority = scoreA - scoreB;
+  const barCell = getBarCell(
+    Math.abs(bSuperiority), bSuperiority > 0 ? bSuperiorityMax : aSuperiorityMax, bSuperiority < 0
+  );
+  const cells = [
+    `<th>${summary}</th>`,
+    `<td class="center">${wcag}</td>`,
+    `<td class="right">${scoreA}</td>`,
+    `<td class="right">${scoreB}</td>`,
+    `<td class="right">${scoreA - scoreB}</td>`,
+    bSuperiority < 0 ? barCell : '<td></td>',
+    bSuperiority > 0 ? barCell : '<td></td>'
+  ];
+  return `<tr>${cells.join('')}</tr>`;
+};
+// Adds parameters to a query for a difgest.
+const populateQuery = (reportA, reportB, query) => {
+  // General parameters.
+  query.fp = id;
+  query.dateISO = new Date().toISOString().slice(0, 10);
+  query.dateSlash = query.dateISO.replace(/-/g, '/');
+  // For each report:
+  const issueIDs = new Set();
+  [reportA, reportB].forEach((report, index) => {
+    // Add report-specific synopsis parameters to the query.
+    const suffix = ['A', 'B'][index];
+    const {id, sources, jobData, score} = report;
+    const {target} = sources;
+    const {summary, details} = score;
+    query[`org${suffix}`] = target.what;
+    query[`url${suffix}`] = target.which;
+    const dateISO = jobData.endTime.slice(0, 8);
+    query[`dateSlash${suffix}`] = dateISO.replace(/-/g, '/');
+    query[`total${suffix}`] = summary.total;
+    query[`digest${suffix}URL`] = process.env.DIGEST_URL.replace('__id__', id);
+    // Get the union of the issues in the reports.
+    Object.keys(details.issue).forEach(issueID => issueIDs.add(issueID));
+  });
+  // Get data on the issues.
+  const issuesData = Array.from(issueIDs).map(issueID => {
+    const issueDataA = reportA.score.details.issue[issueID] || null;
+    const issueDataB = reportB.score.details.issue[issueID] || null;
+    return {
+      id: issueID,
+      what: issueDataA ? issueDataA.summary : issueDataB.summary,
+      wcag: issueDataA ? issueDataA.wcag : issueDataB.wcag,
+      scoreA: issueDataA ? issueDataA.score : 0,
+      scoreB: issueDataB ? issueDataB.score : 0
+    };
+  });
+  // Sort the issue data in descending order of B less A scores.
+  issuesData.sort((i, j) => i.scoreB - i.scoreA - j.scoreB + j.scoreA);
+  // Get rows for the issue-score table.
+  const bSuperiorityMax = Math.max(0, issuesData[0].scoreA - issuesData[0].scoreB);
+  const lastIssue = issuesData[issueIDs.size - 1];
+  const aSuperiorityMax = Math.max(0, lastIssue.scoreB - lastIssue.scoreA);
+  const issueRows = [];
+  issuesData.forEach(issueData => {
+    const {id, what, wcag, scoreA, scoreB} = issueData;
+    if (issues[id]) {
+      issueRows.push(
+        getIssueScoreRow(what, wcag, scoreA, scoreB, bSuperiorityMax, aSuperiorityMax)
+      );
+    }
+    else {
+      console.log(`ERROR: Issue ${id} not found`);
+    }
+  });
+  // Add the rows to the query.
+  query.issueRows = issueRows.join(innerJoiner);
+};
+// Returns a difgested report.
+exports.difgester = async (reportA, reportB) => {
+  // Create a query to replace placeholders.
+  const query = {};
+  populateQuery(reportA, reportB, query);
+  // Get the template.
+  let template = await fs.readFile(`${__dirname}/index.html`, 'utf8');
+  // Replace its placeholders.
+  Object.keys(query).forEach(param => {
+    template = template.replace(new RegExp(`__${param}__`, 'g'), query[param]);
+  });
+  // Return the digest.
+  return template;
+};

package/procs/digest/dpProductPrice/index.js

@@ -1,8 +1,8 @@
 /*
   index: digester for scoring procedure spA11yMessage.
   Creator of parameters for substitution into index.html.
-  Usage example for selected files in REPORTDIR_SCORED: node digest dpA11yMessage 35k1r
-  Usage example for all files in REPORTDIR_SCORED: node digest dpA11yMessage
+  Usage example for selected files in REPORTDIR/scored: node digest dpA11yMessage 35k1r
+  Usage example for all files in REPORTDIR/scored: node digest dpA11yMessage
 */
 
 // CONSTANTS

package/procs/digest/dpa11yMessage/index.js

@@ -1,14 +1,13 @@
 /*
   index: digester for scoring procedure spA11yMessage.
   Creator of parameters for substitution into index.html.
-  Usage example for selected files in REPORTDIR_SCORED: node digest dpA11yMessage 35k1r
-  Usage example for all files in REPORTDIR_SCORED: node digest dpA11yMessage
+  Usage example for selected files in REPORTDIR/scored: node digest dpA11yMessage 35k1r
+  Usage example for all files in REPORTDIR/scored: node digest dpA11yMessage
 */
 
 // CONSTANTS
 
   // Newlines with indentations.
-  const joiner = '\n      ';
   const innerJoiner = '\n        ';
 
 // FUNCTIONS

package/procs/digest/tdp40/index.html

@@ -28,7 +28,7 @@
           <tr><th>Digested by</th><td>Testilo, procedure <code>__dp__</code></td></tr>
           <tr>
             <th>Full report</th>
-            <td><a href="__getReportFrom__"><code>__getReportFrom__</code></a></td>
+            <td><a href="__reportURL__"><code>__reportURL__</code></a></td>
           </tr>
         </table>
       </header>
@@ -47,7 +47,7 @@
         </tbody>
       </table>
       <h2>Itemized issues</h2>
-      <p>The reported rule violations are itemized below, issue by issue. Additional details can be inspected in the <a href="__getReportFrom__">full report</a>.</p>
+      <p>The reported rule violations are itemized below, issue by issue. Additional details can be inspected in the <a href="__reportURL__">full report</a>.</p>
       __issueDetailRows__
       <footer>
         <p class="date">Produced <time itemprop="datePublished" datetime="__dateISO__">__dateSlash__</time></p>

package/procs/digest/tdp40/index.js

@@ -2,6 +2,8 @@
 
 // IMPORTS
 
+// Module to keep secrets.
+require('dotenv').config();
 // Module to classify tool rules into issues
 const {issues} = require('../../score/tic40');
 // Module to process files.
@@ -10,7 +12,7 @@ const fs = require('fs/promises');
 // CONSTANTS
 
 // Digester ID.
-const id = 'tdp40';
+const digesterID = 'tdp40';
 // Newline with indentations.
 const innerJoiner = '\n        ';
 
@@ -21,23 +23,23 @@ const getScoreRow = (componentName, score) => `<tr><th>${componentName}</th><td>
 // Gets a row of the issue-score-summary table.
 const getIssueScoreRow = (summary, wcag, score, tools) => {
   const toolList = tools.map(tool => `<code>${tool}</code>`).join(', ');
-  return `<tr><th>${summary}</th><td>${wcag}<td>${score}</td><td>${toolList}</tr>`;
+  return `<tr><th>${summary}</th><td>${wcag}<td>${score}</td><td>${toolList}</td></tr>`;
 };
 // Adds parameters to a query for a digest.
 const populateQuery = (report, query) => {
-  const {getReportFrom, sources, jobData, score} = report;
+  const {id, sources, jobData, score} = report;
   const {script, target, requester} = sources;
   const {scoreProcID, summary, details} = score;
   query.ts = script;
   query.sp = scoreProcID;
-  query.dp = id;
+  query.dp = digesterID;
   // Add the job data to the query.
   query.dateISO = jobData.endTime.slice(0, 8);
   query.dateSlash = query.dateISO.replace(/-/g, '/');
   query.org = target.what;
   query.url = target.which;
   query.requester = requester;
-  query.getReportFrom = getReportFrom || `reports/${report.id}.json`;
+  query.reportURL = process.env.SCORED_REPORT_URL.replace('__id__', id);
   // Add values for the score-summary table to the query.
   const rows = {
     summaryRows: [],

package/procs/score/tic40.js

@@ -300,6 +300,11 @@ exports.issues = {
           variable: false,
           quality: 1,
           what: 'id attribute value is not unique'
+        },
+        'QW-WCAG-T35': {
+          variable: false,
+          quality: 1,
+          what: 'Several elements have this id attribute value'
         }
       }
     }

package/procs/score/tsp40.js

@@ -146,6 +146,7 @@ exports.scorer = report => {
                 if (! details.issue[issueName]) {
                   details.issue[issueName] = {
                     summary: issues[issueName].summary,
+                    wcag: issues[issueName].wcag || '',
                     score: 0,
                     maxCount: 0,
                     weight: issues[issueName].weight,

package/procs/util.js

@@ -63,3 +63,12 @@ exports.getRandomString = length => {
   }
   return chars.join('');
 };
+// Returns a graph bar.
+exports.getBarCell = (num, max, isRight = false) => {
+  // Make the bar width proportional.
+  const barWidth = 100 * num / max;
+  const xAtt = isRight ? ` x=${100 - barWidth}%` : '';
+  const bar = `<rect height="100%"${xAtt} width="${barWidth}%" fill="red"></rect>`;
+  const barCell = `<td aria-hidden="true"><svg width="100%" height="0.7em">${bar}</svg></td>`;
+  return barCell;
+};