ilib-lint 2.14.0 → 2.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilib-lint",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "type": "module",
   "main": "./src/index.js",
   "module": "./src/index.js",
@@ -71,8 +71,8 @@
     "micromatch": "^4.0.7",
     "options-parser": "^0.4.0",
     "xml-js": "^1.6.11",
-    "ilib-common": "^1.1.6",
     "ilib-lint-common": "^3.4.0",
+    "ilib-common": "^1.1.6",
     "ilib-locale": "^1.2.4",
     "ilib-tools-common": "^1.17.0"
   },

package/src/plugins/BuiltinPlugin.js

@@ -45,6 +45,8 @@ import ResourceXML from '../rules/ResourceXML.js';
 import ResourceCamelCase from '../rules/ResourceCamelCase.js';
 import ResourceSnakeCase from '../rules/ResourceSnakeCase.js';
 import ResourceKebabCase from '../rules/ResourceKebabCase.js';
+import ResourceGNUPrintfMatch from '../rules/ResourceGNUPrintfMatch.js';
+import ResourceReturnChar from '../rules/ResourceReturnChar.js';
 import StringFixer from './string/StringFixer.js';
 import ResourceFixer from './resource/ResourceFixer.js';
 
@@ -55,7 +57,7 @@ export const regexRules = [
         name: "resource-url-match",
         description: "Ensure that URLs that appear in the source string are also used in the translated string",
         note: "URL '{matchString}' from the source string does not appear in the target string",
-        regexps: [ "((https?|github|ftps?|mailto|file|data|irc):\\/\\/)([\\da-zA-Z\\.-]+)\\.([a-zA-Z\\.]{2,6})([\\/\w\\.-]*)*\\/?" ],
+        regexps: [ "((https?|github|ftps?|mailto|file|data|irc):\\/\\/)([\\da-zA-Z\\.-]+)\\.([a-zA-Z\\.]{2,6})([\\/#\\?=%&\\w\\.-]*)*[\\/#\\?=%&\\w-]" ],
         link: "https://github.com/iLib-js/ilib-mono/blob/main/packages/ilib-lint/docs/resource-url-match.md"
     },
     {
@@ -368,6 +370,14 @@ export const regexRules = [
         note: "The numbered parameter '{{matchString}}' from the source string does not appear in the target string",
         regexps: [ "\\{\\s*(?<match>\\d[^}]*?)\\s*\\}" ],
         link: "https://github.com/iLib-js/ilib-mono/blob/main/packages/ilib-lint-javascript/docs/resource-csharp-numbered-params.md"
+    },
+    {
+        type: "resource-matcher",
+        name: "resource-tap-named-params",
+        description: "Ensure that named parameters in Tap I18n that appear in the source string are also used in the translated string",
+        note: "The named parameter '__{matchString}__' from the source string does not appear in the target string",
+        regexps: [ "__(?<match>[a-zA-Z_][a-zA-Z0-9_.]*?)__" ],
+        link: "https://github.com/iLib-js/ilib-mono/blob/main/packages/ilib-lint/docs/resource-tap-named-params.md"
     }
 ];
 
@@ -401,6 +411,11 @@ export const builtInRulesets = {
         "resource-no-space-with-fullwidth-punctuation": true,
     },
 
+    gnu: {
+        // GNU printf style parameter matching
+        "resource-gnu-printf-match": true,
+    },
+
     source: {
         "resource-source-icu-plural-syntax": true,
         "resource-source-icu-plural-categories": true,
@@ -421,6 +436,12 @@ export const builtInRulesets = {
     },
     "csharp": {
         "resource-csharp-numbered-params": true
+    },
+    "windows": {
+        "resource-return-char": true
+    },
+    "tap": {
+        "resource-tap-named-params": true
     }
 };
 
@@ -491,6 +512,8 @@ class BuiltinPlugin extends Plugin {
             ResourceCamelCase,
             ResourceSnakeCase,
             ResourceKebabCase,
+            ResourceGNUPrintfMatch,
+            ResourceReturnChar,
             ...regexRules
         ];
     }

package/src/rules/ResourceGNUPrintfMatch.js

@@ -0,0 +1,206 @@
+/*
+ * ResourceGNUPrintfMatch.js - rule to check if GNU printf-style parameters in the source string
+ * also appear in the target string with the same format specifiers
+ *
+ * Copyright © 2025 JEDLSoft
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Result } from 'ilib-lint-common';
+import { Resource } from 'ilib-tools-common';
+import ResourceRule from './ResourceRule.js';
+
+/**
+ * @class Represent an ilib-lint rule.
+ */
+class ResourceGNUPrintfMatch extends ResourceRule {
+    /**
+     * Make a new rule instance.
+     * @constructor
+     */
+    constructor(options) {
+        super(options);
+        this.name = "resource-gnu-printf-match";
+        this.description = "Test that GNU printf-style substitution parameters match in the source and target strings.";
+        this.sourceLocale = (options && options.sourceLocale) || "en-US";
+        this.link = "https://github.com/iLib-js/ilib-mono/blob/main/packages/ilib-lint/docs/resource-gnu-printf-match.md";
+    }
+
+    /**
+     * Extract GNU printf-style parameters from a string.
+     * Supports positional parameters (%1$s, %2$d), width/precision from arguments (%*s, %.*f),
+     * and GNU extensions (%m, %'d, %I, etc.) as well as Swift/Objective-C %@ specifiers
+     * @private
+     * @param {string} str the string to extract parameters from
+     * @returns {Array<string>} array of parameter strings found
+     */
+    extractParameters(str) {
+        if (!str || typeof str !== 'string') return [];
+
+        // GNU printf regex pattern:
+        // % - literal percent
+        // (?:(\d+)\$)? - optional positional parameter (1$, 2$, etc.)
+        // (?:(\d+))? - optional width/precision from argument (*)
+        // (?:\.(?:\*|\d+))? - optional precision (.* or .123)
+        // (?:[hlL]|hh|ll)? - optional length modifier (h, l, L, hh, ll)
+        // [diouxXfFeEgGaAcCsSpn%m'#0I@] - format specifier including GNU extensions and Swift/Objective-C @
+        const gnuPrintfRegex =
+            /%(?:(\d+)\$)?(?:(\*))?(?:\.(?:\*|\d+))?(?:[hlL]|hh|ll)?[diouxXfFeEgGaAcCsSpn%m'#0I@]/g;
+
+        const matches = [];
+        let match;
+
+        while ((match = gnuPrintfRegex.exec(str)) !== null) {
+            matches.push(match[0]);
+        }
+
+        return matches;
+    }
+
+    /**
+     * Check a string pair for GNU printf parameter mismatches.
+     * @override
+     * @param {Object} params parameters for the string matching
+     * @param {String|undefined} params.source the source string to match against
+     * @param {String|undefined} params.target the target string to match
+     * @param {String} params.file the file path where the resources came from
+     * @param {Resource} params.resource the resource that contains the source and/or target string
+     * @param {number} [params.index] if the resource being tested is an array resource, this represents the index of this string in the array
+     * @param {string} [params.category] if the resource being tested is a plural resource, this represents the plural category of this string
+     * @returns {Result|Array.<Result>|undefined} any results found in this string or undefined if no problems were found
+     */
+    matchString({source, target, file, resource, index, category}) {
+        if (!source || !target) return;
+
+        const sourceParams = this.extractParameters(source);
+        const targetParams = this.extractParameters(target);
+
+        if (sourceParams.length === 0 && targetParams.length === 0) return;
+
+        const results = [];
+
+        // Ensure required fields are available
+        const resourceKey = resource.getKey();
+        if (!resourceKey) {
+            return;
+        }
+        if (!file) {
+            return;
+        }
+
+        // Get location information from the resource
+        const location = resource.getLocation();
+        const lineNumber = location?.line;
+        const charNumber = location?.char;
+
+        // Count occurrences of each parameter
+        function countParams(params) {
+            const counts = {};
+            for (const param of params) {
+                counts[param] = (counts[param] || 0) + 1;
+            }
+            return counts;
+        }
+        const sourceCounts = countParams(sourceParams);
+        const targetCounts = countParams(targetParams);
+
+        // Check for missing parameters in target (by count)
+        // Create separate Result for each different missing parameter
+        for (const param of Object.keys(sourceCounts)) {
+            const missingCount = sourceCounts[param] - (targetCounts[param] || 0);
+            if (missingCount > 0) {
+                const resultFields = {
+                    severity: /** @type {const} */ ("error"),
+                    description: `Source string GNU printf parameter ${param} not found in the target string.`,
+                    rule: this,
+                    id: resourceKey,
+                    source: source,
+                    highlight: `<e0>${target}</e0>`,
+                    pathName: file,
+                    lineNumber: lineNumber,
+                    charNumber: charNumber,
+                };
+                results.push(new Result(resultFields));
+            }
+        }
+
+        // Check for extra parameters in target (by count)
+        // Group extra parameters by type to handle multiple of same type together
+        const extraParamsByType = {};
+        for (const param of Object.keys(targetCounts)) {
+            const extraCount = targetCounts[param] - (sourceCounts[param] || 0);
+            if (extraCount > 0) {
+                extraParamsByType[param] = extraCount;
+            }
+        }
+
+        // Create separate Result for each different extra parameter type
+        for (const [param, extraCount] of Object.entries(extraParamsByType)) {
+            let highlight = target;
+
+            if (extraCount === 1) {
+                // Single extra parameter - highlight the rightmost occurrence
+                const lastIndex = highlight.lastIndexOf(param);
+                if (lastIndex !== -1) {
+                    highlight =
+                        highlight.substring(0, lastIndex) +
+                        `<e0>${param}</e0>` +
+                        highlight.substring(lastIndex + param.length);
+                }
+            } else {
+                // Multiple extra parameters of same type - highlight only the last N occurrences (left-to-right)
+                // Find all indices of the param in the string
+                let allIndices = [];
+                let searchStart = 0;
+                while (true) {
+                    const idx = highlight.indexOf(param, searchStart);
+                    if (idx === -1) break;
+                    allIndices.push(idx);
+                    searchStart = idx + param.length;
+                }
+                // Only tag the last 'extraCount' occurrences
+                const indices = allIndices.slice(-extraCount);
+                // Apply tags in left-to-right order, adjusting for offset as we insert tags
+                let offset = 0;
+                for (let i = 0; i < indices.length; i++) {
+                    const idx = indices[i] + offset;
+                    const tag = `<e${i}>${param}</e${i}>`;
+                    highlight =
+                        highlight.substring(0, idx) +
+                        tag +
+                        highlight.substring(idx + param.length);
+                    offset += tag.length - param.length;
+                }
+            }
+
+            const resultFields = {
+                severity: /** @type {const} */ ("error"),
+                description: `Extra target string GNU printf parameter ${param} not found in the source string.`,
+                rule: this,
+                id: resourceKey,
+                source: source,
+                highlight: highlight,
+                pathName: file,
+                lineNumber: lineNumber,
+                charNumber: charNumber,
+            };
+            results.push(new Result(resultFields));
+        }
+
+        return results.length > 0 ? results : undefined;
+    }
+}
+
+export default ResourceGNUPrintfMatch;

package/src/rules/ResourceReturnChar.js

@@ -0,0 +1,106 @@
+/*
+ * ResourceReturnChar.js - Rule to check that return character counts match between source and target
+ *
+ * Copyright © 2023-2024 JEDLSoft
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import ResourceRule from './ResourceRule.js';
+
+/**
+ * Rule to check that the number of return characters (CR, LF, CRLF) in the source
+ * string matches the number in the target string. This is important for Windows
+ * applications where return characters are used for formatting output.
+ *
+ * @example
+ * // Source: "Line 1\nLine 2\nLine 3" (2 newlines)
+ * // Target: "Line 1\nLine 2" (1 newline) - ERROR
+ * // Target: "Line 1\nLine 2\nLine 3" (2 newlines) - OK
+ */
+export default class ResourceReturnChar extends ResourceRule {
+    constructor(options) {
+        super(options);
+        this.name = "resource-return-char";
+        this.description = "Checks that the number of return characters (CR, LF, CRLF) in the source matches the target";
+        this.link = "https://github.com/iLib-js/ilib-lint/blob/main/docs/resource-return-char.md";
+        this.type = "resource";
+    }
+
+    /**
+     * Count return characters in a string, handling CR, LF, and CRLF sequences
+     * @param {string} str - The string to count return characters in
+     * @returns {number} - The number of return characters
+     */
+    countReturnChars(str) {
+        if (!str) return 0;
+
+        let count = 0;
+        let i = 0;
+
+        while (i < str.length) {
+            if (str[i] === '\r' && i + 1 < str.length && str[i + 1] === '\n') {
+                // CRLF sequence
+                count++;
+                i += 2;
+            } else if (str[i] === '\r' || str[i] === '\n') {
+                // Single CR or LF
+                count++;
+                i++;
+            } else {
+                i++;
+            }
+        }
+
+        return count;
+    }
+
+    /**
+     * Match a resource string to check if return character counts match
+     * @param {Object} params - Parameters for the match
+     * @param {string} params.source - The source string
+     * @param {string} params.target - The target string
+     * @param {Object} params.resource - The resource object
+     * @param {string} params.file - The file path
+     * @returns {Object|undefined} - Result object if there's a mismatch, undefined otherwise
+     */
+    matchString({ source, target, resource, file }) {
+        if (!source || !target) {
+            return;
+        }
+
+        const sourceReturns = this.countReturnChars(source);
+        const targetReturns = this.countReturnChars(target);
+
+        if (sourceReturns !== targetReturns) {
+            return {
+                rule: this,
+                severity: "error",
+                id: "return-char-count-mismatch",
+                pathName: file,
+                source: source,
+                target: target,
+                highlight: `Source has ${sourceReturns} return character(s), target has ${targetReturns}`,
+                description: `Return character count mismatch: source has ${sourceReturns} return character(s), target has ${targetReturns}. This may cause formatting issues in Windows applications.`,
+                lineNumber: resource?.lineNumber,
+                charNumber: resource?.charNumber,
+                endLineNumber: resource?.endLineNumber,
+                endCharNumber: resource?.endCharNumber,
+                locale: resource?.targetLocale
+            };
+        }
+
+        return;
+    }
+}