corebreaker / poreader / 178

Committed 03 May 2024 05:07AM UTC coverage: 98.197% (-1.6%) from 99.764%

Build # 178

Build Type

push

circleci

Committed by

web-flow

Commit Message

Merge pull request #13 from corebreaker/circleci-project-setup

Fix coverage check in CI

Run Details

708 of 721 relevant lines covered (98.2%)

50.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.33

/src/po/line_iter.rs

use super::{line::PoLine, PoParser};
use crate::error::Error;
use std::io::{BufRead, BufReader, Lines, Read};

pub(super) struct LineIter<'p, R: Read> {
    n: usize,
    inner: Option<Lines<BufReader<R>>>,
    parser: &'p PoParser,
}

impl<'p, R: Read> LineIter<'p, R> {
    pub(super) fn new(r: R, parser: &'p PoParser) -> Self {
        Self {
            n: 1,
            inner: Some(BufReader::new(r).lines()),
            parser,
        }
    }
}

impl<'p, R: Read> Iterator for LineIter<'p, R> {
    type Item = Result<PoLine, Error>;

    fn next(&mut self) -> Option<Result<PoLine, Error>> {
        while let Some(reader) = self.inner.as_mut() {
            let n = self.n;
            let line = match reader.next() {
                Some(Ok(s)) => s,
                Some(Err(e)) => {
                    self.inner = None;

                    return Some(Err(Error::Io(n, e)));
                }
                None => {
                    return None;
                }
            };

            self.n += 1;

            match self.parser.parse_line(&line, n) {
                Ok(PoLine::Blank) => (),
                Ok(p) => return Some(Ok(p)),
                Err(()) => {
                    self.inner = None;

                    return Some(Err(Error::Parse(self.n, line, String::new())));
                }
            }
        }

        None
    }
}

// no-coverage:start
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn empty() {
        let lines = "";
        let parser = PoParser::new();
        let mut iter = LineIter::new(lines.as_bytes(), &parser);

        if let Some(v) = iter.next() {
            panic!("Unexpected result for the first line: {:?}", v);
        }
    }

    #[test]
    fn blank() {
        let lines = "          \n\t\t   \n\n\n   \t\r\n";
        let parser = PoParser::new();
        let mut iter = LineIter::new(lines.as_bytes(), &parser);

        if let Some(v) = iter.next() {
            panic!("Unexpected result for the first line: {:?}", v);
        }
    }

    #[test]
    fn two_strict_lines() {
        let lines = "msgid \"Line 1\"\nmsgstr \"Line 2\"";
        let parser = PoParser::new();
        let mut iter = LineIter::new(lines.as_bytes(), &parser);

        match iter.next() {
            Some(Ok(PoLine::Message(line, flag, tag, string))) => {
                assert_eq!(line, 1);
                assert_eq!(flag, "");
                assert_eq!(tag, "msgid");
                assert_eq!(string, "Line 1");
            }
            v => panic!("Unexpected result for the first line: {:?}", v),
        }

        match iter.next() {
            Some(Ok(PoLine::Message(line, flag, tag, string))) => {
                assert_eq!(line, 2);
                assert_eq!(flag, "");
                assert_eq!(tag, "msgstr");
                assert_eq!(string, "Line 2");
            }
            v => panic!("Unexpected result for the second line: {:?}", v),
        }

        if let Some(v) = iter.next() {
            panic!("Unexpected result for the third line: {:?}", v);
        }
    }

    #[test]
    fn two_normal_lines() {
        let lines = r#"
            #~ msgid "Line 1"
            #~ msgstr "Line 2"
        "#;

        let parser = PoParser::new();
        let mut iter = LineIter::new(lines.as_bytes(), &parser);

        match iter.next() {
            Some(Ok(PoLine::Message(line, flag, tag, string))) => {
                assert_eq!(line, 2, "Bad line with flag={}, tag={}, string={}", flag, tag, string);
                assert_eq!(flag, "~");
                assert_eq!(tag, "msgid");
                assert_eq!(string, "Line 1");
            }
            v => panic!("Unexpected result for the first line: {:?}", v),
        }

        match iter.next() {
            Some(Ok(PoLine::Message(line, flag, tag, string))) => {
                assert_eq!(line, 3, "Bad line with flag={}, tag={}, string={}", flag, tag, string);
                assert_eq!(flag, "~");
                assert_eq!(tag, "msgstr");
                assert_eq!(string, "Line 2");
            }
            v => panic!("Unexpected result for the second line: {:?}", v),
        }

        if let Some(v) = iter.next() {
            panic!("Unexpected result for the third line: {:?}", v);
        }
    }

    #[test]
    fn with_error() {
        let lines = r#"
            #: File:1
            msgid "Line 1"
            msgstr "Line 2

            # End
        "#;

        let parser = PoParser::new();
        let mut iter = LineIter::new(lines.as_bytes(), &parser);

        match iter.next() {
            Some(Ok(PoLine::Comment(line, kind, content))) => {
                assert_eq!(line, 2, "Bad line with kind={}, content={}", kind, content);
                assert_eq!(kind, ':');
                assert_eq!(content, "File:1");
            }
            v => panic!("Unexpected result for the first line: {:?}", v),
        }

        match iter.next() {
            Some(Ok(PoLine::Message(line, flag, tag, string))) => {
                assert_eq!(line, 3, "Bad line with flag={}, tag={}, string={}", flag, tag, string);
                assert_eq!(flag, "");
                assert_eq!(tag, "msgid");
                assert_eq!(string, "Line 1");
            }
            v => panic!("Unexpected result for the second line: {:?}", v),
        }

        match iter.next() {
            Some(Err(err)) => {
                assert_eq!(
                    format!("{:?}", err),
                    "Parse error at line 5, got ‘            msgstr \"Line 2’"
                );
            }
            v => panic!("Unexpected result for the third line: {:?}", v),
        }

        if let Some(v) = iter.next() {
            panic!("Unexpected result for the fourth line: {:?}", v);
        }
    }
}
// no-coverage:stop

1	use super::{line::PoLine, PoParser};
2	use crate::error::Error;
3	use std::io::{BufRead, BufReader, Lines, Read};
4
5	pub(super) struct LineIter<'p, R: Read> {
6	n: usize,
7	inner: Option<Lines<BufReader<R>>>,
8	parser: &'p PoParser,
9	}
10
11	impl<'p, R: Read> LineIter<'p, R> {
12	pub(super) fn new(r: R, parser: &'p PoParser) -> Self {	39✔
13	Self {	39✔
14	n: 1,
15	inner: Some(BufReader::new(r).lines()),	39✔
16	parser,
17	}
18	}	39✔
19	}
20
21	impl<'p, R: Read> Iterator for LineIter<'p, R> {
22	type Item = Result<PoLine, Error>;
23
24	fn next(&mut self) -> Option<Result<PoLine, Error>> {	137✔
25	while let Some(reader) = self.inner.as_mut() {	151✔
26	let n = self.n;	147✔
27	let line = match reader.next() {	147✔
28	Some(Ok(s)) => s,	121✔
29	Some(Err(e)) => {	×
30	self.inner = None;	×
31
32	return Some(Err(Error::Io(n, e)));	×
33	}	×
34	None => {
35	return None;	26✔
36	}
37	};	147✔
38
39	self.n += 1;	121✔
40
41	match self.parser.parse_line(&line, n) {	121✔
42	Ok(PoLine::Blank) => (),	14✔
43	Ok(p) => return Some(Ok(p)),	93✔
44	Err(()) => {
45	self.inner = None;	14✔
46
47	return Some(Err(Error::Parse(self.n, line, String::new())));	14✔
48	}
49	}
50	}	147✔
51
52	None	4✔
53	}	141✔
54	}
55
56	// no-coverage:start
57	#[cfg(test)]
58	mod tests {
59	use super::*;
60
61	#[test]
62	fn empty() {
63	let lines = "";
64	let parser = PoParser::new();
65	let mut iter = LineIter::new(lines.as_bytes(), &parser);
66
67	if let Some(v) = iter.next() {
68	panic!("Unexpected result for the first line: {:?}", v);
69	}
70	}
71
72	#[test]
73	fn blank() {
74	let lines = " \n\t\t \n\n\n \t\r\n";
75	let parser = PoParser::new();
76	let mut iter = LineIter::new(lines.as_bytes(), &parser);
77
78	if let Some(v) = iter.next() {
79	panic!("Unexpected result for the first line: {:?}", v);
80	}
81	}
82
83	#[test]
84	fn two_strict_lines() {
85	let lines = "msgid \"Line 1\"\nmsgstr \"Line 2\"";
86	let parser = PoParser::new();
87	let mut iter = LineIter::new(lines.as_bytes(), &parser);
88
89	match iter.next() {
90	Some(Ok(PoLine::Message(line, flag, tag, string))) => {
91	assert_eq!(line, 1);
92	assert_eq!(flag, "");
93	assert_eq!(tag, "msgid");
94	assert_eq!(string, "Line 1");
95	}
96	v => panic!("Unexpected result for the first line: {:?}", v),
97	}
98
99	match iter.next() {
100	Some(Ok(PoLine::Message(line, flag, tag, string))) => {
101	assert_eq!(line, 2);
102	assert_eq!(flag, "");
103	assert_eq!(tag, "msgstr");
104	assert_eq!(string, "Line 2");
105	}
106	v => panic!("Unexpected result for the second line: {:?}", v),
107	}
108
109	if let Some(v) = iter.next() {
110	panic!("Unexpected result for the third line: {:?}", v);
111	}
112	}
113
114	#[test]
115	fn two_normal_lines() {
116	let lines = r#"
117	#~ msgid "Line 1"
118	#~ msgstr "Line 2"
119	"#;
120
121	let parser = PoParser::new();
122	let mut iter = LineIter::new(lines.as_bytes(), &parser);
123
124	match iter.next() {
125	Some(Ok(PoLine::Message(line, flag, tag, string))) => {
126	assert_eq!(line, 2, "Bad line with flag={}, tag={}, string={}", flag, tag, string);
127	assert_eq!(flag, "~");
128	assert_eq!(tag, "msgid");
129	assert_eq!(string, "Line 1");
130	}
131	v => panic!("Unexpected result for the first line: {:?}", v),
132	}
133
134	match iter.next() {
135	Some(Ok(PoLine::Message(line, flag, tag, string))) => {
136	assert_eq!(line, 3, "Bad line with flag={}, tag={}, string={}", flag, tag, string);
137	assert_eq!(flag, "~");
138	assert_eq!(tag, "msgstr");
139	assert_eq!(string, "Line 2");
140	}
141	v => panic!("Unexpected result for the second line: {:?}", v),
142	}
143
144	if let Some(v) = iter.next() {
145	panic!("Unexpected result for the third line: {:?}", v);
146	}
147	}
148
149	#[test]
150	fn with_error() {
151	let lines = r#"
152	#: File:1
153	msgid "Line 1"
154	msgstr "Line 2
155
156	# End
157	"#;
158
159	let parser = PoParser::new();
160	let mut iter = LineIter::new(lines.as_bytes(), &parser);
161
162	match iter.next() {
163	Some(Ok(PoLine::Comment(line, kind, content))) => {
164	assert_eq!(line, 2, "Bad line with kind={}, content={}", kind, content);
165	assert_eq!(kind, ':');
166	assert_eq!(content, "File:1");
167	}
168	v => panic!("Unexpected result for the first line: {:?}", v),
169	}
170
171	match iter.next() {
172	Some(Ok(PoLine::Message(line, flag, tag, string))) => {
173	assert_eq!(line, 3, "Bad line with flag={}, tag={}, string={}", flag, tag, string);
174	assert_eq!(flag, "");
175	assert_eq!(tag, "msgid");
176	assert_eq!(string, "Line 1");
177	}
178	v => panic!("Unexpected result for the second line: {:?}", v),
179	}
180
181	match iter.next() {
182	Some(Err(err)) => {
183	assert_eq!(
184	format!("{:?}", err),
185	"Parse error at line 5, got ‘ msgstr \"Line 2’"
186	);
187	}
188	v => panic!("Unexpected result for the third line: {:?}", v),
189	}
190
191	if let Some(v) = iter.next() {
192	panic!("Unexpected result for the fourth line: {:?}", v);
193	}
194	}
195	}
196	// no-coverage:stop

corebreaker / poreader / 178

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous