sail-rs 0.7.1

//! Docker-compatible `.dockerignore` matching for Dockerfile build contexts.
//!
//! Ignore rules are applied exactly once, during the local context walk:
//! the staged context ships with any build-time re-application suppressed,
//! so the walk alone decides which files reach the build and must reach the
//! verdicts Docker's own matcher would. Those rules differ from gitignore
//! in ways that change real
//! contexts: `[...]` classes are regular-expression classes (`[!a]` matches
//! a literal `!` or `a`, not "anything but a"), a bare `*.log` matches only
//! at the context root rather than at any depth, a pattern matching a parent
//! directory excludes everything under it, and a `!` pattern can re-include
//! a file whose parent directory is excluded. This module mirrors the
//! matcher Docker uses (moby's patternmatcher `MatchesOrParentMatches`),
//! including its quirks, e.g. `[` and `]` pass into the regular expression
//! unescaped, a wildcard-free pattern is compared as a plain string (so a
//! `^` in it is literal), a leading `**` with a literal remainder is a
//! plain suffix comparison (`**foo` matches `xfoo`), `|` and `{n,m}` are
//! live regular-expression operators (moby's escape bitmap cannot hold
//! bytes past 63, so its stated escape of `|{}` never happens), and
//! patterns Docker's positional syntax screen refuses (`foo\`, `[a-]`)
//! are errors here too. Docker reads the pattern file with the host's
//! path rules: on Windows every `\` is a separator, rewritten to `/` at
//! read time and never an escape, and this reader makes the same
//! platform split.

/// Parse `.dockerignore` content into its pattern lines the way Docker
/// reads the file: strip a UTF-8 BOM on the first line, skip `#` comments
/// and blank lines, trim whitespace, lexically clean each path, and strip a
/// leading `/` (patterns are always context-relative). Docker scans the
/// file with a 64 KiB line buffer and refuses the whole file when a raw
/// line does not fit it together with its newline, so an overlong line is
/// an error here too. Cleaning follows the host's path rules: on Windows
/// `\` is a separator, rewritten to `/`, and never an escape.
pub(crate) fn read_patterns(content: &[u8]) -> Result<Vec<String>, String> {
    read_patterns_for(content, /* windows_separators */ cfg!(windows))
}

/// [`read_patterns`] with the platform choice explicit, so both behaviors
/// stay testable from any host.
fn read_patterns_for(content: &[u8], windows_separators: bool) -> Result<Vec<String>, String> {
    const MAX_LINE_BYTES: usize = 64 * 1024 - 1;
    let mut patterns = Vec::new();
    for (index, raw_line) in content.split(|&byte| byte == b'\n').enumerate() {
        if raw_line.len() > MAX_LINE_BYTES {
            return Err(format!(
                "ignore pattern line {} is longer than {MAX_LINE_BYTES} bytes, which Docker refuses",
                index + 1
            ));
        }
        let text = String::from_utf8_lossy(raw_line);
        let mut line = text.strip_suffix('\r').unwrap_or(&text);
        if index == 0 {
            line = line.strip_prefix('\u{feff}').unwrap_or(line);
        }
        // A comment is recognized before trimming: a line whose first
        // character is a space is a pattern, not a comment.
        if line.starts_with('#') {
            continue;
        }
        let line = line.trim();
        if line.is_empty() {
            continue;
        }
        let (invert, rest) = match line.strip_prefix('!') {
            Some(rest) => (true, rest.trim()),
            None => (false, line),
        };
        let mut pattern = rest.to_string();
        if !pattern.is_empty() {
            pattern = if windows_separators {
                clean_windows_pattern(&pattern)
            } else {
                clean(&pattern)
            };
            if pattern.len() > 1 && pattern.starts_with('/') {
                pattern.remove(0);
            }
        }
        if invert {
            pattern.insert(0, '!');
        }
        patterns.push(pattern);
    }
    Ok(patterns)
}

/// Lexically clean a slash-separated path (Go's `path.Clean`): collapse
/// repeated separators, drop `.` components, resolve `..` against earlier
/// components, and strip trailing separators. An empty result is `.`.
fn clean(path: &str) -> String {
    let rooted = path.starts_with('/');
    let mut components: Vec<&str> = Vec::new();
    for component in path.split('/') {
        match component {
            "" | "." => {}
            ".." => {
                if components.last().is_some_and(|last| *last != "..") {
                    components.pop();
                } else if !rooted {
                    components.push("..");
                }
            }
            other => components.push(other),
        }
    }
    let joined = components.join("/");
    if rooted {
        format!("/{joined}")
    } else if joined.is_empty() {
        ".".to_string()
    } else {
        joined
    }
}

/// Clean one pattern the way Docker's reader does on Windows, where the
/// host's path rules make `\` a separator and never an escape: cleaning
/// treats `\` and `/` alike and the result is rewritten to `/`, so a
/// `build\output` line excludes the `build/output` subtree exactly as it
/// does under a local Windows `docker build`. Cleaning also refuses to
/// let `..` pop or repeated separators collapse a volume prefix (a drive
/// `C:` or a UNC leading `//`); a pattern carrying one stays rooted or
/// keeps a `:` no Windows file name can contain, so it matches nothing,
/// as under Docker.
fn clean_windows_pattern(pattern: &str) -> String {
    let converted = pattern.replace('\\', "/");
    let bytes = converted.as_bytes();
    let drive = bytes.len() >= 2 && bytes[0].is_ascii_alphabetic() && bytes[1] == b':';
    if !drive && !converted.starts_with("//") {
        return clean(&converted);
    }
    let (volume, rest) = converted.split_at(2);
    let cleaned = clean(rest);
    if cleaned == "." {
        // Go's Clean keeps a bare separator-ended volume as itself and
        // marks a bare drive prefix current-directory-relative (`C:.`).
        if volume.ends_with('/') {
            return volume.to_string();
        }
        return format!("{volume}.");
    }
    format!("{volume}{cleaned}")
}

/// Docker's four ways of matching one pattern. The translation to a
/// regular expression tracks whether any consumed character actually
/// required one; when none did, Docker compares strings directly, which
/// keeps regex-significant characters it never escapes, such as `^`,
/// literal.
enum Matcher {
    /// A pattern with no wildcard, class bracket, or escape: compared
    /// byte-for-byte.
    Exact(String),
    /// A literal pattern ending in `**`: a prefix comparison. The slice
    /// keeps a separator before the `**`, so `foo/**` matches `foo/bar`
    /// but not `foo` or `foobar`, while `foo**` matches `foobar`.
    Prefix(String),
    /// A literal pattern starting with `**`: a suffix comparison, so
    /// `**foo` matches `xfoo` mid-segment; `**/foo` keeps its separator
    /// and additionally matches the bare root-level `foo`.
    Suffix(String),
    /// Everything else: the anchored regular expression (`*` and `?` stop
    /// at `/`, `**` crosses it, the metacharacters Docker escapes
    /// (`.+()$`) are literal, everything else passes through raw — so `|`
    /// alternates and a valid `{n,m}` repeats, exactly as they reach Go's
    /// engine through Docker's translation).
    Regex(regex::Regex),
}

impl Matcher {
    fn is_match(&self, path: &str) -> bool {
        match self {
            Matcher::Exact(pattern) => path == pattern,
            Matcher::Prefix(prefix) => path.starts_with(prefix),
            Matcher::Suffix(suffix) => {
                path.ends_with(suffix) || (suffix.starts_with('/') && path == &suffix[1..])
            }
            Matcher::Regex(regex) => regex.is_match(path),
        }
    }
}

/// One pattern, its matcher built on first consult. Docker compiles each
/// pattern's regular expression lazily inside its matcher, and the
/// polarity skip in `matches` can keep a pattern from ever being
/// consulted, so a defective pattern that could not have changed any
/// verdict must not error either.
struct Pattern {
    exclusion: bool,
    /// The cleaned pattern text the matcher is built from.
    cleaned: String,
    /// The line as written, for error messages.
    raw: String,
    compiled: std::sync::OnceLock<Result<Matcher, String>>,
}

impl Pattern {
    fn is_match(&self, path: &str) -> Result<bool, String> {
        match self.compiled.get_or_init(|| compile_pattern(&self.cleaned)) {
            Ok(matcher) => Ok(matcher.is_match(path)),
            Err(err) => Err(format!("invalid ignore pattern {:?}: {err}", self.raw)),
        }
    }
}

/// Docker's exclusion matcher over an ordered pattern list: the last
/// matching pattern decides, where `!` patterns decide "included".
pub(crate) struct DockerPatternMatcher {
    patterns: Vec<Pattern>,
    exclusions: bool,
}

impl DockerPatternMatcher {
    pub(crate) fn new(raw_patterns: &[String]) -> Result<Self, String> {
        let mut patterns = Vec::new();
        let mut exclusions = false;
        for raw in raw_patterns {
            let mut pattern = raw.trim().to_string();
            if pattern.is_empty() {
                continue;
            }
            pattern = clean(&pattern);
            let mut exclusion = false;
            if let Some(rest) = pattern.strip_prefix('!') {
                if rest.is_empty() {
                    return Err("illegal exclusion pattern: \"!\"".to_string());
                }
                exclusion = true;
                exclusions = true;
                pattern = rest.to_string();
            }
            // Docker runs each pattern through Go's filepath.Match purely
            // for its error state and refuses the whole `.dockerignore`
            // when it reports a syntax error.
            if filepath_match_syntax_error(&pattern) {
                return Err(format!(
                    "invalid ignore pattern {raw:?}: syntax error in pattern"
                ));
            }
            patterns.push(Pattern {
                exclusion,
                cleaned: pattern,
                raw: raw.clone(),
                compiled: std::sync::OnceLock::new(),
            });
        }
        Ok(DockerPatternMatcher {
            patterns,
            exclusions,
        })
    }

    /// Whether any `!` pattern exists. A walk may prune an excluded
    /// directory only when there are none, because a `!` pattern can
    /// re-include a file below it.
    pub(crate) fn has_exclusions(&self) -> bool {
        self.exclusions
    }

    /// Whether `rel_path` (slash-separated, context-relative) is excluded.
    /// Each pattern is tried against the path itself and against every
    /// ancestor directory path, so a pattern matching any ancestor covers
    /// the file. Errors when a consulted pattern's regular expression
    /// fails to compile, which is where Docker first reports one.
    pub(crate) fn matches(&self, rel_path: &str) -> Result<bool, String> {
        let mut matched = false;
        let parent_dirs: Vec<&str> = match rel_path.rfind('/') {
            Some(split) => rel_path[..split].split('/').collect(),
            None => Vec::new(),
        };
        for pattern in &self.patterns {
            // A pattern that would confirm the current verdict cannot
            // change it; only the opposite polarity is worth testing.
            if pattern.exclusion != matched {
                continue;
            }
            let mut hit = pattern.is_match(rel_path)?;
            for depth in 1..=parent_dirs.len() {
                if hit {
                    break;
                }
                hit = pattern.is_match(&parent_dirs[..depth].join("/"))?;
            }
            if hit {
                matched = !pattern.exclusion;
            }
        }
        Ok(matched)
    }
}

/// Whether Go's `filepath.Match(pattern, ".")` reports a syntax error.
/// Docker runs every pattern through that call purely for its error state
/// and refuses the whole `.dockerignore` on an error, so the walk must
/// refuse exactly the same patterns. The screen is positional, not a full
/// validation: `Match` returns no-match as soon as a chunk fails against
/// `.` without scanning the rest of the pattern, so a malformed tail
/// behind a non-matching chunk (`a*b\`) passes the screen, while the same
/// defect in the first chunk (`foo\`, `[a-]`) is an error. This function
/// and its two helpers are direct ports of Go's `Match`, `scanChunk`,
/// `matchChunk`, and `getEsc` (non-Windows), asked about the name `.`.
fn filepath_match_syntax_error(pattern: &str) -> bool {
    let chars: Vec<char> = pattern.chars().collect();
    let mut pattern: &[char] = &chars;
    let dot = ['.'];
    let mut name: &[char] = &dot;
    'pattern: while !pattern.is_empty() {
        let (star, chunk, rest) = scan_chunk(pattern);
        pattern = rest;
        if star && chunk.is_empty() {
            // A trailing `*` matches the rest of the name.
            return false;
        }
        match match_chunk(chunk, name) {
            Err(()) => return true,
            Ok(Some(t)) if t.is_empty() || !pattern.is_empty() => {
                name = t;
                continue;
            }
            Ok(_) => {}
        }
        if star {
            // Retry the chunk at each later offset the `*` could reach.
            let mut i = 0;
            while i < name.len() && name[i] != '/' {
                match match_chunk(chunk, &name[i + 1..]) {
                    Err(()) => return true,
                    Ok(Some(t)) => {
                        if pattern.is_empty() && !t.is_empty() {
                            i += 1;
                            continue;
                        }
                        name = t;
                        continue 'pattern;
                    }
                    Ok(None) => {}
                }
                i += 1;
            }
        }
        return false;
    }
    false
}

/// Split off the next chunk: any leading `*`s, then everything up to the
/// next `*` outside a class.
fn scan_chunk(mut pattern: &[char]) -> (bool, &[char], &[char]) {
    let mut star = false;
    while pattern.first() == Some(&'*') {
        pattern = &pattern[1..];
        star = true;
    }
    let mut inrange = false;
    let mut i = 0;
    while i < pattern.len() {
        match pattern[i] {
            '\\' => {
                if i + 1 < pattern.len() {
                    i += 1;
                }
            }
            '[' => inrange = true,
            ']' => inrange = false,
            '*' if !inrange => break,
            _ => {}
        }
        i += 1;
    }
    (star, &pattern[..i], &pattern[i..])
}

/// Match one chunk against the start of `s`, scanning the whole chunk for
/// syntax errors even after the match has failed, as Go does. `Ok(Some)`
/// carries the unmatched remainder of `s`; `Ok(None)` is a clean
/// mismatch; `Err` is a syntax error.
fn match_chunk<'a>(mut chunk: &[char], mut s: &'a [char]) -> Result<Option<&'a [char]>, ()> {
    let mut failed = false;
    while !chunk.is_empty() {
        if !failed && s.is_empty() {
            failed = true;
        }
        match chunk[0] {
            '[' => {
                let mut r = '\0';
                if !failed {
                    r = s[0];
                    s = &s[1..];
                }
                chunk = &chunk[1..];
                let negated = chunk.first() == Some(&'^');
                if negated {
                    chunk = &chunk[1..];
                }
                let mut matched = false;
                let mut nrange = 0;
                loop {
                    if chunk.first() == Some(&']') && nrange > 0 {
                        chunk = &chunk[1..];
                        break;
                    }
                    let lo;
                    (lo, chunk) = get_esc(chunk)?;
                    let mut hi = lo;
                    if chunk[0] == '-' {
                        (hi, chunk) = get_esc(&chunk[1..])?;
                    }
                    if lo <= r && r <= hi {
                        matched = true;
                    }
                    nrange += 1;
                }
                if matched == negated {
                    failed = true;
                }
            }
            '?' => {
                if !failed {
                    if s[0] == '/' {
                        failed = true;
                    }
                    s = &s[1..];
                }
                chunk = &chunk[1..];
            }
            '\\' => {
                chunk = &chunk[1..];
                if chunk.is_empty() {
                    return Err(());
                }
                if !failed {
                    if chunk[0] != s[0] {
                        failed = true;
                    }
                    s = &s[1..];
                }
                chunk = &chunk[1..];
            }
            _ => {
                if !failed {
                    if chunk[0] != s[0] {
                        failed = true;
                    }
                    s = &s[1..];
                }
                chunk = &chunk[1..];
            }
        }
    }
    if failed {
        Ok(None)
    } else {
        Ok(Some(s))
    }
}

/// One class member (a range endpoint): a character other than `-` or
/// `]`, optionally backslash-escaped, with the class still open after it.
fn get_esc(chunk: &[char]) -> Result<(char, &[char]), ()> {
    if chunk.is_empty() || chunk[0] == '-' || chunk[0] == ']' {
        return Err(());
    }
    let mut chunk = chunk;
    if chunk[0] == '\\' {
        chunk = &chunk[1..];
        if chunk.is_empty() {
            return Err(());
        }
    }
    let nchunk = &chunk[1..];
    if nchunk.is_empty() {
        return Err(());
    }
    Ok((chunk[0], nchunk))
}

/// The class shorthands Go's engine reads as ASCII where Rust's default
/// is Unicode, with replacements reproducing Go's exact semantics: `\s`
/// is `[\t\n\f\r ]` (no vertical tab, which Rust's ASCII `\s` would
/// include), and each negated form matches any rune outside the ASCII
/// set. The negated forms cannot use a `(?-u:)` scope — a byte class that
/// can match invalid UTF-8 is rejected by the string API — but explicit
/// classes carry identical semantics. Go keeps the ASCII reading inside a
/// bracket expression too, and the bracketed replacements nest there as
/// character classes, so they apply in both positions. The word boundaries
/// stay `(?-u:)`, which makes them ASCII-defined like Go's; a boundary
/// cannot appear inside a bracket expression, so those replacements are
/// outside-only.
fn ascii_class_replacement(shorthand: char) -> Option<&'static str> {
    Some(match shorthand {
        'd' => "[0-9]",
        'D' => "[^0-9]",
        's' => "[\\t\\n\\x0C\\r ]",
        'S' => "[^\\t\\n\\x0C\\r ]",
        'w' => "[0-9A-Za-z_]",
        'W' => "[^0-9A-Za-z_]",
        'b' => "(?-u:\\b)",
        'B' => "(?-u:\\B)",
        _ => return None,
    })
}

/// Whether `chars` (starting at its `{`) opens a valid Go repetition:
/// `{n}`, `{n,}`, or `{n,m}` with decimal bounds free of leading zeros.
/// Returns the token length including both braces, and whether Go would
/// refuse the repetition outright (a bound over its limit of 1000).
fn scan_repetition(chars: &[char]) -> Option<(usize, bool)> {
    let mut i = 1;
    let (mut over_limit, len) = scan_repetition_bound(&chars[i..])?;
    i += len;
    if chars.get(i) == Some(&',') {
        i += 1;
        if let Some((max_over, len)) = scan_repetition_bound(&chars[i..]) {
            i += len;
            over_limit |= max_over;
        }
    }
    if chars.get(i) != Some(&'}') {
        return None;
    }
    Some((i + 1, over_limit))
}

/// One decimal repetition bound: `0`, or a digit run not starting with
/// `0`. Returns whether the value exceeds Go's repetition limit and the
/// count of consumed characters. A leading zero disqualifies the whole
/// repetition — Go treats the braces as literal text then.
fn scan_repetition_bound(chars: &[char]) -> Option<(bool, usize)> {
    let mut len = 0;
    while chars.get(len).is_some_and(char::is_ascii_digit) {
        len += 1;
    }
    if len == 0 || (len > 1 && chars[0] == '0') {
        return None;
    }
    let over_limit = len > 4
        || chars[..len]
            .iter()
            .collect::<String>()
            .parse::<u32>()
            .unwrap()
            > 1000;
    Some((over_limit, len))
}

/// Whether Go refuses the numeric escape `\<digit>`, given the character
/// after the digit. `\0` always opens an octal code, but a nonzero octal
/// digit must be followed by a second octal digit (`\14`), because a bare
/// `\1` reads as a backreference, which Go rejects as unsupported; `\8`
/// and `\9` are not octal at all. Rust, with octal escapes enabled, reads
/// `\1` as character code 1 and would silently diverge.
fn go_rejects_numeric_escape(digit: char, following: Option<char>) -> bool {
    matches!(digit, '1'..='9') && !(digit <= '7' && matches!(following, Some('0'..='7')))
}

/// Length of the `[:name:]` form opening at `chars[0]`, scanning the rest
/// of the expression for the closing `:]` exactly as Go does (the scan
/// runs past a `]` that would otherwise close the class), or `None` when
/// it never closes and the `[` is an ordinary member.
fn posix_class_len(chars: &[char]) -> Option<usize> {
    let close = chars.windows(2).skip(2).position(|w| w == [':', ']'])?;
    Some(close + 4)
}

/// The unicode class names Go accepts, in Go's canonical spelling,
/// sorted. Generated by compiling `\p{name}` under Go 1.25 for every
/// name reachable through its lookup: the specials Any, Assigned, Ascii,
/// and Lc, the category tables and their aliases, and the script tables.
/// Go canonicalizes a name before the lookup (below), which leaves a
/// multi-word script spelling like `Old_Italic` unreachable; such names
/// are correctly absent.
const GO_UNICODE_CLASS_NAMES: &[&str] = &[
    "Adlam",
    "Ahom",
    "Any",
    "Arabic",
    "Armenian",
    "Ascii",
    "Assigned",
    "Avestan",
    "Balinese",
    "Bamum",
    "Batak",
    "Bengali",
    "Bhaiksuki",
    "Bopomofo",
    "Brahmi",
    "Braille",
    "Buginese",
    "Buhid",
    "C",
    "Carian",
    "Casedletter",
    "Cc",
    "Cf",
    "Chakma",
    "Cham",
    "Cherokee",
    "Chorasmian",
    "Closepunctuation",
    "Cn",
    "Cntrl",
    "Co",
    "Combiningmark",
    "Common",
    "Connectorpunctuation",
    "Control",
    "Coptic",
    "Cs",
    "Cuneiform",
    "Currencysymbol",
    "Cypriot",
    "Cyrillic",
    "Dashpunctuation",
    "Decimalnumber",
    "Deseret",
    "Devanagari",
    "Digit",
    "Dogra",
    "Duployan",
    "Elbasan",
    "Elymaic",
    "Enclosingmark",
    "Ethiopic",
    "Finalpunctuation",
    "Format",
    "Georgian",
    "Glagolitic",
    "Gothic",
    "Grantha",
    "Greek",
    "Gujarati",
    "Gurmukhi",
    "Han",
    "Hangul",
    "Hanunoo",
    "Hatran",
    "Hebrew",
    "Hiragana",
    "Inherited",
    "Initialpunctuation",
    "Javanese",
    "Kaithi",
    "Kannada",
    "Katakana",
    "Kawi",
    "Kharoshthi",
    "Khmer",
    "Khojki",
    "Khudawadi",
    "L",
    "Lao",
    "Latin",
    "Lc",
    "Lepcha",
    "Letter",
    "Letternumber",
    "Limbu",
    "Lineseparator",
    "Lisu",
    "Ll",
    "Lm",
    "Lo",
    "Lowercaseletter",
    "Lt",
    "Lu",
    "Lycian",
    "Lydian",
    "M",
    "Mahajani",
    "Makasar",
    "Malayalam",
    "Mandaic",
    "Manichaean",
    "Marchen",
    "Mark",
    "Mathsymbol",
    "Mc",
    "Me",
    "Medefaidrin",
    "Miao",
    "Mn",
    "Modi",
    "Modifierletter",
    "Modifiersymbol",
    "Mongolian",
    "Mro",
    "Multani",
    "Myanmar",
    "N",
    "Nabataean",
    "Nandinagari",
    "Nd",
    "Newa",
    "Nko",
    "Nl",
    "No",
    "Nonspacingmark",
    "Number",
    "Nushu",
    "Ogham",
    "Openpunctuation",
    "Oriya",
    "Osage",
    "Osmanya",
    "Other",
    "Otherletter",
    "Othernumber",
    "Otherpunctuation",
    "Othersymbol",
    "P",
    "Palmyrene",
    "Paragraphseparator",
    "Pc",
    "Pd",
    "Pe",
    "Pf",
    "Phoenician",
    "Pi",
    "Po",
    "Privateuse",
    "Ps",
    "Punct",
    "Punctuation",
    "Rejang",
    "Runic",
    "S",
    "Samaritan",
    "Saurashtra",
    "Sc",
    "Separator",
    "Sharada",
    "Shavian",
    "Siddham",
    "Sinhala",
    "Sk",
    "Sm",
    "So",
    "Sogdian",
    "Soyombo",
    "Spaceseparator",
    "Spacingmark",
    "Sundanese",
    "Surrogate",
    "Symbol",
    "Syriac",
    "Tagalog",
    "Tagbanwa",
    "Takri",
    "Tamil",
    "Tangsa",
    "Tangut",
    "Telugu",
    "Thaana",
    "Thai",
    "Tibetan",
    "Tifinagh",
    "Tirhuta",
    "Titlecaseletter",
    "Toto",
    "Ugaritic",
    "Unassigned",
    "Uppercaseletter",
    "Vai",
    "Vithkuqi",
    "Wancho",
    "Yezidi",
    "Yi",
    "Z",
    "Zl",
    "Zp",
    "Zs",
];

/// The class names Go's `[:name:]` form accepts, exactly as spelled
/// (an optional leading `^` negates).
const GO_POSIX_CLASS_NAMES: &[&str] = &[
    "alnum", "alpha", "ascii", "blank", "cntrl", "digit", "graph", "lower", "print", "punct",
    "space", "upper", "word", "xdigit",
];

/// Go's canonicalization of a unicode class name before lookup: drop
/// `_`, `-`, and spaces, uppercase the first remaining ASCII letter, and
/// lowercase the rest.
fn go_canonical_unicode_name(name: &str) -> String {
    let mut out = String::with_capacity(name.len());
    let mut first = true;
    for c in name.chars() {
        if matches!(c, '_' | '-' | ' ') {
            continue;
        }
        if first {
            out.push(c.to_ascii_uppercase());
            first = false;
        } else {
            out.push(c.to_ascii_lowercase());
        }
    }
    out
}

/// Translate the `\p`/`\P` unicode class escape opening at
/// `chars[start]` (its backslash), appending Rust syntax that carries
/// Go's reading and returning the unit's length. Go resolves the name
/// loosely (canonicalized as above, with `{^Name}` negating), so the
/// accepted spellings are Go's, not Rust's: the canonical spelling is
/// emitted, and a name Go refuses is a deferred error even where Rust
/// would accept it (`\p{Emoji}`, `\p{Old_Italic}`) and vice versa
/// (`\p{GREEK}`). The one representational gap is the surrogate
/// category: its code points have no UTF-8 encoding, so it can never
/// match a path character, and Rust cannot even spell it, so it becomes
/// Rust's closest legal never-matching class instead.
///
/// Name acceptance is exact; a class's contents then come from each
/// engine's own Unicode tables (Go 1.25 carries Unicode 15.0, Rust's
/// engine 16.0), so membership of code points assigned between those
/// versions can differ. Docker has the same skew across its own
/// releases, each built with a different Go, so there is no single
/// canonical membership to reproduce.
fn emit_unicode_class(
    chars: &[char],
    start: usize,
    reg: &mut String,
    deferred_error: &mut Option<String>,
) -> usize {
    let mut negated = chars[start + 1] == 'P';
    let (name, len) = if chars.get(start + 2) == Some(&'{') {
        let Some(close) = chars[start + 3..].iter().position(|&c| c == '}') else {
            // An unclosed `\p{` runs to the end of the expression; Go
            // refuses it.
            let unit: String = chars[start..].iter().collect();
            deferred_error.get_or_insert(format!("invalid character class range: {unit}"));
            return chars.len() - start;
        };
        let name: String = chars[start + 3..start + 3 + close].iter().collect();
        (name, close + 4)
    } else if let Some(&single) = chars.get(start + 2) {
        (single.to_string(), 3)
    } else {
        deferred_error.get_or_insert(format!(
            "invalid character class range: \\{}",
            chars[start + 1]
        ));
        return 2;
    };
    let bare = match name.strip_prefix('^') {
        Some(rest) => {
            negated = !negated;
            rest
        }
        None => name.as_str(),
    };
    let canonical = go_canonical_unicode_name(bare);
    if GO_UNICODE_CLASS_NAMES
        .binary_search(&canonical.as_str())
        .is_err()
    {
        let unit: String = chars[start..start + len].iter().collect();
        deferred_error.get_or_insert(format!("invalid character class range: {unit}"));
        return len;
    }
    let (negated, emitted) = if canonical == "Cs" || canonical == "Surrogate" {
        (!negated, "Any")
    } else {
        (negated, canonical.as_str())
    };
    reg.push('\\');
    reg.push(if negated { 'P' } else { 'p' });
    reg.push('{');
    reg.push_str(emitted);
    reg.push('}');
    len
}

/// Append one class member — an escape unit, a POSIX `[:name:]` class, or
/// a single character — starting at `chars[*j]`, advancing `*j` past it.
/// Returns whether the member was a whole set (a Perl shorthand or POSIX
/// class), which Go never extends into a range.
fn emit_class_member(
    chars: &[char],
    j: &mut usize,
    reg: &mut String,
    deferred_error: &mut Option<String>,
) -> bool {
    let c = chars[*j];
    if c == '\\' {
        let Some(&next) = chars.get(*j + 1) else {
            // A trailing backslash leaves the class unterminated too;
            // both engines refuse the expression.
            reg.push('\\');
            *j += 1;
            return false;
        };
        if matches!(next, 'p' | 'P') {
            // Go reads `\p` inside a class exactly as outside one.
            *j += emit_unicode_class(chars, *j, reg, deferred_error);
            return true;
        }
        if go_rejects_numeric_escape(next, chars.get(*j + 2).copied())
            // Word boundaries cannot appear inside a class: Go refuses
            // the escape there, while Rust would read `\b` as a
            // backspace. Go also has no `\u`/`\U` escapes anywhere;
            // Rust would read a hex character code.
            || matches!(next, 'b' | 'B' | 'u' | 'U')
        {
            deferred_error.get_or_insert(format!("invalid escape sequence: \\{next}"));
        }
        if let Some(replacement) =
            ascii_class_replacement(next).filter(|_| !matches!(next, 'b' | 'B'))
        {
            reg.push_str(replacement);
            *j += 2;
            return true;
        }
        reg.push('\\');
        reg.push(next);
        *j += 2;
        return false;
    }
    if c == '[' {
        // `[:name:]` is the one bracketed form Go reads inside a class.
        if chars.get(*j + 1) == Some(&':') {
            if let Some(len) = posix_class_len(&chars[*j..]) {
                // Go looks the name up in a fixed table and refuses the
                // class on a miss; Rust would read the unknown form as a
                // nested class of literal members instead.
                let name: String = chars[*j + 2..*j + len - 2].iter().collect();
                if !GO_POSIX_CLASS_NAMES.contains(&name.strip_prefix('^').unwrap_or(&name)) {
                    deferred_error
                        .get_or_insert(format!("invalid character class range: [:{name}:]"));
                }
                reg.extend(&chars[*j..*j + len]);
                *j += len;
                return true;
            }
        }
        reg.push_str("\\[");
        *j += 1;
        return false;
    }
    match c {
        // Rust reads doubled `&&`/`~~` as class set operations, `-` by
        // position as a range, `[` above as a nested class, and `]` as
        // the closing bracket; Go gives a member none of those meanings,
        // so escape them to stay literal. The `.+()$` set is escaped for
        // uniformity with the outside-class translation; those are
        // literal in a class either way.
        '&' | '~' | '-' | ']' | '.' | '+' | '(' | ')' | '$' => {
            reg.push('\\');
            reg.push(c);
        }
        _ => reg.push(c),
    }
    *j += 1;
    false
}

/// Replay Docker's pattern-to-regex translation over the whole pattern:
/// the translated characters, each paired with the index of the pattern
/// character that produced it, plus where each pattern character's
/// translation begins. Docker translates with no bracket state, so Go
/// parses a bracket expression over this translated text; outside a
/// class the main translation loop reads the pattern itself identically
/// and never needs this view.
fn expand_for_class_scan(chars: &[char]) -> (Vec<char>, Vec<usize>, Vec<usize>) {
    fn emit(exp: &mut Vec<char>, orig: &mut Vec<usize>, unit: usize, text: &str) {
        for c in text.chars() {
            exp.push(c);
            orig.push(unit);
        }
    }
    let mut exp = Vec::new();
    let mut orig = Vec::new();
    let mut at = vec![0; chars.len()];
    let mut i = 0;
    while i < chars.len() {
        let unit = i;
        let start = exp.len();
        let ch = chars[i];
        if ch == '*' && chars.get(i + 1) == Some(&'*') {
            i += 1;
            // `**/` is `**`: the separator is part of the wildcard.
            if chars.get(i + 1) == Some(&'/') {
                i += 1;
            }
            emit(
                &mut exp,
                &mut orig,
                unit,
                if i + 1 >= chars.len() { ".*" } else { "(.*/)?" },
            );
        } else if ch == '*' {
            emit(&mut exp, &mut orig, unit, "[^/]*");
        } else if ch == '?' {
            emit(&mut exp, &mut orig, unit, "[^/]");
        } else if matches!(ch, '.' | '+' | '(' | ')' | '$') {
            exp.push('\\');
            orig.push(unit);
            exp.push(ch);
            orig.push(unit);
        } else if ch == '\\' {
            exp.push('\\');
            orig.push(unit);
            if let Some(&next) = chars.get(i + 1) {
                exp.push(next);
                orig.push(unit);
                i += 1;
            }
        } else {
            exp.push(ch);
            orig.push(unit);
        }
        at[unit..=i].fill(start);
        i += 1;
    }
    (exp, orig, at)
}

/// Translate one bracket expression over the pattern's expanded view,
/// `exp[k0 - 1]` being its `[`. Docker translates `*`, `?`, and its
/// escape set with no bracket state, so Go parses the class over the
/// TRANSLATED text: a source `?` contributes the four characters of
/// `[^/]` as members, and its `]` can close the class early. The scan
/// mirrors Go's class parser over that text: any character is a member
/// (`-` and a first-position `]` included), extended to a range when a
/// `-` follows and the character after that is not `]`. Go reads a
/// range's upper endpoint with its plain escape reader, which has no
/// whole-set forms: `[` is one ordinary character there and a Perl
/// shorthand refuses the class. Returns the pattern index the caller
/// resumes at and whether the last emitted token was a repetition (the
/// `*` of a translated source `*` can land just past the closing `]`
/// and quantify the class).
fn translate_class(
    exp: &[char],
    exp_orig: &[usize],
    k0: usize,
    pattern_len: usize,
    reg: &mut String,
    deferred_error: &mut Option<String>,
) -> (usize, bool) {
    reg.push('[');
    let mut k = k0;
    if exp.get(k) == Some(&'^') {
        reg.push('^');
        k += 1;
    }
    let mut first = true;
    let mut closed = None;
    while k < exp.len() {
        if exp[k] == ']' && !first {
            reg.push(']');
            closed = Some(k);
            k += 1;
            break;
        }
        first = false;
        let lo_is_set = emit_class_member(exp, &mut k, reg, deferred_error);
        // A `-` after a single-character member extends it to a range
        // unless the class closes right after the `-`; an item like `\d`
        // is already a whole set, which Go never extends.
        if !lo_is_set
            && exp.get(k) == Some(&'-')
            && exp.get(k + 1).is_some_and(|&after| after != ']')
        {
            reg.push('-');
            k += 1;
            if exp[k] == '[' {
                // Go's endpoint reader takes `[` as one ordinary
                // character; the member reader's POSIX lookup must not
                // run here.
                reg.push_str("\\[");
                k += 1;
            } else {
                let escape = (exp[k] == '\\').then(|| exp.get(k + 1).copied()).flatten();
                if emit_class_member(exp, &mut k, reg, deferred_error) {
                    if let Some(next) = escape {
                        deferred_error.get_or_insert(format!("invalid escape sequence: \\{next}"));
                    }
                }
            }
        }
    }
    let mut last_was_repetition = false;
    if let Some(closer) = closed {
        // Characters the closing unit emitted past its `]` — the `*` of
        // a translated source `*` — follow the class and quantify it.
        while k < exp.len() && exp_orig[k] == exp_orig[closer] {
            reg.push(exp[k]);
            last_was_repetition = exp[k] == '*';
            k += 1;
        }
    }
    (
        if k < exp.len() {
            exp_orig[k]
        } else {
            pattern_len
        },
        last_was_repetition,
    )
}

/// Translate one cleaned pattern to Docker's matcher for it. The regular
/// expression is built alongside a running classification that starts at
/// `Exact` and only leaves it when a character genuinely needs the regular
/// expression; a pattern that never leaves the string-comparison kinds
/// discards the regular expression, exactly as Docker does — including
/// any error the discarded expression would have raised, so `x{1001}`
/// alone is an ordinary string comparison.
fn compile_pattern(pattern: &str) -> Result<Matcher, String> {
    enum Kind {
        Exact,
        Prefix,
        Suffix,
        Regex,
    }
    let chars: Vec<char> = pattern.chars().collect();
    let mut kind = Kind::Exact;
    let mut reg = String::from("^");
    // Go's engine refuses a repetition applied to another repetition and
    // a repeat count over 1000 at compile time; Rust's engine accepts
    // both, so the translation detects them itself and errors only when
    // the regular expression is genuinely compiled.
    let mut deferred_error: Option<String> = None;
    let mut last_was_repetition = false;
    let mut end_anchor_swallowed = false;
    // Built on the first bracket expression; patterns without one never
    // pay for the expanded view.
    let mut expanded: Option<(Vec<char>, Vec<usize>, Vec<usize>)> = None;
    let mut i = 0;
    while i < chars.len() {
        let ch = chars[i];
        if ch == '*' && chars.get(i + 1) == Some(&'*') {
            let leading = i == 0;
            i += 1;
            // `**/` is `**`: the separator is part of the wildcard.
            if chars.get(i + 1) == Some(&'/') {
                i += 1;
            }
            if i + 1 >= chars.len() {
                // A trailing `**` accepts everything below: a still-literal
                // pattern becomes a prefix comparison, otherwise the
                // regular expression accepts the rest.
                if matches!(kind, Kind::Exact) {
                    kind = Kind::Prefix;
                } else {
                    reg.push_str(".*");
                    kind = Kind::Regex;
                }
            } else {
                // Zero or more whole path segments, separators included;
                // the next segment starts at a boundary.
                reg.push_str("(.*/)?");
                kind = Kind::Regex;
            }
            // A pattern-opening `**` makes this a suffix comparison unless
            // a later character switches to the regular expression, whose
            // leading group above then requires a segment boundary:
            // `**foo` matches `xfoo` but `**foo*` does not.
            if leading {
                kind = Kind::Suffix;
            }
            last_was_repetition = true;
        } else if ch == '*' {
            reg.push_str("[^/]*");
            kind = Kind::Regex;
            last_was_repetition = true;
        } else if ch == '?' {
            // `[^/]` is a class, not a repetition: `?{2}` legally repeats
            // it in both engines.
            reg.push_str("[^/]");
            kind = Kind::Regex;
            last_was_repetition = false;
        } else if matches!(ch, '.' | '+' | '(' | ')' | '$') {
            // The metacharacters Docker actually escapes. Its escape list
            // names `|{}` too, but the bitmap holding the list is built
            // with `1 << (byte / 8)` into single bytes, which truncates
            // to zero for bytes past 63 — `{` (123), `|` (124), and `}`
            // (125) are never escaped and stay live below. Escaping keeps
            // the pattern eligible for string comparison: these
            // characters are literal either way.
            reg.push('\\');
            reg.push(ch);
            last_was_repetition = false;
        } else if matches!(ch, '{' | '}' | '|') {
            if ch == '{' {
                if let Some((token_len, over_limit)) = scan_repetition(&chars[i..]) {
                    let token: String = chars[i..i + token_len].iter().collect();
                    if over_limit {
                        deferred_error.get_or_insert(format!("invalid repeat count: {token}"));
                    } else if last_was_repetition {
                        deferred_error
                            .get_or_insert(format!("invalid nested repetition operator: {token}"));
                    }
                    reg.push_str(&token);
                    i += token_len - 1;
                    last_was_repetition = true;
                } else {
                    // Go treats a `{` that opens no valid repetition as a
                    // literal; Rust's engine errors on it, so escape it.
                    reg.push_str("\\{");
                    last_was_repetition = false;
                }
            } else {
                // `|` alternates and a lone `}` is literal in both
                // engines.
                reg.push(ch);
                last_was_repetition = false;
            }
        } else if ch == '\\' {
            // A backslash carries the next character into the regular
            // expression verbatim.
            if let Some(&next) = chars.get(i + 1) {
                if go_rejects_numeric_escape(next, chars.get(i + 2).copied())
                    // Go has no `\u`/`\U` escapes; Rust would read a hex
                    // character code.
                    || matches!(next, 'u' | 'U')
                {
                    deferred_error.get_or_insert(format!("invalid escape sequence: \\{next}"));
                }
                if next == 'Q' {
                    // Go's engine reads `\Q...\E` as a span of quoted text.
                    // Docker's translation runs before Go's parser, so the
                    // quoting applies to the TRANSLATED expression:
                    // `\Qfoo.bar\E` quotes the translated `foo\.bar`,
                    // backslash included, and `\Q*\E` quotes `[^/]*`.
                    // Replay the translation into a buffer, cut it at the
                    // first raw `\E` the translated text contains, and emit
                    // the span escaped for Rust.
                    let mut quoted = String::new();
                    let mut j = i + 2;
                    let mut terminated = false;
                    while j < chars.len() {
                        let qc = chars[j];
                        if qc == '*' && chars.get(j + 1) == Some(&'*') {
                            j += 1;
                            if chars.get(j + 1) == Some(&'/') {
                                j += 1;
                            }
                            if j + 1 >= chars.len() {
                                quoted.push_str(".*");
                            } else {
                                quoted.push_str("(.*/)?");
                            }
                        } else if qc == '*' {
                            quoted.push_str("[^/]*");
                        } else if qc == '?' {
                            quoted.push_str("[^/]");
                        } else if matches!(qc, '.' | '+' | '(' | ')' | '$') {
                            quoted.push('\\');
                            quoted.push(qc);
                        } else if qc == '\\' {
                            quoted.push('\\');
                            if let Some(&pair) = chars.get(j + 1) {
                                quoted.push(pair);
                                j += 1;
                            }
                        } else {
                            quoted.push(qc);
                        }
                        j += 1;
                        // The terminator is a substring of the translated
                        // text, so it can span two pattern units:
                        // `\Qa\\Eb` quotes `a\`. Every unit that can
                        // complete the two characters puts them at the end
                        // of the buffer, so the suffix check sees each
                        // terminator the moment it forms.
                        if quoted.ends_with("\\E") {
                            quoted.truncate(quoted.len() - 2);
                            terminated = true;
                            break;
                        }
                    }
                    if !terminated {
                        // An unterminated span runs through the anchor
                        // Docker appends after the pattern: `\Qfoo` quotes
                        // `foo$` and matches any path that begins with it.
                        quoted.push('$');
                        end_anchor_swallowed = true;
                    }
                    reg.push_str(&regex::escape(&quoted));
                    i = j - 1;
                } else if matches!(next, 'p' | 'P') {
                    // Go reads `\p` as a Unicode class wherever it appears.
                    i += emit_unicode_class(&chars, i, &mut reg, &mut deferred_error) - 1;
                } else if next == 'x' && chars.get(i + 2) == Some(&'{') {
                    // Go lexes `\x{...}` as one braced escape; carry it
                    // whole so the literal-`{` escape and the repetition
                    // scan above can neither corrupt nor misread it.
                    reg.push('\\');
                    reg.push(next);
                    i += 1;
                    while let Some(&braced) = chars.get(i + 1) {
                        reg.push(braced);
                        i += 1;
                        if braced == '}' {
                            break;
                        }
                    }
                } else if let Some(replacement) = ascii_class_replacement(next) {
                    reg.push_str(replacement);
                    i += 1;
                } else {
                    reg.push('\\');
                    reg.push(next);
                    i += 1;
                }
                kind = Kind::Regex;
            } else {
                // A trailing backslash only survives the syntax screen
                // hidden behind a wildcard (`a*b\`), so the kind is
                // already `Regex`; the lone backslash then escapes the
                // appended `$`, exactly as Docker's translation leaves
                // it.
                reg.push('\\');
            }
            last_was_repetition = false;
        } else if ch == '[' {
            // Docker translates with no bracket state, so Go parses the
            // class over TRANSLATED text; scan that view. The class can
            // consume translated wildcards, so scanning resumes wherever
            // the expanded scan ended.
            let (exp, exp_orig, exp_at) =
                expanded.get_or_insert_with(|| expand_for_class_scan(&chars));
            let (resume, was_repetition) = translate_class(
                exp,
                exp_orig,
                exp_at[i] + 1,
                chars.len(),
                &mut reg,
                &mut deferred_error,
            );
            kind = Kind::Regex;
            last_was_repetition = was_repetition;
            i = resume;
            continue;
        } else if ch == ']' {
            // A stray `]` with no open class is literal in both engines.
            reg.push(ch);
            kind = Kind::Regex;
            last_was_repetition = false;
        } else {
            reg.push(ch);
            last_was_repetition = false;
        }
        i += 1;
    }
    Ok(match kind {
        Kind::Exact => Matcher::Exact(pattern.to_string()),
        // `**` is ASCII, so both slices sit on character boundaries.
        Kind::Prefix => Matcher::Prefix(pattern[..pattern.len() - 2].to_string()),
        Kind::Suffix => Matcher::Suffix(pattern[2..].to_string()),
        Kind::Regex => {
            if let Some(err) = deferred_error {
                return Err(err);
            }
            if !end_anchor_swallowed {
                reg.push('$');
            }
            // Go's engine reads `\141` as an octal character code; Rust
            // disables octal escapes by default so a numeric escape can be
            // reported as a backreference error, but neither engine has
            // backreferences, so enabling them restores Go's reading.
            regex::RegexBuilder::new(&reg)
                .octal(true)
                .build()
                .map(Matcher::Regex)
                .map_err(|err| err.to_string())?
        }
    })
}

#[cfg(test)]
mod tests {
    use super::*;

    fn matcher(patterns: &[&str]) -> DockerPatternMatcher {
        let owned: Vec<String> = patterns.iter().map(ToString::to_string).collect();
        DockerPatternMatcher::new(&owned).expect("valid patterns")
    }

    #[test]
    fn read_patterns_normalizes_like_docker() {
        let content =
            b"\xEF\xBB\xBF*.log\r\n# comment\n\n  spaced  \n/rooted\ndir/\n!  keep.log\na/./b//c\n";
        assert_eq!(
            read_patterns(content).unwrap(),
            ["*.log", "spaced", "rooted", "dir", "!keep.log", "a/b/c"]
        );
    }

    #[test]
    fn read_patterns_windows_treats_backslash_as_separator() {
        // Docker reads the file with the host's path rules: on Windows a
        // `build\output` line excludes the `build/output` subtree, and
        // cleaning resolves `.`/`..` across either separator.
        let content =
            b"build\\output\nmixed/sub\\dir\na\\..\\b\n\\rooted\nfoo\\\n!build\\output\\keep.txt\n";
        assert_eq!(
            read_patterns_for(content, /* windows_separators */ true).unwrap(),
            [
                "build/output",
                "mixed/sub/dir",
                "b",
                "rooted",
                "foo",
                "!build/output/keep.txt"
            ]
        );
        // Elsewhere `\` is an escape byte, left for the matcher.
        assert_eq!(
            read_patterns_for(content, /* windows_separators */ false).unwrap(),
            [
                "build\\output",
                "mixed/sub\\dir",
                "a\\..\\b",
                "\\rooted",
                "foo\\",
                "!build\\output\\keep.txt"
            ]
        );
    }

    #[test]
    fn read_patterns_windows_keeps_volume_patterns_inert() {
        // An absolute pattern is meaningless against a context-relative
        // path, and Docker's Windows cleaning preserves the volume
        // prefix, so such a line matches nothing. Letting `..` pop a
        // drive prefix or separators collapse a UNC lead-in would
        // instead leave a live relative pattern.
        let patterns = read_patterns_for(
            b"C:\\..\\foo\n\\\\server\\share\\build\nC:\\logs\n",
            /* windows_separators */ true,
        )
        .unwrap();
        assert_eq!(patterns, ["C:/foo", "/server/share/build", "C:/logs"]);
        let m = DockerPatternMatcher::new(&patterns).expect("valid patterns");
        assert!(!m.matches("foo").unwrap());
        assert!(!m.matches("server/share/build").unwrap());
        assert!(!m.matches("logs").unwrap());
    }

    #[test]
    fn windows_read_patterns_drive_docker_windows_semantics() {
        let patterns = read_patterns_for(
            b"build\\output\n!build\\output\\keep.txt\n",
            /* windows_separators */ true,
        )
        .unwrap();
        let m = DockerPatternMatcher::new(&patterns).expect("valid patterns");
        assert!(m.matches("build/output/app.bin").unwrap());
        assert!(m.matches("build/output").unwrap());
        assert!(!m.matches("build/output/keep.txt").unwrap());
        // The Unix reading of `build\output` is the escape spelling of
        // the literal name `buildoutput`; the Windows reading must not
        // touch that file.
        assert!(!m.matches("buildoutput").unwrap());
    }

    #[test]
    fn character_classes_are_regex_classes_not_gitignore() {
        // Docker: `[!a]` is a class containing `!` and `a`; gitignore would
        // read it as negation. For example, `[!a].txt` must exclude a.txt
        // and keep b.txt.
        let m = matcher(&["[!a].txt"]);
        assert!(m.matches("a.txt").unwrap());
        assert!(m.matches("!.txt").unwrap());
        assert!(!m.matches("b.txt").unwrap());
        // Regex negation spelling works.
        let m = matcher(&["[^a].txt"]);
        assert!(!m.matches("a.txt").unwrap());
        assert!(m.matches("b.txt").unwrap());
    }

    #[test]
    fn single_star_is_anchored_to_one_segment() {
        let m = matcher(&["*.log"]);
        assert!(m.matches("app.log").unwrap());
        assert!(!m.matches("sub/app.log").unwrap());
        let m = matcher(&["**/*.log"]);
        assert!(m.matches("app.log").unwrap());
        assert!(m.matches("sub/app.log").unwrap());
        assert!(m.matches("a/b/app.log").unwrap());
    }

    #[test]
    fn question_mark_matches_one_non_separator_character() {
        let m = matcher(&["?.txt"]);
        assert!(m.matches("a.txt").unwrap());
        assert!(!m.matches("ab.txt").unwrap());
        assert!(!m.matches("/.txt").unwrap());
    }

    #[test]
    fn a_matching_parent_directory_excludes_the_file() {
        let m = matcher(&["logs"]);
        assert!(m.matches("logs").unwrap());
        assert!(m.matches("logs/app.log").unwrap());
        assert!(m.matches("logs/deep/nested.log").unwrap());
        assert!(!m.matches("logstash").unwrap());
        let m = matcher(&["a/b"]);
        assert!(m.matches("a/b/c/d").unwrap());
        assert!(!m.matches("a/c").unwrap());
    }

    #[test]
    fn every_ancestor_directory_is_checked_for_a_match() {
        // `**/dropdir` matches the ancestor `a/b/dropdir`, one component
        // deeper than the pattern; a parent check truncated to the
        // pattern's own component count misses it.
        let m = matcher(&["**/dropdir", "!**/dropdir/keep.txt"]);
        assert!(m.matches("a/b/dropdir/drop.txt").unwrap());
        assert!(!m.matches("a/b/dropdir/keep.txt").unwrap());
        assert!(m.matches("dropdir/drop.txt").unwrap());
        assert!(!m.matches("dropdir/keep.txt").unwrap());
    }

    #[test]
    fn docker_escaped_metacharacters_are_literal() {
        // Wildcard-free, so these are string comparisons.
        let m = matcher(&["file+name"]);
        assert!(m.matches("file+name").unwrap());
        assert!(!m.matches("filename").unwrap());
        assert!(!m.matches("fileename").unwrap());
        let m = matcher(&["a|b"]);
        assert!(m.matches("a|b").unwrap());
        assert!(!m.matches("a").unwrap());
        assert!(!m.matches("b").unwrap());
        let m = matcher(&["a(b)"]);
        assert!(m.matches("a(b)").unwrap());
        assert!(!m.matches("ab").unwrap());
        let m = matcher(&["x{2}"]);
        assert!(m.matches("x{2}").unwrap());
        assert!(!m.matches("xx").unwrap());
        // A trailing `*` forces the regular expression, where `.+()$` are
        // escaped but `|` and `{n,m}` stay live operators, exactly as they
        // reach Go's engine through Docker's translation.
        let m = matcher(&["file+name*"]);
        assert!(m.matches("file+names").unwrap());
        assert!(!m.matches("filename").unwrap());
        let m = matcher(&["a|b*"]);
        assert!(m.matches("a|bc").unwrap());
        assert!(m.matches("a").unwrap());
        assert!(m.matches("bx").unwrap());
        assert!(!m.matches("c").unwrap());
        let m = matcher(&["a(b)*"]);
        assert!(m.matches("a(b)c").unwrap());
        assert!(!m.matches("ab").unwrap());
        let m = matcher(&["x{2}*"]);
        assert!(m.matches("xx").unwrap());
        assert!(m.matches("xxy").unwrap());
        assert!(!m.matches("x{2}y").unwrap());
        let m = matcher(&["a$b*"]);
        assert!(m.matches("a$b").unwrap());
        assert!(m.matches("a$bc").unwrap());
    }

    #[test]
    fn non_trailing_double_star_stops_at_a_segment_boundary() {
        let m = matcher(&["**/foo"]);
        assert!(m.matches("foo").unwrap());
        assert!(m.matches("a/foo").unwrap());
        assert!(m.matches("a/b/foo").unwrap());
        assert!(!m.matches("xfoo").unwrap());
        assert!(!m.matches("a/xfoo").unwrap());
        let m = matcher(&["a/**/b"]);
        assert!(m.matches("a/b").unwrap());
        assert!(m.matches("a/x/b").unwrap());
        assert!(m.matches("a/x/y/b").unwrap());
        assert!(!m.matches("a/xb").unwrap());
    }

    #[test]
    fn leading_double_star_without_separator_is_a_suffix_match() {
        // Docker's quirk: a literal remainder makes `**foo` a plain suffix
        // comparison, but one more wildcard switches to the regular
        // expression, which requires a separator before `foo`.
        let m = matcher(&["**foo"]);
        assert!(m.matches("foo").unwrap());
        assert!(m.matches("xfoo").unwrap());
        assert!(m.matches("a/xfoo").unwrap());
        let m = matcher(&["**foo*"]);
        assert!(m.matches("foo").unwrap());
        assert!(m.matches("a/foobar").unwrap());
        assert!(!m.matches("xfoo").unwrap());
    }

    #[test]
    fn exclusion_reincludes_under_an_excluded_directory() {
        let m = matcher(&["logs", "!logs/keep.log"]);
        assert!(m.matches("logs/drop.log").unwrap());
        assert!(!m.matches("logs/keep.log").unwrap());
        assert!(m.has_exclusions());
        assert!(!matcher(&["logs"]).has_exclusions());
    }

    #[test]
    fn last_matching_pattern_decides() {
        let m = matcher(&["*.log", "!keep.log", "keep.*"]);
        assert!(m.matches("keep.log").unwrap());
        let m = matcher(&["*.log", "keep.*", "!keep.log"]);
        assert!(!m.matches("keep.log").unwrap());
    }

    #[test]
    fn trailing_double_star_accepts_everything_below() {
        let m = matcher(&["foo/**"]);
        assert!(m.matches("foo/a").unwrap());
        assert!(m.matches("foo/a/b/c").unwrap());
        assert!(!m.matches("foo").unwrap());
        assert!(!m.matches("bar/a").unwrap());
    }

    #[test]
    fn dot_is_literal() {
        let m = matcher(&["a.txt"]);
        assert!(m.matches("a.txt").unwrap());
        assert!(!m.matches("axtxt").unwrap());
        // In the regular expression too, not only the string comparison.
        let m = matcher(&["a.txt*"]);
        assert!(m.matches("a.txt").unwrap());
        assert!(!m.matches("axtxt").unwrap());
    }

    #[test]
    fn caret_is_literal_in_string_compared_patterns() {
        // Docker only consults its regular expression when a wildcard,
        // class bracket, or escape appears; otherwise the pattern is a
        // plain string comparison and `^`, which Docker never escapes,
        // stays literal.
        let m = matcher(&["foo^bar"]);
        assert!(m.matches("foo^bar").unwrap());
        assert!(m.matches("foo^bar/sub.txt").unwrap());
        assert!(!m.matches("foobar").unwrap());
        let m = matcher(&["foo^bar/**"]);
        assert!(m.matches("foo^bar/x").unwrap());
        assert!(!m.matches("foo^bar").unwrap());
        let m = matcher(&["**foo^bar"]);
        assert!(m.matches("xfoo^bar").unwrap());
        assert!(m.matches("a/xfoo^bar").unwrap());
        // With a wildcard the same caret lands in the regular expression
        // unescaped, where it is an anchor that can never match
        // mid-string; Docker's own matcher rejects everything here too.
        let m = matcher(&["foo^*"]);
        assert!(!m.matches("foo^").unwrap());
        assert!(!m.matches("foo^x").unwrap());
        assert!(!m.matches("foox").unwrap());
    }

    #[test]
    fn backslash_escapes_the_next_character() {
        let m = matcher(&["a\\*b"]);
        assert!(m.matches("a*b").unwrap());
        assert!(!m.matches("axb").unwrap());
    }

    #[test]
    fn bare_exclusion_is_an_error() {
        let err = DockerPatternMatcher::new(&["!".to_string()])
            .map(|_| ())
            .unwrap_err();
        assert!(err.contains("illegal exclusion pattern"), "{err}");
    }

    #[test]
    fn invalid_patterns_are_errors() {
        let err = DockerPatternMatcher::new(&["a[".to_string()])
            .map(|_| ())
            .unwrap_err();
        assert!(err.contains("invalid ignore pattern"), "{err}");
    }

    #[test]
    fn pattern_screening_matches_docker() {
        // Docker runs every pattern through Go's filepath.Match for its
        // error state and refuses the whole `.dockerignore` on a syntax
        // error; accepting one locally would walk a context Docker will
        // not build. Expectations generated with Go's filepath.Match and
        // moby's patternmatcher, which agree on every case.
        for bad in [
            "foo\\", "*foo\\", "*\\", "[ab\\", "[", "[a", "a[", "[]", "[a-]", "[-a]", "[a-b",
            "[^]", ".b\\", "?x\\", ".*b\\", "*b\\", "**\\", "[a][", "?[",
        ] {
            let err = DockerPatternMatcher::new(&[bad.to_string()])
                .map(|_| ())
                .unwrap_err();
            assert!(err.contains("syntax error in pattern"), "{bad}: {err}");
        }
        for good in [
            "[!a]", "[^a]", "[a-z]", "[\\]]", "[\\-a]", "a\\*b", "a-b", "a]b", "[a]", "a**\\",
            "[a]*x\\", "a*[a-]", "x*[-a]",
        ] {
            assert!(
                DockerPatternMatcher::new(&[good.to_string()]).is_ok(),
                "{good}"
            );
        }
        // The screen is positional, as Docker's is: a malformed class
        // behind a chunk that fails to match `.` passes it and errors at
        // regular-expression compilation, which runs on the first match
        // attempt, exactly when Docker first reports it.
        for late in ["a*[", "[a-z]*[", "x*[]"] {
            let err = matcher(&[late]).matches("anything").unwrap_err();
            assert!(!err.contains("syntax error in pattern"), "{late}: {err}");
            assert!(err.contains("invalid ignore pattern"), "{late}: {err}");
        }
        // A trailing backslash that survives the screen compiles to a
        // regular expression whose lone `\` escapes the appended `$`, so
        // it matches a literal trailing dollar, never a backslash --
        // Docker's translation produces the same expression.
        let m = matcher(&["a*b\\"]);
        assert!(m.matches("axb$").unwrap());
        assert!(!m.matches("axb\\").unwrap());
        assert!(!m.matches("axb").unwrap());
    }

    #[test]
    fn brace_and_alternation_follow_go_regexp() {
        // Docker's stated escape of `|{}` never happens (its escape bitmap
        // cannot hold bytes past 63), so these reach Go's engine raw: a
        // valid `{n,m}` repeats, a `{` opening no valid repetition is a
        // literal, and Go's compile-time refusals (a bound over 1000, a
        // repetition applied to a repetition) are reproduced as errors.
        // Every row verified against Go's regexp on the exact pattern.
        let m = matcher(&["a{b*"]);
        assert!(m.matches("a{bc").unwrap());
        assert!(!m.matches("ab").unwrap());
        let m = matcher(&["a{,2}b*"]);
        assert!(m.matches("a{,2}bc").unwrap());
        let m = matcher(&["x{01}*"]);
        assert!(m.matches("x{01}").unwrap());
        assert!(!m.matches("x").unwrap());
        let m = matcher(&["{a}*"]);
        assert!(m.matches("{a}").unwrap());
        let m = matcher(&["x{1,3}*"]);
        assert!(m.matches("xxx").unwrap());
        assert!(!m.matches("y").unwrap());
        let m = matcher(&["x{0}y*"]);
        assert!(m.matches("y").unwrap());
        assert!(!m.matches("xy").unwrap());
        let m = matcher(&["x{1000}*"]);
        assert!(m.matches(&"x".repeat(1000)).unwrap());
        let err = matcher(&["x{1001}*"]).matches("x").unwrap_err();
        assert!(err.contains("invalid repeat count"), "{err}");
        let err = matcher(&["x*{2}"]).matches("x").unwrap_err();
        assert!(err.contains("nested repetition"), "{err}");
        // Wildcard-free, the regular expression is discarded, errors and
        // all, exactly as Docker discards it.
        let m = matcher(&["x{2}{2}"]);
        assert!(m.matches("x{2}{2}").unwrap());
        assert!(!m.matches("xxxx").unwrap());
        let m = matcher(&["\\p{L}*"]);
        assert!(m.matches("a").unwrap());
        assert!(!m.matches("1").unwrap());
    }

    #[test]
    fn perl_class_shorthands_are_ascii_like_go() {
        // Go's engine reads `\d`/`\s`/`\w` and their negations as ASCII;
        // Rust's default is Unicode. Rows verified against Go's regexp:
        // the Arabic-Indic digit, the no-break space, and the accented
        // letter must not match the positive classes and must match the
        // negated ones, and Go's `\s` excludes the vertical tab.
        let m = matcher(&["\\d*"]);
        assert!(m.matches("7").unwrap());
        assert!(!m.matches("١").unwrap());
        let m = matcher(&["\\D*"]);
        assert!(m.matches("١").unwrap());
        assert!(!m.matches("7").unwrap());
        let m = matcher(&["\\s*"]);
        assert!(m.matches(" ").unwrap());
        assert!(!m.matches("\u{0B}").unwrap());
        assert!(!m.matches("\u{A0}").unwrap());
        let m = matcher(&["\\S*"]);
        assert!(m.matches("\u{0B}").unwrap());
        assert!(m.matches("\u{A0}").unwrap());
        assert!(!m.matches(" ").unwrap());
        let m = matcher(&["\\w*"]);
        assert!(m.matches("a").unwrap());
        assert!(!m.matches("é").unwrap());
        let m = matcher(&["\\W*"]);
        assert!(m.matches("é").unwrap());
        assert!(!m.matches("a").unwrap());
    }

    #[test]
    fn perl_class_shorthands_inside_brackets_are_ascii_like_go() {
        // Go keeps the ASCII reading inside a bracket expression; Rust's
        // default Unicode reading would ignore a file named with the
        // Arabic-Indic digit below, dropping from the context a file that
        // docker ships.
        let m = matcher(&["[\\d]*"]);
        assert!(m.matches("7").unwrap());
        assert!(!m.matches("١").unwrap());
        let m = matcher(&["[\\D]*"]);
        assert!(m.matches("x").unwrap());
        assert!(m.matches("١").unwrap());
        assert!(!m.matches("4").unwrap());
        let m = matcher(&["a[\\s]b"]);
        assert!(m.matches("a b").unwrap());
        assert!(!m.matches("a\u{A0}b").unwrap());
        let m = matcher(&["[x\\w]*"]);
        assert!(m.matches("x").unwrap());
        assert!(m.matches("a").unwrap());
        assert!(!m.matches("é").unwrap());
    }

    #[test]
    fn octal_escapes_read_like_go() {
        // Go's engine reads `\141` as the octal code for `a`; Rust
        // reserves numeric escapes for backreference errors unless octal
        // is enabled, refusing a pattern docker accepts.
        let m = matcher(&["\\141*"]);
        assert!(m.matches("abc").unwrap());
        assert!(!m.matches("bcd").unwrap());
        let m = matcher(&["\\14*"]);
        assert!(m.matches("\u{c}x").unwrap());
        assert!(!m.matches("14").unwrap());
    }

    #[test]
    fn bracket_members_go_reads_literally_stay_literal() {
        // Rust alone gives doubled `&&`/`~~` set meaning and opens a
        // nested class at `[`; Go reads them as ordinary members.
        let m = matcher(&["[a&&b]"]);
        assert!(m.matches("a").unwrap());
        assert!(m.matches("&").unwrap());
        assert!(m.matches("b").unwrap());
        assert!(!m.matches("c").unwrap());
        let m = matcher(&["[a~~b]"]);
        assert!(m.matches("~").unwrap());
        assert!(m.matches("a").unwrap());
        assert!(!m.matches("c").unwrap());
        let m = matcher(&["[a[b]"]);
        assert!(m.matches("[").unwrap());
        assert!(m.matches("a").unwrap());
        assert!(!m.matches("c").unwrap());
        let m = matcher(&["[\\?]"]);
        assert!(m.matches("?").unwrap());
        assert!(!m.matches("x").unwrap());
        let m = matcher(&["[\\*]"]);
        assert!(m.matches("*").unwrap());
    }

    #[test]
    fn bracket_wildcards_read_as_their_translations() {
        // Docker translates `*` and `?` BEFORE Go parses the result,
        // with no bracket state: a source `[?]` reaches Go's parser as
        // `[[^/]]`, whose class the translated `]` closes early, leaving
        // the source `]` a trailing literal. Rows verified against
        // Docker's matcher.
        let m = matcher(&["[?]"]);
        assert!(!m.matches("?").unwrap());
        assert!(m.matches("^]").unwrap());
        assert!(m.matches("[]").unwrap());
        let m = matcher(&["[*]"]);
        assert!(!m.matches("*").unwrap());
        assert!(m.matches("]").unwrap());
        assert!(m.matches("[[]").unwrap());
        let m = matcher(&["[a?b]"]);
        assert!(!m.matches("a").unwrap());
        assert!(!m.matches("?").unwrap());
        assert!(m.matches("ab]").unwrap());
        let m = matcher(&["[a*b]"]);
        assert!(m.matches("ab]").unwrap());
        assert!(m.matches("aab]").unwrap());
        assert!(m.matches("b]").unwrap());
        assert!(!m.matches("ab").unwrap());
        assert!(!m.matches("*").unwrap());
        let m = matcher(&["x[?]y"]);
        assert!(m.matches("x[]y").unwrap());
        assert!(!m.matches("x?y").unwrap());
        let m = matcher(&["[^?]"]);
        assert!(m.matches("a]").unwrap());
        assert!(!m.matches("a").unwrap());
        let m = matcher(&["[??]"]);
        assert!(m.matches("[a]").unwrap());
    }

    #[test]
    fn bracket_double_star_and_ranges_read_as_their_translations() {
        // `**` reaches the class as `(.*/)?` (`.*` when it ends the
        // pattern), and a translated wildcard's `[` can serve as a range
        // endpoint while its `*` lands past the closing `]` and
        // quantifies the class. Rows verified against Docker's matcher.
        let m = matcher(&["[**]"]);
        assert!(m.matches("(").unwrap());
        assert!(m.matches("/").unwrap());
        assert!(!m.matches("x").unwrap());
        let m = matcher(&["[**/x]"]);
        assert!(m.matches("x").unwrap());
        assert!(m.matches("(").unwrap());
        // The `?` ending the translated `(.*/)?` forms the range `?`-`z`.
        let m = matcher(&["[**-z]"]);
        assert!(m.matches("A").unwrap());
        let m = matcher(&["[?-z]"]);
        assert!(m.matches("[-z]").unwrap());
        assert!(!m.matches("a").unwrap());
        let m = matcher(&["[A-?]"]);
        assert!(m.matches("B]").unwrap());
        let m = matcher(&["[A-*]"]);
        assert!(m.matches("]").unwrap());
        // `a`-`[` is a reversed range, which both engines refuse.
        let err = matcher(&["[a-?]"]).matches("x").unwrap_err();
        assert!(err.contains("invalid ignore pattern"), "{err}");
        let m = matcher(&["[*]{2}"]);
        assert!(m.matches("]]").unwrap());
        // The translated `*` quantifies the class, so `{2}` nests.
        let err = matcher(&["[*{2}]"]).matches("x").unwrap_err();
        assert!(err.contains("invalid nested repetition"), "{err}");
        let m = matcher(&["[A-[:alpha:]]"]);
        assert!(m.matches("B]").unwrap());
        assert!(m.matches(":]").unwrap());
    }

    #[test]
    fn whole_set_range_endpoints_are_errors() {
        // Go reads a range's upper endpoint with its plain escape
        // reader, which has no whole-set forms, so `\d` there refuses
        // the class; a whole set as the LOWER item never forms a range
        // and the dash stays a member.
        let err = matcher(&["z*[--\\d]"]).matches("za").unwrap_err();
        assert!(err.contains("invalid escape sequence"), "{err}");
        let err = matcher(&["z*[a-\\p{L}]"]).matches("za").unwrap_err();
        assert!(err.contains("invalid escape sequence"), "{err}");
        // The bad class only errs when consulted; a broader earlier
        // pattern keeps it skipped.
        let m = matcher(&["*", "z*[--\\d]"]);
        assert!(m.matches("za").unwrap());
        let m = matcher(&["[\\d-x]"]);
        assert!(m.matches("-").unwrap());
        let m = matcher(&["[\\pL-z]"]);
        assert!(m.matches("a").unwrap());
    }

    #[test]
    fn bracket_dashes_and_first_bracket_follow_go_positions() {
        // Go reads a class greedily member by member — a first-position
        // `]` is a member, a dash between two members is a range, every
        // other dash is literal — never Rust's `--` set difference. The
        // malformed forms hide behind a star chunk because the positional
        // syntax screen stops at the chunk the input fails.
        let m = matcher(&["z*[--b]"]);
        assert!(m.matches("z0").unwrap());
        assert!(m.matches("z-").unwrap());
        assert!(m.matches("zb").unwrap());
        assert!(!m.matches("zc").unwrap());
        // `[a--b]` is the reversed range `a`..`-`, which Go refuses.
        let err = matcher(&["z*[a--b]"]).matches("z").unwrap_err();
        assert!(err.contains("invalid ignore pattern"), "{err}");
        let m = matcher(&["z*[a-]"]);
        assert!(m.matches("za").unwrap());
        assert!(m.matches("z-").unwrap());
        assert!(!m.matches("zb").unwrap());
        let m = matcher(&["z*[]a]"]);
        assert!(m.matches("z]").unwrap());
        assert!(m.matches("za").unwrap());
        assert!(!m.matches("zb").unwrap());
        let m = matcher(&["z*[]-a]"]);
        assert!(m.matches("z^").unwrap());
        assert!(m.matches("z]").unwrap());
        assert!(!m.matches("zb").unwrap());
    }

    #[test]
    fn escapes_go_rejects_are_errors() {
        // A bare `\1` is a backreference to Go, which its engine refuses,
        // while Rust with octal escapes on would read character code 1;
        // `\8` is not octal in either engine; a word boundary cannot
        // appear inside a class, where Rust would read a backspace.
        for pattern in ["\\1", "z*[\\1]", "\\8", "a[\\b]"] {
            let err = matcher(&[pattern]).matches("anything").unwrap_err();
            assert!(err.contains("invalid escape sequence"), "{pattern}: {err}");
        }
    }

    #[test]
    fn quoted_spans_quote_the_translated_text() {
        // `\Q...\E` reaches Go's parser AFTER Docker's translation, so
        // the span quotes translated text: Docker's `\.` escape makes
        // `\Qfoo.bar\E` match a literal backslash, and a quoted `*` is
        // the five characters of its translation. Rows verified against
        // Docker's matcher.
        let m = matcher(&["\\Qfoo.bar\\E*"]);
        assert!(m.matches("foo\\.bar").unwrap());
        assert!(m.matches("foo\\.barX").unwrap());
        assert!(!m.matches("foo.bar").unwrap());
        let m = matcher(&["\\Qa*b\\E"]);
        assert!(m.matches("a[^/]*b").unwrap());
        assert!(!m.matches("axb").unwrap());
        assert!(!m.matches("a*b").unwrap());
        let m = matcher(&["\\Q**\\Ex"]);
        assert!(m.matches("(.*/)?x").unwrap());
        assert!(!m.matches("x").unwrap());
        assert!(!m.matches("**x").unwrap());
        let m = matcher(&["\\Q+\\E"]);
        assert!(m.matches("\\+").unwrap());
        assert!(!m.matches("+").unwrap());
        // The terminator is a substring of the translated text: the
        // `\\` pair's second backslash and a following `E` complete it.
        let m = matcher(&["\\Qa\\\\Eb"]);
        assert!(m.matches("a\\b").unwrap());
        assert!(!m.matches("ab").unwrap());
        // Text after the span translates normally again.
        let m = matcher(&["\\Qa\\E*\\Qb\\E"]);
        assert!(m.matches("ab").unwrap());
        assert!(m.matches("axb").unwrap());
        assert!(!m.matches("ax/b").unwrap());
        // A repetition after the span binds to its last character.
        let m = matcher(&["\\Qa\\E{2}"]);
        assert!(m.matches("aa").unwrap());
        assert!(!m.matches("a").unwrap());
        // An empty span quotes nothing.
        let m = matcher(&["x\\Q\\Ey"]);
        assert!(m.matches("xy").unwrap());
        assert!(!m.matches("xay").unwrap());
        let m = matcher(&["\\Qα β\\E"]);
        assert!(m.matches("α β").unwrap());
    }

    #[test]
    fn unterminated_quoted_spans_swallow_the_anchor() {
        // With no `\E`, the span runs through the `$` Docker appends,
        // quoting it too: the pattern matches any path that BEGINS with
        // the quoted text plus a literal dollar sign.
        let m = matcher(&["\\Qfoo"]);
        assert!(m.matches("foo$").unwrap());
        assert!(m.matches("foo$x").unwrap());
        assert!(!m.matches("foo").unwrap());
        assert!(!m.matches("xfoo$").unwrap());
        let m = matcher(&["\\Q**"]);
        assert!(m.matches(".*$").unwrap());
        assert!(m.matches(".*$zz").unwrap());
        assert!(!m.matches("ab").unwrap());
    }

    #[test]
    fn unicode_escapes_are_go_errors() {
        // Go's engine has no `\u`/`\U`; Rust would read a hex character
        // code and silently match `A`.
        for pattern in ["\\u0041*", "z*[\\u0041]", "\\U00000041*"] {
            let err = matcher(&[pattern]).matches("A").unwrap_err();
            assert!(err.contains("invalid escape sequence"), "{pattern}: {err}");
        }
        // A quoted span in a class is refused by both engines.
        let err = matcher(&["a[\\Qx\\E]"]).matches("ax").unwrap_err();
        assert!(err.contains("invalid ignore pattern"), "{err}");
    }

    #[test]
    fn posix_classes_carry_through_brackets() {
        let m = matcher(&["[[:digit:]]*"]);
        assert!(m.matches("4").unwrap());
        assert!(!m.matches("x").unwrap());
        let m = matcher(&["a[[:alpha:]7]"]);
        assert!(m.matches("ax").unwrap());
        assert!(m.matches("a7").unwrap());
        assert!(!m.matches("a8").unwrap());
    }

    #[test]
    fn defective_patterns_error_on_first_consult_not_construction() {
        // Docker compiles a pattern's regular expression lazily inside
        // its matcher, so a defective pattern the polarity skip never
        // consults cannot fail a build. `[z-a]` passes the positional
        // syntax screen (Go's filepath.Match has no range-order error)
        // and is defective only at compilation.
        let m = matcher(&["*", "[z-a]"]);
        assert!(m.matches("a").unwrap());
        let m = matcher(&["nomatch", "![z-a]"]);
        assert!(!m.matches("a").unwrap());
        let err = matcher(&["[z-a]"]).matches("a").unwrap_err();
        assert!(err.contains("invalid ignore pattern \"[z-a]\""), "{err}");
    }

    #[test]
    fn repetition_inside_a_class_is_literal() {
        // `{1001}` inside a class is five ordinary members to both
        // engines; the repetition scan must not read it as a repeat
        // count and refuse the bound.
        let m = matcher(&["[[:alpha:]{1001}]*"]);
        assert!(m.matches("a").unwrap());
        assert!(m.matches("{x").unwrap());
        assert!(m.matches("1").unwrap());
        assert!(!m.matches("2").unwrap());
    }

    #[test]
    fn unicode_class_names_follow_go_not_rust() {
        // Go accepts exactly its own table of script, category, and
        // alias names, folding case and separators; Rust's tables differ
        // (it knows `Emoji` and `word`, Go does not). Every accepted
        // name is re-emitted in Go's canonical spelling, which Rust also
        // accepts. Rows verified against Go's regexp.
        let m = matcher(&["\\p{Greek}*"]);
        assert!(m.matches("αβ").unwrap());
        assert!(!m.matches("ab").unwrap());
        let m = matcher(&["\\p{GREEK}*"]);
        assert!(m.matches("α").unwrap());
        let m = matcher(&["\\p{Lowercase_Letter}*"]);
        assert!(m.matches("a").unwrap());
        assert!(!m.matches("A").unwrap());
        let m = matcher(&["\\p{digit}*"]);
        assert!(m.matches("7").unwrap());
        let m = matcher(&["\\pl*"]);
        assert!(m.matches("a").unwrap());
        assert!(!m.matches("7").unwrap());
        // `Assigned` is every assigned code point; U+0378 is unassigned.
        let m = matcher(&["\\p{Assigned}*"]);
        assert!(m.matches("a").unwrap());
        assert!(!m.matches("\u{0378}").unwrap());
        // A `^` after the brace negates, composing with `\P`.
        let m = matcher(&["\\P{^Greek}*"]);
        assert!(m.matches("α").unwrap());
        assert!(!m.matches("a").unwrap());
        // Surrogates have no UTF-8 encoding, so Go's `Cs` class can
        // never match a path; it is emitted as the never-matching
        // complement of `Any`, which Rust accepts where it refuses `Cs`.
        let m = matcher(&["\\p{Cs}*"]);
        assert!(!m.matches("a").unwrap());
        let m = matcher(&["\\P{Cs}*"]);
        assert!(m.matches("a").unwrap());
        for bad in [
            "\\p{Emoji}*",
            "\\p{ASCII_Hex_Digit}*",
            "\\p{Old_Italic}*",
            "\\p{word}*",
            "\\pE*",
            "\\p{}*",
            "\\p{Greek",
        ] {
            let err = matcher(&[bad]).matches("a").unwrap_err();
            assert!(
                err.contains("invalid character class range"),
                "{bad}: {err}"
            );
        }
    }

    #[test]
    fn unicode_classes_inside_brackets_are_whole_members() {
        // Go reads `\p{...}` inside a class as one whole member and
        // never extends it into a range, so the trailing dash is an
        // ordinary member.
        let m = matcher(&["[\\p{Greek}-x]*"]);
        assert!(m.matches("α").unwrap());
        assert!(m.matches("-").unwrap());
        assert!(m.matches("x").unwrap());
        assert!(!m.matches("z").unwrap());
        let m = matcher(&["[\\p{Greek}x]*"]);
        assert!(m.matches("α").unwrap());
        assert!(m.matches("x").unwrap());
        assert!(!m.matches("z").unwrap());
        let err = matcher(&["[\\p{Emoji}]"]).matches("a").unwrap_err();
        assert!(err.contains("invalid character class range"), "{err}");
    }

    #[test]
    fn posix_class_names_follow_go() {
        // Go accepts exactly its table of fourteen lowercase names, with
        // an optional leading `^`; Rust would read `[[:bogus:]]` as a
        // nested class of literal members instead of refusing it.
        let m = matcher(&["[[:^alpha:]]*"]);
        assert!(m.matches("7").unwrap());
        assert!(!m.matches("x").unwrap());
        for bad in ["[[:bogus:]]*", "[[:Alpha:]]*", "[[:^bogus:]]*"] {
            let err = matcher(&[bad]).matches("a").unwrap_err();
            assert!(
                err.contains("invalid character class range"),
                "{bad}: {err}"
            );
        }
    }

    #[test]
    fn overlong_lines_are_refused_like_docker() {
        // Docker scans `.dockerignore` with a 64 KiB line buffer and
        // refuses the whole file when a raw line does not fit it together
        // with its newline.
        let max = "a".repeat(64 * 1024 - 1);
        let content = format!("{max}\n");
        assert_eq!(read_patterns(content.as_bytes()).unwrap(), [max.as_str()]);
        let content = format!("a{max}\n");
        let err = read_patterns(content.as_bytes()).unwrap_err();
        assert!(err.contains("line 1"), "{err}");
    }

    #[test]
    fn clean_resolves_dots_and_separators() {
        assert_eq!(clean("a/./b//c"), "a/b/c");
        assert_eq!(clean("a/b/../c"), "a/c");
        assert_eq!(clean("dir/"), "dir");
        assert_eq!(clean("./a"), "a");
        assert_eq!(clean(".."), "..");
        assert_eq!(clean(""), ".");
        assert_eq!(clean("/a/b"), "/a/b");
    }
}