From dbc56a477b903a04d5aabb3ef060c790659b09fc Mon Sep 17 00:00:00 2001 From: jackfiled Date: Sun, 1 Dec 2024 22:00:51 +0800 Subject: [PATCH] refact: release input from ParserContext. --- src/combinators/alternate_parser.rs | 40 +++---- src/combinators/left_right_parsers.rs | 8 +- src/combinators/many_parsers.rs | 132 +++++++++------------- src/combinators/separated_parsers.rs | 152 ++++++++++---------------- src/combinators/tuple_parser.rs | 56 ++++------ src/parser.rs | 71 ++++-------- src/parser/modified_parsers.rs | 152 ++++++++++---------------- src/parser/primitive_parsers.rs | 68 ++++-------- src/text.rs | 44 +++----- src/text/string_parsers.rs | 2 +- tests/file_lexical_parser_tests.rs | 6 +- tests/lexical_parser_tests.rs | 6 +- tests/tokenizer/mod.rs | 2 +- tests/tokenizer/zero_parsers.rs | 26 ++--- tests/zero_parser_tests.rs | 19 ++-- 15 files changed, 300 insertions(+), 484 deletions(-) diff --git a/src/combinators/alternate_parser.rs b/src/combinators/alternate_parser.rs index 305fe7f..85eddbf 100644 --- a/src/combinators/alternate_parser.rs +++ b/src/combinators/alternate_parser.rs @@ -17,7 +17,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { match self.first.parse(context.clone(), input) { @@ -38,7 +38,7 @@ mod test { #[test] fn alternate_test() { fn parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { char_parser('a') @@ -47,35 +47,35 @@ mod test { .parse(context, input) } - parser_test_helper(ParserContext::new_with_str("a", ()), &'a', parser); - parser_test_helper(ParserContext::new_with_str("b", ()), &'b', parser); - parser_test_helper(ParserContext::new_with_str("c", ()), &'c', parser); + parser_test_helper("a", &'a', parser); + parser_test_helper("b", &'b', parser); + parser_test_helper("c", &'c', parser); } #[test] fn alternate_macro_test() { fn parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!(char_parser('a'), char_parser('b'), char_parser('c')).parse(context, input) } - parser_test_helper(ParserContext::new_with_str("a", ()), &'a', parser); - parser_test_helper(ParserContext::new_with_str("b", ()), &'b', parser); - parser_test_helper(ParserContext::new_with_str("c", ()), &'c', parser); + parser_test_helper("a", &'a', parser); + parser_test_helper("b", &'b', parser); + parser_test_helper("c", &'c', parser); } #[test] fn alternate_function_test() { fn parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!(char_parser('a'), char_parser('b')).parse(context, input) } - parser_test_helper(ParserContext::new_with_str("a", ()), &'a', |c, i| { + parser_test_helper("a", &'a', |c, i| { let parser = alternate!(parser, char_parser('c')); let parser = alternate!(parser, char_parser('d')); parser.parse(c, i) @@ -85,27 +85,23 @@ mod test { #[test] fn alternate_pure_function_test() { fn parser1( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!(char_parser('a').literal(), char_parser('b').literal()).parse(context, input) } fn parser2( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!(char_parser('c').literal(), char_parser('d').literal()).parse(context, input) } - parser_test_helper( - ParserContext::new_with_str("a", ()), - &"a".to_owned(), - |c, i| { - alternate!(parser1, parser2) - .map(|x| x.iter().map(|x| x.clone()).collect()) - .parse(c, i) - }, - ); + parser_test_helper("a", &"a".to_owned(), |c, i| { + alternate!(parser1, parser2) + .map(|x| x.iter().map(|x| x.clone()).collect()) + .parse(c, i) + }); } } diff --git a/src/combinators/left_right_parsers.rs b/src/combinators/left_right_parsers.rs index 45e0f29..ccfacfe 100644 --- a/src/combinators/left_right_parsers.rs +++ b/src/combinators/left_right_parsers.rs @@ -19,7 +19,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { let (input, r) = self.left_parser.parse(context.clone(), input)?; @@ -46,7 +46,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, TRight> { let (input, _) = self.left_parser.parse(context.clone(), input)?; @@ -63,14 +63,14 @@ mod test { #[test] fn left_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &'a', |c, i| { + parser_test_helper("abc", &'a', |c, i| { char_parser('a').left(char_parser('b')).parse(c, i) }); } #[test] fn right_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &'b', |c, i| { + parser_test_helper("abc", &'b', |c, i| { char_parser('a').right(char_parser('b')).parse(c, i) }) } diff --git a/src/combinators/many_parsers.rs b/src/combinators/many_parsers.rs index 0b5bd65..cf7b7b0 100644 --- a/src/combinators/many_parsers.rs +++ b/src/combinators/many_parsers.rs @@ -15,7 +15,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, Vec> { let mut result = vec![]; @@ -41,7 +41,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, Vec> { let (mut input, first_result) = self.parser.parse(context.clone(), input)?; @@ -68,7 +68,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, ()> { let mut input = input; @@ -93,7 +93,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, ()> { let (mut input, _) = self.parser.parse(context.clone(), input)?; @@ -121,7 +121,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, Vec> { let mut input = input; @@ -159,7 +159,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, Vec> { let (mut input, r) = self.parser.parse(context.clone(), input)?; @@ -192,142 +192,112 @@ mod test { #[test] fn many_test() { - parser_test_helper( - ParserContext::new_with_str("aaa", ()), - &vec!['a', 'a', 'a'], - |c, i| char_parser('a').many().parse(c, i), - ); - - parser_test_helper( - ParserContext::new_with_str("aaabbaa", ()), - &vec!['a', 'a', 'a'], - |c, i| char_parser('a').many().parse(c, i), - ); - - parser_test_helper(ParserContext::new_with_str("bbaa", ()), &vec![], |c, i| { + parser_test_helper("aaa", &vec!['a', 'a', 'a'], |c, i| { char_parser('a').many().parse(c, i) }); - parser_test_helper(ParserContext::new_with_str("", ()), &vec![], |c, i| { + parser_test_helper("aaabbaa", &vec!['a', 'a', 'a'], |c, i| { char_parser('a').many().parse(c, i) }); + + parser_test_helper("bbaa", &vec![], |c, i| char_parser('a').many().parse(c, i)); + + parser_test_helper("", &vec![], |c, i| char_parser('a').many().parse(c, i)); } #[test] fn many1_test() { - parser_test_helper( - ParserContext::new_with_str("aaa", ()), - &vec!['a', 'a', 'a'], - |c, i| char_parser('a').many1().parse(c, i), - ); - - parser_test_helper( - ParserContext::new_with_str("aaabbaa", ()), - &vec!['a', 'a', 'a'], - |c, i| char_parser('a').many1().parse(c, i), - ); - - failed_parser_test_helper(ParserContext::new_with_str("bbaa", ()), |c, i| { + parser_test_helper("aaa", &vec!['a', 'a', 'a'], |c, i| { char_parser('a').many1().parse(c, i) }); - failed_parser_test_helper(ParserContext::new_with_str("", ()), |c, i| { + parser_test_helper("aaabbaa", &vec!['a', 'a', 'a'], |c, i| { char_parser('a').many1().parse(c, i) }); + + failed_parser_test_helper("bbaa", |c, i| char_parser('a').many1().parse(c, i)); + + failed_parser_test_helper("baa", |c, i| char_parser('a').many1().parse(c, i)); } #[test] fn skip_test() { - parser_test_helper(ParserContext::new_with_str("aaab", ()), &'b', |c, i| { + parser_test_helper("aaab", &'b', |c, i| { char_parser('a').skip().right(char_parser('b')).parse(c, i) }); - parser_test_helper(ParserContext::new_with_str("b", ()), &'b', |c, i| { + parser_test_helper("b", &'b', |c, i| { char_parser('a').skip().right(char_parser('b')).parse(c, i) }); } #[test] fn skip1_test() { - parser_test_helper(ParserContext::new_with_str("aaab", ()), &'b', |c, i| { + parser_test_helper("aaab", &'b', |c, i| { char_parser('a').skip1().right(char_parser('b')).parse(c, i) }); - failed_parser_test_helper(ParserContext::new_with_str("b", ()), |c, i| { + failed_parser_test_helper("b", |c, i| { char_parser('a').skip1().right(char_parser('b')).parse(c, i) }); } #[test] fn many_till_test() { - parser_test_helper( - ParserContext::new_with_str("aaab", ()), - &vec!['a', 'a', 'a'], - |c, i| char_parser('a').many_till(char_parser('b')).parse(c, i), - ); - - parser_test_helper(ParserContext::new_with_str("b", ()), &vec![], |c, i| { + parser_test_helper("aaab", &vec!['a', 'a', 'a'], |c, i| { char_parser('a').many_till(char_parser('b')).parse(c, i) }); - parser_test_helper( - ParserContext::new_with_str("aaabc", ()), - &vec!['a', 'a', 'a'], - |c, i| { - char_parser('a') - .many_till(char_parser('b')) - .left(char_parser('b')) - .left(char_parser('c')) - .parse(c, i) - }, - ); + parser_test_helper("b", &vec![], |c, i| { + char_parser('a').many_till(char_parser('b')).parse(c, i) + }); - failed_parser_test_helper(ParserContext::new_with_str("aaacb", ()), |c, i| { + parser_test_helper("aaabc", &vec!['a', 'a', 'a'], |c, i| { + char_parser('a') + .many_till(char_parser('b')) + .left(char_parser('b')) + .left(char_parser('c')) + .parse(c, i) + }); + + failed_parser_test_helper("aaacb", |c, i| { char_parser('a').many_till(char_parser('b')).parse(c, i) }); } #[test] fn many1_till_test() { - parser_test_helper( - ParserContext::new_with_str("aaab", ()), - &vec!['a', 'a', 'a'], - |c, i| char_parser('a').many1_till(char_parser('b')).parse(c, i), - ); - - failed_parser_test_helper(ParserContext::new_with_str("b", ()), |c, i| { + parser_test_helper("aaab", &vec!['a', 'a', 'a'], |c, i| { char_parser('a').many1_till(char_parser('b')).parse(c, i) }); - failed_parser_test_helper(ParserContext::new_with_str("aaacb", ()), |c, i| { + failed_parser_test_helper("b", |c, i| { + char_parser('a').many1_till(char_parser('b')).parse(c, i) + }); + + failed_parser_test_helper("aaacb", |c, i| { char_parser('a').many1_till(char_parser('b')).parse(c, i) }); } #[test] fn take_till_test() { - parser_test_helper( - ParserContext::new_with_str("aaab", ()), - &(vec!['a', 'a', 'a'], 'b'), - |c, i| tuple((take_till(char_parser('b')), char_parser('b'))).parse(c, i), - ); + parser_test_helper("aaab", &(vec!['a', 'a', 'a'], 'b'), |c, i| { + tuple((take_till(char_parser('b')), char_parser('b'))).parse(c, i) + }); - parser_test_helper( - ParserContext::new_with_str("b", ()), - &(vec![], 'b'), - |c, i| tuple((take_till(char_parser('b')), char_parser('b'))).parse(c, i), - ); + parser_test_helper("b", &(vec![], 'b'), |c, i| { + tuple((take_till(char_parser('b')), char_parser('b'))).parse(c, i) + }); } #[test] fn take1_till_test() { - parser_test_helper( - ParserContext::new_with_str("aaab", ()), - &(vec!['a', 'a', 'a'], 'b'), - |c, i| tuple((take1_till(char_parser('b')), char_parser('b'))).parse(c, i), - ); + parser_test_helper("aaab", &(vec!['a', 'a', 'a'], 'b'), |c, i| { + tuple((take1_till(char_parser('b')), char_parser('b'))).parse(c, i) + }); - failed_parser_test_helper(ParserContext::new_with_str("b", ()), |c, i| { + failed_parser_test_helper("b", |c, i| { tuple((take1_till(char_parser('b')), char_parser('b'))).parse(c, i) }); } diff --git a/src/combinators/separated_parsers.rs b/src/combinators/separated_parsers.rs index e6b66d9..e887759 100644 --- a/src/combinators/separated_parsers.rs +++ b/src/combinators/separated_parsers.rs @@ -22,7 +22,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, Vec> { let (mut input, _) = match self.left.parse(context.clone(), input) { @@ -70,7 +70,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, Vec> { let (mut input, first) = self.parser.parse(context.clone(), input)?; @@ -105,7 +105,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, Vec> { let (mut input, first) = self.parser.parse(context.clone(), input)?; @@ -141,7 +141,7 @@ mod test { #[test] fn quote_test() { fn parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult> { quote( @@ -152,150 +152,112 @@ mod test { .parse(context, input) } - parser_test_helper( - ParserContext::new_with_str("'abc'", ()), - &vec!['a', 'b', 'c'], - parser, - ); - parser_test_helper(ParserContext::new_with_str("''", ()), &vec![], parser); - failed_parser_test_helper(ParserContext::new_with_str("asd", ()), parser); + parser_test_helper("'abc'", &vec!['a', 'b', 'c'], parser); + parser_test_helper("''", &vec![], parser); + failed_parser_test_helper("asd", parser); - parser_test_helper( - ParserContext::new_with_str("'a'b", ()), - &vec!['a'], - |c, i| { - quote(char_parser('\''), char_parser('a'), char_parser('\'')) - .left(char_parser('b')) - .parse(c, i) - }, - ) + parser_test_helper("'a'b", &vec!['a'], |c, i| { + quote(char_parser('\''), char_parser('a'), char_parser('\'')) + .left(char_parser('b')) + .parse(c, i) + }) } #[test] fn separate_by1_test() { - parser_test_helper( - ParserContext::new_with_str("a,b,c", ()), - &vec!['a', 'b', 'c'], - |c, i| separate_by1(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i), - ); - parser_test_helper(ParserContext::new_with_str("a", ()), &vec!['a'], |c, i| { + parser_test_helper("a,b,c", &vec!['a', 'b', 'c'], |c, i| { + separate_by1(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i) + }); + parser_test_helper("a", &vec!['a'], |c, i| { + separate_by1(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i) + }); + parser_test_helper("bbc", &vec!['b'], |c, i| { separate_by1(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i) }); - parser_test_helper( - ParserContext::new_with_str("bbc", ()), - &vec!['b'], - |c, i| separate_by1(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i), - ); } #[test] fn separate_by_test() { - parser_test_helper( - ParserContext::new_with_str("1,2,3", ()), - &vec!['1', '2', '3'], - |c, i| separate_by(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i), - ); - parser_test_helper(ParserContext::new_with_str("1", ()), &vec!['1'], |c, i| { + parser_test_helper("1,2,3", &vec!['1', '2', '3'], |c, i| { separate_by(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i) }); - parser_test_helper(ParserContext::new_with_str("", ()), &vec![], |c, i| { + parser_test_helper("1", &vec!['1'], |c, i| { + separate_by(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i) + }); + parser_test_helper("", &vec![], |c, i| { + separate_by(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i) + }); + parser_test_helper("abc", &vec!['a'], |c, i| { separate_by(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i) }); - parser_test_helper( - ParserContext::new_with_str("abc", ()), - &vec!['a'], - |c, i| separate_by(satisfy(|c: &char| c.is_ascii()), char_parser(',')).parse(c, i), - ); } #[test] fn end_by1_test() { - parser_test_helper( - ParserContext::new_with_str("aab", ()), - &vec!['a', 'a'], - |c, i| end_by1(char_parser('a'), char_parser('b')).parse(c, i), - ); - parser_test_helper(ParserContext::new_with_str("ab", ()), &vec!['a'], |c, i| { + parser_test_helper("aab", &vec!['a', 'a'], |c, i| { end_by1(char_parser('a'), char_parser('b')).parse(c, i) }); - failed_parser_test_helper(ParserContext::new_with_str("b", ()), |c, i| { + parser_test_helper("ab", &vec!['a'], |c, i| { end_by1(char_parser('a'), char_parser('b')).parse(c, i) }); - failed_parser_test_helper(ParserContext::new_with_str("cd", ()), |c, i| { + failed_parser_test_helper("b", |c, i| { + end_by1(char_parser('a'), char_parser('b')).parse(c, i) + }); + failed_parser_test_helper("cd", |c, i| { end_by1(char_parser('a'), char_parser('b')).parse(c, i) }); } #[test] fn end_by_test() { - parser_test_helper( - ParserContext::new_with_str("aab", ()), - &vec!['a', 'a'], - |c, i| end_by(char_parser('a'), char_parser('b')).parse(c, i), - ); - parser_test_helper(ParserContext::new_with_str("ab", ()), &vec!['a'], |c, i| { + parser_test_helper("aab", &vec!['a', 'a'], |c, i| { end_by(char_parser('a'), char_parser('b')).parse(c, i) }); - parser_test_helper(ParserContext::new_with_str("b", ()), &vec![], |c, i| { + parser_test_helper("ab", &vec!['a'], |c, i| { end_by(char_parser('a'), char_parser('b')).parse(c, i) }); - failed_parser_test_helper(ParserContext::new_with_str("cd", ()), |c, i| { + parser_test_helper("b", &vec![], |c, i| { + end_by(char_parser('a'), char_parser('b')).parse(c, i) + }); + failed_parser_test_helper("cd", |c, i| { end_by(char_parser('a'), char_parser('b')).parse(c, i) }); } #[test] fn separate_or_end_by1_test() { - parser_test_helper( - ParserContext::new_with_str("1,2,3,", ()), - &vec!['1', '2', '3'], - |c, i| { - separate_or_end_by1(satisfy(|c: &char| c.is_numeric()), char_parser(',')) - .parse(c, i) - }, - ); - parser_test_helper(ParserContext::new_with_str("1,", ()), &vec!['1'], |c, i| { + parser_test_helper("1,2,3,", &vec!['1', '2', '3'], |c, i| { separate_or_end_by1(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) }); - parser_test_helper( - ParserContext::new_with_str("1,2,3", ()), - &vec!['1', '2', '3'], - |c, i| { - separate_or_end_by1(satisfy(|c: &char| c.is_numeric()), char_parser(',')) - .parse(c, i) - }, - ); - parser_test_helper(ParserContext::new_with_str("1", ()), &vec!['1'], |c, i| { + parser_test_helper("1,", &vec!['1'], |c, i| { separate_or_end_by1(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) }); - failed_parser_test_helper(ParserContext::new_with_str("abc", ()), |c, i| { + parser_test_helper("1,2,3", &vec!['1', '2', '3'], |c, i| { + separate_or_end_by1(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) + }); + parser_test_helper("1", &vec!['1'], |c, i| { + separate_or_end_by1(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) + }); + failed_parser_test_helper("abc", |c, i| { separate_or_end_by1(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) }); } #[test] fn separate_or_end_by_test() { - parser_test_helper( - ParserContext::new_with_str("1,2,3,", ()), - &vec!['1', '2', '3'], - |c, i| { - separate_or_end_by(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) - }, - ); - parser_test_helper(ParserContext::new_with_str("1,", ()), &vec!['1'], |c, i| { + parser_test_helper("1,2,3,", &vec!['1', '2', '3'], |c, i| { separate_or_end_by(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) }); - parser_test_helper( - ParserContext::new_with_str("1,2,3", ()), - &vec!['1', '2', '3'], - |c, i| { - separate_or_end_by(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) - }, - ); - parser_test_helper(ParserContext::new_with_str("1", ()), &vec!['1'], |c, i| { + parser_test_helper("1", &vec!['1'], |c, i| { separate_or_end_by(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) }); - parser_test_helper(ParserContext::new_with_str("abc", ()), &vec![], |c, i| { + parser_test_helper("1,2,3", &vec!['1', '2', '3'], |c, i| { + separate_or_end_by(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) + }); + parser_test_helper("1,", &vec!['1'], |c, i| { + separate_or_end_by(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) + }); + parser_test_helper("abc", &vec![], |c, i| { separate_or_end_by(satisfy(|c: &char| c.is_numeric()), char_parser(',')).parse(c, i) }); } diff --git a/src/combinators/tuple_parser.rs b/src/combinators/tuple_parser.rs index 0118342..c7d84db 100644 --- a/src/combinators/tuple_parser.rs +++ b/src/combinators/tuple_parser.rs @@ -9,7 +9,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T>; } @@ -25,7 +25,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { self.parser.parse(context, input) @@ -41,7 +41,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, (T1, T2)> { let (input, r1) = self.0.parse(context.clone(), input)?; @@ -61,7 +61,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, (T1, T2, T3)> { let (input, r1) = self.0.parse(context.clone(), input)?; @@ -83,7 +83,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, (T1, T2, T3, T4)> { let (input, r1) = self.0.parse(context.clone(), input)?; @@ -107,7 +107,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, (T1, T2, T3, T4, T5)> { let (input, r1) = self.0.parse(context.clone(), input)?; @@ -148,7 +148,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, (T1, T2, T3, T4, T5, T6)> { let (input, r1) = self.0.parse(context.clone(), input)?; @@ -194,7 +194,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, (T1, T2, T3, T4, T5, T6, T7)> { let (input, r1) = self.0.parse(context.clone(), input)?; @@ -244,7 +244,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, (T1, T2, T3, T4, T5, T6, T7, T8)> { let (input, r1) = self.0.parse(context.clone(), input)?; @@ -269,30 +269,22 @@ mod test { #[test] fn tuple_test() { - parser_test_helper( - ParserContext::new_with_str("ab", ()), - &('a', 'b'), - |c, i| tuple((char_parser('a'), char_parser('b'))).parse(c, i), - ); + parser_test_helper("ab", &('a', 'b'), |c, i| { + tuple((char_parser('a'), char_parser('b'))).parse(c, i) + }); - parser_test_helper( - ParserContext::new_with_str("abc", ()), - &('a', 'b', 'c'), - |c, i| tuple((char_parser('a'), char_parser('b'), char_parser('c'))).parse(c, i), - ); + parser_test_helper("abc", &('a', 'b', 'c'), |c, i| { + tuple((char_parser('a'), char_parser('b'), char_parser('c'))).parse(c, i) + }); - parser_test_helper( - ParserContext::new_with_str("abcd", ()), - &('a', 'b', 'c', 'd'), - |c, i| { - tuple(( - char_parser('a'), - char_parser('b'), - char_parser('c'), - char_parser('d'), - )) - .parse(c, i) - }, - ); + parser_test_helper("abcd", &('a', 'b', 'c', 'd'), |c, i| { + tuple(( + char_parser('a'), + char_parser('b'), + char_parser('c'), + char_parser('d'), + )) + .parse(c, i) + }); } } diff --git a/src/parser.rs b/src/parser.rs index 5adc5cf..8c418bf 100644 --- a/src/parser.rs +++ b/src/parser.rs @@ -63,36 +63,13 @@ impl<'a, TToken: Debug> Display for FailedParserResult<'a, TToken> { pub type ParserResult<'a, TToken, T> = Result<(&'a [TToken], T), FailedParserResult<'a, TToken>>; -pub struct ParserContext -where - TToken: Debug + Clone, -{ +pub struct ParserContext { pub context: TContext, - input_array: Vec, } -impl ParserContext -where - TToken: Debug + Clone, -{ - pub fn new(input: &[TToken], context: TContext) -> Rc> { - Rc::new(RefCell::new(Self { - input_array: input.iter().map(|x| x.clone()).collect(), - context, - })) - } - - pub fn input_slice(&self) -> &[TToken] { - self.input_array.as_slice() - } -} - -impl ParserContext { - pub fn new_with_str(input: &str, context: TContext) -> Rc> { - Rc::new(RefCell::new(Self { - input_array: input.chars().collect(), - context, - })) +impl ParserContext { + pub fn new(context: TContext) -> Rc> { + Rc::new(RefCell::new(Self { context })) } } @@ -103,7 +80,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T>; @@ -242,14 +219,11 @@ where impl<'a, TToken, T: 'a, TContext, F> Parser<'a, TToken, T, TContext> for F where TToken: Debug + Clone + 'a, - F: Fn( - Rc>>, - &'a [TToken], - ) -> ParserResult<'a, TToken, T>, + F: Fn(Rc>>, &'a [TToken]) -> ParserResult<'a, TToken, T>, { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { (*self)(context, input) @@ -263,7 +237,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { (**self).parse(context, input) @@ -339,32 +313,27 @@ where } #[cfg(test)] -pub fn parser_test_helper( - context: Rc>>, - excepted_node: &T, - test_parser: P, -) where +pub fn parser_test_helper(input: &str, excepted_node: &T, test_parser: P) +where T: PartialEq + Debug, - P: for<'a> Fn(Rc>>, &'a [char]) -> ParserResult<'a, char, T>, + P: for<'a> Fn(Rc>>, &'a [char]) -> ParserResult<'a, char, T>, { - let borrowed_context = context.borrow(); - let input = borrowed_context.input_slice(); - let (_, actual_result) = test_parser.parse(context.clone(), input).unwrap(); + let word: Vec = input.chars().collect(); + let (_, actual_result) = test_parser + .parse(ParserContext::new(()), word.as_slice()) + .unwrap(); assert_eq!(excepted_node, &actual_result); } #[cfg(test)] -pub fn failed_parser_test_helper( - context: Rc>>, - test_parser: P, -) where +pub fn failed_parser_test_helper(input: &str, test_parser: P) +where T: Debug, - P: for<'a> Fn(Rc>>, &'a [char]) -> ParserResult<'a, char, T>, + P: for<'a> Fn(Rc>>, &'a [char]) -> ParserResult<'a, char, T>, { - let borrowed_context = context.borrow(); - let input = borrowed_context.input_slice(); - let result = test_parser.parse(context.clone(), input); + let word: Vec = input.chars().collect(); + let result = test_parser.parse(ParserContext::new(()), word.as_slice()); assert!(result.is_err()); } diff --git a/src/parser/modified_parsers.rs b/src/parser/modified_parsers.rs index 2d36bde..3882768 100644 --- a/src/parser/modified_parsers.rs +++ b/src/parser/modified_parsers.rs @@ -19,7 +19,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T2> { self.parser @@ -44,7 +44,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T2> { let (input, middle) = self.parser.parse(context.clone(), input)?; @@ -68,7 +68,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T2> { self.parser @@ -92,7 +92,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, TResult> { let result = self.parser.parse(context, input); @@ -114,7 +114,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, &'a [TToken]> { let origin_input = input; @@ -147,7 +147,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, usize> { let origin_input = input; @@ -179,7 +179,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { let original_input = input; @@ -202,7 +202,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { match self.parser.parse(context, input) { @@ -227,7 +227,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, TResult> { match self.parser.parse(context, input) { @@ -251,7 +251,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, Option> { match self.parser.parse(context, input) { @@ -274,7 +274,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { match self.parser.parse(context, input) { @@ -303,7 +303,7 @@ where { fn parse( &self, - context: Rc>>, + context: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, TResult> { match self.parser.parse(context, input) { @@ -326,20 +326,16 @@ mod test { #[test] fn map_test() { - parser_test_helper( - ParserContext::new_with_str("hello, world!", ()), - &(), - |c, i| take(5).map(|_| ()).parse(c, i), - ) + parser_test_helper("hello, world!", &(), |c, i| take(5).map(|_| ()).parse(c, i)) } #[test] fn bind_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &'b', |c, i| { + parser_test_helper("abc", &'b', |c, i| { char_parser('a').bind(|_| char_parser('b')).parse(c, i) }); - parser_test_helper(ParserContext::new_with_str("abc", ()), &'c', |c, i| { + parser_test_helper("abc", &'c', |c, i| { char_parser('a') .bind(|_| char_parser('b')) .bind(|_| char_parser('c')) @@ -358,7 +354,7 @@ mod test { #[test] fn convert_test() { fn single_numer_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { let (input, result) = satisfy(|c: &char| c.is_numeric()).parse(context, input)?; @@ -369,19 +365,15 @@ mod test { } } - parser_test_helper( - ParserContext::new_with_str("9", ()), - &"9".to_owned(), - |c, i| single_numer_parser.convert().parse(c, i), - ); + parser_test_helper("9", &"9".to_owned(), |c, i| { + single_numer_parser.convert().parse(c, i) + }); - parser_test_helper( - ParserContext::new_with_str("1", ()), - &"1".to_owned(), - |c, i| single_numer_parser.convert().parse(c, i), - ); + parser_test_helper("1", &"1".to_owned(), |c, i| { + single_numer_parser.convert().parse(c, i) + }); - failed_parser_test_helper(ParserContext::new_with_str("abc", ()), |c, i| { + failed_parser_test_helper("abc", |c, i| { single_numer_parser.convert::().parse(c, i) }); } @@ -389,7 +381,7 @@ mod test { #[test] fn next_test() { fn parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { satisfy(|c: &char| c.is_numeric()) @@ -403,65 +395,43 @@ mod test { .parse(context, input) } - parser_test_helper( - ParserContext::new_with_str("9", ()), - &"9".to_owned(), - |c, i| parser.convert().parse(c, i), - ); + parser_test_helper("9", &"9".to_owned(), |c, i| parser.convert().parse(c, i)); - parser_test_helper( - ParserContext::new_with_str("1", ()), - &"1".to_owned(), - |c, i| parser.convert().parse(c, i), - ); + parser_test_helper("1", &"1".to_owned(), |c, i| parser.convert().parse(c, i)); - failed_parser_test_helper(ParserContext::new_with_str("abc", ()), |c, i| { - parser.convert::().parse(c, i) - }); + failed_parser_test_helper("abc", |c, i| parser.convert::().parse(c, i)); } #[test] fn literal_test() { - parser_test_helper( - ParserContext::new_with_str("abc", ()), - &vec!['a'], - |c, i| { - char_parser('a') - .literal() - .map(|x| x.iter().map(|x| x.clone()).collect()) - .parse(c, i) - }, - ); + parser_test_helper("abc", &vec!['a'], |c, i| { + char_parser('a') + .literal() + .map(|x| x.iter().map(|x| x.clone()).collect()) + .parse(c, i) + }); - parser_test_helper( - ParserContext::new_with_str("abc", ()), - &vec!['a', 'b'], - |c, i| { - char_parser('a') - .bind(|_| char_parser('b')) - .literal() - .map(|x| x.iter().map(|x| x.clone()).collect()) - .parse(c, i) - }, - ); + parser_test_helper("abc", &vec!['a', 'b'], |c, i| { + char_parser('a') + .bind(|_| char_parser('b')) + .literal() + .map(|x| x.iter().map(|x| x.clone()).collect()) + .parse(c, i) + }); - parser_test_helper( - ParserContext::new_with_str("abc", ()), - &vec!['a', 'b', 'c'], - |c, i| { - char_parser('a') - .bind(|_| char_parser('b')) - .bind(|_| char_parser('c')) - .literal() - .map(|x| x.iter().map(|x| x.clone()).collect()) - .parse(c, i) - }, - ); + parser_test_helper("abc", &vec!['a', 'b', 'c'], |c, i| { + char_parser('a') + .bind(|_| char_parser('b')) + .bind(|_| char_parser('c')) + .literal() + .map(|x| x.iter().map(|x| x.clone()).collect()) + .parse(c, i) + }); } #[test] fn look_ahead_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &'a', |c, i| { + parser_test_helper("abc", &'a', |c, i| { char_parser('a') .look_ahead() .bind(|_| char_parser('a')) @@ -471,48 +441,40 @@ mod test { #[test] fn try_parse_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &'a', |c, i| { + parser_test_helper("abc", &'a', |c, i| { char_parser('a').try_parse('a').parse(c, i) }); - parser_test_helper(ParserContext::new_with_str("bc", ()), &'a', |c, i| { + parser_test_helper("bc", &'a', |c, i| { char_parser('a').try_parse('a').parse(c, i) }); } #[test] fn reverse_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &(), |c, i| { - char_parser('b').reverse(()).parse(c, i) - }); + parser_test_helper("abc", &(), |c, i| char_parser('b').reverse(()).parse(c, i)); - failed_parser_test_helper(ParserContext::new_with_str("abc", ()), |c, i| { - char_parser('a').reverse(()).parse(c, i) - }); + failed_parser_test_helper("abc", |c, i| char_parser('a').reverse(()).parse(c, i)); } #[test] fn optional_test() { - parser_test_helper( - ParserContext::new_with_str("abc", ()), - &Some('a'), - |c, i| char_parser('a').optional().parse(c, i), - ); - parser_test_helper(ParserContext::new_with_str("bc", ()), &None, |c, i| { + parser_test_helper("abc", &Some('a'), |c, i| { char_parser('a').optional().parse(c, i) }); + parser_test_helper("bc", &None, |c, i| char_parser('a').optional().parse(c, i)); } #[test] fn run_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &'a', |c, i| { + parser_test_helper("abc", &'a', |c, i| { char_parser('a').run(|c| assert_eq!(c, &'a')).parse(c, i) }) } #[test] fn and_then_test() { - parser_test_helper(ParserContext::new_with_str("123", ()), &1, |c, i| { + parser_test_helper("123", &1, |c, i| { char_satisfy(char::is_ascii_digit) .and_then(|c| { let word = c.to_string(); diff --git a/src/parser/primitive_parsers.rs b/src/parser/primitive_parsers.rs index c071777..e07d12c 100644 --- a/src/parser/primitive_parsers.rs +++ b/src/parser/primitive_parsers.rs @@ -15,7 +15,7 @@ where { fn parse( &self, - _: Rc>>, + _: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { Ok((input, self.value.clone())) @@ -32,7 +32,7 @@ where { fn parse( &self, - _: Rc>>, + _: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { Err(FailedParserResult::new_with_str( @@ -53,7 +53,7 @@ where { fn parse( &self, - _: Rc>>, + _: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { Err(FailedParserResult::new(input, self.message.clone())) @@ -71,7 +71,7 @@ where { fn parse( &self, - _: Rc>>, + _: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, TToken> { if input.is_empty() { @@ -97,7 +97,7 @@ where { fn parse( &self, - _: Rc>>, + _: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, T> { if input.is_empty() { @@ -120,7 +120,7 @@ where { fn parse( &self, - _: Rc>>, + _: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, TToken> { if input.is_empty() { @@ -141,7 +141,7 @@ where { fn parse( &self, - _: Rc>>, + _: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, Vec> { if input.len() < self.count { @@ -171,7 +171,7 @@ where { fn parse( &self, - _: Rc>>, + _: Rc>>, input: &'a [TToken], ) -> ParserResult<'a, TToken, ()> { if input.len() < self.count { @@ -198,85 +198,63 @@ mod test { #[test] fn succeed_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &(), |c, i| { - succeed(()).parse(c, i) - }); + parser_test_helper("abc", &(), |c, i| succeed(()).parse(c, i)); } #[test] fn fail_test() { - failed_parser_test_helper(ParserContext::new_with_str("abc", ()), |c, i| { - fail::().parse(c, i) - }); + failed_parser_test_helper("abc", |c, i| fail::().parse(c, i)); } #[test] fn fail_with_message_test() { - failed_parser_test_helper(ParserContext::new_with_str("abc", ()), |c, i| { + failed_parser_test_helper("abc", |c, i| { fail_with_message::("Failed!").parse(c, i) }); } #[test] fn satisfy_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &'a', |c, i| { - satisfy(|x| x == &'a').parse(c, i) - }); + parser_test_helper("abc", &'a', |c, i| satisfy(|x| x == &'a').parse(c, i)); - failed_parser_test_helper(ParserContext::new_with_str("abc", ()), |c, i| { - satisfy(|x| x == &'b').parse(c, i) - }); + failed_parser_test_helper("abc", |c, i| satisfy(|x| x == &'b').parse(c, i)); } #[test] fn satified_map_test() { - parser_test_helper(ParserContext::new_with_str("123", ()), &1, |c, i| { + parser_test_helper("123", &1, |c, i| { satified_map(|x: &char| x.to_digit(10)).parse(c, i) }); - parser_test_helper(ParserContext::new_with_str("23", ()), &2, |c, i| { + parser_test_helper("23", &2, |c, i| { satified_map(|x: &char| x.to_digit(10)).parse(c, i) }); - parser_test_helper(ParserContext::new_with_str("3", ()), &3, |c, i| { + parser_test_helper("3", &3, |c, i| { satified_map(|x: &char| x.to_digit(10)).parse(c, i) }); } #[test] fn any_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &'a', |c, i| { - any().parse(c, i) - }); + parser_test_helper("abc", &'a', |c, i| any().parse(c, i)); - parser_test_helper(ParserContext::new_with_str("cde", ()), &'c', |c, i| { - any().parse(c, i) - }); + parser_test_helper("cde", &'c', |c, i| any().parse(c, i)); } #[test] fn take_test() { - parser_test_helper( - ParserContext::new_with_str("hello, world!", ()), - &("hello".chars().collect()), - |c, i| take(5).parse(c, i), - ); - - failed_parser_test_helper(ParserContext::new_with_str("abcd", ()), |c, i| { + parser_test_helper("hello, world!", &("hello".chars().collect()), |c, i| { take(5).parse(c, i) }); + + failed_parser_test_helper("abcd", |c, i| take(5).parse(c, i)); } #[test] fn skip_test() { - parser_test_helper( - ParserContext::new_with_str("hello, world!", ()), - &(), - |c, i| skip(5).parse(c, i), - ); + parser_test_helper("hello, world!", &(), |c, i| skip(5).parse(c, i)); - failed_parser_test_helper(ParserContext::new_with_str("abcd", ()), |c, i| { - skip(5).parse(c, i) - }); + failed_parser_test_helper("abcd", |c, i| skip(5).parse(c, i)); } } diff --git a/src/text.rs b/src/text.rs index 8d1ed7b..89512f8 100644 --- a/src/text.rs +++ b/src/text.rs @@ -36,31 +36,25 @@ mod test { #[test] fn char_parser_test() { - parser_test_helper( - ParserContext::new_with_str("abc", ()), - &'a', - |context, input| char_parser('a').parse(context, input), - ); + parser_test_helper("abc", &'a', |context, input| { + char_parser('a').parse(context, input) + }); - failed_parser_test_helper(ParserContext::new_with_str("bc", ()), |context, input| { + failed_parser_test_helper("bc", |context, input| { char_parser('a').parse(context, input) }); } #[test] fn string_parser_test() { - parser_test_helper( - ParserContext::new_with_str("Hello, world!", ()), - &"Hello".to_owned(), - |context, input| { - string_parser("Hello") - .map(|x| x.iter().collect()) - .parse(context, input) - }, - ); + parser_test_helper("Hello, world!", &"Hello".to_owned(), |context, input| { + string_parser("Hello") + .map(|x| x.iter().collect()) + .parse(context, input) + }); fn test_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { let (input, first) = string_parser("hello, ").parse(context.clone(), input)?; @@ -72,22 +66,14 @@ mod test { )) } - parser_test_helper( - ParserContext::new_with_str("hello, world!", ()), - &"hello, world!".to_owned(), - test_parser, - ); - parser_test_helper( - ParserContext::new_with_str("hello, world!", ()), - &(), - |context, input| test_parser.map(|_| ()).parse(context, input), - ) + parser_test_helper("hello, world!", &"hello, world!".to_owned(), test_parser); + parser_test_helper("hello, world!", &(), |context, input| { + test_parser.map(|_| ()).parse(context, input) + }) } #[test] fn char_satsify_test() { - parser_test_helper(ParserContext::new_with_str("abc", ()), &'a', |c, i| { - char_satisfy(char::is_ascii).parse(c, i) - }); + parser_test_helper("abc", &'a', |c, i| char_satisfy(char::is_ascii).parse(c, i)); } } diff --git a/src/text/string_parsers.rs b/src/text/string_parsers.rs index 9384ce0..8c3c156 100644 --- a/src/text/string_parsers.rs +++ b/src/text/string_parsers.rs @@ -9,7 +9,7 @@ pub struct StringParser { impl<'a, TContext> Parser<'a, char, &'a [char], TContext> for StringParser { fn parse( &self, - _: Rc>>, + _: Rc>>, input: &'a [char], ) -> ParserResult<'a, char, &'a [char]> { let length = self.str.chars().count(); diff --git a/tests/file_lexical_parser_tests.rs b/tests/file_lexical_parser_tests.rs index 67eff2c..474eebe 100644 --- a/tests/file_lexical_parser_tests.rs +++ b/tests/file_lexical_parser_tests.rs @@ -75,9 +75,9 @@ fn file_lexical_parser_test() -> anyhow::Result<()> { let (_, nom_tokens) = nom_lexical_parser(source_file.content.as_str()).or_else(|e| Err(e.to_owned()))?; - let context = ParserContext::new_with_str(source_file.content.as_str(), ()); - let borrowed_context = context.borrow(); - let (_, zero_tokens) = zero_lexical_parser(context.clone(), borrowed_context.input_slice()) + let context = ParserContext::new(()); + let word: Vec = source_file.content.chars().collect(); + let (_, zero_tokens) = zero_lexical_parser(context.clone(), word.as_slice()) .or_else(|e| Err(anyhow!("{}", e)))?; assert_eq!(nom_tokens.len(), zero_tokens.len()); diff --git a/tests/lexical_parser_tests.rs b/tests/lexical_parser_tests.rs index 70aee0e..f27cdd8 100644 --- a/tests/lexical_parser_tests.rs +++ b/tests/lexical_parser_tests.rs @@ -5,11 +5,11 @@ use zero_parser::parser::ParserContext; mod tokenizer; fn validate_tokens(input: &'static str, tokens: Vec) { - let context = ParserContext::new_with_str(input, ()); - let borrowed_context = context.borrow(); + let context = ParserContext::new(()); + let word: Vec = input.chars().collect(); let (_, actual_tokens) = - zero_lexical_parser(context.clone(), borrowed_context.input_slice()).unwrap(); + zero_lexical_parser(context.clone(),word.as_slice()).unwrap(); dbg!(&tokens, &actual_tokens); assert_eq!(tokens.len(), actual_tokens.len()); diff --git a/tests/tokenizer/mod.rs b/tests/tokenizer/mod.rs index 037cea1..3608409 100644 --- a/tests/tokenizer/mod.rs +++ b/tests/tokenizer/mod.rs @@ -109,7 +109,7 @@ pub fn nom_lexical_parser(mut input: &str) -> IResult<&str, Vec> { } pub fn zero_lexical_parser( - context: Rc>>, + context: Rc>>, mut input: &[char], ) -> ParserResult> { let mut array = vec![]; diff --git a/tests/tokenizer/zero_parsers.rs b/tests/tokenizer/zero_parsers.rs index 3481ebb..3684b96 100644 --- a/tests/tokenizer/zero_parsers.rs +++ b/tests/tokenizer/zero_parsers.rs @@ -9,7 +9,7 @@ use zero_parser::text::{char_parser, one_of, string_parser}; use zero_parser::{alternate, parser::satisfy}; pub fn keyword_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { tuple(( @@ -38,7 +38,7 @@ pub fn keyword_parser( } pub fn delimiter_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!( @@ -60,7 +60,7 @@ pub fn delimiter_parser( } pub fn operator_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!( @@ -89,7 +89,7 @@ pub fn operator_parser( } pub fn identifier_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { tuple(( @@ -105,7 +105,7 @@ pub fn identifier_parser( } pub fn decimal_integer_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { tuple(( @@ -126,7 +126,7 @@ pub fn decimal_integer_parser( } pub fn octal_integer_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { tuple(( @@ -147,7 +147,7 @@ pub fn octal_integer_parser( } pub fn hexadecimal_integer_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { tuple(( @@ -168,7 +168,7 @@ pub fn hexadecimal_integer_parser( } pub fn integer_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!( @@ -180,7 +180,7 @@ pub fn integer_parser( } pub fn float_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { tuple(( @@ -202,7 +202,7 @@ pub fn float_parser( } pub fn literal_string_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { quote(char_parser('"'), any(), char_parser('"')) @@ -218,7 +218,7 @@ pub fn literal_string_parser( } pub fn comments_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!( @@ -239,7 +239,7 @@ pub fn comments_parser( } pub fn junk_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!( @@ -250,7 +250,7 @@ pub fn junk_parser( } pub fn combine_parser( - context: Rc>>, + context: Rc>>, input: &[char], ) -> ParserResult { alternate!( diff --git a/tests/zero_parser_tests.rs b/tests/zero_parser_tests.rs index b86f431..6a577bb 100644 --- a/tests/zero_parser_tests.rs +++ b/tests/zero_parser_tests.rs @@ -1,3 +1,5 @@ +extern crate core; + use crate::tokenizer::zero_parsers::{ combine_parser, comments_parser, decimal_integer_parser, delimiter_parser, float_parser, hexadecimal_integer_parser, identifier_parser, integer_parser, keyword_parser, @@ -14,15 +16,14 @@ mod tokenizer; fn assert_lexical_parser( except: LexicalToken, parser: fn( - Rc>>, + Rc>>, &[char], ) -> ParserResult, input: &str, ) { - let context = ParserContext::new_with_str(input, ()); - let borrowed_context = context.borrow(); - let input = borrowed_context.input_slice(); - let (_, token) = parser(context.clone(), input).unwrap(); + let context = ParserContext::new(()); + let word: Vec = input.chars().collect(); + let (_, token) = parser(context.clone(), word.as_slice()).unwrap(); assert_eq!(except, token); } @@ -30,11 +31,11 @@ fn assert_lexical_parser( fn assert_parser(except: T, parser: F, input: &str) where T: PartialEq + Debug, - F: Fn(Rc>>, &[char]) -> ParserResult, + F: Fn(Rc>>, &[char]) -> ParserResult, { - let context = ParserContext::new_with_str(input, ()); - let borrowed_context = context.borrow(); - let (_, token) = parser(context.clone(), borrowed_context.input_slice()).unwrap(); + let context = ParserContext::new(()); + let word: Vec = input.chars().collect(); + let (_, token) = parser(context.clone(), word.as_slice()).unwrap(); assert_eq!(except, token); }