ilib-lint 2.12.0 → 2.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilib-lint",
-  "version": "2.12.0",
+  "version": "2.13.0",
   "type": "module",
   "main": "./src/index.js",
   "module": "./src/index.js",
@@ -71,10 +71,10 @@
     "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-tools-common": "^1.17.0",
-    "ilib-locale": "^1.2.4"
+    "ilib-locale": "^1.2.4",
+    "ilib-common": "^1.1.6"
   },
   "scripts": {
     "coverage": "pnpm test -- --coverage",

package/src/plugins/BuiltinPlugin.js

@@ -44,6 +44,7 @@ import ResourceSourceICUUnexplainedParams from '../rules/ResourceSourceICUUnexpl
 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 StringFixer from './string/StringFixer.js';
 import ResourceFixer from './resource/ResourceFixer.js';
 
@@ -271,6 +272,7 @@ export const builtInRulesets = {
         "resource-xml": true,
         "resource-snake-case": true,
         "resource-camel-case": true,
+        "resource-kebab-case": true,
 
         // declarative rules from above
         "resource-url-match": true,
@@ -365,6 +367,7 @@ class BuiltinPlugin extends Plugin {
             ResourceXML,
             ResourceCamelCase,
             ResourceSnakeCase,
+            ResourceKebabCase,
             ...regexRules
         ];
     }

package/src/plugins/resource/ResourceFullwidthPunctuationSubsetFixer.test.js

@@ -0,0 +1,162 @@
+/*
+ * ResourceFullwidthPunctuationSubsetFixer.test.js - test the fixer for fullwidth punctuation characters
+ *
+ * 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 { ResourceString, ResourcePlural, ResourceArray } from 'ilib-tools-common';
+import { IntermediateRepresentation, SourceFile } from "ilib-lint-common";
+import ResourceFixer from "../../../src/plugins/resource/ResourceFixer.js";
+import { regexRules } from '../../../src/plugins/BuiltinPlugin.js';
+
+const rule = regexRules.find(rule => rule.name === "resource-no-fullwidth-punctuation-subset");
+
+describe("ResourceFullwidthPunctuationSubsetFixer", () => {
+    test("fixes fullwidth punctuation in simple string", () => {
+        const fixer = new ResourceFixer();
+        const resource = new ResourceString({
+            key: "test.key",
+            source: "Really? Yes! 100%",
+            target: "本当？ はい！ 100％",
+        });
+        const source = getSource();
+        const representation = getIntermediateRepresentation({ source, resource });
+        const fixes = getFixesForStringResource(resource);
+
+        fixer.applyFixes(representation, fixes);
+
+        expect(resource.getTarget()).toBe("本当? はい! 100%");
+    });
+
+    test("fixes fullwidth punctuation in plural string", () => {
+        const fixer = new ResourceFixer();
+        const resource = new ResourcePlural({
+            key: "test.key",
+            source: {
+                one: "Really?",
+                other: "Really? Yes! 100%"
+            },
+            target: {
+                other: "本当？ はい！ 100％"
+            },
+        });
+        const source = getSource()
+        const representation = getIntermediateRepresentation({ source, resource })
+        const fixes = getFixesForObjectResource(resource);
+
+        fixer.applyFixes(representation, fixes);
+
+        expect(resource.getTarget().other).toBe("本当? はい! 100%");
+    });
+
+    test("fixes fullwidth punctuation in array string", () => {
+        const fixer = new ResourceFixer();
+        const resource = new ResourceArray({
+            key: "test.key",
+            source: ["Really?", "Yes! 100%"],
+            target: ["本当？", "はい！ 100％"],
+        });
+        const source = getSource()
+        const representation = getIntermediateRepresentation({ source, resource })
+        const fixes = getFixesForArrayResource(resource);
+
+        fixer.applyFixes(representation, fixes);
+
+        expect(resource.getTarget()).toEqual(["本当?", "はい! 100%"]);
+    });
+});
+
+
+function getIntermediateRepresentation({ source, resource }) {
+    return new IntermediateRepresentation({
+        sourceFile: source,
+        type: "resource",
+        ir: [resource],
+        dirty: false
+    })
+}
+
+function getSource() {
+    return new SourceFile("test.xliff", {
+        sourceLocale: "en-US",
+        type: "resource"
+    });
+}
+
+function getFixesForStringResource(resource) {
+    if (!rule || !rule.fixes) return [];
+    return rule.fixes.map(fix => {
+        const target = resource.getTarget()
+        const fullwidthChar = String.fromCharCode(parseInt(fix.search.slice(2), 16));
+        const position = target.indexOf(fullwidthChar);
+        const hasFullwidthChar = position !== -1;
+
+        if (hasFullwidthChar) {
+            return ResourceFixer.createFix({
+                resource,
+                commands: [
+                    ResourceFixer.createStringCommand(position, 1, fix.replace)
+                ]
+            });
+        }
+        return null;
+    }).filter(fix => fix !== null);
+}
+
+function getFixesForObjectResource(resource) {
+    if (!rule || !rule.fixes) return [];
+    return rule.fixes.map(fix => {
+        const target = resource.getTarget().other
+        const fullwidthChar = String.fromCharCode(parseInt(fix.search.slice(2), 16));
+        const position = target.indexOf(fullwidthChar);
+        const hasFullwidthChar = position !== -1;
+
+        if (hasFullwidthChar) {
+            return ResourceFixer.createFix({
+                resource,
+                category: "other",
+                commands: [
+                    ResourceFixer.createStringCommand(position, 1, fix.replace)
+                ]
+            });
+        }
+        return null;
+    }).filter(fix => fix !== null)
+}
+
+function getFixesForArrayResource(resource) {
+    if (!rule || !rule.fixes) return [];
+    const targets = resource.getTarget()
+
+    return targets.flatMap((target, index) => {
+        return rule.fixes.map(fix => {
+            const fullwidthChar = String.fromCharCode(parseInt(fix.search.slice(2), 16));
+            const position = target.indexOf(fullwidthChar);
+            const hasFullwidthChar = position !== -1;
+
+            if (hasFullwidthChar) {
+                return ResourceFixer.createFix({
+                    resource,
+                    index,
+                    commands: [
+                        ResourceFixer.createStringCommand(position, 1, fix.replace)
+                    ]
+                });
+            }
+            return null;
+        }).filter(fix => fix !== null);
+    });
+} 

package/src/rules/ResourceCamelCase.js

@@ -1,5 +1,6 @@
 import ResourceRule from './ResourceRule.js';
 import {Result} from 'ilib-lint-common';
+import ResourceFixer from '../plugins/resource/ResourceFixer.js';
 
 /** @ignore @typedef {import('ilib-tools-common').Resource} Resource */
 
@@ -49,7 +50,7 @@ class ResourceCamelCase extends ResourceRule {
         }
 
         if (source !== target) {
-            return new Result({
+            const result = new Result({
                 severity: "error",
                 id: resource.getKey(),
                 source,
@@ -58,10 +59,29 @@ class ResourceCamelCase extends ResourceRule {
                 locale: resource.sourceLocale,
                 pathName: file,
                 highlight: `<e0>${target}</e0>`
-            })
+            });
+            result.fix = this.getFix(resource, source);
+            
+            return result;
         }
     }
 
+    /**
+     * Get the fix for ResourceCamelCase rule
+     * @param {Resource} resource The resource to fix
+     * @param {string} source The source string that should be used in the target
+     * @returns {import('../plugins/resource/ResourceFix.js').default} The fix for ResourceCamelCase rule
+     */
+    getFix(resource, source) {
+        const command = ResourceFixer.createStringCommand(0, resource.getTarget().length, source);
+        
+        return ResourceFixer.createFix({
+            resource,
+            target: true,
+            commands: [command]
+        });
+    }
+
     /**
      * @public
      * @param {string} string A non-empty string to check.

package/src/rules/ResourceKebabCase.js

@@ -0,0 +1,102 @@
+import ResourceRule from './ResourceRule.js';
+import {Result} from 'ilib-lint-common';
+import ResourceFixer from '../plugins/resource/ResourceFixer.js';
+
+/** @ignore @typedef {import('ilib-tools-common').Resource} Resource */
+
+/**
+ * @classdesc Class representing an ilib-lint programmatic rule for linting kebab cased strings.
+ * @class
+ */
+class ResourceKebabCase extends ResourceRule {
+    /**
+     * Create a ResourceKebabCase rule instance.
+     * @param {object} options
+     * @param {object} [options.param]
+     * @param {string[]} [options.param.except] An array of strings to exclude from the rule.
+     */
+    constructor(options) {
+        super(options);
+
+        this.name = "resource-kebab-case";
+        this.description = "Ensure that when source strings contain only kebab case and no whitespace, then the targets are the same";
+        this.link = "https://gihub.com/iLib-js/ilib-mono/blob/main/packages/ilib-lint/docs/resource-kebab-case.md";
+        this.regexps = [
+            "^\\s*[a-zA-Z0-9]*(-[a-zA-Z0-9]+)+\\s*$",
+            "^\\s*[a-zA-Z0-9]+(-[a-zA-Z0-9]+)*-\\s*$"
+        ];
+        this.exceptions = Array.isArray(options?.param?.except) ? options.param.except : [];
+    }
+
+    /**
+     * Check if a source string is in kebab case and if the target string is the same as the source.
+     * @override
+     * @param {{source: (String|undefined), target: (String|undefined), file: String, resource: Resource}} params
+     * @returns {Result|undefined} A Result with severity 'error' if the source string is in kebab case and target string is not the same as the source string, otherwise undefined.
+     */
+    matchString({source, target, file, resource}) {
+        if (!source || !target) {
+            return;
+        }
+
+        const isException = this.exceptions.includes(source);
+        if (isException) {
+            return;
+        }
+
+        const isKebabCase = this.isKebabCase(source);
+        if (!isKebabCase) {
+            return;
+        }
+
+        if (source !== target) {
+            const result = new Result({
+                severity: "error",
+                id: resource.getKey(),
+                source,
+                description: "Do not translate the source string if it consists solely of kebab cased strings and/or digits. Please update the target string so it matches the source string.",
+                rule: this,
+                locale: resource.sourceLocale,
+                pathName: file,
+                highlight: `<e0>${target}</e0>`
+            });
+            result.fix = this.getFix(resource, source);
+            return result;
+        }
+    }
+
+    /**
+     * Get the fix for this rule
+     * @param {Resource} resource the resource to fix
+     * @param {string} source the source string that should be used in the target
+     * @returns {import('../plugins/resource/ResourceFix.js').default} the fix for this rule
+     */
+    getFix(resource, source) {
+        const command = ResourceFixer.createStringCommand(0, resource.getTarget().length, source);
+        return ResourceFixer.createFix({
+            resource,
+            target: true,
+            commands: [command]
+        });
+    }
+
+    /**
+     * @public
+     * @param {string} string A non-empty string to check.
+     * @returns {boolean} Returns true for a string that is in kebab case (matches one of the regular expressions declared in the constructor).
+     * Otherwise, returns false.
+     */
+    isKebabCase(string) {
+        const trimmed = string.trim();
+        for (const regexp of this.regexps) {
+            const match = RegExp(regexp).test(trimmed);
+
+            if (match) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+export default ResourceKebabCase; 

package/src/rules/ResourceSnakeCase.js

@@ -1,5 +1,6 @@
 import ResourceRule from './ResourceRule.js';
 import {Result} from 'ilib-lint-common';
+import ResourceFixer from '../plugins/resource/ResourceFixer.js';
 
 /** @ignore @typedef {import('ilib-tools-common').Resource} Resource */
 
@@ -49,7 +50,7 @@ class ResourceSnakeCase extends ResourceRule {
         }
 
         if (source !== target) {
-            return new Result({
+            const result = new Result({
                 severity: "error",
                 id: resource.getKey(),
                 source,
@@ -58,10 +59,29 @@ class ResourceSnakeCase extends ResourceRule {
                 locale: resource.sourceLocale,
                 pathName: file,
                 highlight: `<e0>${target}</e0>`
-            })
+            });
+            result.fix = this.getFix(resource, source);
+            
+            return result;
         }
     }
 
+    /**
+     * Get the fix for ResourceSnakeCase rule
+     * @param {Resource} resource the resource to fix
+     * @param {string} source the source string that should be used in the target
+     * @returns {import('../plugins/resource/ResourceFix.js').default} the fix for ResourceSnakeCase rule
+     */
+    getFix(resource, source) {
+        const command = ResourceFixer.createStringCommand(0, resource.getTarget().length, source);
+        
+        return ResourceFixer.createFix({
+            resource,
+            target: true,
+            commands: [command]
+        });
+    }
+
     /**
      * @public
      * @param {string} string A non-empty string to check.