@esgettext/tools 1.0.0 → 1.2.0

package/dist/parser/parser.js

@@ -27,40 +27,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
-var iconv_lite_1 = require("iconv-lite");
-var traverse_1 = __importDefault(require("@babel/traverse"));
-var t = __importStar(require("@babel/types"));
-var runtime_1 = require("@esgettext/runtime");
-var entry_1 = require("../pot/entry");
-var keyword_1 = require("../pot/keyword");
-var gtx = runtime_1.Textdomain.getInstance('tools');
-var Parser = (function () {
-    function Parser(catalog, options) {
-        if (options === void 0) { options = {}; }
-        var _this = this;
+const iconv_lite_1 = require("iconv-lite");
+const traverse_1 = __importDefault(require("@babel/traverse"));
+const t = __importStar(require("@babel/types"));
+const runtime_1 = require("@esgettext/runtime");
+const entry_1 = require("../pot/entry");
+const keyword_1 = require("../pot/keyword");
+const gtx = runtime_1.Textdomain.getInstance('tools');
+class Parser {
+    constructor(catalog, options = {}) {
         this.catalog = catalog;
         this.options = options;
+        this.filename = '';
+        this.errors = 0;
+        this.comments = [];
         this.keywords = {};
-        (options.keyword || Parser.cookedDefaultKeywords()).forEach(function (keyword) {
-            _this.keywords[keyword.method] = keyword;
+        (options.keyword || Parser.cookedDefaultKeywords()).forEach(keyword => {
+            this.keywords[keyword.method] = keyword;
         });
         if (options.instance) {
             this.instances = new Array();
-            for (var i = 0; i < options.instance.length; ++i) {
+            for (let i = 0; i < options.instance.length; ++i) {
                 this.instances[i] = options.instance[i].split('.').reverse();
             }
         }
     }
-    Parser.prototype.parse = function (buf, filename) {
+    parse(buf, filename) {
         this.filename = filename;
-        var encoding = typeof this.options.fromCode === 'undefined'
+        const encoding = typeof this.options.fromCode === 'undefined'
             ? 'ascii'
             : this.options.fromCode;
-        var canonical = this.canonicalizeEncoding(encoding);
-        var input;
-        var pos = 0;
+        const canonical = this.canonicalizeEncoding(encoding);
+        let input;
+        let pos = 0;
         if ('ascii' === canonical) {
-            if (buf.find(function (ord, idx) {
+            if (buf.find((ord, idx) => {
                 if (ord > 0x7f) {
                     pos = idx;
                     return true;
@@ -69,17 +70,22 @@ var Parser = (function () {
                     return false;
                 }
             })) {
-                var loc = {
+                const loc = {
                     start: {
                         line: 1,
-                        column: pos,
-                        index: 0
+                        column: 1,
+                        index: 1,
+                    },
+                    end: {
+                        line: 0,
+                        column: 0,
+                        index: 0,
                     },
-                    end: null,
-                    filename: filename,
-                    identifierName: null
+                    filename,
+                    identifierName: null,
                 };
-                for (var i = 0; i < pos; ++i) {
+                // Find the offending character.
+                for (let i = 0; i < pos; ++i) {
                     if (buf[i] === 10) {
                         ++loc.start.line;
                         loc.start.column = 1;
@@ -95,7 +101,7 @@ var Parser = (function () {
             input = buf.toString();
         }
         else if ('utf8' === canonical) {
-            var loc = this.findNonUtf8(buf);
+            const loc = this.findNonUtf8(buf);
             if (loc !== null) {
                 this.error(gtx._('invalid multibyte sequence'), loc);
                 return false;
@@ -103,18 +109,19 @@ var Parser = (function () {
             input = buf.toString();
         }
         else {
+            // Convert.
             try {
                 input = (0, iconv_lite_1.decode)(buf, this.options.fromCode);
             }
             catch (e) {
-                var usedFilename = '-' === filename ? gtx._('[standard input]') : filename;
-                console.error("".concat(usedFilename, ": ").concat(e));
+                const usedFilename = '-' === filename ? gtx._('[standard input]') : filename;
+                console.error(`${usedFilename}: ${e}`);
                 return false;
             }
         }
         return this.doParse(input, filename);
-    };
-    Parser.prototype.extract = function (filename, ast) {
+    }
+    extract(filename, ast) {
         this.errors = 0;
         this.comments = this.filterComments(ast.comments);
         this.filename = filename;
@@ -125,33 +132,38 @@ var Parser = (function () {
             this.extractStrings(ast);
         }
         return !this.errors;
-    };
-    Parser.prototype.extractStrings = function (ast) {
-        var _this = this;
+    }
+    extractStrings(ast) {
         (0, traverse_1.default)(ast, {
-            CallExpression: function (path) {
-                _this.extractArguments(path);
+            CallExpression: path => {
+                this.extractArguments(path);
             },
         });
-    };
-    Parser.prototype.extractAllStrings = function (ast) {
-        var _this = this;
+    }
+    extractAllStrings(ast) {
+        // Step 1: Transform string concatenations into one string.
         (0, traverse_1.default)(ast, {
-            StringLiteral: function (path) {
-                _this.concatStrings(path);
+            StringLiteral: path => {
+                this.concatStrings(path);
             },
         });
+        // Step 2: Extract the remaining strings. Those that are part of a
+        // binary expression have not been recognized in step 1 and must be
+        // ignored.
         (0, traverse_1.default)(ast, {
-            StringLiteral: function (path) {
+            StringLiteral: path => {
                 if (!t.isBinaryExpression(path.parentPath.node)) {
-                    var loc = path.node.loc;
-                    _this.addEntry({ msgid: path.node.value, loc: loc });
+                    const loc = path.node.loc;
+                    this.addEntry({
+                        msgid: path.node.value,
+                        loc: loc,
+                    });
                 }
             },
         });
-    };
-    Parser.prototype.checkPath = function (wanted, got) {
-        for (var i = 0; i < got.length; ++i) {
+    }
+    checkPath(wanted, got) {
+        for (let i = 0; i < got.length; ++i) {
             if (i >= wanted.length) {
                 return true;
             }
@@ -160,25 +172,25 @@ var Parser = (function () {
             }
         }
         return true;
-    };
-    Parser.prototype.checkInstance = function (instance) {
-        if (!this.options.instance) {
+    }
+    checkInstance(instance) {
+        if (!this.instances) {
             return true;
         }
-        for (var i = 0; i < this.instances.length; ++i) {
+        for (let i = 0; i < this.instances.length; ++i) {
             if (this.checkPath(this.instances[i], instance)) {
                 return true;
             }
         }
         return false;
-    };
-    Parser.prototype.extractArguments = function (path) {
-        var method;
+    }
+    extractArguments(path) {
+        let method;
         if (t.isIdentifier(path.node.callee) && !this.instances) {
             method = path.node.callee.name;
         }
         else if (t.isMemberExpression(path.node.callee)) {
-            var instance = new Array();
+            const instance = new Array();
             method = this.methodFromMemberExpression(path.node.callee, instance);
             if (method === null) {
                 return;
@@ -194,7 +206,8 @@ var Parser = (function () {
         if (!Object.prototype.hasOwnProperty.call(this.keywords, method)) {
             return;
         }
-        var keywordSpec = this.keywords[method];
+        // Enough arguments?
+        const keywordSpec = this.keywords[method];
         if (keywordSpec.totalArgs &&
             path.node.arguments.length !== keywordSpec.totalArgs) {
             return;
@@ -209,27 +222,33 @@ var Parser = (function () {
             keywordSpec.context > path.node.arguments.length) {
             return;
         }
-        var msgid = this.extractArgument(path.node.arguments[keywordSpec.singular - 1]);
+        const msgid = this.extractArgument(path.node.arguments[keywordSpec.singular - 1]);
         if (msgid === null) {
             return;
         }
-        var msgidPlural;
+        let msgidPlural;
         if (keywordSpec.plural) {
             msgidPlural = this.extractArgument(path.node.arguments[keywordSpec.plural - 1]);
             if (msgidPlural === null) {
                 return;
             }
         }
-        var msgctxt;
+        let msgctxt;
         if (keywordSpec.context) {
             msgctxt = this.extractArgument(path.node.arguments[keywordSpec.context - 1]);
             if (msgctxt === null) {
                 return;
             }
         }
-        this.addEntry({ msgid: msgid, loc: path.node.loc, method: method, msgidPlural: msgidPlural, msgctxt: msgctxt });
-    };
-    Parser.prototype.extractArgument = function (argument) {
+        this.addEntry({
+            msgid: msgid,
+            loc: path.node.loc,
+            method,
+            msgidPlural,
+            msgctxt,
+        });
+    }
+    extractArgument(argument) {
         if (t.isStringLiteral(argument)) {
             return argument.value;
         }
@@ -240,19 +259,19 @@ var Parser = (function () {
             return this.extractTemplateLiteral(argument);
         }
         return null;
-    };
-    Parser.prototype.extractBinaryExpression = function (exp) {
-        var left = this.extractArgument(exp.left);
+    }
+    extractBinaryExpression(exp) {
+        const left = this.extractArgument(exp.left);
         if (left === null) {
             return null;
         }
-        var right = this.extractArgument(exp.right);
+        const right = this.extractArgument(exp.right);
         if (right === null) {
             return null;
         }
         return left + right;
-    };
-    Parser.prototype.extractTemplateLiteral = function (literal) {
+    }
+    extractTemplateLiteral(literal) {
         if (literal.expressions.length === 0 &&
             literal.quasis.length === 1 &&
             t.isTemplateElement(literal.quasis[0])) {
@@ -262,39 +281,40 @@ var Parser = (function () {
             ' allowed as arguments to gettext functions because they' +
             ' are not constant'), literal.loc);
         return null;
-    };
-    Parser.prototype.concatStrings = function (path) {
+    }
+    concatStrings(path) {
         if (!t.isBinaryExpression(path.parent)) {
             return;
         }
-        var parentPath = path.parentPath;
+        const parentPath = path.parentPath;
         if (parentPath.node.operator === '+' &&
             t.isStringLiteral(parentPath.node.left) &&
             t.isStringLiteral(parentPath.node.right)) {
-            parentPath.replaceWithSourceString("\"".concat(parentPath.node.left.value).concat(parentPath.node.right.value, "\""));
+            const node = t.stringLiteral(parentPath.node.left.value + parentPath.node.right.value);
+            node.loc = parentPath.node.loc;
+            parentPath.replaceInline(node);
         }
-    };
-    Parser.prototype.addEntry = function (props) {
+    }
+    addEntry(props) {
         props.flag = new Array();
-        console.log(props);
-        var dict = props.loc;
-        var references = [];
-        if (dict != null) {
-            var filename = '-' === dict.filename ? '[stdin]' : dict.filename;
-            references = ["".concat(filename, ":").concat(props.loc.start.line)];
-        }
-        var commentBlocks = this.findPrecedingComments(props.loc);
-        var extractedComments = commentBlocks.map(function (block) { return block.value.trim(); });
+        const dict = props.loc;
+        let references = [];
+        if (dict !== null && typeof dict !== 'undefined') {
+            const filename = '-' === dict.filename ? '[stdin]' : dict.filename;
+            references = [`${filename}:${props.loc.start.line}`];
+        }
+        const commentBlocks = this.findPrecedingComments(props.loc);
+        let extractedComments = commentBlocks.map(block => block.value.trim());
         if (typeof props.method !== 'undefined') {
             extractedComments = extractedComments
-                .map(function (comment) {
-                var match = /xgettext:(.*)/.exec(comment);
+                .map(comment => {
+                const match = /xgettext:(.*)/.exec(comment);
                 if (match) {
-                    var str = match[1];
-                    var validTokens_1 = ['fuzzy', 'wrap', 'no-wrap'];
-                    var tokens = str.split(/[ \x09-\x0d]+/);
-                    tokens.forEach(function (token) {
-                        if (validTokens_1.includes(token) ||
+                    const str = match[1];
+                    const validTokens = ['fuzzy', 'wrap', 'no-wrap'];
+                    const tokens = str.split(/[ \x09-\x0d]+/);
+                    tokens.forEach(token => {
+                        if (validTokens.includes(token) ||
                             /^(?:[a-z]+-)+(?:format|check)$/.exec(token)) {
                             props.flag.push(token);
                         }
@@ -303,7 +323,7 @@ var Parser = (function () {
                 }
                 return comment;
             })
-                .filter(function (comment) { return comment !== ''; });
+                .filter(comment => comment !== '');
         }
         if (!props.flag.includes('no-perl-brace-format') &&
             /\{[_a-zA-Z][_a-zA-Z0-9]*\}/.exec(props.msgid)) {
@@ -314,12 +334,11 @@ var Parser = (function () {
             msgidPlural: props.msgidPlural,
             msgctxt: props.msgctxt,
             flags: props.flag,
-            references: references,
-            extractedComments: extractedComments,
+            references,
+            extractedComments,
         }));
-    };
-    Parser.prototype.methodFromMemberExpression = function (me, instance) {
-        if (instance === void 0) { instance = []; }
+    }
+    methodFromMemberExpression(me, instance = []) {
         if (t.isIdentifier(me.object)) {
             if (t.isLiteral(me.property) && me.computed) {
                 instance.push(this.literalValue(me.property));
@@ -338,20 +357,22 @@ var Parser = (function () {
         else if (t.isMemberExpression(me.object) &&
             t.isIdentifier(me.property) &&
             !me.computed) {
+            // Recurse.
             instance.push(me.property.name);
             return this.methodFromMemberExpression(me.object, instance);
         }
         else if (t.isMemberExpression(me.object) &&
             t.isLiteral(me.property) &&
             me.computed) {
+            // Recurse.
             instance.push(this.literalValue(me.property));
             return this.methodFromMemberExpression(me.object, instance);
         }
         else {
             return null;
         }
-    };
-    Parser.prototype.literalValue = function (node) {
+    }
+    literalValue(node) {
         if (t.isStringLiteral(node)) {
             return node.value;
         }
@@ -364,11 +385,13 @@ var Parser = (function () {
         else {
             return null;
         }
-    };
-    Parser.prototype.findPrecedingComments = function (loc) {
-        var last;
+    }
+    findPrecedingComments(loc) {
+        let last;
+        // Find the last relevant comment, which is the first one that
+        // immediately precedes the location.
         for (last = 0; last < this.comments.length; ++last) {
-            var commentLocation = this.comments[last].loc;
+            const commentLocation = this.comments[last].loc;
             if (commentLocation.end.line === loc.start.line ||
                 commentLocation.end.line === loc.start.line - 1) {
                 break;
@@ -382,35 +405,37 @@ var Parser = (function () {
             this.comments.splice(0, this.comments.length);
             return [];
         }
-        var ptr = this.comments[last].loc;
-        var preceding = this.comments.splice(0, last + 1);
+        // Now go back and find all adjacent comments.
+        let ptr = this.comments[last].loc;
+        const preceding = this.comments.splice(0, last + 1);
         if (!last) {
             return preceding;
         }
-        var first;
+        let first;
         for (first = preceding.length - 2; first >= 0; --first) {
-            var commentLocation = preceding[first].loc;
-            if (commentLocation.end.line < ptr.start.line - 1) {
+            const commentLocation = preceding[first].loc;
+            if (commentLocation &&
+                commentLocation.end.line < ptr.start.line - 1) {
                 break;
             }
             ptr = commentLocation;
         }
         return preceding.slice(first + 1);
-    };
-    Parser.prototype.filterComments = function (comments) {
+    }
+    filterComments(comments) {
         if (this.options.addAllComments) {
             return comments;
         }
-        var markers = this.options.addComments
+        const markers = this.options.addComments
             ? this.options.addComments
             : new Array();
-        return comments.filter(function (block) {
+        return comments.filter(block => {
             if (block.value.includes('xgettext:')) {
                 return true;
             }
             else {
-                for (var i = 0; i < markers.length; ++i) {
-                    var marker = markers[i].trim();
+                for (let i = 0; i < markers.length; ++i) {
+                    const marker = markers[i].trim();
                     if (marker === block.value.trim().substr(0, marker.length)) {
                         return true;
                     }
@@ -418,11 +443,11 @@ var Parser = (function () {
             }
             return false;
         });
-    };
-    Parser.cookedDefaultKeywords = function () {
-        return Parser.defaultKeywords().map(function (keyword) { return keyword_1.Keyword.from(keyword); });
-    };
-    Parser.defaultKeywords = function () {
+    }
+    static cookedDefaultKeywords() {
+        return Parser.defaultKeywords().map(keyword => keyword_1.Keyword.from(keyword));
+    }
+    static defaultKeywords() {
         return [
             '_',
             '_x',
@@ -449,27 +474,28 @@ var Parser = (function () {
             'N_lp:2c,3',
             'N_lpx:2c,3',
         ];
-    };
-    Parser.prototype.warn = function (msg, loc) {
-        var start = "".concat(loc.start.line, ":").concat(loc.start.column);
-        var end = loc.end ? "-".concat(loc.end.line, ":").concat(loc.end.column) : '';
-        var filename = '-' === this.filename ? gtx._('[standard input]') : this.filename;
-        var location = "".concat(filename, ":").concat(start).concat(end);
-        console.warn(gtx._x('{location}: warning: {msg}', { location: location, msg: msg }));
-    };
-    Parser.prototype.error = function (msg, loc) {
+    }
+    warn(msg, loc) {
+        const start = `${loc.start.line}:${loc.start.column}`;
+        const end = loc.end.line > 0 ? `-${loc.end.line}:${loc.end.column}` : '';
+        const filename = '-' === this.filename ? gtx._('[standard input]') : this.filename;
+        const location = `${filename}:${start}${end}`;
+        console.warn(gtx._x('{location}: warning: {msg}', { location, msg }));
+    }
+    error(msg, loc) {
         ++this.errors;
-        var start = "".concat(loc.start.line, ":").concat(loc.start.column);
-        var end = loc.end ? "-".concat(loc.end.line, ":").concat(loc.end.column) : '';
-        var filename = '-' === this.filename ? gtx._('[standard input]') : this.filename;
-        var location = "".concat(filename, ":").concat(start).concat(end);
-        console.error(gtx._x('{location}: error: {msg}', { location: location, msg: msg }));
-    };
-    Parser.prototype.canonicalizeEncoding = function (encoding) {
-        var canonical = ('' + encoding)
+        const start = `${loc.start.line}:${loc.start.column}`;
+        const end = loc.end && loc.end.line > 0 ? `-${loc.end.line}:${loc.end.column}` : '';
+        const filename = '-' === this.filename ? gtx._('[standard input]') : this.filename;
+        const location = `${filename}:${start}${end}`;
+        console.error(gtx._x('{location}: Error: {msg}', { location, msg }));
+    }
+    canonicalizeEncoding(encoding) {
+        // This is taken from iconv-lite.
+        const canonical = ('' + encoding)
             .toLowerCase()
             .replace(/:[0-9]{4}$|[^0-9a-z]/g, '');
-        var asciiAliases = [
+        const asciiAliases = [
             'ascii8bit',
             'usascii',
             'ansix34',
@@ -489,18 +515,22 @@ var Parser = (function () {
         else {
             return canonical;
         }
-    };
-    Parser.prototype.findNonUtf8 = function (buf) {
-        var i = 0;
-        var loc = {
+    }
+    findNonUtf8(buf) {
+        let i = 0;
+        const loc = {
             start: {
                 line: 1,
                 column: 1,
-                index: 0
+                index: 0,
+            },
+            end: {
+                line: 0,
+                column: 0,
+                index: 0,
             },
-            end: null,
             filename: '',
-            identifierName: ''
+            identifierName: '',
         };
         while (i < buf.length) {
             if (buf[i] === 0x09 ||
@@ -575,8 +605,6 @@ var Parser = (function () {
             return loc;
         }
         return null;
-    };
-    return Parser;
-}());
+    }
+}
 exports.Parser = Parser;
-//# sourceMappingURL=parser.js.map