@esgettext/tools 1.0.0 → 1.2.0

package/dist/commands/msgmerge-all.js

@@ -0,0 +1,230 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MsgmergeAll = void 0;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const childProcess = __importStar(require("child_process"));
+const runtime_1 = require("@esgettext/runtime");
+const package_1 = require("../package");
+const gtx = runtime_1.Textdomain.getInstance('com.cantanea.esgettext-tools');
+class MsgmergeAll {
+    constructor(configuration) {
+        var _a, _b;
+        this.locales = [];
+        this.options = {};
+        this.configuration = configuration;
+        if (((_a = configuration.package) === null || _a === void 0 ? void 0 : _a.textdomain) &&
+            typeof ((_b = configuration.po) === null || _b === void 0 ? void 0 : _b.directory) !== 'undefined') {
+            const filename = `${configuration.package.textdomain}.pot`;
+            const potfile = path.join(configuration.po.directory, filename);
+            if (fs.existsSync(potfile)) {
+                this.potfile = potfile;
+            }
+        }
+    }
+    synopsis() {
+        if (typeof this.potfile === 'undefined') {
+            return `<${gtx._('POTFILE')}>`;
+        }
+        else {
+            return `[${gtx._('POTFILE')}]`;
+        }
+    }
+    description() {
+        return gtx._("Invoke 'msgmerge' for multiple files.");
+    }
+    aliases() {
+        return [];
+    }
+    args() {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        const options = {
+            locales: {
+                alias: 'l',
+                type: 'array',
+                describe: gtx._('List of locale identifiers'),
+                demandOption: true,
+                default: (_a = this.configuration.po) === null || _a === void 0 ? void 0 : _a.locales,
+                group: gtx._('Input file options:'),
+            },
+            directory: {
+                alias: 'D',
+                type: 'string',
+                describe: gtx._("Search '.po' files in DIRECTORY"),
+                default: (_c = (_b = this.configuration.po) === null || _b === void 0 ? void 0 : _b.directory) !== null && _c !== void 0 ? _c : '.',
+                group: gtx._('Input file options:'),
+            },
+            msgmerge: {
+                type: 'string',
+                describe: gtx._('msgmerge program if not in PATH [string]'),
+                default: (_f = (_e = (_d = this.configuration.programs) === null || _d === void 0 ? void 0 : _d.msgmerge) === null || _e === void 0 ? void 0 : _e.path) !== null && _f !== void 0 ? _f : 'msgmerge',
+                group: gtx._('Mode of operation:'),
+            },
+            options: {
+                type: 'string',
+                array: true,
+                describe: gtx._x("Options to pass to '{program}' program (without hyphens)", { program: 'msgmerge' }),
+                default: (_h = (_g = this.configuration.programs) === null || _g === void 0 ? void 0 : _g.msgfmt) === null || _h === void 0 ? void 0 : _h.options,
+                group: gtx._('Mode of operation:'),
+            },
+            verbose: {
+                alias: 'V',
+                type: 'boolean',
+                describe: gtx._('Enable verbose output'),
+            },
+        };
+        for (const name of ['locales', 'options']) {
+            if (!options[name].default) {
+                delete options[name].default;
+            }
+        }
+        return options;
+    }
+    additional(argv) {
+        argv.positional(gtx._('POTFILE'), {
+            type: 'string',
+            describe: gtx._('Catalog file with up-to-date message ids'),
+            default: this.potfile,
+        });
+    }
+    init(argv) {
+        var _a, _b;
+        const options = argv;
+        this.options = options;
+        const conf = this.configuration;
+        this.potfile = options[gtx._('POTFILE')];
+        if (!options.locales && ((_a = conf.po) === null || _a === void 0 ? void 0 : _a.locales)) {
+            options.locales = (_b = conf.po) === null || _b === void 0 ? void 0 : _b.locales;
+        }
+        if (!options.locales || !options.locales.length) {
+            throw new Error(gtx._('no locales given'));
+        }
+        this.locales = [];
+        for (let i = 0; i < options.locales.length; ++i) {
+            const locales = options.locales[i].split(/[ \t]*,[ \t]*/);
+            for (let j = 0; j < locales.length; ++j) {
+                this.locales.push(locales[j]);
+            }
+        }
+    }
+    run(argv) {
+        this.init(argv);
+        return new Promise(resolve => {
+            const promises = this.locales.map(locale => this.msgmergeLocale(locale));
+            Promise.all(promises)
+                .then(results => {
+                const hasOne = results.some(result => result === 1);
+                resolve(hasOne ? 1 : 0);
+            })
+                .catch(() => {
+                resolve(1);
+            });
+        });
+    }
+    convertOptions(options) {
+        const msgmergeOptions = [];
+        let errors = 0;
+        if (options) {
+            options.forEach(name => {
+                if (name.substring(0, 1) === '-') {
+                    console.error(gtx._x("{programName}: option '{option}': Options passed to '{program}' must not start with a hyphen", {
+                        programName: package_1.Package.getName(),
+                        program: 'msgfmt',
+                        option: name,
+                    }));
+                    ++errors;
+                }
+                if (name.length > 1) {
+                    msgmergeOptions.push(`--${name}`);
+                }
+                else if (name.length === 1) {
+                    msgmergeOptions.push(`-${name}`);
+                }
+            });
+        }
+        return errors ? null : msgmergeOptions;
+    }
+    msgmergeLocale(locale) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise(resolve => {
+                const args = this.convertOptions(this.options.options);
+                if (!args)
+                    return resolve(1);
+                const poFile = this.options.directory + '/' + locale + '.po';
+                const oldPoFile = this.options.directory + '/' + locale + '.old.po';
+                args.push(oldPoFile, this.potfile, '-o', poFile);
+                console.log(gtx._x("Merging '{pot}' into '{po}'.", {
+                    pot: this.potfile,
+                    po: poFile,
+                }));
+                try {
+                    fs.renameSync(poFile, oldPoFile);
+                    const msgmerge = childProcess.spawn(this.options.msgmerge, args, {
+                        windowsHide: true,
+                    });
+                    msgmerge.on('error', err => {
+                        throw new Error(gtx._x("Failed to run '{prg}': {err}", {
+                            prg: this.options.msgmerge,
+                            err,
+                        }));
+                    });
+                    msgmerge.stdout.on('data', (data) => process.stdout.write(data.toString()));
+                    msgmerge.stderr.on('data', (data) => process.stderr.write(data.toString()));
+                    msgmerge.on('close', code => {
+                        if (code) {
+                            fs.renameSync(oldPoFile, poFile);
+                            resolve(1);
+                        }
+                        else {
+                            fs.unlinkSync(oldPoFile);
+                            resolve(0);
+                        }
+                    });
+                }
+                catch (err) {
+                    try {
+                        fs.renameSync(oldPoFile, poFile);
+                    }
+                    catch (err1) {
+                        console.error(err1);
+                    }
+                    console.error(err);
+                    resolve(1);
+                }
+            });
+        });
+    }
+}
+exports.MsgmergeAll = MsgmergeAll;

package/dist/commands/xgettext/file-resolver.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileResolver = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+class FileResolver {
+    constructor(directories = ['']) {
+        this.directories = directories;
+    }
+    resolve(filename) {
+        for (let i = 0; i < this.directories.length; ++i) {
+            const resolved = (0, path_1.join)(this.directories[i], filename);
+            if ((0, fs_1.existsSync)(resolved)) {
+                return resolved;
+            }
+        }
+        return null;
+    }
+}
+exports.FileResolver = FileResolver;

package/dist/commands/xgettext/files-collector.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesCollector = void 0;
+const fs_1 = require("fs");
+const runtime_1 = require("@esgettext/runtime");
+const gtx = runtime_1.Textdomain.getInstance('tools');
+class FilesCollector {
+    constructor(filesFrom, args) {
+        if (typeof filesFrom === 'undefined' && args.length === 0) {
+            throw new Error(gtx._('no input file given'));
+        }
+        const filenames = new Array();
+        if (typeof filesFrom !== 'undefined') {
+            filesFrom.forEach(fromFile => {
+                this.getFilesFromFile(fromFile).forEach(filename => {
+                    filenames.push(filename);
+                });
+            });
+        }
+        args.forEach(filename => filenames.push(filename));
+        // Make filenames unique.
+        this.filenames = Array.from(new Set(filenames));
+    }
+    getFilesFromFile(filename) {
+        let content;
+        if ('-' === filename) {
+            content = process.stdin.read();
+        }
+        else {
+            content = (0, fs_1.readFileSync)(filename);
+        }
+        return content
+            .toString()
+            .split('\n')
+            .map(line => line.replace(/#.*/, '').trim())
+            .filter(line => line.length);
+    }
+}
+exports.FilesCollector = FilesCollector;