Which of these names are the same name?

The same thing in your own code

Each code block has been compiled and verified in CI. Provided under the MIT license to illustrate disarm. disarm on GitHub →

# Which of these names are the same name?
#   pip install disarm
from disarm import find_key_collisions

# Not a per-string check. No entry in this list is wrong on its own: "gross.txt"
# is an ordinary filename, and the Cyrillic а in "аdmin" is only a problem
# because the real "admin" is sitting next to it.
NAMES = ["admin", "аdmin", "Admin", "groß.txt", "gross.txt", "other.txt"]

# Choosing the key is choosing the policy, and there is no default. fold_case is
# the narrowest: it collides case variants and the German sharp s, and folds no
# lookalikes, so the Cyrillic а stays Cyrillic.
narrow = find_key_collisions(NAMES, key="fold_case")
assert [c.values for c in narrow] == [
    ["admin", "Admin"],
    ["groß.txt", "gross.txt"],
]

# search_key is the broadest: transliterate, fold lookalikes, strip accents,
# fold case. It reaches the impersonation the narrow key let through.
broad = find_key_collisions(NAMES, key="search_key")
assert broad[0].values == ["admin", "аdmin", "Admin"]

# indices is every position in the group, not a parallel list to values: a
# registry wants the names, an extractor wants the entries to refuse.
assert broad[0].indices == [0, 1, 2]

# The language hint reaches the two romanizing keys and is ignored by the rest.
# German romanizes ü as ue, so the same list gives a different answer.
DE = ["Müller", "Mueller", "Muller"]
assert find_key_collisions(DE, key="search_key")[0].values == ["Müller", "Muller"]
assert find_key_collisions(DE, key="search_key", lang="de")[0].values == ["Müller", "Mueller"]

print("2 groups under fold_case; search_key also folds the Cyrillic admin")

// Which of these names are the same name?
//   disarm = "0.14"
use disarm::api::{find_key_collisions, KeyForm};

fn main() {
    // Not a per-string check. No entry in this list is wrong on its own:
    // "gross.txt" is an ordinary filename, and the Cyrillic а in "аdmin" is only
    // a problem because the real "admin" is sitting next to it.
    let names = ["admin", "аdmin", "Admin", "groß.txt", "gross.txt", "other.txt"];

    // Choosing the key is choosing the policy, and there is no default.
    // FoldCase is the narrowest: it collides case variants and the German sharp
    // s, and folds no lookalikes, so the Cyrillic а stays Cyrillic.
    let narrow = find_key_collisions(&names, KeyForm::FoldCase, None).unwrap();
    let narrow_values: Vec<&[String]> = narrow.iter().map(|c| c.values.as_slice()).collect();
    assert_eq!(narrow_values.len(), 2);
    assert_eq!(narrow_values[0], ["admin", "Admin"]);
    assert_eq!(narrow_values[1], ["groß.txt", "gross.txt"]);

    // SearchKey is the broadest: transliterate, fold lookalikes, strip accents,
    // fold case. It reaches the impersonation the narrow key let through.
    let broad = find_key_collisions(&names, KeyForm::SearchKey, None).unwrap();
    assert_eq!(broad[0].values, ["admin", "аdmin", "Admin"]);

    // indices is every position in the group, not a parallel list to values: a
    // registry wants the names, an extractor wants the entries to refuse.
    assert_eq!(broad[0].indices, [0, 1, 2]);

    // The language hint reaches the two romanizing keys and is ignored by the
    // rest. German romanizes ü as ue, so the same list gives a different answer.
    let de = ["Müller", "Mueller", "Muller"];
    let plain = find_key_collisions(&de, KeyForm::SearchKey, None).unwrap();
    let german = find_key_collisions(&de, KeyForm::SearchKey, Some("de")).unwrap();
    assert_eq!(plain[0].values, ["Müller", "Muller"]);
    assert_eq!(german[0].values, ["Müller", "Mueller"]);

    println!("2 groups under fold_case; search_key also folds the Cyrillic admin");
}

// Which of these names are the same name?
//   npm install disarm
const assert = require("node:assert");
const { findKeyCollisions } = require("disarm");

// Not a per-string check. No entry in this list is wrong on its own:
// "gross.txt" is an ordinary filename, and the Cyrillic а in "аdmin" is only a
// problem because the real "admin" is sitting next to it.
const NAMES = ["admin", "аdmin", "Admin", "groß.txt", "gross.txt", "other.txt"];

// Choosing the key is choosing the policy, and there is no default. fold_case
// is the narrowest: it collides case variants and the German sharp s, and folds
// no lookalikes, so the Cyrillic а stays Cyrillic.
const narrow = findKeyCollisions(NAMES, "fold_case");
assert.deepStrictEqual(
  narrow.map((c) => c.values),
  [
    ["admin", "Admin"],
    ["groß.txt", "gross.txt"],
  ],
);

// search_key is the broadest: transliterate, fold lookalikes, strip accents,
// fold case. It reaches the impersonation the narrow key let through.
const broad = findKeyCollisions(NAMES, "search_key");
assert.deepStrictEqual(broad[0].values, ["admin", "аdmin", "Admin"]);

// indices is every position in the group, not a parallel list to values: a
// registry wants the names, an extractor wants the entries to refuse.
assert.deepStrictEqual(broad[0].indices, [0, 1, 2]);

// The language hint reaches the two romanizing keys and is ignored by the rest.
// German romanizes ü as ue, so the same list gives a different answer. Node
// takes it in an options object, where Python and Rust take it positionally.
const DE = ["Müller", "Mueller", "Muller"];
assert.deepStrictEqual(findKeyCollisions(DE, "search_key")[0].values, ["Müller", "Muller"]);
assert.deepStrictEqual(findKeyCollisions(DE, "search_key", { lang: "de" })[0].values, ["Müller", "Mueller"]);

console.log("2 groups under fold_case; search_key also folds the Cyrillic admin");