jats-xml 0.0.15 → 0.0.17

package/README.md

@@ -53,6 +53,28 @@ This will provide a summary, including a list of what the JATS file contains.
 jats validate article.jats --jats 1.2 --mathmml 2
 ```
 
+`test`: test a JATS file against a list of unit tests in YAML
+
+The test cases are useful for known exports and expecting specific pieces of information in the XML.
+
+```bash
+jats test article.jats --cases tests.yml
+```
+
+```yaml
+cases:
+  - title: Correct publisher ID (publisher-id)
+    select: 'front > journal-meta > journal-id[journal-id-type="publisher-id"] > *'
+    equals:
+      type: text
+      value: plos
+  - title: Every orcid is authenticated
+    selectAll: 'front > article-meta > contrib-group > contrib > contrib-id'
+    equals:
+      contrib-id-type: orcid
+      authenticated: 'true'
+```
+
 ## Working in Typescript
 
 All tags are accessible as types/enums. There is also documentation from each node-type

package/dist/cjs/cli/index.js

@@ -8,9 +8,11 @@ const commander_1 = __importDefault(require("commander"));
 const version_1 = __importDefault(require("../version"));
 const parse_1 = require("./parse");
 const validate_1 = require("./validate");
+const jats_test_1 = require("./jats-test");
 const program = new commander_1.default.Command();
 (0, parse_1.addDownloadCLI)(program);
 (0, validate_1.addValidateCLI)(program);
+(0, jats_test_1.addTestCLI)(program);
 program.version(`v${version_1.default}`, '-v, --version', 'Print the current version of jats-xml');
 program.option('-d, --debug', 'Log out any errors to the console.');
 program.parse(process.argv);

package/dist/cjs/cli/jats-test.js

@@ -0,0 +1,125 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTestCLI = exports.testJatsFile = void 0;
+const commander_1 = require("commander");
+const myst_cli_utils_1 = require("myst-cli-utils");
+const session_1 = require("../session");
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const fs_1 = __importDefault(require("fs"));
+const parse_1 = require("./parse");
+const unist_util_select_1 = require("unist-util-select");
+const unist_util_is_1 = require("unist-util-is");
+const chalk_1 = __importDefault(require("chalk"));
+const INDENT = '       ';
+function printNodes(expected, received) {
+    return chalk_1.default.reset(`\n${INDENT}${chalk_1.default.greenBright('Expected node containing')}:\n${INDENT}  ${js_yaml_1.default
+        .dump(expected)
+        .replace(/\n/g, `\n${INDENT}  `)}\n${INDENT}${chalk_1.default.redBright('Received node')}:\n${INDENT}  ${js_yaml_1.default.dump(received).replace(/\n/g, `\n${INDENT}  `)}`);
+}
+function testJatsFile(session, file, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const toc = (0, myst_cli_utils_1.tic)();
+        const jats = yield (0, parse_1.parseJats)(session, file);
+        const tests = js_yaml_1.default.load(fs_1.default.readFileSync(opts.cases).toString());
+        const results = tests.cases.map((testCase, index) => {
+            if (!testCase.title) {
+                return [`Test Case ${index}`, null, 'Test must include a title'];
+            }
+            if (testCase.equals === undefined) {
+                return [testCase.title, null, 'Test must have an equals statement'];
+            }
+            if (testCase.select) {
+                const node = (0, unist_util_select_1.select)(testCase.select, jats.tree);
+                const pass = (0, unist_util_is_1.is)(node, testCase.equals);
+                if (testCase.equals == null && node) {
+                    return [testCase.title, false, 'Expected no node to be present'];
+                }
+                if (!node && testCase.equals == null)
+                    return [testCase.title, true];
+                if (!node)
+                    return [testCase.title, false];
+                let failed = false;
+                const messages = [];
+                if (!pass) {
+                    failed = failed || true;
+                    messages.push(`Failed to validate node\n${printNodes(testCase.equals, node)}`);
+                }
+                return [testCase.title, !failed, messages.join('\n')];
+            }
+            else if (testCase.selectAll) {
+                const testNodes = (0, unist_util_select_1.selectAll)(testCase.selectAll, jats.tree);
+                if (!testNodes && testCase.equals == null)
+                    return [testCase.title, true];
+                if (!testNodes)
+                    return [testCase.title, false, 'Node not found'];
+                let equals = testCase.equals;
+                if (!Array.isArray(testCase.equals)) {
+                    equals = Array(testNodes.length).fill(testCase.equals);
+                }
+                let failed = false;
+                const messages = [];
+                if (equals.length !== testNodes.length) {
+                    failed = failed || true;
+                    messages.push(`Expected ${equals.length} nodes, got ${testNodes.length}\n${printNodes(equals, testNodes)}`);
+                }
+                else {
+                    equals.forEach((node, ii) => {
+                        const pass = (0, unist_util_is_1.is)(testNodes[ii], node);
+                        if (!pass) {
+                            failed = failed || true;
+                            messages.push(`Failed to validate node ${ii}\n${printNodes(node, testNodes[ii])}`);
+                        }
+                    });
+                }
+                return [testCase.title, !failed, messages.join('\n')];
+            }
+            else {
+                return [testCase.title, false, 'Test must have either `select` or `selectAll`'];
+            }
+        });
+        results.forEach((result) => {
+            const [title, pass, message] = result;
+            if (pass === null)
+                session.log.info(`${chalk_1.default.redBright.bold(`ERROR`)} - ${title}\n  ${chalk_1.default.blueBright(message)}`);
+            else if (pass)
+                session.log.info(`${chalk_1.default.green(`PASS`)} - ${title}`);
+            else
+                session.log.info(`${chalk_1.default.red(`FAIL`)} - ${title}\n\n${INDENT}${chalk_1.default.blueBright(message)}\n`);
+        }, true);
+        const passed = results.reduce((num, [, pass]) => num + (pass ? 1 : 0), 0);
+        const failed = results.length - passed;
+        if (failed > 0 && passed === 0) {
+            throw new Error(toc(`${chalk_1.default.red(`Failed ${failed} tests in %s`)} 👎`));
+        }
+        if (failed > 0) {
+            throw new Error(toc(`${chalk_1.default.green(`Passed ${passed}/${results.length} tests in %s`)}\n${chalk_1.default.red(`Failed ${failed} tests`)} 👎`));
+        }
+        session.log.info(chalk_1.default.green(toc(`Passed ${passed} tests in %s 🚀`)));
+        return true;
+    });
+}
+exports.testJatsFile = testJatsFile;
+function makeTestCLI(program) {
+    const command = new commander_1.Command('test')
+        .description('Test JATS file against a list of cases')
+        .argument('<file>', 'JATS file to test')
+        .addOption(new commander_1.Option('--cases <value>', 'The YAML file of unit tests to test against'))
+        .action((0, myst_cli_utils_1.clirun)(testJatsFile, { program, getSession: session_1.getSession }));
+    return command;
+}
+function addTestCLI(program) {
+    program.addCommand(makeTestCLI(program));
+}
+exports.addTestCLI = addTestCLI;

package/dist/cjs/cli/parse.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addDownloadCLI = void 0;
+exports.addDownloadCLI = exports.parseJats = void 0;
 const commander_1 = require("commander");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = require("path");
@@ -77,6 +77,7 @@ function parseJats(session, file, opts = { resolvers: resolvers_1.DEFAULT_RESOLV
         return jats;
     });
 }
+exports.parseJats = parseJats;
 function formatLongString(data, offset = 0, length = 88 - offset) {
     const out = [data.slice(0, length)];
     let left = data.slice(length);

package/dist/cjs/cli/validate.js

@@ -7,11 +7,18 @@ const session_1 = require("../session");
 const validate_1 = require("../validate");
 function makeValidateCLI(program) {
     const command = new commander_1.Command('validate')
-        .description('Fetch JATS DTD schema file from nih.gov ftp server')
+        .description(`
+      Validate JATS file against DTD schema.
+      
+      The JATS DTD schema file is fetched from nih.gov ftp server if not available locally.
+      This will attempt to infer the specific JATS DTD version, library, etc from the file header,
+      but options are available to override the inferred values.
+      `)
         .argument('<file>', 'JATS file to validate')
-        .addOption(new commander_1.Option('--jats <version>', 'JATS version, must be 1.2 or later').default('1.3'))
-        .addOption(new commander_1.Option('--mathml <version>', 'MathML version, 2 or 3').default('3'))
-        .addOption(new commander_1.Option('--oasis', 'Use OASIS table model').default(false))
+        .addOption(new commander_1.Option('--library <value>', 'JATS library - archiving, publishing, or authoring (default: archiving, if value cannot be inferred from file)'))
+        .addOption(new commander_1.Option('--jats <version>', 'JATS version, must be 1.1 or later (default: 1.3, if value cannot be inferred from file)'))
+        .addOption(new commander_1.Option('--mathml <version>', 'MathML version, 2 or 3 (default: 3, if value cannot be inferred from file)'))
+        .addOption(new commander_1.Option('--oasis', 'Use OASIS table model (default: false, if value cannot be inferred from file)'))
         .addOption(new commander_1.Option('--directory <value>', 'Directory to save DTD file'))
         .action((0, myst_cli_utils_1.clirun)(validate_1.validateJatsAgainstDtdWrapper, { program, getSession: session_1.getSession }));
     return command;

package/dist/cjs/utils.js

@@ -14,13 +14,18 @@ function convertToUnist(node) {
             const { name, attributes, elements } = node;
             const children = elements === null || elements === void 0 ? void 0 : elements.map(convertToUnist).filter((n) => !!n);
             const next = Object.assign({ type: name !== null && name !== void 0 ? name : 'unknown' }, attributes);
-            if (children)
+            if (name === 'code') {
+                next.value = elements === null || elements === void 0 ? void 0 : elements[0].text;
+            }
+            else if (children)
                 next.children = children;
             return next;
         }
         case 'text': {
             const { attributes, text } = node;
-            return Object.assign(Object.assign({ type: 'text' }, attributes), { value: String(text) });
+            return Object.assign(Object.assign({ type: 'text' }, attributes), { value: String(text)
+                    .replace(/\n(\s+)$/, '')
+                    .replace('\n', ' ') });
         }
         case 'cdata': {
             const { attributes, cdata } = node;

package/dist/cjs/validate/dtd.js

@@ -35,7 +35,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateJatsAgainstDtdWrapper = exports.validateJatsAgainstDtd = void 0;
+exports.validateJatsAgainstDtdWrapper = exports.validateJatsAgainstDtd = exports.inferOptions = void 0;
 const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const node_fetch_1 = __importDefault(require("node-fetch"));
@@ -43,15 +43,54 @@ const unzipper_1 = __importDefault(require("unzipper"));
 const which_1 = require("which");
 const myst_cli_utils_1 = require("myst-cli-utils");
 const chalk_1 = __importDefault(require("chalk"));
-const JATS_VERSIONS = ['1.2', '1.2d1', '1.2d2', '1.3', '1.3d1', '1.3d2'];
+const JATS_VERSIONS = [
+    '1.1',
+    '1.1d1',
+    '1.1d2',
+    '1.1d3',
+    '1.2',
+    '1.2d1',
+    '1.2d2',
+    '1.3',
+    '1.3d1',
+    '1.3d2',
+];
 const DEFAULT_JATS_VERSION = '1.3';
 const MATHML_VERSIONS = ['2', '3'];
 const DEFAULT_MATHML_VERSION = '3';
-function validateOptions(opts) {
-    var _a;
+const JATS_LIBRARIES = ['authoring', 'publishing', 'archiving'];
+const DEFAULT_JATS_LIBRARY = 'archiving';
+/**
+ * Return static/ directory adjacent to the code
+ *
+ * This provides a standard location to cache DTD files, minimizing re-downloading.
+ */
+function defaultDirectory() {
+    return path_1.default.join(__dirname, 'static');
+}
+function warnOnOptionsMismatch(session, opts, inferredOpts) {
+    if (opts.jats && inferredOpts.jats && opts.jats !== inferredOpts.jats) {
+        session.log.warn(`Using JATS version ${opts.jats}; does not match version inferred from file ${inferredOpts.jats}`);
+    }
+    if (opts.library && inferredOpts.library && opts.library !== inferredOpts.library) {
+        session.log.warn(`Using JATS library ${opts.library}; does not match library inferred from file ${inferredOpts.library}`);
+    }
+    if (opts.mathml && inferredOpts.mathml && opts.mathml !== inferredOpts.mathml) {
+        session.log.warn(`Using MathML version ${opts.mathml}; does not match version inferred from file ${inferredOpts.mathml}`);
+    }
+    if (opts.oasis && !inferredOpts.oasis) {
+        session.log.warn('Using OASIS table model; does not match non-OASIS inferred from file');
+    }
+}
+/**
+ * Validate input value as JATS options and fill in defaults
+ */
+function validateOptions(session, opts, inferredOpts) {
+    var _a, _b, _c, _d, _e;
+    warnOnOptionsMismatch(session, opts, inferredOpts);
     let jats;
     if (!opts.jats) {
-        jats = DEFAULT_JATS_VERSION;
+        jats = (_a = inferredOpts.jats) !== null && _a !== void 0 ? _a : DEFAULT_JATS_VERSION;
     }
     else if (!JATS_VERSIONS.includes(opts.jats)) {
         throw new Error(`Invalid JATS version "${opts.jats}" - must be one of [${JATS_VERSIONS.join(', ')}]`);
@@ -61,7 +100,7 @@ function validateOptions(opts) {
     }
     let mathml;
     if (!opts.mathml) {
-        mathml = DEFAULT_MATHML_VERSION;
+        mathml = (_b = inferredOpts.mathml) !== null && _b !== void 0 ? _b : DEFAULT_MATHML_VERSION;
     }
     else if (!MATHML_VERSIONS.includes(opts.mathml)) {
         throw new Error(`Invalid MathML version "${opts.mathml}" - must be one of [${MATHML_VERSIONS.join(', ')}]`);
@@ -69,41 +108,128 @@ function validateOptions(opts) {
     else {
         mathml = opts.mathml;
     }
+    let library;
+    if (!opts.library) {
+        library = (_c = inferredOpts.library) !== null && _c !== void 0 ? _c : DEFAULT_JATS_LIBRARY;
+    }
+    else if (typeof opts.library !== 'string' ||
+        !JATS_LIBRARIES.includes(opts.library.toLowerCase())) {
+        throw new Error(`Invalid JATS library "${opts.library}" - must be one of [${JATS_LIBRARIES.join(', ')}]`);
+    }
+    else {
+        library = opts.library.toLowerCase();
+    }
+    const oasis = (_d = inferredOpts.oasis) !== null && _d !== void 0 ? _d : !!opts.oasis;
+    if (library === 'authoring' && oasis) {
+        throw new Error('JATS article authoring library cannot use OASIS table model');
+    }
     const out = {
+        library,
         jats,
         mathml,
-        oasis: !!opts.oasis,
-        directory: (_a = opts.directory) !== null && _a !== void 0 ? _a : defaultDirectory(),
+        oasis,
+        directory: (_e = opts.directory) !== null && _e !== void 0 ? _e : defaultDirectory(),
     };
     return out;
 }
+/**
+ * DTD folder name
+ */
 function dtdFolder(opts) {
     const version = opts.jats.replace('.', '-');
     const oasis = opts.oasis ? '-OASIS' : '';
     const mathml = `MathML${opts.mathml}`;
-    return `JATS-Archiving-${version}${oasis}-${mathml}-DTD`;
+    const library = opts.library.charAt(0).toUpperCase() + opts.library.slice(1);
+    return `JATS-${library}-${version}${oasis}-${mathml}-DTD`;
 }
+/**
+ * DTD zip file name on FTP server
+ */
 function dtdZipFile(opts) {
     return `${dtdFolder(opts)}.zip`;
 }
+/**
+ * Local location of DTD zip file
+ */
 function localDtdZipFile(opts) {
     return path_1.default.join(opts.directory, dtdZipFile(opts));
 }
+/**
+ * Extracted DTD file name
+ */
 function dtdFile(opts) {
-    const version = opts.jats.startsWith('1.2') ? '1' : opts.jats.replace('.', '-');
-    const article = opts.oasis ? 'archive-oasis-article' : 'archivearticle';
+    const version = opts.jats.startsWith('1.3') ? opts.jats.replace('.', '-') : '1';
+    let article;
+    if (opts.library === 'archiving') {
+        article = opts.oasis ? 'archive-oasis-article' : 'archivearticle';
+    }
+    else if (opts.library === 'publishing') {
+        article = opts.oasis ? 'journalpublishing-oasis-article' : 'journalpublishing';
+    }
+    else {
+        article = 'articleauthoring';
+    }
     const mathml = opts.mathml === '3' ? '-mathml3' : '';
     return `JATS-${article}${version}${mathml}.dtd`;
 }
+/**
+ * Local location of extracted DTD file
+ */
 function localDtdFile(opts) {
     return path_1.default.join(opts.directory, dtdFolder(opts), dtdFile(opts));
 }
+/**
+ * NIH FTP server and path for downloading JATS DTD files
+ *
+ * This is accessed by node-fetch over https.
+ */
 function ftpUrl(opts) {
-    return `https://ftp.ncbi.nih.gov/pub/jats/archiving/${opts.jats}/${dtdZipFile(opts)}`;
+    const library = opts.library === 'authoring' ? 'articleauthoring' : opts.library;
+    return `https://ftp.ncbi.nih.gov/pub/jats/${library}/${opts.jats}/${dtdZipFile(opts)}`;
 }
-function defaultDirectory() {
-    return path_1.default.join(__dirname, 'static');
+/**
+ * Create a DTS-filename-options lookup for implicitly setting options based on JATS header content
+ */
+function buildDtdFileLookup() {
+    const lookup = {};
+    JATS_VERSIONS.filter((jats) => jats === '1.2' || jats.startsWith('1.3')).forEach((jats) => {
+        MATHML_VERSIONS.forEach((mathml) => {
+            JATS_LIBRARIES.forEach((library) => {
+                (library === 'authoring' ? [false] : [true, false]).forEach((oasis) => {
+                    const opts = { jats, mathml, library, oasis };
+                    lookup[dtdFile(opts)] = opts;
+                });
+            });
+        });
+    });
+    return lookup;
+}
+/**
+ * Infer DTD options from file content
+ *
+ * This looks at DTD file name in DOCTYPE as well as dtd-version in article element
+ */
+function inferOptions(file) {
+    var _a, _b;
+    const data = fs_1.default.readFileSync(file).toString();
+    const doctype = (_a = data.match(/<!DOCTYPE [\s\S]+?">/g)) === null || _a === void 0 ? void 0 : _a[0];
+    const lookup = buildDtdFileLookup();
+    let opts = {};
+    Object.entries(lookup).forEach(([key, value]) => {
+        if (doctype === null || doctype === void 0 ? void 0 : doctype.includes(key))
+            opts = Object.assign({}, value);
+    });
+    const article = (_b = data.match(/<article [\s\S]+?>/g)) === null || _b === void 0 ? void 0 : _b[0];
+    JATS_VERSIONS.forEach((jats) => {
+        if (article === null || article === void 0 ? void 0 : article.includes(`dtd-version="${jats}"`))
+            opts.jats = jats;
+    });
+    return opts;
 }
+exports.inferOptions = inferOptions;
+/**
+ * Download DTD zip file from NIH FTP server
+ */
 function dtdDownload(session, opts) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!fs_1.default.existsSync(opts.directory)) {
@@ -115,6 +241,9 @@ function dtdDownload(session, opts) {
         (0, myst_cli_utils_1.writeFileToFolder)(localDtdZipFile(opts), yield resp.buffer());
     });
 }
+/**
+ * Download DTD zip file from NIH FTP server if it does not yet exist
+ */
 function ensureDtdZipExists(session, opts) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!fs_1.default.existsSync(path_1.default.join(opts.directory, dtdZipFile(opts)))) {
@@ -122,32 +251,48 @@ function ensureDtdZipExists(session, opts) {
         }
     });
 }
+/**
+ * Download and extract DTD file if it does not yet exist
+ */
 function ensureDtdExists(session, opts) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!fs_1.default.existsSync(localDtdFile(opts))) {
             yield ensureDtdZipExists(session, opts);
             const zipFile = localDtdZipFile(opts);
-            session.log.info(`🤐 Unzipping template on disk ${zipFile}`);
+            session.log.info(`🤐 Unzipping template: ${zipFile}`);
             yield (0, fs_1.createReadStream)(zipFile)
                 .pipe(unzipper_1.default.Extract({ path: opts.directory }))
                 .promise();
         }
-        session.log.debug(`Validating against ${localDtdFile(opts)}`);
     });
 }
+/**
+ * Test if xmllint is available as a cli command
+ */
 function isXmllintAvailable() {
     return (0, which_1.sync)('xmllint', { nothrow: true });
 }
+/**
+ * Check if JATS file is valid based on JATS version/library/etc.
+ *
+ * Returns true if valid and false if invalid.
+ */
 function validateJatsAgainstDtd(session, file, opts) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!isXmllintAvailable()) {
             session.log.error(`JATS validation against DTD requires xmllint\n\n${chalk_1.default.dim('To install:\n  mac:    brew install xmlstarlet\n  debian: apt install libxml2-utils')}`);
             return;
         }
-        const validatedOpts = validateOptions(opts !== null && opts !== void 0 ? opts : {});
+        const inferredOpts = inferOptions(file);
+        const validatedOpts = validateOptions(session, opts !== null && opts !== void 0 ? opts : {}, inferredOpts);
         yield ensureDtdExists(session, validatedOpts);
+        session.log.debug(`Validating against: ${localDtdFile(validatedOpts)}`);
+        session.log.info(`🧐 Validating against: ${dtdFolder(validatedOpts)}`);
         try {
-            yield (0, myst_cli_utils_1.makeExecutable)(`xmllint --dtdvalid ${localDtdFile(validatedOpts)} --noout ${file}`, session.log)();
+            // First drop DOCTYPE with DTD in it - we have already fetched the DTD
+            const dropDtdCommand = `xmllint --dropdtd`;
+            const validateCommand = `xmllint --noout --dtdvalid ${localDtdFile(validatedOpts)}`;
+            yield (0, myst_cli_utils_1.makeExecutable)(`${dropDtdCommand} ${file} | ${validateCommand} -`, session.log)();
         }
         catch (_a) {
             return false;
@@ -156,6 +301,11 @@ function validateJatsAgainstDtd(session, file, opts) {
     });
 }
 exports.validateJatsAgainstDtd = validateJatsAgainstDtd;
+/**
+ * Check if JATS file is valid based on JATS version/library/etc.
+ *
+ * Logs confirmation message if valid and throws an error if invalid.
+ */
 function validateJatsAgainstDtdWrapper(session, file, opts) {
     return __awaiter(this, void 0, void 0, function* () {
         const success = yield validateJatsAgainstDtd(session, file, opts);

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const version = '0.0.15';
+const version = '0.0.17';
 exports.default = version;

package/dist/esm/cli/index.js

@@ -3,9 +3,11 @@ import commander from 'commander';
 import version from '../version';
 import { addDownloadCLI } from './parse';
 import { addValidateCLI } from './validate';
+import { addTestCLI } from './jats-test';
 const program = new commander.Command();
 addDownloadCLI(program);
 addValidateCLI(program);
+addTestCLI(program);
 program.version(`v${version}`, '-v, --version', 'Print the current version of jats-xml');
 program.option('-d, --debug', 'Log out any errors to the console.');
 program.parse(process.argv);

package/dist/esm/cli/jats-test.js

@@ -0,0 +1,117 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Command, Option } from 'commander';
+import { clirun, tic } from 'myst-cli-utils';
+import { getSession } from '../session';
+import yaml from 'js-yaml';
+import fs from 'fs';
+import { parseJats } from './parse';
+import { select, selectAll } from 'unist-util-select';
+import { is } from 'unist-util-is';
+import chalk from 'chalk';
+const INDENT = '       ';
+function printNodes(expected, received) {
+    return chalk.reset(`\n${INDENT}${chalk.greenBright('Expected node containing')}:\n${INDENT}  ${yaml
+        .dump(expected)
+        .replace(/\n/g, `\n${INDENT}  `)}\n${INDENT}${chalk.redBright('Received node')}:\n${INDENT}  ${yaml.dump(received).replace(/\n/g, `\n${INDENT}  `)}`);
+}
+export function testJatsFile(session, file, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const toc = tic();
+        const jats = yield parseJats(session, file);
+        const tests = yaml.load(fs.readFileSync(opts.cases).toString());
+        const results = tests.cases.map((testCase, index) => {
+            if (!testCase.title) {
+                return [`Test Case ${index}`, null, 'Test must include a title'];
+            }
+            if (testCase.equals === undefined) {
+                return [testCase.title, null, 'Test must have an equals statement'];
+            }
+            if (testCase.select) {
+                const node = select(testCase.select, jats.tree);
+                const pass = is(node, testCase.equals);
+                if (testCase.equals == null && node) {
+                    return [testCase.title, false, 'Expected no node to be present'];
+                }
+                if (!node && testCase.equals == null)
+                    return [testCase.title, true];
+                if (!node)
+                    return [testCase.title, false];
+                let failed = false;
+                const messages = [];
+                if (!pass) {
+                    failed = failed || true;
+                    messages.push(`Failed to validate node\n${printNodes(testCase.equals, node)}`);
+                }
+                return [testCase.title, !failed, messages.join('\n')];
+            }
+            else if (testCase.selectAll) {
+                const testNodes = selectAll(testCase.selectAll, jats.tree);
+                if (!testNodes && testCase.equals == null)
+                    return [testCase.title, true];
+                if (!testNodes)
+                    return [testCase.title, false, 'Node not found'];
+                let equals = testCase.equals;
+                if (!Array.isArray(testCase.equals)) {
+                    equals = Array(testNodes.length).fill(testCase.equals);
+                }
+                let failed = false;
+                const messages = [];
+                if (equals.length !== testNodes.length) {
+                    failed = failed || true;
+                    messages.push(`Expected ${equals.length} nodes, got ${testNodes.length}\n${printNodes(equals, testNodes)}`);
+                }
+                else {
+                    equals.forEach((node, ii) => {
+                        const pass = is(testNodes[ii], node);
+                        if (!pass) {
+                            failed = failed || true;
+                            messages.push(`Failed to validate node ${ii}\n${printNodes(node, testNodes[ii])}`);
+                        }
+                    });
+                }
+                return [testCase.title, !failed, messages.join('\n')];
+            }
+            else {
+                return [testCase.title, false, 'Test must have either `select` or `selectAll`'];
+            }
+        });
+        results.forEach((result) => {
+            const [title, pass, message] = result;
+            if (pass === null)
+                session.log.info(`${chalk.redBright.bold(`ERROR`)} - ${title}\n  ${chalk.blueBright(message)}`);
+            else if (pass)
+                session.log.info(`${chalk.green(`PASS`)} - ${title}`);
+            else
+                session.log.info(`${chalk.red(`FAIL`)} - ${title}\n\n${INDENT}${chalk.blueBright(message)}\n`);
+        }, true);
+        const passed = results.reduce((num, [, pass]) => num + (pass ? 1 : 0), 0);
+        const failed = results.length - passed;
+        if (failed > 0 && passed === 0) {
+            throw new Error(toc(`${chalk.red(`Failed ${failed} tests in %s`)} 👎`));
+        }
+        if (failed > 0) {
+            throw new Error(toc(`${chalk.green(`Passed ${passed}/${results.length} tests in %s`)}\n${chalk.red(`Failed ${failed} tests`)} 👎`));
+        }
+        session.log.info(chalk.green(toc(`Passed ${passed} tests in %s 🚀`)));
+        return true;
+    });
+}
+function makeTestCLI(program) {
+    const command = new Command('test')
+        .description('Test JATS file against a list of cases')
+        .argument('<file>', 'JATS file to test')
+        .addOption(new Option('--cases <value>', 'The YAML file of unit tests to test against'))
+        .action(clirun(testJatsFile, { program, getSession }));
+    return command;
+}
+export function addTestCLI(program) {
+    program.addCommand(makeTestCLI(program));
+}

package/dist/esm/cli/parse.js

@@ -53,7 +53,7 @@ function logAboutJatsFailing(session, jatsUrls) {
     session.log.debug(formatPrinciples('A*', { chalk }));
     session.log.info(`\n${chalk.blue('The link may work in a browser.')}\n`);
 }
-function parseJats(session, file, opts = { resolvers: DEFAULT_RESOLVERS }) {
+export function parseJats(session, file, opts = { resolvers: DEFAULT_RESOLVERS }) {
     return __awaiter(this, void 0, void 0, function* () {
         const toc = tic();
         if (fs.existsSync(file)) {