haz-domain 0.2.0

//! Task references: the textual form used to identify one or more
//! tasks across the workspace.
//!
//! Six syntactic forms exist (per `REF-002`..`REF-005`, `REF-008`):
//!
//! - `~:<task>`: same-project reference,
//! - `<project>:<task>`: project reference,
//! - `^:<task>`: fan-out reference,
//! - `^~:<task>`: sibling-fan-out reference,
//! - `[<tag>]:<task>`: tag reference,
//! - `[<tag>]~:<task>`: sibling-tag reference.
//!
//! The sibling-modifier forms (`^~:` and `[<tag>]~:`) exclude the
//! bearing project from the otherwise-included fan-out resolution.
//!
//! Each name component (project, tag, task) is a validated
//! identifier per [`crate::name`]. Parsing checks only syntactic
//! validity (`REF-001`..`REF-008`); resolution against the
//! workspace happens later.

use std::fmt;

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

use crate::name::{NameError, ProjectName, TagName, TaskName};

/// Which name component of a task reference failed validation.
///
/// Used as a field of [`TaskRefError::InvalidName`] so a single
/// variant covers `REF-001` violations across all four reference
/// forms without sacrificing diagnostic detail.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum NameComponent {
    /// The project name in a [`TaskRef::Project`] reference.
    Project,
    /// The tag name in a [`TaskRef::Tag`] reference.
    Tag,
    /// The task name in any reference form.
    Task,
}

impl fmt::Display for NameComponent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = match self {
            NameComponent::Project => "project",
            NameComponent::Tag => "tag",
            NameComponent::Task => "task",
        };
        f.write_str(s)
    }
}

/// Error produced when parsing a [`TaskRef`].
///
/// Each variant maps to either the grammar (`REF-002`..`REF-006`)
/// or to identifier inheritance (`REF-001`).
#[derive(Debug, Clone, PartialEq, Eq, Snafu)]
pub enum TaskRefError {
    /// Violates the grammar: the input is empty.
    #[snafu(display("task reference is empty"))]
    EmptyInput,

    /// Violates `REF-006` for the project-reference form: the input
    /// has no leading sigil and contains no `:` separator.
    #[snafu(display("task reference has no `:` separator"))]
    MissingColon,

    /// Violates the grammar for the tag-reference form (`REF-005` /
    /// `REF-006`): the input begins with `[` but is missing the
    /// closing `]` or the `:` that must follow it.
    #[snafu(display("tag reference malformed: missing `]` or `:` after `]`"))]
    MalformedTagBrackets,

    /// Violates `REF-001`: a name component fails the identifier
    /// rules `ID-001`..`ID-003`.
    #[snafu(display("invalid {component} name: {source}"))]
    InvalidName {
        /// Which component (project, tag, or task) failed.
        component: NameComponent,
        /// The underlying identifier error.
        source: NameError,
    },
}

/// A validated task reference.
///
/// Construction is via [`TaskRef::parse`]. The [`fmt::Display`]
/// implementation produces a string that round-trips through
/// [`TaskRef::parse`].
///
/// # Examples
///
/// ```
/// use haz_domain::task_ref::TaskRef;
///
/// let r = TaskRef::parse("~:compile").unwrap();
/// assert_eq!(r.to_string(), "~:compile");
///
/// let r = TaskRef::parse("[typescript]:compile").unwrap();
/// assert_eq!(r.to_string(), "[typescript]:compile");
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TaskRef {
    /// `~:<task>`. Resolves within the bearing project (`REF-002`).
    SameProject(TaskName),
    /// `<project>:<task>`. Resolves to a task in the named project
    /// (`REF-003`).
    Project(ProjectName, TaskName),
    /// `^:<task>`. Resolves to every task with this name across the
    /// workspace, including the bearing project (`REF-004`).
    FanOut(TaskName),
    /// `^~:<task>`. Resolves to every task with this name across the
    /// workspace *except the bearing project* (`REF-008`).
    SiblingFanOut(TaskName),
    /// `[<tag>]:<task>`. Resolves to every task with this name
    /// whose project carries the named tag, including the bearing
    /// project (`REF-005`).
    Tag(TagName, TaskName),
    /// `[<tag>]~:<task>`. Resolves to every task with this name
    /// whose project carries the named tag, *excluding the bearing
    /// project* even if it carries the named tag (`REF-008`).
    SiblingTag(TagName, TaskName),
}

impl TaskRef {
    /// Parse `s` as a [`TaskRef`].
    ///
    /// Dispatch follows `REF-006`: at most three characters of
    /// lookahead for `^`-prefixed forms, plus scanning past the
    /// closing `]` for tag forms.
    ///
    /// # Errors
    ///
    /// Returns a [`TaskRefError`] when `s` violates the grammar
    /// (`REF-002`..`REF-006`, `REF-008`) or when any name component
    /// violates the identifier rules (`REF-001`, delegating to
    /// `ID-001`..`ID-003`):
    ///
    /// - [`TaskRefError::EmptyInput`] if `s` is the empty string.
    /// - [`TaskRefError::MissingColon`] if `s` is a project
    ///   reference with no `:` separator.
    /// - [`TaskRefError::MalformedTagBrackets`] if `s` begins with
    ///   `[` but is not a well-formed `[<tag>]:<task>` or
    ///   `[<tag>]~:<task>`.
    /// - [`TaskRefError::InvalidName`] if any name component is
    ///   not a valid identifier.
    ///
    /// # Examples
    ///
    /// ```
    /// use haz_domain::task_ref::TaskRef;
    ///
    /// assert!(TaskRef::parse("~:compile").is_ok());
    /// assert!(TaskRef::parse("lib_core:compile").is_ok());
    /// assert!(TaskRef::parse("^:compile").is_ok());
    /// assert!(TaskRef::parse("^~:compile").is_ok());
    /// assert!(TaskRef::parse("[typescript]:compile").is_ok());
    /// assert!(TaskRef::parse("[typescript]~:compile").is_ok());
    ///
    /// assert!(TaskRef::parse("").is_err());
    /// assert!(TaskRef::parse("compile").is_err());
    /// assert!(TaskRef::parse("[tag]compile").is_err());
    /// assert!(TaskRef::parse("[tag]~compile").is_err());
    /// ```
    pub fn parse(s: &str) -> Result<Self, TaskRefError> {
        ensure!(!s.is_empty(), EmptyInputSnafu);

        if let Some(rest) = s.strip_prefix("~:") {
            let task = TaskName::try_new(rest).context(InvalidNameSnafu {
                component: NameComponent::Task,
            })?;
            return Ok(TaskRef::SameProject(task));
        }

        // The sibling-fan-out form `^~:` must be tested before the
        // plain fan-out form `^:` (longer prefix wins).
        if let Some(rest) = s.strip_prefix("^~:") {
            let task = TaskName::try_new(rest).context(InvalidNameSnafu {
                component: NameComponent::Task,
            })?;
            return Ok(TaskRef::SiblingFanOut(task));
        }

        if let Some(rest) = s.strip_prefix("^:") {
            let task = TaskName::try_new(rest).context(InvalidNameSnafu {
                component: NameComponent::Task,
            })?;
            return Ok(TaskRef::FanOut(task));
        }

        if let Some(rest) = s.strip_prefix('[') {
            let close_idx = rest.find(']').ok_or(TaskRefError::MalformedTagBrackets)?;
            let (tag_str, after_close) = rest.split_at(close_idx);
            let after_bracket = &after_close[']'.len_utf8()..];

            // The character(s) following `]` decide between the
            // plain tag form `:` and the sibling-tag form `~:`.
            // The sibling-tag form must be tested first (longer
            // prefix wins).
            let (task_str, is_sibling) = if let Some(rest) = after_bracket.strip_prefix("~:") {
                (rest, true)
            } else if let Some(rest) = after_bracket.strip_prefix(':') {
                (rest, false)
            } else {
                return Err(TaskRefError::MalformedTagBrackets);
            };

            let tag = TagName::try_new(tag_str).context(InvalidNameSnafu {
                component: NameComponent::Tag,
            })?;
            let task = TaskName::try_new(task_str).context(InvalidNameSnafu {
                component: NameComponent::Task,
            })?;
            return Ok(if is_sibling {
                TaskRef::SiblingTag(tag, task)
            } else {
                TaskRef::Tag(tag, task)
            });
        }

        // Default: project reference `<project>:<task>` (REF-006).
        let colon_idx = s.find(':').ok_or(TaskRefError::MissingColon)?;
        let (proj_str, after_colon) = s.split_at(colon_idx);
        let task_str = &after_colon[':'.len_utf8()..];
        let project = ProjectName::try_new(proj_str).context(InvalidNameSnafu {
            component: NameComponent::Project,
        })?;
        let task = TaskName::try_new(task_str).context(InvalidNameSnafu {
            component: NameComponent::Task,
        })?;
        Ok(TaskRef::Project(project, task))
    }

    /// `true` if this is a same-project reference (`~:<task>`).
    #[must_use]
    pub fn is_same_project(&self) -> bool {
        matches!(self, TaskRef::SameProject(_))
    }

    /// `true` if this is a project reference (`<project>:<task>`).
    #[must_use]
    pub fn is_project(&self) -> bool {
        matches!(self, TaskRef::Project(_, _))
    }

    /// `true` if this is a fan-out reference (`^:<task>`).
    #[must_use]
    pub fn is_fan_out(&self) -> bool {
        matches!(self, TaskRef::FanOut(_))
    }

    /// `true` if this is a sibling-fan-out reference (`^~:<task>`).
    #[must_use]
    pub fn is_sibling_fan_out(&self) -> bool {
        matches!(self, TaskRef::SiblingFanOut(_))
    }

    /// `true` if this is a tag reference (`[<tag>]:<task>`).
    #[must_use]
    pub fn is_tag(&self) -> bool {
        matches!(self, TaskRef::Tag(_, _))
    }

    /// `true` if this is a sibling-tag reference (`[<tag>]~:<task>`).
    #[must_use]
    pub fn is_sibling_tag(&self) -> bool {
        matches!(self, TaskRef::SiblingTag(_, _))
    }
}

impl fmt::Display for TaskRef {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TaskRef::SameProject(task) => write!(f, "~:{task}"),
            TaskRef::Project(project, task) => write!(f, "{project}:{task}"),
            TaskRef::FanOut(task) => write!(f, "^:{task}"),
            TaskRef::SiblingFanOut(task) => write!(f, "^~:{task}"),
            TaskRef::Tag(tag, task) => write!(f, "[{tag}]:{task}"),
            TaskRef::SiblingTag(tag, task) => write!(f, "[{tag}]~:{task}"),
        }
    }
}

#[cfg(test)]
mod tests {
    use crate::name::NameError;
    use crate::task_ref::{NameComponent, TaskRef, TaskRefError};

    // REF-001: identifier inheritance. A few representative
    // violations across the four forms.

    #[test]
    fn ref_001_rejects_invalid_project_name() {
        assert!(matches!(
            TaskRef::parse("lib core:compile"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Project,
                source: NameError::InvalidChar { c: ' ' },
            })
        ));
    }

    #[test]
    fn ref_001_rejects_invalid_tag_name() {
        assert!(matches!(
            TaskRef::parse("[a b]:compile"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Tag,
                source: NameError::InvalidChar { c: ' ' },
            })
        ));
    }

    #[test]
    fn ref_001_rejects_invalid_task_name() {
        assert!(matches!(
            TaskRef::parse("~:foo bar"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::InvalidChar { c: ' ' },
            })
        ));
    }

    #[test]
    fn ref_001_rejects_empty_project_name() {
        assert!(matches!(
            TaskRef::parse(":compile"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Project,
                source: NameError::Empty,
            })
        ));
    }

    #[test]
    fn ref_001_rejects_empty_tag_name() {
        assert!(matches!(
            TaskRef::parse("[]:compile"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Tag,
                source: NameError::Empty,
            })
        ));
    }

    #[test]
    fn ref_001_rejects_empty_task_in_same_project() {
        assert!(matches!(
            TaskRef::parse("~:"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::Empty,
            })
        ));
    }

    #[test]
    fn ref_001_rejects_empty_task_in_fan_out() {
        assert!(matches!(
            TaskRef::parse("^:"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::Empty,
            })
        ));
    }

    #[test]
    fn ref_001_rejects_empty_task_in_project() {
        assert!(matches!(
            TaskRef::parse("lib:"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::Empty,
            })
        ));
    }

    #[test]
    fn ref_001_rejects_empty_task_in_tag() {
        assert!(matches!(
            TaskRef::parse("[typescript]:"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::Empty,
            })
        ));
    }

    // REF-002: same-project reference.

    #[test]
    fn ref_002_parses_same_project() {
        let r = TaskRef::parse("~:compile").unwrap();
        assert!(r.is_same_project());
        assert_eq!(r.to_string(), "~:compile");
    }

    #[test]
    fn ref_002_parses_same_project_with_underscore_and_dash() {
        let r = TaskRef::parse("~:test_unit-1").unwrap();
        assert!(matches!(r, TaskRef::SameProject(_)));
    }

    // REF-003: project reference.

    #[test]
    fn ref_003_parses_project() {
        let r = TaskRef::parse("lib_core:compile").unwrap();
        assert!(r.is_project());
        assert_eq!(r.to_string(), "lib_core:compile");
    }

    #[test]
    fn ref_003_parses_project_with_dash() {
        let r = TaskRef::parse("web-frontend:bundle").unwrap();
        assert!(matches!(r, TaskRef::Project(_, _)));
    }

    // REF-004: fan-out reference.

    #[test]
    fn ref_004_parses_fan_out() {
        let r = TaskRef::parse("^:compile").unwrap();
        assert!(r.is_fan_out());
        assert_eq!(r.to_string(), "^:compile");
    }

    // REF-005: tag reference.

    #[test]
    fn ref_005_parses_tag() {
        let r = TaskRef::parse("[typescript]:compile").unwrap();
        assert!(r.is_tag());
        assert_eq!(r.to_string(), "[typescript]:compile");
    }

    #[test]
    fn ref_005_parses_tag_with_dash() {
        let r = TaskRef::parse("[release]:publish").unwrap();
        assert!(matches!(r, TaskRef::Tag(_, _)));
    }

    // REF-008: sibling-fan-out and sibling-tag references.

    #[test]
    fn ref_008_parses_sibling_fan_out() {
        let r = TaskRef::parse("^~:compile").unwrap();
        assert!(r.is_sibling_fan_out());
        assert_eq!(r.to_string(), "^~:compile");
    }

    #[test]
    fn ref_008_parses_sibling_fan_out_with_underscore_and_dash() {
        let r = TaskRef::parse("^~:test_unit-1").unwrap();
        assert!(matches!(r, TaskRef::SiblingFanOut(_)));
    }

    #[test]
    fn ref_008_parses_sibling_tag() {
        let r = TaskRef::parse("[typescript]~:compile").unwrap();
        assert!(r.is_sibling_tag());
        assert_eq!(r.to_string(), "[typescript]~:compile");
    }

    #[test]
    fn ref_008_parses_sibling_tag_with_dash() {
        let r = TaskRef::parse("[release]~:publish").unwrap();
        assert!(matches!(r, TaskRef::SiblingTag(_, _)));
    }

    #[test]
    fn ref_008_rejects_empty_task_in_sibling_fan_out() {
        assert!(matches!(
            TaskRef::parse("^~:"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::Empty,
            })
        ));
    }

    #[test]
    fn ref_008_rejects_empty_task_in_sibling_tag() {
        assert!(matches!(
            TaskRef::parse("[typescript]~:"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::Empty,
            })
        ));
    }

    #[test]
    fn ref_008_rejects_invalid_task_in_sibling_fan_out() {
        assert!(matches!(
            TaskRef::parse("^~:foo bar"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::InvalidChar { c: ' ' },
            })
        ));
    }

    #[test]
    fn ref_008_rejects_invalid_tag_in_sibling_tag() {
        assert!(matches!(
            TaskRef::parse("[a b]~:compile"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Tag,
                source: NameError::InvalidChar { c: ' ' },
            })
        ));
    }

    #[test]
    fn ref_008_rejects_empty_tag_in_sibling_tag() {
        assert!(matches!(
            TaskRef::parse("[]~:compile"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Tag,
                source: NameError::Empty,
            })
        ));
    }

    // REF-006: dispatch by leading characters.

    #[test]
    fn ref_006_dispatch_same_project() {
        // `~:` always wins, even when the rest looks tag-like
        // (which would also fail ID-001 anyway).
        let r = TaskRef::parse("~:compile").unwrap();
        assert!(r.is_same_project());
    }

    #[test]
    fn ref_006_dispatch_fan_out() {
        let r = TaskRef::parse("^:compile").unwrap();
        assert!(r.is_fan_out());
    }

    #[test]
    fn ref_006_dispatch_sibling_fan_out() {
        // `^~:` must beat `^:` (longer prefix wins).
        let r = TaskRef::parse("^~:compile").unwrap();
        assert!(r.is_sibling_fan_out());
    }

    #[test]
    fn ref_006_dispatch_tag() {
        let r = TaskRef::parse("[t]:compile").unwrap();
        assert!(r.is_tag());
    }

    #[test]
    fn ref_006_dispatch_sibling_tag() {
        // The `~:` after `]` must beat the bare `:` (longer prefix
        // wins).
        let r = TaskRef::parse("[t]~:compile").unwrap();
        assert!(r.is_sibling_tag());
    }

    #[test]
    fn ref_006_dispatch_project_default() {
        let r = TaskRef::parse("p:t").unwrap();
        assert!(r.is_project());
    }

    #[test]
    fn ref_006_rejects_tilde_without_colon() {
        // `~compile` has no `:` at all; it falls through to the
        // project-reference branch which then fails MissingColon.
        assert!(matches!(
            TaskRef::parse("~compile"),
            Err(TaskRefError::MissingColon)
        ));
    }

    #[test]
    fn ref_006_rejects_caret_without_colon() {
        assert!(matches!(
            TaskRef::parse("^compile"),
            Err(TaskRefError::MissingColon)
        ));
    }

    #[test]
    fn ref_006_rejects_tag_missing_close_bracket() {
        assert!(matches!(
            TaskRef::parse("[tag"),
            Err(TaskRefError::MalformedTagBrackets)
        ));
    }

    #[test]
    fn ref_006_rejects_tag_missing_colon_after_close() {
        assert!(matches!(
            TaskRef::parse("[tag]compile"),
            Err(TaskRefError::MalformedTagBrackets)
        ));
    }

    #[test]
    fn ref_006_rejects_sibling_fan_out_without_colon() {
        // `^~compile` has no `:` after `^~`; falls through to the
        // project-reference branch and fails MissingColon.
        assert!(matches!(
            TaskRef::parse("^~compile"),
            Err(TaskRefError::MissingColon)
        ));
    }

    #[test]
    fn ref_006_rejects_sibling_tag_without_colon() {
        // `[tag]~compile` has `~` after `]` but no `:` after it;
        // neither `~:` nor `:` strip-prefix matches, so it falls
        // through to MalformedTagBrackets.
        assert!(matches!(
            TaskRef::parse("[tag]~compile"),
            Err(TaskRefError::MalformedTagBrackets)
        ));
    }

    #[test]
    fn ref_006_rejects_sibling_tag_bare_tilde_after_close() {
        // `[tag]~` ends right after `~`; no `:` follows.
        assert!(matches!(
            TaskRef::parse("[tag]~"),
            Err(TaskRefError::MalformedTagBrackets)
        ));
    }

    #[test]
    fn ref_006_rejects_tilde_suffix_on_project_name() {
        // `lib~:compile` is not a sibling form; `~` is not in the
        // identifier alphabet, so the project-name validation
        // rejects it.
        assert!(matches!(
            TaskRef::parse("lib~:compile"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Project,
                source: NameError::InvalidChar { c: '~' },
            })
        ));
    }

    #[test]
    fn ref_006_rejects_no_colon_at_all() {
        assert!(matches!(
            TaskRef::parse("compile"),
            Err(TaskRefError::MissingColon)
        ));
    }

    #[test]
    fn ref_006_rejects_empty_input() {
        assert!(matches!(TaskRef::parse(""), Err(TaskRefError::EmptyInput)));
    }

    // REF-007: no whitespace, no extras. Inherited from ID-001
    // for chars inside identifier slots; checked here for the
    // characters directly after a sigil.

    #[test]
    fn ref_007_rejects_space_after_same_project_sigil() {
        // `~: foo` keeps the leading space inside what would be
        // the task name, which then fails ID-001.
        assert!(matches!(
            TaskRef::parse("~: foo"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::InvalidLeadingChar { c: ' ' },
            })
        ));
    }

    #[test]
    fn ref_007_rejects_non_ascii_in_task() {
        // U+00E9 (LATIN SMALL LETTER E WITH ACUTE) is not ASCII.
        assert!(matches!(
            TaskRef::parse("~:caf\u{00E9}"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Task,
                source: NameError::InvalidChar { c: '\u{00E9}' },
            })
        ));
    }

    #[test]
    fn ref_007_rejects_tab_in_project() {
        assert!(matches!(
            TaskRef::parse("lib\tcore:compile"),
            Err(TaskRefError::InvalidName {
                component: NameComponent::Project,
                source: NameError::InvalidChar { c: '\t' },
            })
        ));
    }

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

    #[test]
    fn round_trip_same_project() {
        let original = "~:compile";
        let r = TaskRef::parse(original).unwrap();
        assert_eq!(r.to_string(), original);
        assert_eq!(TaskRef::parse(&r.to_string()).unwrap(), r);
    }

    #[test]
    fn round_trip_project() {
        let original = "lib_core:compile";
        let r = TaskRef::parse(original).unwrap();
        assert_eq!(r.to_string(), original);
        assert_eq!(TaskRef::parse(&r.to_string()).unwrap(), r);
    }

    #[test]
    fn round_trip_fan_out() {
        let original = "^:test";
        let r = TaskRef::parse(original).unwrap();
        assert_eq!(r.to_string(), original);
        assert_eq!(TaskRef::parse(&r.to_string()).unwrap(), r);
    }

    #[test]
    fn round_trip_tag() {
        let original = "[typescript]:compile";
        let r = TaskRef::parse(original).unwrap();
        assert_eq!(r.to_string(), original);
        assert_eq!(TaskRef::parse(&r.to_string()).unwrap(), r);
    }

    #[test]
    fn round_trip_sibling_fan_out() {
        let original = "^~:test";
        let r = TaskRef::parse(original).unwrap();
        assert_eq!(r.to_string(), original);
        assert_eq!(TaskRef::parse(&r.to_string()).unwrap(), r);
    }

    #[test]
    fn round_trip_sibling_tag() {
        let original = "[typescript]~:compile";
        let r = TaskRef::parse(original).unwrap();
        assert_eq!(r.to_string(), original);
        assert_eq!(TaskRef::parse(&r.to_string()).unwrap(), r);
    }

    // Properties: every reference produced by the six valid
    // strategies parses, displays back to itself, and is recognised
    // by the right `is_*` predicate.

    use proptest::prelude::*;

    fn name_strategy() -> impl Strategy<Value = String> {
        "[A-Za-z0-9][A-Za-z0-9_-]{0,15}"
    }

    proptest! {
        #[test]
        fn prop_same_project_round_trips(task in name_strategy()) {
            let s = format!("~:{task}");
            let r = TaskRef::parse(&s).unwrap();
            prop_assert!(r.is_same_project());
            prop_assert_eq!(r.to_string(), s);
        }

        #[test]
        fn prop_project_round_trips(
            project in name_strategy(),
            task in name_strategy(),
        ) {
            let s = format!("{project}:{task}");
            let r = TaskRef::parse(&s).unwrap();
            prop_assert!(r.is_project());
            prop_assert_eq!(r.to_string(), s);
        }

        #[test]
        fn prop_fan_out_round_trips(task in name_strategy()) {
            let s = format!("^:{task}");
            let r = TaskRef::parse(&s).unwrap();
            prop_assert!(r.is_fan_out());
            prop_assert_eq!(r.to_string(), s);
        }

        #[test]
        fn prop_sibling_fan_out_round_trips(task in name_strategy()) {
            let s = format!("^~:{task}");
            let r = TaskRef::parse(&s).unwrap();
            prop_assert!(r.is_sibling_fan_out());
            prop_assert_eq!(r.to_string(), s);
        }

        #[test]
        fn prop_tag_round_trips(
            tag in name_strategy(),
            task in name_strategy(),
        ) {
            let s = format!("[{tag}]:{task}");
            let r = TaskRef::parse(&s).unwrap();
            prop_assert!(r.is_tag());
            prop_assert_eq!(r.to_string(), s);
        }

        #[test]
        fn prop_sibling_tag_round_trips(
            tag in name_strategy(),
            task in name_strategy(),
        ) {
            let s = format!("[{tag}]~:{task}");
            let r = TaskRef::parse(&s).unwrap();
            prop_assert!(r.is_sibling_tag());
            prop_assert_eq!(r.to_string(), s);
        }
    }
}