projectfluent/fluent-rs | Build 4666143902 | fluent-syntax/src/parser/helper.rs | Coveralls

8

    pub(super) fn is_current_byte(&self, b: u8) -> bool {

190,004✔

9

        get_current_byte!(self) == Some(&b)

190,004✔

10

190,004✔

12

    pub(super) fn is_byte_at(&self, b: u8, pos: usize) -> bool {

1,791✔

13

        get_byte!(self, pos) == Some(&b)

1,791✔

14

1,791✔

16

    pub(super) fn skip_to_next_entry_start(&mut self) {

737✔

17

        while let Some(b) = get_current_byte!(self) {

7,696✔

18

            let new_line = self.ptr == 0 || get_byte!(self, self.ptr - 1) == Some(&b'\n');

7,509✔

20

            if new_line && (b.is_ascii_alphabetic() || [b'-', b'#'].contains(b)) {

7,509✔

21

                break;

550✔

22

6,959✔

23

6,959✔

24

            self.ptr += 1;

6,959✔

26

737✔

28

    pub(super) fn skip_eol(&mut self) -> bool {

68,107✔

29

        match get_current_byte!(self) {

68,107✔

31

                self.ptr += 1;

7,775✔

32

                true

7,775✔

34

            Some(b'\r') if self.is_byte_at(b'\n', self.ptr + 1) => {

18✔

35

                self.ptr += 2;

18✔

36

                true

18✔

38

            _ => false,

60,318✔

40

68,111✔

42

    pub(super) fn skip_unicode_escape_sequence(&mut self, length: usize) -> Result<()> {

49✔

43

        let start = self.ptr;

49✔

44

        for _ in 0..length {

49✔

45

            match get_current_byte!(self) {

220✔

46

                Some(b) if b.is_ascii_hexdigit() => self.ptr += 1,

212✔

47

                _ => break,

8✔

50

        if self.ptr - start != length {

49✔

51

            let end = if self.ptr >= self.length {

8✔

54

                self.ptr + 1

8✔

56

            let seq = self.source.slice(start..end).as_ref().to_owned();

8✔

57

            return error!(ErrorKind::InvalidUnicodeEscapeSequence(seq), self.ptr);

8✔

58

41✔

59

        Ok(())

41✔

60

49✔

62

    pub(super) fn is_identifier_start(&self) -> bool {

32,733✔

63

        matches!(get_current_byte!(self), Some(b) if b.is_ascii_alphabetic())

32,733✔

64

32,732✔

66

    pub(super) fn take_byte_if(&mut self, b: u8) -> bool {

123,819✔

67

        if self.is_current_byte(b) {

123,819✔

68

            self.ptr += 1;

29,933✔

69

            true

29,933✔

71

            false

93,886✔

73

123,819✔

75

    pub(super) fn skip_blank_block(&mut self) -> usize {

39,155✔

76

        let mut count = 0;

39,155✔

78

            let start = self.ptr;

40,828✔

79

            self.skip_blank_inline();

40,828✔

80

            if !self.skip_eol() {

40,828✔

81

                self.ptr = start;

39,155✔

82

                break;

39,155✔

83

1,673✔

84

            count += 1;

1,673✔

86

        count

39,155✔

87

39,155✔

89

    pub(super) fn skip_blank(&mut self) {

60,310✔

90

        loop {

93,248✔

91

            match get_current_byte!(self) {

93,248✔

92

                Some(b' ') | Some(b'\n') => self.ptr += 1,

32,938✔

94

                _ => break,

60,310✔

95

60,310✔

96

60,310✔

97

60,310✔

99

    pub(super) fn skip_blank_inline(&mut self) -> usize {

147,284✔

100

        let start = self.ptr;

147,284✔

101

        while let Some(b' ') = get_current_byte!(self) {

269,694✔

102

            self.ptr += 1;

122,410✔

103

122,410✔

104

        self.ptr - start

147,285✔

105

147,285✔

107

    pub(super) fn is_byte_pattern_continuation(b: u8) -> bool {

7,092✔

108

        !matches!(b, b'.' | b'}' | b'[' | b'*')

7,092✔

109

7,092✔

111

    pub(super) fn is_callee(name: &S) -> bool {

872✔

112

        name.as_ref()

872✔

113

            .as_bytes()

872✔

114

            .iter()

872✔

115

            .all(|c| c.is_ascii_uppercase() || c.is_ascii_digit() || *c == b'_' || *c == b'-')

6,745✔

116

872✔

118

    pub(super) fn expect_byte(&mut self, b: u8) -> Result<()> {

44,561✔

119

        if !self.is_current_byte(b) {

44,561✔

120

            return error!(ErrorKind::ExpectedToken(b as char), self.ptr);

208✔

121

44,353✔

122

        self.ptr += 1;

44,353✔

123

        Ok(())

44,353✔

124

44,561✔

126

    pub(super) fn is_number_start(&self) -> bool {

3,132✔

127

        matches!(get_current_byte!(self), Some(b) if b.is_ascii_digit() || b == &b'-')

3,132✔

128

3,132✔

130

    pub(super) fn is_eol(&self) -> bool {

94,786✔

131

        match get_current_byte!(self) {

94,786✔

132

            Some(b'\n') => true,

2,400✔

133

            Some(b'\r') if self.is_byte_at(b'\n', self.ptr + 1) => true,

89✔

134

            None => true,

5✔

135

            _ => false,

92,369✔

137

94,788✔

139

    pub(super) fn skip_digits(&mut self) -> Result<()> {

2,666✔

140

        let start = self.ptr;

2,666✔

141

        loop {

5,525✔

142

            match get_current_byte!(self) {

5,525✔

143

                Some(b) if b.is_ascii_digit() => self.ptr += 1,

2,859✔

144

                _ => break,

2,666✔

145

2,666✔

146

2,666✔

147

        if start == self.ptr {

2,666✔

148

            error!(

12✔

149

                ErrorKind::ExpectedCharRange {

12✔

150

                    range: "0-9".to_string()

12✔

151

},

12✔

152

                self.ptr

12✔

153

12✔

155

            Ok(())

2,654✔

157

2,666✔

159

    pub(super) fn get_number_literal(&mut self) -> Result<S> {

2,561✔

160

        let start = self.ptr;

2,561✔

161

        self.take_byte_if(b'-');

2,561✔

162

        self.skip_digits()?;

2,561✔

163

        if self.take_byte_if(b'.') {

2,557✔

164

            self.skip_digits()?;

105✔

165

2,452✔

167

        Ok(self.source.slice(start..self.ptr))

2,549✔

168

2,561✔

projectfluent / fluent-rs / 4666143902

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

1	use super::errors::{ErrorKind, ParserError};
2	use super::{core::Parser, core::Result, slice::Slice};
3
4	impl<'s, S> Parser<S>
5	where
6	S: Slice<'s>,
7	{
8	pub(super) fn is_current_byte(&self, b: u8) -> bool {	190,004✔
9	get_current_byte!(self) == Some(&b)	190,004✔
10	}	190,004✔
11
12	pub(super) fn is_byte_at(&self, b: u8, pos: usize) -> bool {	1,791✔
13	get_byte!(self, pos) == Some(&b)	1,791✔
14	}	1,791✔
15
16	pub(super) fn skip_to_next_entry_start(&mut self) {	737✔
17	while let Some(b) = get_current_byte!(self) {	7,696✔
18	let new_line = self.ptr == 0 \|\| get_byte!(self, self.ptr - 1) == Some(&b'\n');	7,509✔
19
20	if new_line && (b.is_ascii_alphabetic() \|\| [b'-', b'#'].contains(b)) {	7,509✔
21	break;	550✔
22	}	6,959✔
23		6,959✔
24	self.ptr += 1;	6,959✔
25	}
26	}	737✔
27
28	pub(super) fn skip_eol(&mut self) -> bool {	68,107✔
29	match get_current_byte!(self) {	68,107✔
30	Some(b'\n') => {
31	self.ptr += 1;	7,775✔
32	true	7,775✔
33	}
34	Some(b'\r') if self.is_byte_at(b'\n', self.ptr + 1) => {	18✔
35	self.ptr += 2;	18✔
36	true	18✔
37	}
38	_ => false,	60,318✔
39	}
40	}	68,111✔
41
42	pub(super) fn skip_unicode_escape_sequence(&mut self, length: usize) -> Result<()> {	49✔
43	let start = self.ptr;	49✔
44	for _ in 0..length {	49✔
45	match get_current_byte!(self) {	220✔
46	Some(b) if b.is_ascii_hexdigit() => self.ptr += 1,	212✔
47	_ => break,	8✔
48	}
49	}
50	if self.ptr - start != length {	49✔
51	let end = if self.ptr >= self.length {	8✔
52	self.ptr	×
53	} else {
54	self.ptr + 1	8✔
55	};
56	let seq = self.source.slice(start..end).as_ref().to_owned();	8✔
57	return error!(ErrorKind::InvalidUnicodeEscapeSequence(seq), self.ptr);	8✔
58	}	41✔
59	Ok(())	41✔
60	}	49✔
61
62	pub(super) fn is_identifier_start(&self) -> bool {	32,733✔
63	matches!(get_current_byte!(self), Some(b) if b.is_ascii_alphabetic())	32,733✔
64	}	32,732✔
65
66	pub(super) fn take_byte_if(&mut self, b: u8) -> bool {	123,819✔
67	if self.is_current_byte(b) {	123,819✔
68	self.ptr += 1;	29,933✔
69	true	29,933✔
70	} else {
71	false	93,886✔
72	}
73	}	123,819✔
74
75	pub(super) fn skip_blank_block(&mut self) -> usize {	39,155✔
76	let mut count = 0;	39,155✔
77	loop {
78	let start = self.ptr;	40,828✔
79	self.skip_blank_inline();	40,828✔
80	if !self.skip_eol() {	40,828✔
81	self.ptr = start;	39,155✔
82	break;	39,155✔
83	}	1,673✔
84	count += 1;	1,673✔
85	}
86	count	39,155✔
87	}	39,155✔
88
89	pub(super) fn skip_blank(&mut self) {	60,310✔
90	loop {	93,248✔
91	match get_current_byte!(self) {	93,248✔
92	Some(b' ') \| Some(b'\n') => self.ptr += 1,	32,938✔
93	Some(b'\r') if get_byte!(self, self.ptr + 1) == Some(&b'\n') => self.ptr += 2,	×
94	_ => break,	60,310✔
95	}	60,310✔
96	}	60,310✔
97	}	60,310✔
98
99	pub(super) fn skip_blank_inline(&mut self) -> usize {	147,284✔
100	let start = self.ptr;	147,284✔
101	while let Some(b' ') = get_current_byte!(self) {	269,694✔
102	self.ptr += 1;	122,410✔
103	}	122,410✔
104	self.ptr - start	147,285✔
105	}	147,285✔
106
107	pub(super) fn is_byte_pattern_continuation(b: u8) -> bool {	7,092✔
108	!matches!(b, b'.' \| b'}' \| b'[' \| b'*')	7,092✔
109	}	7,092✔
110
111	pub(super) fn is_callee(name: &S) -> bool {	872✔
112	name.as_ref()	872✔
113	.as_bytes()	872✔
114	.iter()	872✔
115	.all(\|c\| c.is_ascii_uppercase() \|\| c.is_ascii_digit() \|\| c == b'_' \|\| c == b'-')	6,745✔
116	}	872✔
117
118	pub(super) fn expect_byte(&mut self, b: u8) -> Result<()> {	44,561✔
119	if !self.is_current_byte(b) {	44,561✔
120	return error!(ErrorKind::ExpectedToken(b as char), self.ptr);	208✔
121	}	44,353✔
122	self.ptr += 1;	44,353✔
123	Ok(())	44,353✔
124	}	44,561✔
125
126	pub(super) fn is_number_start(&self) -> bool {	3,132✔
127	matches!(get_current_byte!(self), Some(b) if b.is_ascii_digit() \|\| b == &b'-')	3,132✔
128	}	3,132✔
129
130	pub(super) fn is_eol(&self) -> bool {	94,786✔
131	match get_current_byte!(self) {	94,786✔
132	Some(b'\n') => true,	2,400✔
133	Some(b'\r') if self.is_byte_at(b'\n', self.ptr + 1) => true,	89✔
134	None => true,	5✔
135	_ => false,	92,369✔
136	}
137	}	94,788✔
138
139	pub(super) fn skip_digits(&mut self) -> Result<()> {	2,666✔
140	let start = self.ptr;	2,666✔
141	loop {	5,525✔
142	match get_current_byte!(self) {	5,525✔
143	Some(b) if b.is_ascii_digit() => self.ptr += 1,	2,859✔
144	_ => break,	2,666✔
145	}	2,666✔
146	}	2,666✔
147	if start == self.ptr {	2,666✔
148	error!(	12✔
149	ErrorKind::ExpectedCharRange {	12✔
150	range: "0-9".to_string()	12✔
151	},	12✔
152	self.ptr	12✔
153	)	12✔
154	} else {
155	Ok(())	2,654✔
156	}
157	}	2,666✔
158
159	pub(super) fn get_number_literal(&mut self) -> Result<S> {	2,561✔
160	let start = self.ptr;	2,561✔
161	self.take_byte_if(b'-');	2,561✔
162	self.skip_digits()?;	2,561✔
163	if self.take_byte_if(b'.') {	2,557✔
164	self.skip_digits()?;	105✔
165	}	2,452✔
166
167	Ok(self.source.slice(start..self.ptr))	2,549✔
168	}	2,561✔
169	}

projectfluent / fluent-rs / 4666143902

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