i18n-smell-detector 0.1.1 → 0.2.0

package/README.md

@@ -67,7 +67,7 @@ export default {
 
   allowIdenticalKeys: [
     'brand.*',
-    'protocol.*',
+    /^protocol\./,
     'common.ok',
     'common.id'
   ],
@@ -75,12 +75,21 @@ export default {
   allowIdenticalValues: [
     'OK',
     'ID',
-    'HTTP',
+    /^HTTP\/\d(\.\d)?$/,
     'API',
     'GET',
     'POST'
   ],
 
+  placeholderPatterns: [
+    '\\{[^}]+\\}',
+    '\\{\\{[^}]+\\}\\}',
+    '%[sdif]',
+    '%\\([^)]+\\)[sdif]',
+    '\\$\\d+'
+  ],
+
+  ignoreCodeLike: true,
   ignoreSameLanguageFamily: true,
   trimWhitespace: true,
   ignoreCase: false,
@@ -95,8 +104,10 @@ export default {
 |---|---|---:|---|
 | `baseLocale` | `string` | `'en'` | Locale used as the comparison source. It must also be listed in `locales`. |
 | `locales` | `Record<string, string>` | `{}` | Map of locale codes to JSON locale file paths. Relative paths are resolved from the config file directory. |
-| `allowIdenticalKeys` | `string[]` | `[]` | Key patterns that are allowed to match the base locale. Supports `*` wildcards, for example `brand.*`. |
-| `allowIdenticalValues` | `string[]` | `[]` | Exact values that are allowed to match the base locale, for example `OK`, `API`, or `GET`. |
+| `allowIdenticalKeys` | `(string \| RegExp)[]` | `[]` | Key rules that are allowed to match the base locale. String rules support `*` wildcards, for example `brand.*`. `RegExp` rules are tested against the flattened key. |
+| `allowIdenticalValues` | `(string \| RegExp)[]` | `[]` | Value rules that are allowed to match the base locale. String rules are exact matches, for example `OK`, `API`, or `GET`. `RegExp` rules are tested against the full value. |
+| `placeholderPatterns` | `(string \| RegExp)[]` | `{...}` and `{{...}}` patterns | Placeholder patterns ignored when the whole value is only placeholders and whitespace. String entries must be valid regular expression sources. |
+| `ignoreCodeLike` | `boolean` | `true` | Ignore built-in code-like values such as paths, colors, acronyms, and identifiers. Set to `false` to report them. |
 | `failOn` | `'high' \| 'medium' \| 'low' \| 'none'` | `'high'` | Lowest severity that makes the CLI exit with code `1`. Use `none` to report without failing. |
 | `trimWhitespace` | `boolean` | `true` | Trim leading and trailing whitespace before comparing values. |
 | `ignoreCase` | `boolean` | `false` | Compare values case-insensitively when set to `true`. |
@@ -124,10 +135,16 @@ MEDIUM ja.form.search
 
 ## JSON output
 
-`--format json` prints an object with an `issues` array:
+`--format json` prints an object with a `summary` and an `issues` array:
 
 ```json
 {
+  "summary": {
+    "high": 1,
+    "medium": 0,
+    "low": 0,
+    "ignored": 16
+  },
   "issues": [
     {
       "key": "home.welcome",
@@ -143,6 +160,8 @@ MEDIUM ja.form.search
 
 Fields:
 
+Summary counts include all findings, including ignored findings that may be omitted from the visible `issues` array.
+
 | Field | Type | Description |
 |---|---|---|
 | `key` | `string` | Flattened locale key, such as `settings.profile.title`. |
@@ -169,8 +188,8 @@ Ignored issues are omitted by default. Pass `--include-ignored` to include them
 | Key matches `allowIdenticalKeys` | ignored |
 | Value matches `allowIdenticalValues` | ignored |
 | Same language family, such as `en` and `en-GB` | ignored |
-| URL, path, color, or code-like value | ignored |
 | Placeholder-only value, such as `{count}` | ignored |
+| URL, path, color, or code-like value | ignored by default |
 | Short common label | low |
 | Single English word | medium |
 | English phrase | high |
@@ -189,13 +208,19 @@ export default {
   allowIdenticalKeys: [
     'brand.*',
     'legal.name',
-    'protocol.*'
+    /^protocol\./
   ],
   allowIdenticalValues: [
     'OK',
     'ID',
     'API',
-    'HTTPS'
+    /^HTTP\/\d(\.\d)?$/
+  ],
+  placeholderPatterns: [
+    '\\{[^}]+\\}',
+    '\\{\\{[^}]+\\}\\}',
+    '%[sdif]',
+    '%\\([^)]+\\)[sdif]'
   ],
   failOn: 'high'
 };
@@ -204,7 +229,10 @@ export default {
 Useful tuning patterns:
 
 - Use `allowIdenticalKeys` for groups of expected identical values, such as names, legal labels, and protocol keys.
-- Use `allowIdenticalValues` for exact shared labels, acronyms, method names, and technical terms.
+- Use string `allowIdenticalKeys` entries for exact or wildcard key matches, and `RegExp` entries for broader key families.
+- Use string `allowIdenticalValues` entries for exact shared labels, and `RegExp` entries for structured values such as `HTTP/2`.
+- Add `placeholderPatterns` for framework-specific placeholders such as `%s`, `%(name)s`, or `$1`. Mixed content such as `Total: {count}` is still reported.
+- Set `ignoreCodeLike: false` if paths, colors, acronyms, or identifiers should be shown as findings.
 - Set `ignoreSameLanguageFamily: false` if you want to check regional variants such as `en-GB`, `en-AU`, or `pt-BR`.
 - Set `failOn: 'none'` while tuning a new project, then raise it to `high` or `medium` once the allowlist is stable.
 - Pass `--include-ignored` when reviewing why a value was ignored.
@@ -225,4 +253,4 @@ npm run check
 
 ## License
 
-MIT
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "i18n-smell-detector",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Find locale values copied from the base locale.",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "check": "node ./bin/i18n-smell-detector.js check-identical --config ./examples/vue-vite/i18n-smell.config.mjs",
+    "check": "node ./bin/i18n-smell-detector.js check-identical --config ./examples/vue-vite/i18n-smell.config.mjs --fail-on none",
     "test": "node --test"
   },
   "keywords": [

package/src/config.js

@@ -12,6 +12,11 @@ const CONFIG_FILES = [
   'i18n-smell.config.json',
 ];
 
+const DEFAULT_PLACEHOLDER_PATTERNS = [
+  String.raw`\{\{[^}]+\}\}`,
+  String.raw`\{[^}]+\}`,
+];
+
 async function exists(filePath) {
   try {
     await access(filePath);
@@ -69,6 +74,13 @@ function validateConfig(config) {
       throw new Error(`Config locales.${locale} must be a file path string`);
     }
   }
+
+  validateRuleList(candidate.allowIdenticalKeys, 'allowIdenticalKeys');
+  validateRuleList(candidate.allowIdenticalValues, 'allowIdenticalValues');
+
+  if ('placeholderPatterns' in candidate && !Array.isArray(candidate.placeholderPatterns)) {
+    throw new Error('Config placeholderPatterns must be an array of strings or RegExp objects');
+  }
 }
 
 /** @param {import('./types.js').DetectorConfig} config */
@@ -84,5 +96,39 @@ function withDefaults(config) {
     includeIgnored: false,
     failOn: 'high',
     ...config,
+    placeholderPatterns: normalizePlaceholderPatterns(config.placeholderPatterns || DEFAULT_PLACEHOLDER_PATTERNS),
+    ignoreCodeLike: config.ignoreCodeLike ?? true,
   };
 }
+
+function validateRuleList(rules, name) {
+  if (rules === undefined) return;
+  if (!Array.isArray(rules)) throw new Error(`Config ${name} must be an array`);
+
+  for (const rule of rules) {
+    if (typeof rule !== 'string' && !(rule instanceof RegExp)) {
+      throw new Error(`Config ${name} entries must be strings or RegExp objects`);
+    }
+  }
+}
+
+function normalizePlaceholderPatterns(patterns) {
+  return patterns.map((pattern) => {
+    if (pattern instanceof RegExp) return withGlobalFlag(pattern);
+
+    if (typeof pattern !== 'string') {
+      throw new Error('Config placeholderPatterns entries must be strings or RegExp objects');
+    }
+
+    try {
+      return new RegExp(pattern, 'g');
+    } catch (error) {
+      throw new Error(`Invalid placeholder pattern "${pattern}": ${error.message}`);
+    }
+  });
+}
+
+function withGlobalFlag(pattern) {
+  const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+  return new RegExp(pattern.source, flags);
+}

package/src/reporters/console.js

@@ -1,3 +1,5 @@
+import { summarizeIssues } from './summary.js';
+
 function color(code, text) {
   if (process.env.NO_COLOR) return text;
   return `\u001b[${code}m${text}\u001b[0m`;
@@ -17,7 +19,7 @@ function preview(value) {
 
 export function renderConsoleReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
-  const counts = countBySeverity(issues);
+  const counts = summarizeIssues(issues);
   const lines = [
     color('1', 'i18n-smell-detector: identical translations'),
     `high=${counts.high} medium=${counts.medium} low=${counts.low} ignored=${counts.ignored}`,
@@ -37,13 +39,3 @@ export function renderConsoleReport(issues, options) {
 
   return lines.join('\n');
 }
-
-function countBySeverity(issues) {
-  return issues.reduce(
-    (acc, issue) => {
-      acc[issue.severity] += 1;
-      return acc;
-    },
-    { high: 0, medium: 0, low: 0, ignored: 0 }
-  );
-}

package/src/reporters/json.js

@@ -1,4 +1,6 @@
+import { summarizeIssues } from './summary.js';
+
 export function renderJsonReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
-  return `${JSON.stringify({ issues: visible }, null, 2)}\n`;
+  return `${JSON.stringify({ summary: summarizeIssues(issues), issues: visible }, null, 2)}\n`;
 }

package/src/reporters/markdown.js

@@ -1,10 +1,18 @@
+import { summarizeIssues } from './summary.js';
+
 function escapeCell(value) {
   return String(value).replace(/\|/g, '\\|').replace(/\n/g, '<br>');
 }
 
 export function renderMarkdownReport(issues, options) {
   const visible = options.includeIgnored ? issues : issues.filter((issue) => issue.severity !== 'ignored');
-  const lines = ['# Identical translations', ''];
+  const summary = summarizeIssues(issues);
+  const lines = [
+    '# Identical translations',
+    '',
+    `high=${summary.high} medium=${summary.medium} low=${summary.low} ignored=${summary.ignored}`,
+    '',
+  ];
 
   if (visible.length === 0) {
     lines.push('No copied base-locale values found.');

package/src/reporters/summary.js

@@ -0,0 +1,9 @@
+export function summarizeIssues(issues) {
+  return issues.reduce(
+    (summary, issue) => {
+      summary[issue.severity] += 1;
+      return summary;
+    },
+    { high: 0, medium: 0, low: 0, ignored: 0 }
+  );
+}

package/src/rules/classify-identical.js

@@ -1,4 +1,4 @@
-import { matchesAnyPattern } from './match-pattern.js';
+import { matchesAnyRule } from './match-rule.js';
 
 function isBlank(value) {
   return value.trim().length === 0;
@@ -18,12 +18,17 @@ function isCodeLike(value) {
     || (/^[a-z0-9_.:-]+$/.test(text) && !/\s/.test(text) && !/[A-Z]/.test(text));
 }
 
-function isPlaceholderOnly(value) {
-  const text = value
-    .replace(/\{\{\s*[^}]+\s*\}\}/g, '')
-    .replace(/\{\s*[^}]+\s*\}/g, '')
-    .replace(/[\s\p{P}\p{S}]/gu, '');
-  return text.length === 0;
+function isPlaceholderOnly(value, patterns) {
+  let text = value.trim();
+
+  const orderedPatterns = [...(patterns || [])].sort((a, b) => b.source.length - a.source.length);
+
+  for (const pattern of orderedPatterns) {
+    pattern.lastIndex = 0;
+    text = text.replace(pattern, '');
+  }
+
+  return text.trim() === '';
 }
 
 function getLatinWords(value) {
@@ -49,22 +54,22 @@ function isShortCommonLabel(value) {
  * @returns {{ severity: import('../types.js').Severity, reason: string }}
  */
 export function classifyIdentical({ key, value, baseLocale, targetLocale, config }) {
-  if ((config.ignoreSameLanguageFamily ?? true) && languageFamily(baseLocale) === languageFamily(targetLocale)) {
-    return { severity: 'ignored', reason: 'same language family' };
-  }
-
-  if (matchesAnyPattern(key, config.allowIdenticalKeys || [])) {
+  if (matchesAnyRule(key, config.allowIdenticalKeys || [], { wildcard: true })) {
     return { severity: 'ignored', reason: 'allowed key' };
   }
 
-  if ((config.allowIdenticalValues || []).includes(value)) {
+  if (matchesAnyRule(value, config.allowIdenticalValues || [])) {
     return { severity: 'ignored', reason: 'allowed value' };
   }
 
+  if ((config.ignoreSameLanguageFamily ?? true) && languageFamily(baseLocale) === languageFamily(targetLocale)) {
+    return { severity: 'ignored', reason: 'same language family' };
+  }
+
   if (isBlank(value)) return { severity: 'ignored', reason: 'blank value' };
+  if (isPlaceholderOnly(value, config.placeholderPatterns || [])) return { severity: 'ignored', reason: 'placeholder only' };
   if (isExternalReference(value)) return { severity: 'ignored', reason: 'external reference' };
-  if (isPlaceholderOnly(value)) return { severity: 'ignored', reason: 'placeholder only' };
-  if (isCodeLike(value)) return { severity: 'ignored', reason: 'code-like value' };
+  if ((config.ignoreCodeLike ?? true) && isCodeLike(value)) return { severity: 'ignored', reason: 'code-like value' };
   if (isShortCommonLabel(value)) return { severity: 'low', reason: 'short common label' };
 
   const words = getLatinWords(value);

package/src/rules/match-pattern.js

@@ -1,8 +1,5 @@
-function patternToRegExp(pattern) {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-  return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
-}
+import { matchesAnyRule } from './match-rule.js';
 
 export function matchesAnyPattern(value, patterns = []) {
-  return patterns.some((pattern) => patternToRegExp(pattern).test(value));
+  return matchesAnyRule(value, patterns, { wildcard: true });
 }

package/src/rules/match-rule.js

@@ -0,0 +1,21 @@
+function wildcardToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^${escaped.replace(/\*/g, '.*')}$`);
+}
+
+function testRegExp(value, pattern) {
+  pattern.lastIndex = 0;
+  return pattern.test(value);
+}
+
+export function matchesRule(value, rule, options = {}) {
+  if (rule instanceof RegExp) return testRegExp(value, rule);
+  if (typeof rule !== 'string') return false;
+
+  if (options.wildcard) return wildcardToRegExp(rule).test(value);
+  return value === rule;
+}
+
+export function matchesAnyRule(value, rules = [], options = {}) {
+  return rules.some((rule) => matchesRule(value, rule, options));
+}

package/src/types.js

@@ -5,8 +5,10 @@
  * @typedef {Object} DetectorConfig
  * @property {string} baseLocale
  * @property {Record<string, string>} locales
- * @property {string[]=} allowIdenticalKeys
- * @property {string[]=} allowIdenticalValues
+ * @property {(string | RegExp)[]=} allowIdenticalKeys
+ * @property {(string | RegExp)[]=} allowIdenticalValues
+ * @property {(string | RegExp)[]=} placeholderPatterns
+ * @property {boolean=} ignoreCodeLike
  * @property {boolean=} ignoreSameLanguageFamily
  * @property {boolean=} trimWhitespace
  * @property {boolean=} ignoreCase