Merge pull request #4 from paytonward6/nested_testing

Nested testing

Author: paytonward6

run.sh

@@ -1,4 +1,4 @@
 #!/usr/bin/env bash
 
-cargo run -- -i tests/notes.md -o tests/TeX/main.tex
-#cargo run -- -i tests/test.md -o tests/TeX/main.tex
+#cargo run -- -i tests/notes.md -o tests/TeX/main.tex
+cargo run -- -i tests/test.md -o tests/TeX/main.tex

src/transpiler.rs

@@ -23,11 +23,7 @@ pub fn run(file_str: &str, path: &PathBuf) {
 fn write(path: &PathBuf, parser: parser::Parser) -> Result<(), Error> {
     let mut file = fs::File::create(path)?;
     writeln!(file, "{}", generator::documentclass())?;
-    writeln!(
-        file,
-        "{}",
-        generator::packages(parser.contains_code_block)
-    )?;
+    writeln!(file, "{}", generator::packages(parser.contains_code_block))?;
     for line in parser.results.into_iter() {
         if let Some(line) = generator::generate_line(line) {
             writeln!(file, "{}", line)?;

src/transpiler/generator.rs

@@ -2,31 +2,42 @@ use crate::transpiler::{lexer, parser, re};
 
 pub fn generate_line(mut contents: parser::Contents) -> Option<String> {
     type Token = lexer::Token;
-    match contents.kind {
-        Token::FileStart => Some(format!("\\begin{{document}}\n {}", qol_customizations())),
-        Token::FileEnd => Some(format!("\\end{{document}}")),
-        Token::Blank => None,
-        _ => {
-            // Can unwrap since any other Token's line will not be None
-            // by Parser's design
-            let line = transpile_line(&mut contents.line).unwrap();
-            match contents.kind {
-                Token::Heading(level) => match level {
-                    1 => Some(format!("\\section{{{}}}\n", line)),
-                    2 => Some(format!("\\subsection{{{}}}\n", line)),
-                    3 => Some(format!("\\subsubsection{{{}}}\n", line)),
-                    _ => Some(format!("\\subsubsection{{{}}}\n", line)),
-                },
-                Token::UnorderedList | Token::OrderedList(_) => Some(listify(contents)),
-                Token::Text => Some(line),
-                Token::CodeBlock => Some(code_block(contents)),
-                Token::BlockQuote => Some(block_quote(&mut contents)),
-                _ => None
+    if let None = contents.line {
+        match contents.kind {
+            Token::FileStart => Some(format!("\\begin{{document}}\n {}", qol_customizations())),
+            Token::FileEnd => Some(format!("\\end{{document}}")),
+            Token::OrderedList(_) => Some(format!(
+                "{}\\end{{enumerate}}",
+                indent(contents.indent_level)
+            )),
+            Token::UnorderedList => {
+                Some(format!("{}\\end{{itemize}}", indent(contents.indent_level)))
             }
+            _ => None,
+        }
+    } else {
+        // Can unwrap since line is not None
+        let line = transpile_line(&mut contents.line).unwrap();
+        match contents.kind {
+            Token::Heading(level) => match level {
+                1 => Some(format!("\\section{{{}}}\n", line)),
+                2 => Some(format!("\\subsection{{{}}}\n", line)),
+                3 => Some(format!("\\subsubsection{{{}}}\n", line)),
+                _ => Some(format!("\\subsubsection{{{}}}\n", line)),
+            },
+            Token::UnorderedList | Token::OrderedList(_) => Some(listify(contents)),
+            Token::Text => Some(line),
+            Token::CodeBlock => Some(code_block(contents)),
+            Token::BlockQuote => Some(block_quote(&mut contents)),
+            _ => None,
         }
     }
 }
 
+pub fn indent(indent_level: usize) -> String {
+    return "    ".repeat(indent_level);
+}
+
 fn transpile_line(line: &mut Option<String>) -> Option<String> {
     if let Some(line) = line {
         *line = re::bold(line);
@@ -44,7 +55,7 @@ fn transpile_line(line: &mut Option<String>) -> Option<String> {
 fn block_quote(contents: &mut parser::Contents) -> String {
     // Can unwrap since any group item will not be None per Parser's
     // design
-    let line =  re::replace_block_quote(&contents.line.as_ref().unwrap());
+    let line = re::replace_block_quote(&contents.line.as_ref().unwrap());
     type Chronology = parser::Chronology;
     match contents.chron {
         Chronology::Start => {
@@ -63,15 +74,23 @@ fn listify(contents: parser::Contents) -> String {
     // design
     let line = contents.line.unwrap();
     if let Token::UnorderedList = contents.kind {
+        let indent = indent(contents.indent_level);
+        println!("{:?} => \"{}\"", line, indent);
         match contents.chron {
             Chronology::Start => {
-                format!("\\begin{{itemize}}\n    \\item {}", line)
+                format!(
+                    "{}\\begin{{itemize}}\n    {}\\item {}",
+                    indent, indent, line
+                )
             }
-            Chronology::Middle => format!("    \\item {}", line),
-            Chronology::End => format!("    \\item {}\n\\end{{itemize}}\n", line),
+            Chronology::Middle => format!("{}    \\item {}", indent, line),
+            Chronology::End => format!(
+                "{}    \\item {}\n{}\\end{{itemize}}\n",
+                indent, line, indent
+            ),
             Chronology::None => format!(
-                "\\begin{{enumerate}}\n    \\item {}\n\\end{{enumerate}}\n",
-                line
+                "{}\\begin{{itemize}}\n    {}\\item {}\n{}\\end{{itemize}}\n",
+                indent, indent, line, indent,
             ),
         }
     } else if let Token::OrderedList(num) = contents.kind {
@@ -105,13 +124,14 @@ fn code_block(content: parser::Contents) -> String {
     }
 }
 
-const PACKAGES: [&str; 6] = [
+const PACKAGES: [&str; 7] = [
     "geometry",
     "ulem",
     "listings",
     "hyperref",
     "xcolor",
     "indentfirst",
+    "enumitem",
 ];
 
 pub fn packages(contains_code_block: bool) -> String {

src/transpiler/lexer.rs

@@ -69,8 +69,9 @@ impl Lexer {
                 self.results
                     .push(Info::new(Token::UnorderedList, Some(line), indent_level));
             } else if line.is_empty() {
-                self.results
-                    .push(Info::new(Token::Blank, None, indent_level));
+                continue;
+                //self.results
+                //    .push(Info::new(Token::Blank, None, indent_level));
             } else if re::is_ordered_list(&line) {
                 let (number, line) = re::replace_ordered_list(&line);
                 self.results.push(Info::new(

src/transpiler/parser.rs

@@ -7,23 +7,25 @@ use crate::transpiler::re;
 
 #[derive(Debug)]
 pub struct Parser {
-    pub stack: Vec<lexer::Token>,
+    pub records: Vec<usize>,
     pub results: Vec<Contents>,
-    pub previous: Previous,
+    pub previous: Record,
     pub contains_code_block: bool,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Contents {
     pub line: Option<String>,
     pub kind: lexer::Token,
+    pub indent_level: usize,
     pub chron: Chronology,
 }
 
 #[derive(Debug)]
-pub struct Previous {
+pub struct Record {
     pub kind: lexer::Token,
     pub chron: Chronology,
+    pub indent_level: usize,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -34,73 +36,103 @@ pub enum Chronology {
     None,
 }
 
-impl From<&Contents> for Previous {
+impl From<&Contents> for Record {
     fn from(contents: &Contents) -> Self {
-        Previous {
+        Record {
             kind: contents.kind,
             chron: contents.chron,
+            indent_level: contents.indent_level,
         }
     }
 }
 
 impl Contents {
-    fn new(line: Option<String>, kind: lexer::Token, chron: Chronology) -> Self {
-        Contents { line, kind, chron }
+    fn new(info: lexer::Info, chron: Chronology) -> Self {
+        Contents {
+            line: info.line,
+            kind: info.token,
+            indent_level: info.indent_level,
+            chron,
+        }
+    }
+
+    fn new_with_line(line: Option<String>, info: lexer::Info, chron: Chronology) -> Self {
+        Contents {
+            line,
+            kind: info.token,
+            indent_level: info.indent_level,
+            chron,
+        }
     }
 }
 
 impl Parser {
     pub fn new() -> Parser {
-        let stack: Vec<lexer::Token> = Vec::new();
-        let previous = Previous {
+        let records: Vec<usize> = Vec::new();
+        let previous = Record {
             kind: Token::FileStart,
             chron: Chronology::None,
+            indent_level: 0,
         };
         let results: Vec<Contents> = Vec::new();
         let contains_code_block = false;
         Parser {
-            stack,
+            records,
             results,
             previous,
             contains_code_block,
         }
     }
 
     pub fn run(&mut self, lexer: lexer::Lexer) {
-        if lexer.results.iter().any(|item| item.token == Token::CodeBlock) {
+        if lexer
+            .results
+            .iter()
+            .any(|item| item.token == Token::CodeBlock)
+        {
             self.contains_code_block = true;
         }
 
-        let mut iter = lexer.results.into_iter().peekable();
+        let mut iter = lexer.results.into_iter().enumerate().peekable();
         while let Some(item) = iter.next() {
-            let current = item;
-            if current.token == Token::Blank {
-                continue
-            }
-            else if let Some(next) = iter.peek() {
+            let (number, current) = item;
+            if let Some((_, next)) = iter.peek() {
                 if lexer::Lexer::is_group(&current.token) {
                     if let Some(contents) = self.group_to_contents(current, next) {
-                        self.previous = Previous::from(&contents);
+                        // Keep track of the indices of the open groups in results
+                        if contents.chron == Chronology::Start {
+                            self.records.push(number);
+                        } else if contents.chron == Chronology::End {
+                            self.records.pop();
+                        }
+
+                        self.previous = Record::from(&contents);
                         self.results.push(contents);
                     }
                 } else {
-                    let contents = Contents::new(
-                        current.line,
-                        current.token,
-                        Chronology::None,
-                    );
-                    self.previous = Previous::from(&contents);
+                    // Close open blocks up to that point since interrupted
+                    for record in self.records.iter() {
+                        let contents = self.results.get(*record).unwrap();
+                        self.results.push(Contents {
+                            line: None,
+                            kind: contents.kind,
+                            chron: Chronology::End,
+                            indent_level: contents.indent_level,
+                        });
+                    }
+                    self.records.clear();
+                    let contents = Contents::new(current, Chronology::None);
+                    self.previous = Record::from(&contents);
                     self.results.push(contents);
                 }
-            } else {
-                self.results.push(Contents::new(
-                    None,
-                    current.token,
-                    Chronology::None,
-                ));
             }
-            println!("{:?}", self.previous);
         }
+        self.results.push(Contents {
+            line: None,
+            kind: Token::FileEnd,
+            indent_level: 0,
+            chron: Chronology::None,
+        });
     }
 
     fn group_to_contents(&self, current: lexer::Info, next: &lexer::Info) -> Option<Contents> {
@@ -111,28 +143,39 @@ impl Parser {
         if let Token::CodeBlock = current.token {
             if let Some(language) = re::replace_code_block(current.line.as_ref().map(|x| &**x)) {
                 let mut language = language;
-                if code_blocks::is_invalid_language(&language)
-                {
+                if code_blocks::is_invalid_language(&language) {
                     eprintln!(
                         "Language \"{}\" not found. Using default of \"python\".",
                         language
                     );
                     language = "python".to_string();
                 };
-                return Some(Contents::new(Some(language), current.token, Chronology::Start))
+                return Some(Contents::new_with_line(
+                    Some(language),
+                    current,
+                    Chronology::Start,
+                ));
             } else {
-                return Some(Contents::new(current.line, current.token, Chronology::End))
+                return Some(Contents::new(current, Chronology::End));
             }
+        } else if current.indent_level > self.previous.indent_level
+            && current.indent_level > next.indent_level
+        {
+            return Some(Contents::new(current, Chronology::None));
+        } else if current.indent_level > self.previous.indent_level {
+            return Some(Contents::new(current, Chronology::Start));
+        } else if current.indent_level > next.indent_level {
+            return Some(Contents::new(current, Chronology::End));
         } else if token_discrim != prev_discrim && token_discrim != next_discrim {
-            return Some(Contents::new(current.line, current.token, Chronology::None));
+            return Some(Contents::new(current, Chronology::None));
         } else if token_discrim != next_discrim {
-            return Some(Contents::new(current.line, current.token, Chronology::End));
+            return Some(Contents::new(current, Chronology::End));
         } else if token_discrim != prev_discrim
-            || (token_discrim == prev_discrim && self.previous.chron == Chronology::End)
+        //|| (token_discrim == prev_discrim && self.previous.chron == Chronology::End)
         {
-            return Some(Contents::new(current.line, current.token, Chronology::Start));
+            return Some(Contents::new(current, Chronology::Start));
         } else if token_discrim == prev_discrim && token_discrim == next_discrim {
-            return Some(Contents::new(current.line, current.token, Chronology::Middle));
+            return Some(Contents::new(current, Chronology::Middle));
         }
         None
     }