haz_domain/path/

pattern.rs

//! `PathPattern`: a literal [`HazPath`] or a glob pattern.
//!
//! A path pattern (per `PATH-008`) is what appears in `inputs` and
//! `outputs`. It is either:
//!
//! - a literal path (no wildcards, no `\` escapes): the existing
//!   [`HazPath`] type, reused as the [`PathPattern::Literal`]
//!   variant; or
//! - a [`GlobPattern`]: a glob conforming to `PATH-009`..`PATH-016`,
//!   compiled by `globset` 0.4 with `literal_separator(true)` and
//!   `case_insensitive(false)`.
//!
//! The classification is decided by [`PathPattern::parse`] from the
//! presence of any of the glob meta-characters `*`, `?`, `[`, `{`,
//! or the escape character `\`. A string with `\` is always
//! classified as a glob (per `PATH-015`), even if every wildcard
//! in it is escaped, because the `\` itself is glob syntax that
//! does not appear in literal paths.
//!
//! The canonical text of a `PathPattern` (the form produced by
//! [`fmt::Display`]) is what determines equality and hashing. The
//! compiled `globset::Glob` is derived state, produced on demand
//! by [`GlobPattern::compile`].

use std::fmt;

use snafu::{ResultExt, Snafu, ensure};

use crate::path::segment::{ForbiddenCategory, forbidden_category};
use crate::path::{HazPath, PathError};

/// Where a path pattern resolves from.
///
/// Mirrors the workspace-absolute / project-relative dichotomy of
/// [`HazPath`], but is exposed as its own type so the
/// [`GlobPattern`] variant can carry it without conflating with the
/// [`HazPath`] variants.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum PathAnchor {
    /// Resolves against the workspace root (`PATH-004`).
    WorkspaceAbsolute,
    /// Resolves against the bearing field's project root
    /// (`PATH-005`).
    ProjectRelative,
}

/// Error produced when validating a single glob segment.
///
/// Each variant maps to one of the glob-pattern rules
/// (`PATH-002` inheritance for forbidden codepoints, `PATH-011`
/// for the `**` placement constraint).
#[derive(Debug, Clone, PartialEq, Eq, Snafu)]
pub enum GlobSegmentError {
    /// Violates `PATH-003`: the segment is empty.
    #[snafu(display("glob segment is empty"))]
    Empty,

    /// Violates `PATH-002`: the segment is the literal `.`.
    #[snafu(display("glob segment is the literal `.`"))]
    Dot,

    /// Violates `PATH-002`: the segment is the literal `..`.
    #[snafu(display("glob segment is the literal `..`"))]
    DotDot,

    /// Violates `PATH-002` (inherited): the segment contains a
    /// codepoint in a forbidden Unicode General Category.
    #[snafu(display(
        "glob segment contains forbidden {category} codepoint U+{:04X}",
        u32::from(*c)
    ))]
    ContainsForbidden {
        /// The offending codepoint.
        c: char,
        /// The Unicode General Category that disqualifies it.
        category: ForbiddenCategory,
    },

    /// Violates `PATH-011`: `**` MUST appear only as a complete
    /// segment, never adjacent to other characters within the same
    /// segment.
    #[snafu(display("glob segment contains `**` adjacent to other characters"))]
    AdjacentDoubleStar,
}

/// Error produced when parsing a [`PathPattern`].
#[derive(Debug, Clone, PartialEq, Eq, Snafu)]
pub enum PathPatternError {
    /// Violates `PATH-002`: the input is empty.
    #[snafu(display("path pattern is empty"))]
    EmptyInput,

    /// Violates `PATH-003`: the input contains the empty
    /// separator `//`.
    #[snafu(display("path pattern contains the empty segment `//`"))]
    EmptySegment,

    /// Violates `PATH-003`: the workspace-absolute pattern is the
    /// single character `/` and has no segments.
    #[snafu(display("workspace-absolute glob has no segments"))]
    OnlySlash,

    /// Violates `PATH-003`: the input ends with `/`.
    #[snafu(display("path pattern ends with trailing `/`"))]
    TrailingSlash,

    /// The literal sub-form (`PATH-001`..`PATH-007`) failed.
    #[snafu(display("invalid literal path: {source}"))]
    LiteralPath {
        /// Underlying [`HazPath`] error.
        source: PathError,
    },

    /// A glob segment failed validation.
    #[snafu(display("invalid glob segment {segment:?} at position {position}: {source}"))]
    InvalidGlobSegment {
        /// The offending segment text.
        segment: String,
        /// Zero-based index of the segment in the pattern body.
        position: usize,
        /// Underlying segment-level error.
        source: GlobSegmentError,
    },

    /// Violates `PATH-014`: a brace-alternation block is nested
    /// inside another brace-alternation block.
    ///
    /// `globset` 0.4 accepts nested alternation, so the constraint
    /// is enforced separately at parse time.
    #[snafu(display("nested alternation is forbidden"))]
    NestedAlternation,

    /// `globset` rejected the structural form of the pattern (for
    /// example, an unclosed `[`).
    #[snafu(display("globset rejected pattern: {message}"))]
    InvalidGlob {
        /// Diagnostic text returned by `globset`.
        message: String,
    },
}

/// A validated glob pattern (`PATH-009`..`PATH-016`).
///
/// The canonical body is stored as a string without the leading
/// `/`; the leading `/` is reintroduced by [`fmt::Display`] when
/// the anchor is workspace-absolute. This keeps `Eq`/`Hash` keyed
/// on a single canonical spelling.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct GlobPattern {
    anchor: PathAnchor,
    body: String,
}

impl GlobPattern {
    /// The anchor (workspace-absolute or project-relative).
    #[must_use]
    pub fn anchor(&self) -> PathAnchor {
        self.anchor
    }

    /// The canonical body (segments joined by `/`), without the
    /// leading `/`.
    #[must_use]
    pub fn body(&self) -> &str {
        &self.body
    }

    /// Compile this pattern into a `globset::Glob` for matching.
    ///
    /// The pattern was validated at construction, so compilation
    /// always succeeds.
    ///
    /// # Panics
    ///
    /// Does not panic on any path of execution reachable from valid
    /// input: an internal invariant assertion exists (the success
    /// of `globset::GlobBuilder::build` after the same builder
    /// already accepted the pattern at parse time) but is
    /// structurally unreachable.
    #[must_use]
    pub fn compile(&self) -> globset::Glob {
        let canonical = self.to_string();
        globset::GlobBuilder::new(&canonical)
            .literal_separator(true)
            .case_insensitive(false)
            .build()
            .expect("validated at construction")
    }
}

impl fmt::Display for GlobPattern {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if matches!(self.anchor, PathAnchor::WorkspaceAbsolute) {
            f.write_str("/")?;
        }
        f.write_str(&self.body)
    }
}

/// A validated path pattern: either a literal [`HazPath`] or a
/// [`GlobPattern`].
///
/// Construction is via [`PathPattern::parse`]. The
/// [`fmt::Display`] implementation produces the canonical text,
/// which round-trips through [`PathPattern::parse`].
///
/// # Examples
///
/// ```
/// use haz_domain::path::PathPattern;
///
/// let p = PathPattern::parse("src/lib.rs").unwrap();
/// assert!(matches!(p, PathPattern::Literal(_)));
///
/// let g = PathPattern::parse("src/**/*.rs").unwrap();
/// assert!(matches!(g, PathPattern::Glob(_)));
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PathPattern {
    /// A literal path (no wildcards, no `\` escapes).
    Literal(HazPath),
    /// A glob pattern.
    Glob(GlobPattern),
}

impl PathPattern {
    /// Parse `s` as a [`PathPattern`].
    ///
    /// Classification rule: if `s` contains any of `*`, `?`, `[`,
    /// `{`, or `\`, the input is a glob; otherwise it is parsed as
    /// a literal [`HazPath`]. The escape character `\` is glob
    /// syntax (`PATH-015`), so its mere presence is enough to
    /// classify the input as a glob.
    ///
    /// # Errors
    ///
    /// Returns a [`PathPatternError`] when `s` violates path or
    /// glob rules:
    ///
    /// - [`PathPatternError::EmptyInput`] if `s` is the empty string.
    /// - [`PathPatternError::OnlySlash`] if `s` is `"/"`.
    /// - [`PathPatternError::EmptySegment`] if `s` contains `//`.
    /// - [`PathPatternError::TrailingSlash`] if `s` ends with `/`.
    /// - [`PathPatternError::LiteralPath`] if the literal sub-form
    ///   ([`HazPath`]) rejects the input.
    /// - [`PathPatternError::InvalidGlobSegment`] if a glob segment
    ///   violates `PATH-002` or `PATH-011`.
    /// - [`PathPatternError::InvalidGlob`] if `globset` rejects the
    ///   structural form (for example, an unclosed `[` or nested
    ///   `{}`).
    ///
    /// # Examples
    ///
    /// ```
    /// use haz_domain::path::PathPattern;
    ///
    /// assert!(PathPattern::parse("src/lib.rs").is_ok());
    /// assert!(PathPattern::parse("/lib_core/src/main.rs").is_ok());
    /// assert!(PathPattern::parse("src/**/*.rs").is_ok());
    /// assert!(PathPattern::parse("/lib_core/src/**/*.rs").is_ok());
    /// assert!(PathPattern::parse("with\\*literal.txt").is_ok());
    ///
    /// assert!(PathPattern::parse("").is_err());
    /// assert!(PathPattern::parse("a**b/foo.rs").is_err());
    /// ```
    pub fn parse(s: &str) -> Result<Self, PathPatternError> {
        ensure!(!s.is_empty(), EmptyInputSnafu);

        if !has_glob_metacharacter(s) {
            return HazPath::parse(s)
                .context(LiteralPathSnafu)
                .map(PathPattern::Literal);
        }

        let (anchor, body) = if let Some(rest) = s.strip_prefix('/') {
            (PathAnchor::WorkspaceAbsolute, rest)
        } else {
            (PathAnchor::ProjectRelative, s)
        };

        ensure!(!body.is_empty(), OnlySlashSnafu);
        ensure!(!body.contains("//"), EmptySegmentSnafu);
        ensure!(!body.ends_with('/'), TrailingSlashSnafu);

        for (position, segment) in body.split('/').enumerate() {
            validate_glob_segment(segment).context(InvalidGlobSegmentSnafu {
                segment: segment.to_owned(),
                position,
            })?;
        }

        ensure!(!has_nested_alternation(body), NestedAlternationSnafu);

        let canonical = match anchor {
            PathAnchor::WorkspaceAbsolute => format!("/{body}"),
            PathAnchor::ProjectRelative => body.to_owned(),
        };
        globset::GlobBuilder::new(&canonical)
            .literal_separator(true)
            .case_insensitive(false)
            .build()
            .map_err(|e| PathPatternError::InvalidGlob {
                message: e.to_string(),
            })?;

        Ok(PathPattern::Glob(GlobPattern {
            anchor,
            body: body.to_owned(),
        }))
    }

    /// `true` if this pattern is a literal path (no wildcards).
    #[must_use]
    pub fn is_literal(&self) -> bool {
        matches!(self, PathPattern::Literal(_))
    }

    /// `true` if this pattern is a glob.
    #[must_use]
    pub fn is_glob(&self) -> bool {
        matches!(self, PathPattern::Glob(_))
    }

    /// The anchor (workspace-absolute or project-relative).
    #[must_use]
    pub fn anchor(&self) -> PathAnchor {
        match self {
            PathPattern::Literal(p) => {
                if p.is_workspace_absolute() {
                    PathAnchor::WorkspaceAbsolute
                } else {
                    PathAnchor::ProjectRelative
                }
            }
            PathPattern::Glob(g) => g.anchor(),
        }
    }
}

impl fmt::Display for PathPattern {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            PathPattern::Literal(p) => p.fmt(f),
            PathPattern::Glob(g) => g.fmt(f),
        }
    }
}

fn has_glob_metacharacter(s: &str) -> bool {
    s.chars().any(|c| matches!(c, '*' | '?' | '[' | '{' | '\\'))
}

/// `true` if any `{` opens an alternation while another is already
/// open. Respects `\` escapes and `[...]` character classes (where
/// `{` is a literal).
fn has_nested_alternation(s: &str) -> bool {
    let mut chars = s.chars();
    let mut brace_depth: u32 = 0;
    let mut in_class = false;
    while let Some(c) = chars.next() {
        match c {
            '\\' => {
                chars.next();
            }
            '[' if !in_class => in_class = true,
            ']' if in_class => in_class = false,
            '{' if !in_class => {
                if brace_depth > 0 {
                    return true;
                }
                brace_depth += 1;
            }
            '}' if !in_class => {
                brace_depth = brace_depth.saturating_sub(1);
            }
            _ => {}
        }
    }
    false
}

fn validate_glob_segment(s: &str) -> Result<(), GlobSegmentError> {
    if s == "**" {
        return Ok(());
    }
    ensure!(!s.is_empty(), EmptySnafu);
    ensure!(s != ".", DotSnafu);
    ensure!(s != "..", DotDotSnafu);
    ensure!(!s.contains("**"), AdjacentDoubleStarSnafu);

    for c in s.chars() {
        if let Some(category) = forbidden_category(c) {
            return ContainsForbiddenSnafu { c, category }.fail();
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use crate::path::pattern::{
        GlobSegmentError, PathAnchor, PathPattern, PathPatternError, has_glob_metacharacter,
    };
    use crate::path::segment::ForbiddenCategory;
    use crate::path::{HazPath, PathError, SegmentError};

    // PATH-008: literal vs glob classification.

    #[test]
    fn path_008_classifies_literal_no_metacharacters() {
        let p = PathPattern::parse("src/lib.rs").unwrap();
        assert!(p.is_literal());
        assert!(matches!(
            p,
            PathPattern::Literal(HazPath::ProjectRelative(_))
        ));
    }

    #[test]
    fn path_008_classifies_workspace_absolute_literal() {
        let p = PathPattern::parse("/lib_core/src/main.rs").unwrap();
        assert!(p.is_literal());
        assert_eq!(p.anchor(), PathAnchor::WorkspaceAbsolute);
    }

    #[test]
    fn path_008_classifies_glob_with_star() {
        let p = PathPattern::parse("src/*.rs").unwrap();
        assert!(p.is_glob());
    }

    #[test]
    fn path_008_classifies_glob_with_question() {
        let p = PathPattern::parse("src/lib?.rs").unwrap();
        assert!(p.is_glob());
    }

    #[test]
    fn path_008_classifies_glob_with_charclass() {
        let p = PathPattern::parse("dist/[!_]a/index.html").unwrap();
        assert!(p.is_glob());
    }

    #[test]
    fn path_008_classifies_glob_with_alternation() {
        let p = PathPattern::parse("assets/x.{png,jpg}").unwrap();
        assert!(p.is_glob());
    }

    #[test]
    fn path_008_classifies_escape_as_glob() {
        // Per PATH-015, `\` is glob syntax. A pattern containing `\`
        // is therefore a glob, not a literal, even if every wildcard
        // is escaped.
        let p = PathPattern::parse("with\\*literal.txt").unwrap();
        assert!(p.is_glob());
    }

    // Detection helper itself.

    #[test]
    fn detection_recognises_all_metacharacters() {
        assert!(!has_glob_metacharacter("src/lib.rs"));
        assert!(has_glob_metacharacter("src/*.rs"));
        assert!(has_glob_metacharacter("src/lib?.rs"));
        assert!(has_glob_metacharacter("src/[a].rs"));
        assert!(has_glob_metacharacter("src/{a,b}.rs"));
        assert!(has_glob_metacharacter("with\\*.rs"));
    }

    // PATH-009: globset baseline. We exercise this implicitly by
    // checking that valid globset patterns parse and that obviously
    // invalid ones (unclosed bracket) are rejected.

    #[test]
    fn path_009_rejects_unclosed_charclass() {
        assert!(matches!(
            PathPattern::parse("src/[abc.rs"),
            Err(PathPatternError::InvalidGlob { .. })
        ));
    }

    // PATH-010: `*` matches within a single segment. (Behavioural
    // guarantee delegated to globset; here we verify acceptance.)

    #[test]
    fn path_010_accepts_single_star_in_segment() {
        assert!(PathPattern::parse("src/*.rs").is_ok());
    }

    // PATH-011: `**` placement.

    #[test]
    fn path_011_accepts_doublestar_as_complete_segment() {
        assert!(PathPattern::parse("src/**/main.rs").is_ok());
        assert!(PathPattern::parse("tests/**").is_ok());
        assert!(PathPattern::parse("**/foo.rs").is_ok());
    }

    #[test]
    fn path_011_rejects_doublestar_adjacent_to_other_chars() {
        assert!(matches!(
            PathPattern::parse("a**b/foo.rs"),
            Err(PathPatternError::InvalidGlobSegment {
                source: GlobSegmentError::AdjacentDoubleStar,
                ..
            })
        ));
    }

    #[test]
    fn path_011_rejects_triple_star_segment() {
        // `***` collapses to `**` adjacent to `*`, which is rejected.
        assert!(matches!(
            PathPattern::parse("foo/***/bar.rs"),
            Err(PathPatternError::InvalidGlobSegment {
                source: GlobSegmentError::AdjacentDoubleStar,
                ..
            })
        ));
    }

    // PATH-012: `?`. Acceptance is the only thing we verify here;
    // the `not /` constraint is a globset behavioural guarantee.

    #[test]
    fn path_012_accepts_question_mark() {
        assert!(PathPattern::parse("file?.rs").is_ok());
    }

    // PATH-013: character class.

    #[test]
    fn path_013_accepts_charclass() {
        assert!(PathPattern::parse("dist/[abc]/index.html").is_ok());
    }

    #[test]
    fn path_013_accepts_negated_charclass() {
        assert!(PathPattern::parse("dist/[!_]a/index.html").is_ok());
    }

    #[test]
    fn path_013_accepts_range_charclass() {
        assert!(PathPattern::parse("v[0-9].txt").is_ok());
    }

    // PATH-014: alternation, no nesting.

    #[test]
    fn path_014_accepts_flat_alternation() {
        assert!(PathPattern::parse("assets/x.{png,jpg}").is_ok());
    }

    #[test]
    fn path_014_rejects_nested_alternation() {
        assert!(matches!(
            PathPattern::parse("src/{a,{b,c}}/foo.rs"),
            Err(PathPatternError::NestedAlternation)
        ));
    }

    #[test]
    fn path_014_rejects_deeper_nesting() {
        assert!(matches!(
            PathPattern::parse("a/{x,{y,{z,w}}}/b"),
            Err(PathPatternError::NestedAlternation)
        ));
    }

    #[test]
    fn path_014_accepts_brace_in_charclass() {
        // `{` inside `[...]` is a literal character class member,
        // not an alternation opener; so it does not count toward
        // brace depth.
        assert!(PathPattern::parse("foo/[{abc]/bar").is_ok());
    }

    #[test]
    fn path_014_accepts_escaped_brace_inside_alternation() {
        // The inner `{` is escaped, so it does not nest.
        assert!(PathPattern::parse("foo/{a,\\{lit\\}}.txt").is_ok());
    }

    // PATH-015: escape.

    #[test]
    fn path_015_accepts_escaped_star() {
        let p = PathPattern::parse("with\\*literal.txt").unwrap();
        assert!(p.is_glob());
        assert_eq!(p.to_string(), "with\\*literal.txt");
    }

    #[test]
    fn path_015_accepts_escaped_brace() {
        assert!(PathPattern::parse("opt\\{a\\}.txt").is_ok());
    }

    // PATH-002 inheritance for glob segments.

    #[test]
    fn path_002_glob_rejects_dot_segment() {
        assert!(matches!(
            PathPattern::parse("./foo*.rs"),
            Err(PathPatternError::InvalidGlobSegment {
                source: GlobSegmentError::Dot,
                ..
            })
        ));
    }

    #[test]
    fn path_002_glob_rejects_dotdot_segment() {
        assert!(matches!(
            PathPattern::parse("../foo*.rs"),
            Err(PathPatternError::InvalidGlobSegment {
                source: GlobSegmentError::DotDot,
                ..
            })
        ));
    }

    #[test]
    fn path_002_glob_rejects_zero_width_space_in_segment() {
        // U+200B inside a glob segment.
        assert!(matches!(
            PathPattern::parse("src/foo\u{200B}*.rs"),
            Err(PathPatternError::InvalidGlobSegment {
                source: GlobSegmentError::ContainsForbidden {
                    category: ForbiddenCategory::Format,
                    ..
                },
                ..
            })
        ));
    }

    #[test]
    fn path_002_glob_rejects_tab_in_segment() {
        assert!(matches!(
            PathPattern::parse("src/foo\t*.rs"),
            Err(PathPatternError::InvalidGlobSegment {
                source: GlobSegmentError::ContainsForbidden {
                    c: '\t',
                    category: ForbiddenCategory::Control,
                },
                ..
            })
        ));
    }

    // PATH-003 reuse for globs.

    #[test]
    fn path_003_glob_rejects_double_slash() {
        assert!(matches!(
            PathPattern::parse("src//*.rs"),
            Err(PathPatternError::EmptySegment)
        ));
    }

    #[test]
    fn path_003_glob_rejects_trailing_slash() {
        assert!(matches!(
            PathPattern::parse("src/*/"),
            Err(PathPatternError::TrailingSlash)
        ));
    }

    #[test]
    fn path_003_glob_rejects_only_slash_workspace_absolute() {
        // `/` alone is literal; tested via the literal sub-path
        // (HazPath returns OnlySlash).
        assert!(matches!(
            PathPattern::parse("/"),
            Err(PathPatternError::LiteralPath {
                source: PathError::OnlySlash,
            })
        ));
    }

    #[test]
    fn pathpattern_rejects_empty_string() {
        assert!(matches!(
            PathPattern::parse(""),
            Err(PathPatternError::EmptyInput)
        ));
    }

    // Literal sub-form propagates HazPath errors.

    #[test]
    fn literal_propagates_hazpath_dot_segment() {
        assert!(matches!(
            PathPattern::parse("./foo.rs"),
            Err(PathPatternError::LiteralPath {
                source: PathError::InvalidSegment {
                    source: SegmentError::Dot,
                    ..
                },
            })
        ));
    }

    // PATH-016: case sensitivity is implicit (we configure
    // `case_insensitive(false)` and `PATH-007` already mandates
    // case sensitivity for literal paths).

    #[test]
    fn path_016_case_sensitive_glob_equality() {
        let upper = PathPattern::parse("Src/*.rs").unwrap();
        let lower = PathPattern::parse("src/*.rs").unwrap();
        assert_ne!(upper, lower);
    }

    // Round-trip parse -> Display -> parse.

    #[test]
    fn round_trip_literal_relative() {
        let original = "src/lib.rs";
        let p = PathPattern::parse(original).unwrap();
        assert_eq!(p.to_string(), original);
        assert_eq!(PathPattern::parse(&p.to_string()).unwrap(), p);
    }

    #[test]
    fn round_trip_literal_absolute() {
        let original = "/lib_core/src/main.rs";
        let p = PathPattern::parse(original).unwrap();
        assert_eq!(p.to_string(), original);
        assert_eq!(PathPattern::parse(&p.to_string()).unwrap(), p);
    }

    #[test]
    fn round_trip_glob_relative() {
        let original = "src/**/*.rs";
        let p = PathPattern::parse(original).unwrap();
        assert_eq!(p.to_string(), original);
        assert_eq!(PathPattern::parse(&p.to_string()).unwrap(), p);
    }

    #[test]
    fn round_trip_glob_absolute() {
        let original = "/lib_core/src/**/*.rs";
        let p = PathPattern::parse(original).unwrap();
        assert_eq!(p.to_string(), original);
        assert_eq!(PathPattern::parse(&p.to_string()).unwrap(), p);
    }

    // Glob compilation produces a working matcher.

    #[test]
    fn glob_compile_matches_expected_paths() {
        let p = PathPattern::parse("src/**/*.rs").unwrap();
        let glob = match p {
            PathPattern::Glob(ref g) => g.compile(),
            PathPattern::Literal(_) => unreachable!(),
        };
        let matcher = glob.compile_matcher();
        assert!(matcher.is_match("src/lib.rs"));
        assert!(matcher.is_match("src/foo/bar.rs"));
        assert!(!matcher.is_match("src/lib.txt"));
        assert!(!matcher.is_match("other/lib.rs"));
    }

    #[test]
    fn glob_star_does_not_cross_separator() {
        // PATH-010 / globset literal_separator(true).
        let p = PathPattern::parse("src/*.rs").unwrap();
        let glob = match p {
            PathPattern::Glob(ref g) => g.compile(),
            PathPattern::Literal(_) => unreachable!(),
        };
        let matcher = glob.compile_matcher();
        assert!(matcher.is_match("src/lib.rs"));
        assert!(!matcher.is_match("src/foo/bar.rs"));
    }

    // Properties.

    use proptest::prelude::*;

    fn segment_strategy() -> impl Strategy<Value = String> {
        "[a-zA-Z0-9][a-zA-Z0-9._-]{0,15}"
    }

    proptest! {
        #[test]
        fn prop_literal_relative_round_trips(
            segs in proptest::collection::vec(segment_strategy(), 1..=5)
        ) {
            let s = segs.join("/");
            let parsed = PathPattern::parse(&s).unwrap();
            prop_assert!(parsed.is_literal());
            prop_assert_eq!(parsed.to_string(), s);
        }

        #[test]
        fn prop_literal_absolute_round_trips(
            segs in proptest::collection::vec(segment_strategy(), 1..=5)
        ) {
            let s = format!("/{}", segs.join("/"));
            let parsed = PathPattern::parse(&s).unwrap();
            prop_assert!(parsed.is_literal());
            prop_assert_eq!(parsed.to_string(), s);
        }

        #[test]
        fn prop_simple_star_glob_round_trips(
            segs in proptest::collection::vec(segment_strategy(), 1..=4)
        ) {
            let s = format!("{}/*.rs", segs.join("/"));
            let parsed = PathPattern::parse(&s).unwrap();
            prop_assert!(parsed.is_glob());
            prop_assert_eq!(parsed.to_string(), s);
        }
    }
}