ilib-lint 2.6.0 → 2.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ilib-lint",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "module": "./src/index.js",
   "type": "module",
   "bin": "./src/index.js",

package/src/config/README.md

@@ -155,6 +155,16 @@ Here is an example of a configuration file:
             // so this both includes the rule in the rule set and instantiates
             // it with the "localeOnly" option
             "resource-quote-matcher": "localeOnly"
+        },
+        "overrides": {
+            "resource-camel-case": {
+                // adds a list of exceptions for ResourceCamelCase rule
+                "except": ["SomeException"]
+            },
+            "resource-snake-case": {
+                // adds a list of exceptions for ResourceSnakeCase rule
+                "except": ["some_exception"]
+            }
         }
     },
     // defines common settings for a particular types of file
@@ -170,6 +180,9 @@ Here is an example of a configuration file:
         "jsx": {
             "ruleset": ["react-rules"]
         },
+        "xliff": {
+            "ruleset": ["overrides"]
+        },
         "sdl-xliff": {
             // these are actually special xliff files in our project,
             // but they have the same syntax as regular xliff, so we can

package/src/plugins/BuiltinPlugin.js

@@ -40,6 +40,8 @@ import ResourceSourceICUPluralParams from '../rules/ResourceSourceICUPluralParam
 import ResourceSourceICUPluralCategories from '../rules/ResourceSourceICUPluralCategories.js';
 import ResourceSourceICUUnexplainedParams from '../rules/ResourceSourceICUUnexplainedParams.js';
 import ResourceXML from '../rules/ResourceXML.js';
+import ResourceCamelCase from '../rules/ResourceCamelCase.js';
+import ResourceSnakeCase from '../rules/ResourceSnakeCase.js';
 
 // built-in declarative rules
 export const regexRules = [
@@ -231,30 +233,6 @@ export const regexRules = [
         link: "https://github.com/ilib-js/ilib-lint/blob/main/docs/source-no-manual-date-formatting.md",
         severity: "error"
     },
-    {
-        type: "resource-matcher",
-        name: "resource-snake-case",
-        description: "Ensure that when source strings contain only snake case (words and/or numbers separeated by underscores) and no whitespace, then the targets are the same",
-        note: "Do not translate the source string if it consists solely of snake-cased strings and/or digits. Please update the target string so it matches the source string.",
-        regexps: [
-            "^\\s*[a-zA-Z0-9]*(_[a-zA-Z0-9]+)+\\s*$",
-            "^\\s*[a-zA-Z0-9]+(_[a-zA-Z0-9]+)*_\\s*$"
-        ],
-        link: "https://github.com/ilib-js/ilib-lint/blob/main/docs/resource-snake-case.md",
-        severity: "error"
-    },
-    {
-        type: "resource-matcher",
-        name: "resource-camel-case",
-        description: "Ensure that when source strings contain only camel case and no whitespace, then the targets are the same",
-        note: "Do not translate the source string if it consists solely of camel-cased strings and/or digits. Please update the target string so it matches the source string.",
-        regexps: [
-            "^\\s*[a-z\\d]+([A-Z][a-z\\d]+)+\\s*$", // camelCase and 6amelCaseWithD1g1t3
-            "^\\s*[A-Z][a-z\\d]+([A-Z][a-z\\d]+)+\\s*$", // PascalCase and 4ascalCaseWithD1g1t3
-        ],
-        link: "https://github.com/ilib-js/ilib-lint/blob/main/docs/resource-camel-case.md",
-        severity: "error"
-    },
 ];
 
 // built-in ruleset that contains all the built-in rules
@@ -270,6 +248,8 @@ export const builtInRulesets = {
         "resource-no-translation": true,
         "resource-icu-plurals-translated": true,
         "resource-xml": true,
+        "resource-snake-case": true,
+        "resource-camel-case": true,
 
         // declarative rules from above
         "resource-url-match": true,
@@ -282,8 +262,6 @@ export const builtInRulesets = {
         "resource-no-halfwidth-kana-characters": true,
         "resource-no-double-byte-space": true,
         "resource-no-space-with-fullwidth-punctuation": true,
-        "resource-snake-case": true,
-        "resource-camel-case": true,
     },
 
     source: {
@@ -353,6 +331,8 @@ class BuiltinPlugin extends Plugin {
             ResourceSourceICUPluralCategories,
             ResourceSourceICUUnexplainedParams,
             ResourceXML,
+            ResourceCamelCase,
+            ResourceSnakeCase,
             ...regexRules
         ];
     }

package/src/rules/ResourceCamelCase.js

@@ -0,0 +1,86 @@
+import ResourceRule from './ResourceRule.js';
+import {Result} from 'ilib-lint-common';
+
+/** @ignore @typedef {import('ilib-tools-common').Resource} Resource */
+
+/**
+ * @classdesc Class representing an ilib-lint programmatic rule for linting camel cased strings.
+ * @class
+ * @augments ResourceRule
+ */
+class ResourceCamelCase extends ResourceRule {
+    /**
+     * Create a ResourceCamelCase 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-camel-case";
+        this.description = "Ensure that when source strings contain only camel case and no whitespace, then the targets are the same";
+        this.link = "https://gihub.com/ilib-js/ilib-lint/blob/main/docs/resource-camel-case.md";
+        this.regexps = [
+            "^\\s*[a-z\\d]+([A-Z][a-z\\d]+)+\\s*$",
+            "^\\s*[A-Z][a-z\\d]+([A-Z][a-z\\d]+)+\\s*$",
+        ];
+        this.exceptions = Array.isArray(options?.param?.except) ? options.param.except : [];
+    }
+
+    /**
+     * Check if a source string is in camel case and if the target string is the same as the source.
+     * @public
+     * @override ResourceRule.matchString
+     * @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 camel 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 isCamelCase = this.isCamelCase(source);
+        if (!isCamelCase) {
+            return;
+        }
+
+        if (source !== target) {
+            return new Result({
+                severity: "error",
+                id: resource.getKey(),
+                source,
+                description: "Do not translate the source string if it consists solely of camel 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>`
+            })
+        }
+    }
+
+    /**
+     * @public
+     * @param {string} string A non-empty string to check.
+     * @returns {boolean} Returns true for a string that is in camel case (matches one of the regular expressions declared in the constructor).
+     * Otherwise, returns false.
+     */
+    isCamelCase(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 ResourceCamelCase;

package/src/rules/ResourceSnakeCase.js

@@ -0,0 +1,86 @@
+import ResourceRule from './ResourceRule.js';
+import {Result} from 'ilib-lint-common';
+
+/** @ignore @typedef {import('ilib-tools-common').Resource} Resource */
+
+/**
+ * @classdesc Class representing an ilib-lint programmatic rule for linting snake cased strings.
+ * @class
+ * @augments ResourceRule
+ */
+class ResourceSnakeCase extends ResourceRule {
+    /**
+     * Create a ResourceSnakeCase 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-snake-case";
+        this.description = "Ensure that when source strings contain only snake case and no whitespace, then the targets are the same";
+        this.link = "https://gihub.com/ilib-js/ilib-lint/blob/main/docs/resource-snake-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 snake case and if the target string is the same as the source.
+     * @public
+     * @override ResourceRule.matchString
+     * @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 snake 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 isSnakeCase = this.isSnakeCase(source);
+        if (!isSnakeCase) {
+            return;
+        }
+
+        if (source !== target) {
+            return new Result({
+                severity: "error",
+                id: resource.getKey(),
+                source,
+                description: "Do not translate the source string if it consists solely of snake 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>`
+            })
+        }
+    }
+
+    /**
+     * @public
+     * @param {string} string A non-empty string to check.
+     * @returns {boolean} Returns true for a string that is in snake case (matches one of the regular expressions declared in the constructor).
+     * Otherwise, returns false.
+     */
+    isSnakeCase(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 ResourceSnakeCase;

package/src/rules/__tests__/ResourceCamelCase.test.js

@@ -0,0 +1,180 @@
+import {Result} from "ilib-lint-common";
+import ResourceCamelCase from "../ResourceCamelCase.js";
+import {ResourceString} from "ilib-tools-common";
+
+describe("ResourceCamelCase", () => {
+    test("creates ResourceCamelCase rule instance", () => {
+        const rule = new ResourceCamelCase({})
+
+        expect(rule).toBeInstanceOf(ResourceCamelCase);
+        expect(rule.getName()).toBe("resource-camel-case");
+    });
+
+    test.each([
+        undefined,
+        null,
+        true,
+        100,
+        'string',
+        {},
+        () => {},
+    ])("handles invalid `except` parameter gracefully (and does not break in runtime)", (invalidExcept) => {
+        const rule = new ResourceCamelCase({param: {except: invalidExcept}});
+        
+        const resource = createTestResourceString({source: "camelCaseException", target: "someCamelCaseTarget"});
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeInstanceOf(Result);
+        expect(result.rule).toBeInstanceOf(ResourceCamelCase);
+        expect(result.severity).toEqual("error");
+    });
+
+    test.each([
+        {source: ""},
+        {source: undefined},
+        {source: null},
+    ])("returns `undefined` if source string is empty ($source)", ({source}) => {
+        const rule = new ResourceCamelCase({});
+        const resource = createTestResourceString({source, target: "some_target"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test.each([
+        {target: ""},
+        {target: undefined},
+        {target: null},
+    ])("returns `undefined` if target string is empty ($target)", ({target}) => {
+        const rule = new ResourceCamelCase({});
+        const resource = createTestResourceString({source: "some_source", target});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test("returns `undefined` if source string is an exception", () => {
+        const options = {param: {except: ["camelCaseException"]}}
+        const rule = new ResourceCamelCase(options);
+        const resource = createTestResourceString({source: "camelCaseException", target: "some_target"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test("returns `undefined` if source string is NOT in camel case", () => {
+        const rule = new ResourceCamelCase({});
+        const resource = createTestResourceString({source: "some source", target: "some target"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test("returns `undefined` if source is in camel case and target is the same", () => {
+        const rule = new ResourceCamelCase({});
+        const resource = createTestResourceString({source: "camelCase", target: "camelCase"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test("returns error if source is in camel case and target is different", () => {
+        const rule = new ResourceCamelCase({});
+        const resource = createTestResourceString({source: "camelCase", target: "differentTarget"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeInstanceOf(Result);
+        expect(result.rule).toBeInstanceOf(ResourceCamelCase);
+        expect(result.severity).toEqual("error");
+    });
+});
+
+describe('ResourceCamelCase.isCamelCase', () => {
+    test.each(
+        [
+            {name: "lower camel case", source: "camelCase"},
+            {name: "upper camel case a.k.a. pascal case", source: "PascalCase"},
+            {name: "randomly mixed camel case", source: "cAmelCaSe"},
+
+            {name: "any camel case with leading and trailing whitespace", source: " AnyCamelCase "},
+            {name: "any camel case with digits at any position", source: "C4m3lC4s3W1thD1g1ts"},
+        ]
+    )("returns `true` if source string is $name", ({source}) => {
+        const rule = new ResourceCamelCase({});
+
+        const result = rule.isCamelCase(source);
+
+        expect(result).toBe(true);
+    });
+
+    test.each([
+        {name: "whitespace solely", source: " "},
+        {name: "digits solely", source: "123"},
+        {name: "lowercase letters word solely", source: "word"},
+        {name: "uppercase letters word solely", source: "WORD"},
+        {name: "uppercase letters word solely", source: "Word"},
+
+        {name: "text and whitespace", source: "camel Case"},
+        {name: "camel case and text", source: "camelCase and text"},
+
+        {name: "trailing capitalized letter", source: "CamelCasE"},
+        {name: "multiple consecutive uppercase letters", source: "CAmelCase"},
+    ])("returns `false` if source string is $name", ({source}) => {
+        const rule = new ResourceCamelCase({});
+
+        const result = rule.isCamelCase(source);
+
+        expect(result).toBe(false);
+    });
+});
+
+function createTestResourceString({source, target}) {
+    return new ResourceString({
+        source,
+        target,
+        key: "camel.case.test.string.id",
+        targetLocale: "xd-XD",
+        pathName: "tests/for/camelCase.xliff"
+    });
+}

package/src/rules/__tests__/ResourceSnakeCase.test.js

@@ -0,0 +1,187 @@
+import {ResourceString} from 'ilib-tools-common';
+import {Result} from 'ilib-lint-common';
+import ResourceSnakeCase from "../ResourceSnakeCase.js";
+
+describe("ResourceSnakeCase", () => {
+    test("creates ResourceSnakeCase rule instance", () => {
+        const rule = new ResourceSnakeCase({});
+
+        expect(rule).toBeInstanceOf(ResourceSnakeCase);
+        expect(rule.getName()).toEqual("resource-snake-case");
+    });
+
+    test.each([
+        undefined,
+        null,
+        true,
+        100,
+        'string',
+        {},
+        () => {},
+    ])("handles invalid `except` parameter gracefully (and does not break in runtime)", (invalidExcept) => {
+        const rule = new ResourceSnakeCase({param: {except: invalidExcept}});
+        
+        const resource = createTestResourceString({source: "snake_case_exception", target: "some_target"});
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeInstanceOf(Result);
+        expect(result.rule).toBeInstanceOf(ResourceSnakeCase);
+        expect(result.severity).toEqual("error");
+    });
+
+    test.each([
+        {source: ""},
+        {source: undefined},
+        {source: null},
+    ])("returns `undefined` if source string is empty ($source)", ({source}) => {
+        const rule = new ResourceSnakeCase({});
+        const resource = createTestResourceString({source, target: "some_target"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+
+    });
+
+    test.each([
+        {target: ""},
+        {target: undefined},
+        {target: null},
+    ])("returns `undefined` if target string is empty ($target)", ({target}) => {
+        const rule = new ResourceSnakeCase({});
+        const resource = createTestResourceString({source: "some_source", target});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test("returns `undefined` if source string is an exception", () => {
+        const options = {param: {except: ["snake_case_exception"]}}
+        const rule = new ResourceSnakeCase(options);
+        const resource = createTestResourceString({source: "snake_case_exception", target: "some_target"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test("returns `undefined` if source string is NOT in snake case", () => {
+        const rule = new ResourceSnakeCase({});
+        const resource = createTestResourceString({source: "some source", target: "some target"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test("returns `undefined` if source is in snake case and target is the same", () => {
+        const rule = new ResourceSnakeCase({});
+        const resource = createTestResourceString({source: "snake_case", target: "snake_case"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeUndefined();
+    });
+
+    test("returns error if source is in snake case and target is different", () => {
+        const rule = new ResourceSnakeCase({});
+        const resource = createTestResourceString({source: "snake_case", target: "different_target"});
+
+        const result = rule.matchString({
+            source: resource.source,
+            target: resource.target,
+            file: resource.pathName,
+            resource
+        });
+
+        expect(result).toBeInstanceOf(Result);
+        expect(result.rule).toBeInstanceOf(ResourceSnakeCase);
+        expect(result.severity).toEqual("error");
+    });
+});
+
+describe('ResourceSnakeCase.isSnakeCase', () => {
+    test.each(
+        [
+            {name: "snake case", source: "snake_case"},
+            {name: "snake case with leading and trailing whitespace", source: " snake_case "},
+            {name: "snake case with numbers (123)", source: " snake_case123 "},
+            {name: "snake case with underscored numbers (_123)", source: " snake_case_123 "},
+
+            {name: "screaming snake case", source: "SOME_SCREAMING_SNAKE_CASE"},
+            {name: "screaming snake case with leading and trailing whitespace", source: " SOME_SCREAMING_SNAKE_CASE "},
+            {name: "screaming snake case with numbers", source: "SOME_SCREAMING_SNAKE_CASE123 "},
+            {name: "screaming snake case with underscored numbers", source: "SOME_SCREAMING_SNAKE_CASE_123 "},
+
+            {name: "camel snake case", source: "camel_Snake_Case"},
+            {name: "came snake case with leading and trailing whitespace", source: " camel_Snake_Case "},
+            {name: "camel snake case with numbers", source: "camel_Snake_Case123 "},
+            {name: "camel snake case with underscored numbers", source: "camel_Snake_Case_123 "},
+        ]
+    )("returns `true` if source string is $name", ({source}) => {
+        const rule = new ResourceSnakeCase({});
+
+        const result = rule.isSnakeCase(source);
+
+        expect(result).toBe(true);
+    });
+
+    test.each(
+        [
+            {name: "whitespace (solely)", source: " "},
+            {name: "text and whitespace", source: "snake case"},
+            {name: "snake case and text", source: "snake_case and text"},
+            {name: "screaming snake case and text", source: "SCREAMING_SNAKE_CASE and text"},
+            {name: "mixed case", source: "mixed_CASE"},
+        ]
+    )("returns `false` if string is $name", ({name, source}) => {
+        const rule = new ResourceSnakeCase({});
+        const resource = createTestResourceString({source, target: "does not matter"});
+
+        const result = rule.matchString({source: resource.source});
+
+        expect(result).toBeUndefined();
+    });
+});
+
+function createTestResourceString({source, target}) {
+    return new ResourceString({
+        source,
+        target,
+        key: "snake.case.test.string.id",
+        targetLocale: "xd-XD",
+        pathName: "tests/for/snake_case.xliff"
+    });
+}
+