fix: per-group char classes in toRegex to prevent false positives (#76)

* fix: use per-group char classes in toRegex to prevent false positives

toRegex() inferred a single character class for all positions from
examples. For validators where the compact form mixes letters and
digits in distinct positions (e.g., German SVNR "12010188M011"),
this produced [A-Z0-9] for every group. The overly broad pattern
matched all-caps prose like "OF NOVEMBER 6" as a valid candidate,
consuming the span and preventing the correct date pattern from
firing.

Add inferPerGroupInfo() which derives per-group character classes
from the formatted output. For SVNR, "12 010188 M 01 1" now
produces \d{2} \d{6} [A-Z]{1} \d{2} \d{1} instead of [A-Z0-9]
for all positions. Letter-only groups before the first digit group
(format-prepended prefixes like "CHE") are still excluded.

* fix: address review comments

- Extract shared charClassFor helper; inferCharClass now delegates
  to it instead of duplicating the letter/digit scanning logic
- Add regression tests for de.svnr: per-group char class matching
  and all-caps prose rejection

Author: jan-kubica

__test__/patterns.test.ts

@@ -69,6 +69,29 @@ describe("toRegex", () => {
     expect(matches).toHaveLength(1);
     expect(matches[0]![0]).toBe("DE136695976");
   });
+
+  test("per-group char classes for mixed-position validators", () => {
+    // de.svnr format: "12 010188 M 01 1"
+    // Groups must use \d for digit positions and
+    // [A-Z] for the letter.
+    const { source } = toRegex(de.svnr);
+    const test = (s: string) =>
+      new RegExp(source, "g").test(s);
+    expect(test("12 010188 M 01 1")).toBe(true);
+    expect(test("12010188M011")).toBe(true);
+    expect(test("12.010188.M.01.1")).toBe(true);
+  });
+
+  test("de.svnr rejects all-caps prose (regression)", () => {
+    // The old pattern used [A-Z0-9] for all positions,
+    // which matched "OF NOVEMBER 6" as a candidate.
+    const { source } = toRegex(de.svnr);
+    const test = (s: string) =>
+      new RegExp(source, "g").test(s);
+    expect(test("OF NOVEMBER 6")).toBe(false);
+    expect(test("AS OF NOVEMBER 6, 2024, BY")).toBe(false);
+    expect(test("AMENDMENT DATED NOVEMBER 6")).toBe(false);
+  });
 });
 
 describe("toPatterns", () => {

src/patterns.ts

@@ -127,6 +127,23 @@ const inferPrefix = (v: Validator): string | null => {
   return null;
 };
 
+/**
+ * Character class for a string fragment:
+ * `\d` if all digits, `[A-Z]` if all letters,
+ * `[A-Z0-9]` if mixed.
+ */
+const charClassFor = (s: string): string => {
+  let hasLetter = false;
+  let hasDigit = false;
+  for (const ch of s) {
+    if (/[a-zA-Z]/.test(ch)) hasLetter = true;
+    if (/\d/.test(ch)) hasDigit = true;
+  }
+  if (hasLetter && hasDigit) return "[A-Z0-9]";
+  if (hasLetter) return "[A-Z]";
+  return "\\d";
+};
+
 /**
  * Determine the character class needed for the
  * compact form: `\d` if all digits, `[A-Z0-9]`
@@ -136,18 +153,82 @@ const inferCharClass = (v: Validator): string => {
   if (!v.examples || v.examples.length === 0) {
     return "\\d";
   }
-  let hasLetter = false;
-  let hasDigit = false;
-  for (const ex of v.examples) {
-    const c = v.compact(ex);
-    for (const ch of c) {
-      if (/[a-zA-Z]/.test(ch)) hasLetter = true;
-      if (/\d/.test(ch)) hasDigit = true;
+  const combined = v.examples
+    .map((ex) => v.compact(ex))
+    .join("");
+  return charClassFor(combined);
+};
+
+type PerGroupInfo = {
+  sizes: number[];
+  classes: string[];
+};
+
+/**
+ * Infer per-group sizes AND character classes from
+ * format(). Returns groups with per-position char
+ * classes, e.g., "12 010188 M 01 1" →
+ *   sizes: [2, 6, 1, 2, 1]
+ *   classes: ["\d", "\d", "[A-Z]", "\d", "\d"]
+ *
+ * Only returns non-null when per-group classes
+ * differ (some groups are letters, some digits).
+ * Letter-only groups before the first digit group
+ * are treated as prefixes and excluded (handled
+ * by inferPrefix separately).
+ */
+const inferPerGroupInfo = (
+  v: Validator,
+): PerGroupInfo | null => {
+  if (!v.examples || v.examples.length === 0) {
+    return null;
+  }
+  const compact = v.compact(v.examples[0]!);
+  const formatted = v.format(compact);
+  if (formatted === compact) return null;
+
+  // Only applies to mixed validators (compact has
+  // both letters and digits in separate positions,
+  // like German SVNR "12010188M011").
+  const compactMixed =
+    /[a-zA-Z]/.test(compact) && /\d/.test(compact);
+  if (!compactMixed) return null;
+
+  // Also skip if any single part mixes letters and
+  // digits (IBAN, ISIN) — inferGroups already
+  // handles those correctly with the global class.
+  const parts = formatted.split(/[^a-zA-Z0-9]+/);
+  const isAlphanumeric = parts.some(
+    (p) => /[a-zA-Z]/.test(p) && /\d/.test(p),
+  );
+  if (isAlphanumeric) return null;
+
+  // Keep digit groups and letter-only groups that
+  // appear AFTER the first digit group (embedded
+  // letters). Skip letter-only groups before the
+  // first digit group (prefix like "CHE").
+  const filtered: string[] = [];
+  let seenDigitGroup = false;
+  for (const p of parts) {
+    if (p.length === 0) continue;
+    if (/\d/.test(p)) {
+      seenDigitGroup = true;
+      filtered.push(p);
+    } else if (seenDigitGroup) {
+      filtered.push(p);
     }
   }
-  if (hasLetter && hasDigit) return "[A-Z0-9]";
-  if (hasLetter) return "[A-Z]";
-  return "\\d";
+
+  if (filtered.length <= 1) return null;
+
+  const classes = filtered.map(charClassFor);
+  const allSame = classes.every((c) => c === classes[0]);
+  if (allSame) return null;
+
+  return {
+    sizes: filtered.map((p) => p.length),
+    classes,
+  };
 };
 
 /**
@@ -159,6 +240,17 @@ const groupsToPattern = (
   cc: string,
 ): string => groups.map((g) => `${cc}{${g}}`).join(SEP);
 
+/**
+ * Build a group regex with per-group char classes.
+ * Produces tighter patterns when groups have different
+ * character types (e.g., digits vs letters).
+ */
+const groupsToPatternPerClass = (
+  groups: number[],
+  classes: string[],
+): string =>
+  groups.map((g, i) => `${classes[i]!}{${g}}`).join(SEP);
+
 /**
  * Derive a loose candidate-matching regex from
  * a validator. The regex finds potential matches;
@@ -175,7 +267,19 @@ export const toRegex = (v: Validator): RegExp => {
 
   let pattern: string;
 
-  if (groups && lengths.length <= 1) {
+  // Use per-group char classes when groups mix
+  // digits and letters (e.g., German SVNR:
+  // "12 010188 M 01 1" → [\d, \d, [A-Z], \d, \d]).
+  // This prevents overly broad [A-Z0-9] from
+  // matching all-caps prose as identifiers.
+  const perGroup = inferPerGroupInfo(v);
+
+  if (perGroup && lengths.length <= 1) {
+    pattern = groupsToPatternPerClass(
+      perGroup.sizes,
+      perGroup.classes,
+    );
+  } else if (groups && lengths.length <= 1) {
     pattern = groupsToPattern(groups, cc);
   } else if (lengths.length === 1) {
     pattern = `${cc}{${lengths[0]}}`;