source-mesh-core 1.2.2

Rust dependency graph analysis, diagrams, and cycle reports
Documentation
use anyhow::Context as _;
use anyhow::Result;
use anyhow::bail;
use anyhow::ensure;
use getset::CopyGetters;

#[derive(PartialEq, Eq, Hash, CopyGetters)]
pub(crate) struct ScipRange {
    #[getset(get_copy = "pub(crate)")]
    start: (u32, u32),
    end: (u32, u32),
}

impl ScipRange {
    pub(crate) fn parse(coordinates: &[i32]) -> Result<Self> {
        let (start, end) = match *coordinates {
            [line, start_column, end_column] => ((line, start_column), (line, end_column)),
            [start_line, start_column, end_line, end_column] => ((start_line, start_column), (end_line, end_column)),
            _ => bail!("SCIP range must contain three or four coordinates: {coordinates:?}"),
        };
        let unsigned_coordinate = |coordinate: i32| {
            u32::try_from(coordinate).with_context(|| format!("SCIP range must contain nonnegative positions: {coordinates:?}"))
        };
        let start = (unsigned_coordinate(start.0)?, unsigned_coordinate(start.1)?);
        let end = (unsigned_coordinate(end.0)?, unsigned_coordinate(end.1)?);
        ensure!(start <= end, "SCIP range must contain ordered positions: {coordinates:?}");
        Ok(Self { start, end })
    }

    #[must_use]
    pub(crate) fn contains(&self, range: &Self) -> bool {
        self.start <= range.start && range.end <= self.end && range.start < range.end
    }
}

#[cfg(test)]
mod tests {
    use claims::assert_ok;
    use pretty_assertions::assert_eq;
    use rstest::rstest;

    use super::ScipRange;

    #[rstest]
    #[case::origin(&[0, 0, 1], (0, 0), (0, 1))]
    #[case::single_line(&[7, 13, 17], (7, 13), (7, 17))]
    #[case::explicit_single_line(&[7, 13, 7, 17], (7, 13), (7, 17))]
    #[case::multiple_lines(&[7, 13, 8, 2], (7, 13), (8, 2))]
    #[case::empty_origin(&[0, 0, 0], (0, 0), (0, 0))]
    #[case::empty_single_line(&[7, 13, 13], (7, 13), (7, 13))]
    #[case::empty_explicit_single_line(&[7, 13, 7, 13], (7, 13), (7, 13))]
    #[case::maximum_single_line(&[i32::MAX, 0, i32::MAX], (2_147_483_647, 0), (2_147_483_647, 2_147_483_647))]
    #[case::maximum_multiple_lines(&[0, 0, i32::MAX, i32::MAX], (0, 0), (2_147_483_647, 2_147_483_647))]
    #[case::maximum_empty(&[i32::MAX, i32::MAX, i32::MAX], (2_147_483_647, 2_147_483_647), (2_147_483_647, 2_147_483_647),)]
    fn test_range_coordinates(#[case] coordinates: &[i32], #[case] expected_start: (u32, u32), #[case] expected_end: (u32, u32)) {
        let system_under_test = ScipRange::parse(coordinates);
        let system_under_test = assert_ok!(system_under_test, "Valid SCIP coordinates must parse: {coordinates:?}");

        let positions = (system_under_test.start(), system_under_test.end);

        assert_eq!(positions, (expected_start, expected_end), "Incorrect SCIP range coordinates: {coordinates:?}");
    }

    #[rstest]
    #[case::nonempty(&[7, 13, 17], &[7, 13, 7, 17])]
    #[case::empty(&[7, 13, 13], &[7, 13, 7, 13])]
    fn test_equivalent_range_encodings(#[case] compact: &[i32], #[case] explicit: &[i32]) {
        let fixture = ScipRange::parse(explicit);
        let system_under_test = ScipRange::parse(compact);
        let system_under_test = assert_ok!(system_under_test, "The compact SCIP range must parse: {compact:?}");
        let fixture = assert_ok!(fixture, "The explicit SCIP range must parse: {explicit:?}");

        let equivalent = system_under_test == fixture;

        assert!(equivalent, "Equivalent SCIP range encodings must have the same identity");
    }

    #[rstest]
    #[case(&[3, 0, 1], true)]
    #[case(&[12, 0, 1], true)]
    #[case(&[4, 0, 8, 1], true)]
    #[case(&[3, 0, 12, 1], true)]
    #[case(&[12, 1, 2], false)]
    #[case(&[2, 0, 3], false)]
    #[case(&[2, 0, 4, 0], false)]
    #[case(&[11, 0, 12, 2], false)]
    #[case(&[7, 0, 0], false)]
    #[case(&[7, 0, 7, 0], false)]
    fn test_scope_range_containment(#[case] coordinates: &[i32], #[case] expected: bool) {
        let reference_range = ScipRange::parse(coordinates);
        let system_under_test = ScipRange::parse(&[3, 0, 12, 1]);
        let system_under_test = assert_ok!(system_under_test, "The enclosing scope range must parse");
        let reference_range = assert_ok!(reference_range, "The reference range must parse: {coordinates:?}");

        let contains_reference = system_under_test.contains(&reference_range);

        assert_eq!(contains_reference, expected, "Scope containment was incorrect for {coordinates:?}");
    }

    #[rstest]
    #[case::empty(&[])]
    #[case::one_coordinate(&[0])]
    #[case::two_coordinates(&[0, 0])]
    #[case::five_coordinates(&[0, 0, 1, 0, 1])]
    #[case::negative_line(&[-1, 0, 3])]
    #[case::negative_start_column(&[3, -1, 4])]
    #[case::negative_columns(&[3, -2, -1])]
    #[case::negative_end_column(&[3, 0, -1])]
    #[case::negative_explicit_start_line(&[-1, 0, 4, 0])]
    #[case::negative_explicit_start_column(&[3, -1, 4, 0])]
    #[case::negative_explicit_end_line(&[3, 0, -1, 0])]
    #[case::negative_explicit_end_column(&[3, 0, 4, -1])]
    #[case::reversed_columns(&[0, 4, 3])]
    #[case::reversed_lines(&[4, 0, 3, 0])]
    #[case::reversed_explicit_columns(&[3, 4, 3, 0])]
    #[case::minimum_coordinate(&[i32::MIN, 0, 3])]
    fn test_invalid_scope_ranges(#[case] coordinates: &[i32]) {
        let expected_coordinates = format!("{coordinates:?}");

        let system_under_test = ScipRange::parse(coordinates);
        let diagnostic = system_under_test.err().map(|error| error.to_string());

        assert!(
            diagnostic.is_some_and(|message| message.contains("SCIP range") && message.contains(&expected_coordinates)),
            "Invalid SCIP ranges must retain format and coordinate context"
        );
    }
}