gps 7.3.3

Official CLI & library for Git Patch Stack
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use std::collections::VecDeque;

use super::patch_index_range::{ParsePatchIndexOrRangeError, PatchIndexRange};

#[derive(Debug, Clone)]
pub struct PatchIndexRangeBatch {
    patch_index_ranges: VecDeque<PatchIndexRange>,
}

#[derive(Debug)]
pub enum ParsePatchIndexRangeBatchError {
    ParsePatchIndexOrRangeFailed(ParsePatchIndexOrRangeError),
}

impl std::fmt::Display for ParsePatchIndexRangeBatchError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ParsePatchIndexOrRangeFailed(e) => write!(f, "{}", e),
        }
    }
}

impl std::error::Error for ParsePatchIndexRangeBatchError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            Self::ParsePatchIndexOrRangeFailed(e) => Some(e),
        }
    }
}

impl PatchIndexRangeBatch {
    #[allow(dead_code)]
    pub fn len(&self) -> usize {
        self.patch_index_ranges.len()
    }
}

impl std::str::FromStr for PatchIndexRangeBatch {
    type Err = ParsePatchIndexRangeBatchError;

    /// Parse string representation of an a batch of patch indexes & ranges
    ///
    /// A patch index style would simply be a string that is the patch index, e.g. "12". A patch index
    /// range on the other hand is two patch index strings separated by a dash character, e.g. "2-4".
    /// The left most patch index is the starting patch index and the right most patch index is the
    /// ending patch index. A batch is a collection of patch indexes and patch index rages
    /// separated by spaces, e.g. "1 2-4 8". In this example it would result in three
    /// PatchIndexRange objects, one representing the 1, another representing the 2 to 4 range, and
    /// another representing the 8. This interprets this string representation and initializes a
    /// PatchIndexRangeBatch object from it.
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let mut index_ranges: Vec<PatchIndexRange> = vec![];

        for index_or_range_str in s.split(' ') {
            let index_range = index_or_range_str
                .parse::<PatchIndexRange>()
                .map_err(ParsePatchIndexRangeBatchError::ParsePatchIndexOrRangeFailed)?;
            index_ranges.push(index_range);
        }

        Ok(PatchIndexRangeBatch {
            patch_index_ranges: VecDeque::from(index_ranges),
        })
    }
}

impl std::iter::Iterator for PatchIndexRangeBatch {
    type Item = PatchIndexRange;

    fn next(&mut self) -> Option<Self::Item> {
        self.patch_index_ranges.pop_front()
    }
}

#[cfg(test)]
mod tests {
    use crate::commands::{
        patch_index_range::PatchIndexRange, patch_index_range_batch::PatchIndexRangeBatch,
    };

    #[test]
    fn smoke_test_parse_patch_index_range_batch() {
        let mut batch: PatchIndexRangeBatch =
            "0 2-4 5 8-9".parse::<PatchIndexRangeBatch>().unwrap();
        assert_eq!(batch.len(), 4);

        let first = batch.next().unwrap();
        assert_eq!(
            first,
            PatchIndexRange {
                start_index: 0,
                end_index: None,
            },
        );

        let second = batch.next().unwrap();
        assert_eq!(
            second,
            PatchIndexRange {
                start_index: 2,
                end_index: Some(4),
            },
        );

        let third = batch.next().unwrap();
        assert_eq!(
            third,
            PatchIndexRange {
                start_index: 5,
                end_index: None,
            },
        );

        let fourth = batch.next().unwrap();
        assert_eq!(
            fourth,
            PatchIndexRange {
                start_index: 8,
                end_index: Some(9),
            },
        );

        let fifth = batch.next();
        assert!(fifth.is_none());
    }
}