gen-core 0.1.31

Core structs and representations for the gen sequence graph and version control system.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

use std::num::ParseIntError;

use thiserror::Error;

#[derive(Debug, PartialEq)]
pub struct Region {
    pub name: String,
    pub start: i64,
    pub end: i64,
}

#[derive(Debug, Error, PartialEq)]
pub enum RegionParseError {
    #[error("Region start is less than region end")]
    InvalidRange,
    #[error("Parsing error: Region name not present")]
    NoName,
    #[error("Parsing error: Region coordinates not present")]
    NoCoordinates,
    #[error("Parsing error: Start coordinate not present")]
    NoStartCoordinate,
    #[error("Parsing error: End coordinate not present")]
    NoEndCoordinate,
    #[error("Parsing error: Invalid coordinate: {0}")]
    InvalidCoordinate(#[from] ParseIntError),
}

impl Region {
    pub fn parse(region_string: &str) -> Result<Self, RegionParseError> {
        // Example input: "chr1:100-200"
        let mut parts = region_string.split(':');
        let name = parts.next().ok_or(RegionParseError::NoName)?.to_string();
        let interval = parts.next().ok_or(RegionParseError::NoCoordinates)?;
        let mut bounds = interval.split('-');
        let start = bounds
            .next()
            .ok_or(RegionParseError::NoStartCoordinate)?
            .parse::<i64>()
            .map_err(RegionParseError::InvalidCoordinate)?;
        let end = bounds
            .next()
            .ok_or(RegionParseError::NoEndCoordinate)?
            .parse::<i64>()
            .map_err(RegionParseError::InvalidCoordinate)?;
        if start > end {
            return Err(RegionParseError::InvalidRange);
        }

        Ok(Self { name, start, end })
    }
}

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

    #[test]
    fn test_parse_valid_region() {
        let region = Region::parse("chr1:100-200");
        assert_eq!(
            region,
            Ok(Region {
                name: "chr1".to_string(),
                start: 100,
                end: 200,
            })
        );
    }

    #[test]
    fn test_parse_invalid_format() {
        let region = Region::parse("chr1-100-200");
        assert_eq!(region, Err(RegionParseError::NoCoordinates));
    }

    #[test]
    fn test_parse_start_greater_than_end() {
        let region = Region::parse("chr1:300-200");
        assert_eq!(region, Err(RegionParseError::InvalidRange));
    }

    #[test]
    fn test_region_applies_to_array_slice() {
        let string = "foobarbaz";
        let region = Region::parse("chr1:3-5").unwrap();
        let slice = &string[region.start as usize..region.end as usize];
        assert_eq!(slice, "ba");
    }
}