FIX: multiple styles on one line breaking rendering

Cargo.lock

···
 
 [[package]]
 name = "tsk"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "clap",
  "clap_complete",

Cargo.toml

···
 [package]
 name = "tsk"
-version = "0.2.1"
+version = "0.2.2"
 edition = "2021"
 publish = true
 

src/main.rs

···
         /// Shows raw file attributes for the file
         #[arg(short = 'x', default_value_t = false)]
         show_attrs: bool,
+
+        #[arg(short = 'R', default_value_t = false)]
+        raw: bool,
         /// The [TSK-]ID of the task to display
         #[command(flatten)]
         task_id: TaskId,
···
         Commands::Swap => command_swap(dir),
         Commands::Show {
             task_id,
+            raw,
             show_attrs,
-        } => command_show(dir, task_id, show_attrs),
+        } => command_show(dir, task_id, show_attrs, raw),
         Commands::Follow {
             task_id,
             link_index,
···
     Workspace::from_path(dir)?.deprioritize(task_id.into())
 }
 
-fn command_show(dir: PathBuf, task_id: TaskId, show_attrs: bool) -> Result<()> {
+fn command_show(dir: PathBuf, task_id: TaskId, show_attrs: bool, raw: bool) -> Result<()> {
     let task = Workspace::from_path(dir)?.task(task_id.into())?;
     // YAML front-matter style. YAML is gross, but it's what everyone uses!
     if show_attrs && !task.attributes.is_empty() {
···
         }
         println!("---");
     }
-    if let Some(styled_task) = task::parse(&task.to_string()) {
-        writeln!(io::stdout(), "{}", styled_task.content)?;
-    } else {
-        println!("{task}");
+    match task::parse(&task.to_string()) {
+        Some(styled_task) if !raw => {
+            writeln!(io::stdout(), "{}", styled_task.content)?;
+        }
+        _ => {
+            println!("{task}");
+        }
     }
     Ok(())
 }
···
                 if edit {
                     command_edit(dir, taskid)
                 } else {
-                    command_show(dir, taskid, false)
+                    command_show(dir, taskid, false, false)
                 }
             }
         }

src/task.rs

···
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 enum ParserState {
     // Started by ` =`, terminated by `=
-    Highlight(usize),
+    Highlight(usize, usize),
     // Started by ` [`, terminated by `](`
-    Linktext(usize),
+    Linktext(usize, usize),
     // Started by `](`, terminated by `) `, must immedately follow a Linktext
-    Link(usize),
-    RawLink(usize),
+    Link(usize, usize),
+    RawLink(usize, usize),
     // Started by ` [[`, terminated by `]] `
-    InternalLink(usize),
+    InternalLink(usize, usize),
     // Started by ` *`, terminated by `* `
-    Italics(usize),
+    Italics(usize, usize),
     // Started by ` !`, termianted by `!`
-    Bold(usize),
+    Bold(usize, usize),
     // Started by ` _`, terminated by `_ `
-    Underline(usize),
+    Underline(usize, usize),
     // Started by ` -`, terminated by `- `
-    Strikethrough(usize),
+    Strikethrough(usize, usize),
 
     // TODO: implement these.
     // Started by `_ `, terminated by `_`
···
     // `\n` and followed by a `\n`
     BlockEnd(usize),
     // Started by ` ``, terminated by `` ` or `\n`
-    InlineBlock(usize),
+    InlineBlock(usize, usize),
     // Started by `^\w+>`, terminated by `\n`
     Blockquote(usize),
 }
···
         let state_last = state.last().cloned();
         match stream.next() {
             // there will always be an op code in the stack
-            Some((_, c)) => {
+            Some((char_pos, c)) => {
                 out.push(c);
                 let end = out.len() - 1;
                 match (last, c, state_last) {
                     ('[', '[', _) => {
-                        state.push(InternalLink(end));
+                        state.push(InternalLink(end, char_pos));
                     }
-                    (']', ']', Some(InternalLink(il))) => {
+                    (']', ']', Some(InternalLink(il, s_pos))) => {
                         state.pop();
-                        let contents = out.get(il + 1..out.len() - 2)?;
+                        let contents = s.get(s_pos + 1..char_pos - 1)?;
                         if let Ok(id) = Id::from_str(&contents) {
                             let linktext = format!(
                                 "{}{}",
···
                         }
                     }
                     (' ' | '\r' | '\n', '[', _) => {
-                        state.push(Linktext(end));
+                        state.push(Linktext(end, char_pos));
                     }
-                    (']', '(', Some(Linktext(_))) => {
-                        state.push(Link(end));
+                    (']', '(', Some(Linktext(_, _))) => {
+                        state.push(Link(end, char_pos));
                     }
-                    (')', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Link(_))) => {
-                        let linkpos = if let Link(lp) = state.pop().unwrap() {
+                    (')', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Link(_, _))) => {
+                        // TODO: this needs to be updated to use `s` instead of `out` for position
+                        // parsing
+                        let linkpos = if let Link(lp, _) = state.pop().unwrap() {
                             lp
                         } else {
                             // remove the linktext state, it is always present.
                             state.pop();
                             continue;
                         };
-                        let linktextpos = if let Linktext(lt) = state.pop().unwrap() {
+                        let linktextpos = if let Linktext(lt, _) = state.pop().unwrap() {
                             lt
                         } else {
                             continue;
···
                             out.replace_range(linktextpos..end, &linktext);
                         }
                     }
-                    ('>', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(RawLink(hl))) => {
+                    ('>', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(RawLink(hl, s_pos)))
+                        if s_pos != char_pos - 1 =>
+                    {
                         state.pop();
-                        let link = out.get(hl + 1..out.len() - 2)?;
+                        let link = s.get(s_pos + 1..char_pos - 1)?;
                         if let Ok(url) = Url::parse(link) {
                             let linktext =
                                 format!("{}{}", link.blue(), super_num(links.len() + 1).purple());
···
                         }
                     }
                     (' ' | '\r' | '\n', '<', _) => {
-                        state.push(RawLink(end));
+                        state.push(RawLink(end, char_pos));
                     }
-                    ('=', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Highlight(hl))) => {
+                    ('=', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Highlight(hl, s_pos)))
+                        if s_pos != char_pos - 1 =>
+                    {
                         state.pop();
                         out.replace_range(
                             hl..end,
-                            &out.get(hl + 1..out.len() - 2)?.reversed().to_string(),
+                            &s.get(s_pos + 1..char_pos - 1)?.reversed().to_string(),
                         );
                     }
                     (' ' | '\r' | '\n', '=', _) => {
-                        state.push(Highlight(end));
+                        state.push(Highlight(end, char_pos));
                     }
                     (' ' | '\r' | '\n', '*', _) => {
-                        state.push(Italics(end));
+                        state.push(Italics(end, char_pos));
                     }
-                    ('*', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Italics(il))) => {
+                    ('*', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Italics(il, s_pos)))
+                        if s_pos != char_pos - 1 =>
+                    {
                         state.pop();
                         out.replace_range(
                             il..end,
-                            &out.get(il + 1..out.len() - 2)?.italic().to_string(),
+                            &s.get(s_pos + 1..char_pos - 1)?.italic().to_string(),
                         );
                     }
                     (' ' | '\r' | '\n', '!', _) => {
-                        state.push(Bold(end));
+                        state.push(Bold(end, char_pos));
                     }
-                    ('!', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Bold(il))) => {
+                    ('!', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Bold(il, s_pos)))
+                        if s_pos != char_pos - 1 =>
+                    {
                         state.pop();
-                        out.replace_range(il..end, &out.get(il + 1..end - 1)?.bold().to_string());
+                        out.replace_range(
+                            il..end,
+                            &s.get(s_pos + 1..char_pos - 1)?.bold().to_string(),
+                        );
                     }
                     (' ' | '\r' | '\n', '_', _) => {
-                        state.push(Underline(end));
+                        state.push(Underline(end, char_pos));
                     }
-                    ('_', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Underline(il))) => {
+                    ('_', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Underline(il, s_pos)))
+                        if s_pos != char_pos - 1 =>
+                    {
                         state.pop();
                         out.replace_range(
                             il..end,
-                            &out.get(il + 1..end - 1)?.underline().to_string(),
+                            &s.get(s_pos + 1..char_pos - 1)?.underline().to_string(),
                         );
                     }
                     (' ' | '\r' | '\n', '~', _) => {
-                        state.push(Strikethrough(end));
+                        state.push(Strikethrough(end, char_pos));
                     }
-                    ('~', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Strikethrough(il))) => {
+                    ('~', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(Strikethrough(il, s_pos)))
+                        if s_pos != char_pos - 1 =>
+                    {
                         state.pop();
                         out.replace_range(
                             il..end,
-                            &out.get(il + 1..end - 1)?.strikethrough().to_string(),
+                            &s.get(s_pos + 1..char_pos - 1)?.strikethrough().to_string(),
                         );
                     }
-                    ('`', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(InlineBlock(hl))) => {
-                        state.pop();
+                    ('`', ' ' | '\n' | '\r' | '.' | '!' | '?', Some(InlineBlock(hl, s_pos)))
+                        if s_pos != char_pos - 1 =>
+                    {
                         out.replace_range(
                             hl..end,
-                            &out.get(hl + 1..out.len() - 1)?.green().to_string(),
+                            &s.get(s_pos + 1..char_pos - 1)?.green().to_string(),
                         );
                     }
-                    (' ' | '\r' | '\n', '`', _) => {
-                        state.push(InlineBlock(end));
+                    (' ' | '\n' | '\r' | '.' | '!' | '?', '`', _) => {
+                        state.push(InlineBlock(end, char_pos));
                     }
                     _ => (),
                 }