text.normalise-name

def normalise_name(value: str) -> str

from fune.text.normalise_name import normalise_name  # text.normalise-name@^1

from typing import List

#: Characters after which a new capital starts: hyphen, both apostrophes, full stop.
_PART_SEPARATORS = ("-", "'", "’", ".")

#: Lower-cased in the middle of a name: "Ludwig van Beethoven".
_PARTICLES = frozenset([
    "van", "von", "de", "da", "di", "del", "della", "der", "den", "des", "du",
    "la", "le", "ter", "ten", "dos", "das", "do", "bin", "ibn",
])

#: Names where "mac" is not a Gaelic prefix, so no capital follows it.
_NOT_MAC = frozenset([
    "macari", "macaulay", "macedo", "macey", "machado", "machell", "machen",
    "machin", "macias", "mackay", "mackey", "mackie", "mackin", "macklin",
])


def _is_whitespace(ch: str) -> bool:
    """The Unicode White_Space property, spelled out so all three languages
    agree: str.isspace also accepts U+001C-U+001F, which JavaScript and Rust
    do not.
    """
    cp = ord(ch)
    return (
        0x09 <= cp <= 0x0D
        or cp == 0x20
        or cp == 0x85
        or cp == 0xA0
        or cp == 0x1680
        or 0x2000 <= cp <= 0x200A
        or cp == 0x2028
        or cp == 0x2029
        or cp == 0x202F
        or cp == 0x205F
        or cp == 0x3000
    )


def _lower_one(ch: str) -> str:
    # Only one-to-one mappings: "İ".lower() is two code points, and taking it
    # would make Python disagree with the length-preserving rule in all three.
    mapped = ch.lower()
    return mapped if len(mapped) == 1 else ch


def _upper_one(ch: str) -> str:
    # "ß".upper() is "SS": left alone, for the same reason.
    mapped = ch.upper()
    return mapped if len(mapped) == 1 else ch


def _lower_all(chars: str) -> str:
    return "".join(_lower_one(ch) for ch in chars)


def _is_mixed_case(word: str) -> bool:
    upper = any(_lower_one(ch) != ch for ch in word)
    lower = any(_upper_one(ch) != ch for ch in word)
    return upper and lower


def _capitalise(text: str) -> str:
    return _upper_one(text[0]) + text[1:] if text else ""


def _case_part(part: str) -> str:
    """Title-case one hyphen/apostrophe-delimited part, with the Mc and Mac rules."""
    lower = _lower_all(part)
    if len(lower) >= 3 and lower.startswith("mc"):
        return "Mc" + _capitalise(lower[2:])
    if len(lower) >= 6 and lower.startswith("mac") and lower not in _NOT_MAC:
        return "Mac" + _capitalise(lower[3:])
    return _capitalise(lower)


def _title_word(word: str) -> str:
    out = ""
    part = ""
    for ch in word:
        if ch in _PART_SEPARATORS:
            out += _case_part(part) + ch
            part = ""
        else:
            part += ch
    return out + _case_part(part)


def normalise_name(value: str) -> str:
    """Tidy a personal name: trim, collapse whitespace, and title-case words
    typed all in one case, with the Mc, Mac, O', hyphen and particle rules.
    """
    if not isinstance(value, str):
        raise TypeError("normaliseName needs a string, received %r" % (value,))

    words: List[str] = []
    current = ""
    for ch in value:
        if _is_whitespace(ch):
            if current:
                words.append(current)
            current = ""
        else:
            current += ch
    if current:
        words.append(current)

    out: List[str] = []
    for i, word in enumerate(words):
        # Someone who typed their own capitals knows better than any rule.
        if _is_mixed_case(word):
            out.append(word)
            continue
        lower = _lower_all(word)
        if 0 < i < len(words) - 1 and lower in _PARTICLES:
            out.append(lower)
            continue
        out.append(_title_word(word))
    return " ".join(out)

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the Python package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add text.normalise-name

The manifest, vectors and README with only the Python implementation. Install it without the registry with fune add ./text.normalise-name-1.0.0-python.fune, or fetch it from a terminal with fune pull text.normalise-name@1.0.0:python.

The whole function, every language, is one file too: text.normalise-name-1.0.0.fune, 20,343 bytes, sha256 0bf63c83fe4c2e377d0cdaaa48a46a62df8d3f2ca06519e1f2eda52282043849. It installs into a project of any language.

# fune: before text.normalise-name

# fune: after text.normalise-name

# fune: step text.normalise-name after <n|label>

More from the author

1. Trims, and collapses every run of whitespace to one ASCII space. Whitespace is the Unicode White_Space set, listed explicitly so all three languages agree (tab, line feed, vertical tab, form feed, carriage return, space, U+0085, U+00A0, U+1680, U+2000-U+200A, U+2028, U+2029, U+202F, U+205F, U+3000). 2. Leaves alone any word typed in **mixed case**. "DiCaprio", "MacKenzie", "DeVito" and "Ludwig Van Beethoven" come back exactly as typed. Someone who typed their own capitals knows better than a rule. Only words that are all upper case or all lower case are recased. 3. Title-cases each single-case word: the first letter upper case, the rest lower case, restarting after a hyphen, an apostrophe (' or ’) and a full stop, so "mary-jane" is "Mary-Jane", "o'neill" is "O'Neill", "d'arcy" is "D'Arcy" and "J.R.R." stays "J.R.R.". 4. **Mc**: a part starting "mc" gets a capital after it: "McDonald", "McArthur". 5. **Mac**: a part starting "mac" and at least six letters long gets a capital after it ("MacDonald", "MacIntyre"), except for a short list of names where "mac" is not a prefix: Macari, Macaulay, Macedo, Macey, Machado, Machell, Machen, Machin, Macias, Mackay, Mackey, Mackie, Mackin, Macklin. Shorter words ("Mack", "Macon") are never changed. 6. **Particles**: van, von, de, da, di, del, della, der, den, des, du, la, le, ter, ten, dos, das, do, bin and ibn are written in lower case when they are a whole word that is neither the first nor the last: "Ludwig van Beethoven", "Juan de la Cruz". As the first word they are capitalised ("Van Morrison").

## Honest limits

No rule gets every name right, and this one will be wrong for somebody. The Mac rule is a heuristic: "Mackenzie" becomes "MacKenzie", which some families spell and some do not, and a Mac-name missing from the exception list will gain a capital it should not have. Particles are capitalised by some families ("Dick Van Dyke") and not by others. Irish and Scottish Gaelic forms ("Mac an tSaoir", "Ó Briain" as two words) and Arabic "al-" names are not specially handled. Mixed-case words are trusted, so a genuinely mistyped "jOHN" is kept too. The mixed-case rule is the escape hatch: store what the person typed if they typed capitals, and show them the normalised form to confirm rather than silently rewriting it.

## Letters outside ASCII

Upper and lower case come from each language's own per-character Unicode mapping, used only when a character maps to exactly one character: "Ç" and "ç", "Ë" and "ë", Greek and Cyrillic all work. Characters whose case mapping would change the length ("ß" upper-cases to "SS", "İ" lower-cases to two code points) are left as they are, which keeps the three languages identical. Greek final sigma is not produced: an all-capitals Greek name ending in "Σ" comes back ending in "σ", not "ς".

The input must be a string; anything else is an error.

Files