jats-xml 0.0.14 → 0.0.16

package/README.md

@@ -35,7 +35,7 @@ jats download https://elifesciences.org/articles/81952 article.jats
 
 Note, currently this just downloads the XML, **not** the associated files.
 
-`sumamry`: summarize the contents of the JATS, given a URL, DOI, or local file
+`summary`: summarize the contents of the JATS, given a URL, DOI, or local file
 
 ```bash
 jats summary https://elifesciences.org/articles/81952
@@ -47,6 +47,12 @@ This will provide a summary, including a list of what the JATS file contains.
 
 ![Output of `jats summary`](/images/jats-output.png)
 
+`validate`: validate local file against JATS Archive DTD schema. By default, this uses JATS 1.3.
+
+```bash
+jats validate article.jats --jats 1.2 --mathmml 2
+```
+
 ## Working in Typescript
 
 All tags are accessible as types/enums. There is also documentation from each node-type

package/dist/cjs/cli/index.js

@@ -7,8 +7,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = __importDefault(require("commander"));
 const version_1 = __importDefault(require("../version"));
 const parse_1 = require("./parse");
+const validate_1 = require("./validate");
 const program = new commander_1.default.Command();
 (0, parse_1.addDownloadCLI)(program);
+(0, validate_1.addValidateCLI)(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/parse.js

@@ -212,7 +212,7 @@ function makeDownloadCLI(program) {
     const command = new commander_1.Command('download')
         .description('Parse a JATS file and provide a summary')
         .argument('<url>', 'The JATS url or a DOI')
-        .argument('<output>', 'The JATS url or a DOI')
+        .argument('<output>', 'The JATS output file')
         .action((0, myst_cli_utils_1.clirun)(downloadAndSaveJats, { program, getSession: session_1.getSession }));
     return command;
 }

package/dist/cjs/cli/validate.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addValidateCLI = void 0;
+const commander_1 = require("commander");
+const myst_cli_utils_1 = require("myst-cli-utils");
+const session_1 = require("../session");
+const validate_1 = require("../validate");
+function makeValidateCLI(program) {
+    const command = new commander_1.Command('validate')
+        .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('--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;
+}
+function addValidateCLI(program) {
+    program.addCommand(makeValidateCLI(program));
+}
+exports.addValidateCLI = addValidateCLI;

package/dist/cjs/index.js

@@ -23,3 +23,4 @@ Object.defineProperty(exports, "version", { enumerable: true, get: function () {
 var jats_1 = require("./jats");
 Object.defineProperty(exports, "Jats", { enumerable: true, get: function () { return jats_1.Jats; } });
 __exportStar(require("./types"), exports);
+__exportStar(require("./validate"), exports);

package/dist/cjs/validate/dtd.js

@@ -0,0 +1,320 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.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"));
+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.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';
+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 = (_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(', ')}]`);
+    }
+    else {
+        jats = opts.jats;
+    }
+    let mathml;
+    if (!opts.mathml) {
+        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(', ')}]`);
+    }
+    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,
+        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}`;
+    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.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) {
+    const library = opts.library === 'authoring' ? 'articleauthoring' : opts.library;
+    return `https://ftp.ncbi.nih.gov/pub/jats/${library}/${opts.jats}/${dtdZipFile(opts)}`;
+}
+/**
+ * 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)) {
+            fs_1.default.mkdirSync(opts.directory, { recursive: true });
+        }
+        session.log.info(`🌎 Downloading: ${ftpUrl(opts)}`);
+        session.log.debug(`Saving to ${localDtdZipFile(opts)}`);
+        const resp = yield (0, node_fetch_1.default)(ftpUrl(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)))) {
+            yield dtdDownload(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: ${zipFile}`);
+            yield (0, fs_1.createReadStream)(zipFile)
+                .pipe(unzipper_1.default.Extract({ path: opts.directory }))
+                .promise();
+        }
+    });
+}
+/**
+ * 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 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 {
+            // 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;
+        }
+        return true;
+    });
+}
+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);
+        if (success) {
+            session.log.info(chalk_1.default.greenBright('JATS validation passed!'));
+        }
+        else {
+            throw new Error('JATS validation failed.');
+        }
+    });
+}
+exports.validateJatsAgainstDtdWrapper = validateJatsAgainstDtdWrapper;

package/dist/cjs/validate/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dtd"), exports);

package/dist/cjs/version.js

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

package/dist/esm/cli/index.js

@@ -2,8 +2,10 @@
 import commander from 'commander';
 import version from '../version';
 import { addDownloadCLI } from './parse';
+import { addValidateCLI } from './validate';
 const program = new commander.Command();
 addDownloadCLI(program);
+addValidateCLI(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/parse.js

@@ -206,7 +206,7 @@ function makeDownloadCLI(program) {
     const command = new Command('download')
         .description('Parse a JATS file and provide a summary')
         .argument('<url>', 'The JATS url or a DOI')
-        .argument('<output>', 'The JATS url or a DOI')
+        .argument('<output>', 'The JATS output file')
         .action(clirun(downloadAndSaveJats, { program, getSession }));
     return command;
 }

package/dist/esm/cli/validate.js

@@ -0,0 +1,25 @@
+import { Command, Option } from 'commander';
+import { clirun } from 'myst-cli-utils';
+import { getSession } from '../session';
+import { validateJatsAgainstDtdWrapper } from '../validate';
+function makeValidateCLI(program) {
+    const command = new Command('validate')
+        .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 Option('--library <value>', 'JATS library - archiving, publishing, or authoring (default: archiving, if value cannot be inferred from file)'))
+        .addOption(new Option('--jats <version>', 'JATS version, must be 1.1 or later (default: 1.3, if value cannot be inferred from file)'))
+        .addOption(new Option('--mathml <version>', 'MathML version, 2 or 3 (default: 3, if value cannot be inferred from file)'))
+        .addOption(new Option('--oasis', 'Use OASIS table model (default: false, if value cannot be inferred from file)'))
+        .addOption(new Option('--directory <value>', 'Directory to save DTD file'))
+        .action(clirun(validateJatsAgainstDtdWrapper, { program, getSession }));
+    return command;
+}
+export function addValidateCLI(program) {
+    program.addCommand(makeValidateCLI(program));
+}

package/dist/esm/index.js

@@ -1,3 +1,4 @@
 export { default as version } from './version';
 export { Jats } from './jats';
 export * from './types';
+export * from './validate';