rename and fix end token advancing bug in collect_until

src/parser/subparser.rs

···
         C: concrete_parser::ContainerCp;
 }
 
-mod collect_till;
+mod collect_untill;
 mod collect_while;
 mod collect_if_sequence;
 pub use {
-    collect_till::CollectTill,
+    collect_untill::CollectUntill,
     collect_while::CollectWhile,
     collect_if_sequence::{CollectIfSeq, CollectIfExactSeq},
 };

src/parser/subparser/collect_till.rs src/parser/subparser/collect_untill.rs

···
 /// 
 /// Said concrete pattern here is provided by
 /// the generic parameter `Op`.
-pub struct CollectTill<Op: ConcreteParser>(Op);
-impl<Op> ConcreteSubparser<Op> for CollectTill<Op>
+pub struct CollectUntill<Op: ConcreteParser>(Op);
+impl<Op> ConcreteSubparser<Op> for CollectUntill<Op>
 where
     Op: ConcreteParser
 {
···
         let mut tokens: Tokens = Tokens::new_empty();
 
         loop {
-            if let Some(_token) = op.try_next_token(parser) {
+            if let Some(_token) = op.peek_for_token(parser) {
                 break;
             } else {
                 if let Some(token) = parser.next() {

tests/test_subparser.rs

···
 }
 
 #[test]
-fn test_collect_till_exact_match_subparser() {
+fn test_collect_untill_exact_match_subparser() {
     let mut parser = setup_space_seps_parser(
         "a b c d e f g h"
     );
···
         "a b c d"
     );
 
-    let mut subparser = CollectTill::<ExactMatch>::subparse(
+    let mut subparser = CollectUntill::<ExactMatch>::subparse(
         "e".to_string(), 
         &mut parser
     );
···
 }
 
 #[test]
-fn test_collect_till_is_newline() {
+fn test_collect_untill_is_newline() {
     let mut parser = setup_space_seps_parser(
         "a b\n c d e f g h"
     );
···
         "a b"
     );
 
-    let mut subparser = CollectTill::<IsNewline>::subparse(
+    let mut subparser = CollectUntill::<IsNewline>::subparse(
         (), 
         &mut parser
     );
···
     println!("{:#?}", parser);
 
     assert_parsers_same_till(parser, initial_parser, 4);
+}
+
+
+pub fn tokenize(src: String) -> Parser {
+    let del_param = DelimitersParam{
+        discard: DiscardDelimiters::new(
+            vec![
+                ' ',
+                '\n',
+                '\t'
+            ]
+        ),
+        keep: KeepDelimiters::new(
+            vec![
+                '(',
+                ')',
+                '~',
+                '&',
+                '|',
+                '=',
+                '>',
+                '<',
+                '*',
+                '#'
+            ]
+        )
+    };
+
+    Parser::from(src, del_param)
+}
+
+#[derive(Debug)]
+pub struct Parsers {
+    /// The parser for expressions
+    expr_parser: Parser,
+    /// The parser for initial configuration
+    states_parser: Parser,
+    /// The number of steps to take
+    steps: usize
+}
+impl Parsers {
+    pub fn new(parser: &mut Parser) -> Option<Self> {
+        let states = vec!["*", "#"];
+        let expr_parser = CollectUntill::<OrExactMatch>::subparse(states.clone(), parser);
+        let states_parser = CollectWhile::<OrExactMatch>::subparse(states, parser);
+        let steps: usize = match parser.next() {
+            Some(Token::Str(s)) => s.parse().ok(),
+            _ => None
+        }?;
+
+        Some(Parsers {
+            expr_parser,
+            states_parser,
+            steps
+        })
+    }
+}
+
+#[test]
+fn test_until_doesnt_eat_ending() {
+    let src = "(l | r) & (~l | ~r) **# 16".to_string();
+
+    let mut flat_parser = tokenize(src);
+
+    let known_parser_a = tokenize("**#".to_string());
+
+    let parsers = Parsers::new(&mut flat_parser).unwrap();
+
+    assert_parsers_same_till(known_parser_a, parsers.states_parser, 3);
 }