package glossary import ( "fmt" "regexp" "slices" "sort" "strings" "unicode" "unicode/utf8" ) type protectedTermDef struct { identities []Identity canonical string } type protectedOccurrence struct { text string canonical string } // ProtectedVocabulary is a deterministic glossary-derived protected term set. type ProtectedVocabulary struct { termsByFolded map[string]protectedTermDef pattern *regexp.Regexp } // NewProtectedVocabulary prepares the independently selected terms for matching. func NewProtectedVocabulary(terms []Term) ProtectedVocabulary { termsByFolded := make(map[string]protectedTermDef, len(terms)) ordered := slices.Clone(terms) sort.SliceStable(ordered, func(i, j int) bool { return len(ordered[i].Spelling) > len(ordered[j].Spelling) }) var groups, alternatives []string var left, right string flush := func() { if len(alternatives) > 0 { groups = append(groups, left+`(?:`+strings.Join(alternatives, "|")+`)`+right) alternatives = alternatives[:0] } } for _, term := range ordered { if term.Spelling == "" { continue } if !term.Exempt { termsByFolded[strings.ToLower(term.Spelling)] = protectedTermDef{identities: slices.Clone(term.Identities), canonical: term.Spelling} } first, _ := utf8.DecodeRuneInString(term.Spelling) last, _ := utf8.DecodeLastRuneInString(term.Spelling) // Share boundary checks across adjacent alternatives without // reordering competing spellings. a, b := literalEdge(first), literalEdge(last) if a != left || b != right { flush() left, right = a, b } alternatives = append(alternatives, regexp.QuoteMeta(term.Spelling)) } if len(termsByFolded) == 0 { return ProtectedVocabulary{} } flush() pattern := regexp.MustCompile(`(?i)(?:` + strings.Join(groups, "|") + `)`) return ProtectedVocabulary{termsByFolded: termsByFolded, pattern: pattern} } // A punctuation or symbol edge needs the same ASCII nonword state both // inside and outside the spelling. Letter and number edges retain Go's // regexp word-boundary behavior. Underscore is an ASCII word character. func literalEdge(r rune) string { if r != '_' && (unicode.IsPunct(r) || unicode.IsSymbol(r)) { return `\B` } return `\b` } func (v ProtectedVocabulary) Empty() bool { return v.pattern == nil } // AllowsChange checks the full text of a segment against the protection view. func (v ProtectedVocabulary) AllowsChange(before, after string, allowRepetitionCleanup bool) bool { return v.Violation(before, after, allowRepetitionCleanup) == "" } // Violation compares usable full-segment text before and after a proposed edit. // Spoken-word cleanup may reduce repeated mentions while preserving each identity. func (v ProtectedVocabulary) Violation(before, after string, allowRepetitionCleanup bool) string { if v.Empty() || before == after { return "" } beforeByID := v.occurrencesByIdentity(before) afterByID := v.occurrencesByIdentity(after) if reason := validateIdentityPreservation(beforeByID, afterByID); reason != "" { if allowRepetitionCleanup && preservesRepeatedIdentities(beforeByID, afterByID) { return "" } return reason } return validateCapitalizationTransitions(beforeByID, afterByID) } func (v ProtectedVocabulary) occurrencesByIdentity(text string) map[Identity][]protectedOccurrence { byID := make(map[Identity][]protectedOccurrence) v.scan(text, func(term protectedTermDef, matched string) { occurrence := protectedOccurrence{text: matched, canonical: term.canonical} for _, identity := range term.identities { byID[identity] = append(byID[identity], occurrence) } }) return byID } // MentionedIdentities expands each matched spelling's contributors only once. func (v ProtectedVocabulary) MentionedIdentities(texts ...string) map[Identity]struct{} { identities := make(map[Identity]struct{}) seen := make(map[string]struct{}) for _, text := range texts { v.scan(text, func(term protectedTermDef, _ string) { if _, found := seen[term.canonical]; found { return } seen[term.canonical] = struct{}{} for _, id := range term.identities { identities[id] = struct{}{} } }) } return identities } func (v ProtectedVocabulary) scan(text string, visit func(protectedTermDef, string)) { if v.Empty() { return } for _, span := range v.pattern.FindAllStringIndex(text, -1) { matched := text[span[0]:span[1]] if term, ok := v.termsByFolded[strings.ToLower(matched)]; ok { visit(term, matched) } } } func validateIdentityPreservation(beforeByID, afterByID map[Identity][]protectedOccurrence) string { var selected string found := false for identity, beforeItems := range beforeByID { afterItems := afterByID[identity] if len(afterItems) >= len(beforeItems) { continue } // Protect identity counts. Within an identity that lost a mention, // use spelling counts to identify which alias was affected. remaining := make(map[string]int) for _, item := range afterItems { remaining[item.canonical]++ } for _, item := range beforeItems { spelling := item.canonical if remaining[spelling] > 0 { remaining[spelling]-- continue } if !found || spelling < selected { selected, found = spelling, true } } } return protectedSpellingMessage(selected, found) } func validateCapitalizationTransitions(beforeByID, afterByID map[Identity][]protectedOccurrence) string { var selected string found := false for identity, afterItems := range afterByID { beforeItems := beforeByID[identity] for i, afterItem := range afterItems { if i >= len(beforeItems) || afterItem.text == beforeItems[i].text || afterItem.text == afterItem.canonical { continue } if !found || afterItem.canonical < selected { selected, found = afterItem.canonical, true } } } return protectedSpellingMessage(selected, found) } func protectedSpellingMessage(spelling string, found bool) string { if !found { return "" } return fmt.Sprintf("proposal may alter protected glossary spelling %q", spelling) } // preservesRepeatedIdentities permits a spoken-word proposal to reduce repeated // mentions, but not remove an identity or replace its surviving spelling. // Editorial and meaning validators still decide whether the cleanup is warranted. func preservesRepeatedIdentities(original, result map[Identity][]protectedOccurrence) bool { reduced := false for identity, occurrences := range original { remaining := result[identity] if len(remaining) == 0 { return false } if len(remaining) < len(occurrences) { reduced = true } } return reduced && validateCapitalizationTransitions(original, result) == "" }