Fix sequence ending in order to fix standalone task not being detected

src/construct/task.rs

@@ -6,7 +6,7 @@ use crate::tokenizer::Tokenizer;
 pub fn start(tokenizer: &mut Tokenizer) -> State {
     if matches!(tokenizer.current, Some(b':'))
     {
-        log::debug!("---start--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
+        // log::debug!("---start--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
         tokenizer.tokenize_state.marker = tokenizer.current.unwrap();
         tokenizer.enter(Name::Task);
         tokenizer.enter(Name::TaskFence);
@@ -18,7 +18,7 @@ pub fn start(tokenizer: &mut Tokenizer) -> State {
 }
 
 pub fn open_sequence(tokenizer: &mut Tokenizer) -> State {
-    log::debug!("---open_sequence--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
+    // log::debug!("---open_sequence--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
     if tokenizer.current == Some(tokenizer.tokenize_state.marker) {
         tokenizer.tokenize_state.size += 1;
         tokenizer.consume();
@@ -42,7 +42,7 @@ pub fn open_sequence(tokenizer: &mut Tokenizer) -> State {
 }
 
 pub fn content_start(tokenizer: &mut Tokenizer) -> State {
-    log::debug!("---content_start--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
+    // log::debug!("---content_start--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
     match tokenizer.current {
         None | Some(b':') => {
           State::Retry(StateName::TaskContentEnd)
@@ -55,7 +55,7 @@ pub fn content_start(tokenizer: &mut Tokenizer) -> State {
 }
 
 pub fn content_inside(tokenizer: &mut Tokenizer) -> State {
-    log::debug!("---content_inside--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
+    // log::debug!("---content_inside--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
     match tokenizer.current {
         None => {
             tokenizer.tokenize_state.marker = 0;
@@ -73,14 +73,17 @@ pub fn content_inside(tokenizer: &mut Tokenizer) -> State {
 }
 
 pub fn content_end(tokenizer: &mut Tokenizer) -> State {
-    log::debug!("---content_end--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
+    // log::debug!("---content_end--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
     match tokenizer.current {
         None => {
             tokenizer.tokenize_state.marker = 0;
             State::Nok
         }
         Some(b':') => {
-          State::Retry(StateName::TaskCloseStart)
+          tokenizer.enter(Name::TaskFence);
+          tokenizer.enter(Name::TaskSequence);
+          tokenizer.consume();
+          State::Next(StateName::TaskClose)
         }
         Some(_) => {
           unreachable!("expected eof/eol")
@@ -88,44 +91,10 @@ pub fn content_end(tokenizer: &mut Tokenizer) -> State {
     }
 }
 
-pub fn close_start(tokenizer: &mut Tokenizer) -> State {
-    log::debug!("---close_start--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
-    if tokenizer.current == Some(tokenizer.tokenize_state.marker) {
-        tokenizer.enter(Name::TaskFence);
-        tokenizer.enter(Name::TaskSequence);
-        State::Retry(StateName::TaskCloseSequence)
-    } else {
-        State::Nok
-    }
-}
-
-pub fn close_sequence(tokenizer: &mut Tokenizer) -> State {
-    log::debug!("---close_sequence--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
-    if tokenizer.current == Some(tokenizer.tokenize_state.marker) {
-        tokenizer.tokenize_state.size += 1;
-        tokenizer.consume();
-        State::Next(StateName::TaskCloseSequence)
-    } else if tokenizer.tokenize_state.size == 1 {
-      log::debug!("else if");
-      tokenizer.tokenize_state.size = 0;
-      tokenizer.exit(Name::TaskSequence);
-
-      State::Retry(StateName::TaskCloseAfter)
-    } else {
-        log::debug!("else");
-        tokenizer.tokenize_state.size = 0;
-        State::Nok
-    }
-}
-
-pub fn close_after(tokenizer: &mut Tokenizer) -> State {
-    log::debug!("---close_after--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
-    match tokenizer.current {
-        None => State::Nok,
-        _ => {
-            tokenizer.exit(Name::TaskFence);
-            tokenizer.exit(Name::Task);
-            State::Ok
-        }
-    }
+pub fn close(tokenizer: &mut Tokenizer) -> State {
+    // log::debug!("---close_start--- {:?} {:?}", tokenizer.tokenize_state.size, tokenizer.current.unwrap() as char);
+    tokenizer.exit(Name::TaskSequence);
+    tokenizer.exit(Name::TaskFence);
+    tokenizer.exit(Name::Task);
+    State::Ok
 }

src/state.rs

@@ -469,14 +469,10 @@ pub enum Name {
 
     TaskStart,
     TaskOpenSequence,
-    TaskCloseSequence,
-    // TaskOpenAfter,
     TaskContentStart,
     TaskContentInside,
     TaskContentEnd,
-    TaskCloseStart,
-    TaskCloseAfter,
-    // TaskAfter,
+    TaskClose,
 }
 
 #[allow(clippy::too_many_lines)]
@@ -485,14 +481,10 @@ pub fn call(tokenizer: &mut Tokenizer, name: Name) -> State {
     let func = match name {
         Name::TaskStart => construct::task::start,
         Name::TaskOpenSequence => construct::task::open_sequence,
-        // Name::TaskOpenAfter => construct::task::open_after,
-        // Name::TaskAfter => construct::task::after,
         Name::TaskContentStart => construct::task::content_start,
         Name::TaskContentInside => construct::task::content_inside,
         Name::TaskContentEnd => construct::task::content_end,
-        Name::TaskCloseStart => construct::task::close_start,
-        Name::TaskCloseSequence => construct::task::close_sequence,
-        Name::TaskCloseAfter => construct::task::close_after,
+        Name::TaskClose => construct::task::close,
 
         Name::AttentionStart => construct::attention::start,
         Name::AttentionInside => construct::attention::inside,