Refactoring code block extraction

Author: davidalber

Cargo.lock

@@ -45,6 +45,9 @@ getopts = "0.2"
 derive-new = "0.5"
 cargo_metadata = "0.4"
 
+[dev-dependencies]
+lazy_static = "1.0.0"
+
 [target.'cfg(unix)'.dependencies]
 libc = "0.2.11"
 

Cargo.toml

@@ -10,6 +10,8 @@
 
 #![feature(rustc_private)]
 
+#[macro_use]
+extern crate lazy_static;
 #[macro_use]
 extern crate log;
 extern crate regex;
@@ -19,7 +21,7 @@ extern crate term;
 use std::collections::HashMap;
 use std::fs;
 use std::io::{self, BufRead, BufReader, Read};
-use std::iter::Peekable;
+use std::iter::{Enumerate, Peekable};
 use std::path::{Path, PathBuf};
 use std::str::Chars;
 
@@ -504,18 +506,191 @@ fn string_eq_ignore_newline_repr_test() {
     assert!(!string_eq_ignore_newline_repr("a\r\nbcd", "a\nbcdefghijk"));
 }
 
-struct ConfigPair {
-    name: String,
-    value: String,
+enum ConfigurationSection {
+    CodeBlock((String, u32)),
+    ConfigName(String),
+    ConfigValue(String),
 }
 
-struct CodeBlock {
-    config: ConfigPair,
-    code_block: String,
-    code_block_start_line: u32,
+impl ConfigurationSection {
+    fn get_section<I: Iterator<Item = String>>(
+        file: &mut Enumerate<I>,
+    ) -> Option<ConfigurationSection> {
+        lazy_static! {
+            static ref CONFIG_NAME_REGEX: regex::Regex = regex::Regex::new(r"^## `([^`]+)`").expect("Failed creating configuration pattern");
+            static ref CONFIG_VALUE_REGEX: regex::Regex = regex::Regex::new(r#"^#### `"?([^`"]+)"?`"#).expect("Failed creating configuration value pattern");
+        }
+
+        loop {
+            match file.next() {
+                Some((i, line)) => {
+                    if line.starts_with("```rust") {
+                        // Get the lines of the code block.
+                        let lines: Vec<String> = file.map(|(_i, l)| l)
+                            .take_while(|l| !l.starts_with("```"))
+                            .collect();
+                        let block = format!("{}\n", lines.join("\n"));
+
+                        // +1 to translate to one-based indexing
+                        // +1 to get to first line of code (line after "```")
+                        let start_line = (i + 2) as u32;
+
+                        return Some(ConfigurationSection::CodeBlock((block, start_line)));
+                    } else if let Some(c) = CONFIG_NAME_REGEX.captures(&line) {
+                        return Some(ConfigurationSection::ConfigName(String::from(&c[1])));
+                    } else if let Some(c) = CONFIG_VALUE_REGEX.captures(&line) {
+                        return Some(ConfigurationSection::ConfigValue(String::from(&c[1])));
+                    }
+                }
+                None => return None, // reached the end of the file
+            }
+        }
+    }
+}
+
+// This struct stores the information about code blocks in the configurations
+// file, formats the code blocks, and prints formatting errors.
+struct ConfigCodeBlock {
+    config_name: Option<String>,
+    config_value: Option<String>,
+    code_block: Option<String>,
+    code_block_start: Option<u32>,
 }
 
-// Read Configurations.md and build a `Vec` of `CodeBlock` structs with one
+impl ConfigCodeBlock {
+    fn new() -> ConfigCodeBlock {
+        ConfigCodeBlock {
+            config_name: None,
+            config_value: None,
+            code_block: None,
+            code_block_start: None,
+        }
+    }
+
+    fn set_config_name(&mut self, name: Option<String>) {
+        self.config_name = name;
+        self.config_value = None;
+    }
+
+    fn set_config_value(&mut self, value: Option<String>) {
+        self.config_value = value;
+    }
+
+    fn set_code_block(&mut self, code_block: String, code_block_start: u32) {
+        self.code_block = Some(code_block);
+        self.code_block_start = Some(code_block_start);
+    }
+
+    fn get_block_config(&self) -> Config {
+        let mut config = Config::default();
+        config.override_value(
+            self.config_name.as_ref().unwrap(),
+            self.config_value.as_ref().unwrap(),
+        );
+        config
+    }
+
+    fn code_block_valid(&self) -> bool {
+        // We never expect to not have a code block.
+        assert!(self.code_block.is_some() && self.code_block_start.is_some());
+
+        if self.config_name.is_none() {
+            write_message(format!(
+                "configuration name not found for block beginning at line {}",
+                self.code_block_start.unwrap()
+            ));
+            return false;
+        }
+        if self.config_value.is_none() {
+            write_message(format!(
+                "configuration value not found for block beginning at line {}",
+                self.code_block_start.unwrap()
+            ));
+            return false;
+        }
+        true
+    }
+
+    fn has_parsing_errors(&self, error_summary: Summary) -> bool {
+        if error_summary.has_parsing_errors() {
+            write_message(format!(
+                "\u{261d}\u{1f3fd} Failed to format block starting at Line {} in Configurations.md",
+                self.code_block_start.unwrap()
+            ));
+            return true;
+        }
+
+        false
+    }
+
+    fn print_diff(&self, compare: Vec<Mismatch>) {
+        let mut mismatches = HashMap::new();
+        mismatches.insert(PathBuf::from("Configurations.md"), compare);
+        print_mismatches(mismatches, |line_num| {
+            format!(
+                "\nMismatch at Configurations.md:{}:",
+                line_num + self.code_block_start.unwrap() - 1
+            )
+        });
+    }
+
+    fn formatted_has_diff(&self, file_map: FileMap) -> bool {
+        let &(ref _file_name, ref text) = file_map.first().unwrap();
+        let compare = make_diff(self.code_block.as_ref().unwrap(), text, DIFF_CONTEXT_SIZE);
+        if !compare.is_empty() {
+            self.print_diff(compare);
+            return true;
+        }
+
+        false
+    }
+
+    // Return a bool indicating if formatting this code block is an idempotent
+    // operation. This function also triggers printing any formatting failure
+    // messages.
+    fn formatted_is_idempotent(&self) -> bool {
+        // Verify that we have all of the expected information.
+        if !self.code_block_valid() {
+            return false;
+        }
+
+        let input = Input::Text(self.code_block.as_ref().unwrap().to_owned());
+        let config = self.get_block_config();
+
+        let (error_summary, file_map, _report) =
+            format_input::<io::Stdout>(input, &config, None).unwrap();
+
+        !self.has_parsing_errors(error_summary) && !self.formatted_has_diff(file_map)
+    }
+
+    fn extract<I: Iterator<Item = String>>(
+        file: &mut Enumerate<I>,
+        prev: Option<&ConfigCodeBlock>,
+    ) -> Option<ConfigCodeBlock> {
+        let mut code_block = ConfigCodeBlock::new();
+        code_block.config_name = prev.map_or(None, |cb| cb.config_name.clone());
+
+        loop {
+            match ConfigurationSection::get_section(file) {
+                Some(ConfigurationSection::CodeBlock((block, start_line))) => {
+                    code_block.set_code_block(block, start_line);
+                    break;
+                }
+                Some(ConfigurationSection::ConfigName(name)) => {
+                    code_block.set_config_name(Some(name));
+                }
+                Some(ConfigurationSection::ConfigValue(value)) => {
+                    code_block.set_config_value(Some(value));
+                }
+                None => return None, // end of file was reached
+            }
+        }
+
+        Some(code_block)
+    }
+}
+
+// Read Configurations.md and build a `Vec` of `ConfigCodeBlock` structs with one
 // entry for each Rust code block found. Behavior:
 // - Rust code blocks are identifed by lines beginning with "```rust".
 // - One explicit configuration setting is supported per code block.
@@ -525,120 +700,35 @@ struct CodeBlock {
 //   "## `NAME`".
 // - Configuration values in Configurations.md must be in the form of
 //   "#### `VALUE`".
-fn get_code_blocks() -> Vec<CodeBlock> {
+fn get_code_blocks() -> Vec<ConfigCodeBlock> {
     let filename = "Configurations.md";
     let filebuf = BufReader::new(
         fs::File::open(filename).expect(&format!("Couldn't read file {}", filename)),
     );
 
-    let config_name_regex =
-        regex::Regex::new(r"^## `([^`]+)`").expect("Failed creating configuration pattern");
-    let config_value_regex = regex::Regex::new(r#"^#### `"?([^`"]+)"?`"#)
-        .expect("Failed creating configuration value pattern");
-
-    let mut code_blocks = Vec::new();
-    let mut extracting_block = false;
-    let mut code_block = Vec::new();
-    let mut code_block_start_line = 0;
-    let mut config_name: Option<String> = None;
-    let mut config_value: Option<String> = None;
-
-    for (i, line) in filebuf.lines().map(|l| l.unwrap()).enumerate() {
-        if line.starts_with("```") && extracting_block {
-            // We've reached the end of the code block.
-            extracting_block = false;
-
-            // Get a trailing newline in the code block.
-            code_block.push(String::new());
-
-            // Store the code block information.
-            code_blocks.push(CodeBlock {
-                config: ConfigPair {
-                    name: config_name.as_ref().unwrap().clone(),
-                    value: config_value.unwrap(),
-                },
-                code_block: code_block.join("\n"),
-                code_block_start_line,
-            });
-
-            config_value = None;
-            code_block.clear();
-        } else if line.starts_with("```rust") {
-            // We've reached the beginning of a Rust code block.
-            extracting_block = true;
-
-            // +1 to translate to one-based indexing
-            // +1 to get to first line of code (line after "```")
-            code_block_start_line = (i + 2) as u32;
-
-            // Assert that we have a configuration name and value.
-            assert!(
-                config_name.is_some(),
-                "configuration name not found for block beginning at line {}",
-                code_block_start_line
-            );
-            assert!(
-                config_value.is_some(),
-                "configuration value not found for block beginning at line {}",
-                code_block_start_line
-            );
-        } else if extracting_block {
-            code_block.push(line);
-        } else if let Some(c) = config_name_regex.captures(&line) {
-            config_name = Some(String::from(&c[1]));
-        } else if let Some(c) = config_value_regex.captures(&line) {
-            config_value = Some(String::from(&c[1]));
-        }
-    }
+    let mut code_blocks: Vec<ConfigCodeBlock> = Vec::new();
 
-    code_blocks
-}
-
-// Format the code blocks extracted in `get_code_blocks` and check for
-// failures.
-fn check_blocks_idempotency(blocks: &Vec<CodeBlock>) {
-    let mut failures = 0;
-
-    for block in blocks {
-        let input = Input::Text(block.code_block.clone());
-        let mut config = Config::default();
-        config.override_value(&block.config.name, &block.config.value);
-
-        let (error_summary, file_map, _report) =
-            format_input::<io::Stdout>(input, &config, None).unwrap();
-
-        if error_summary.has_parsing_errors() {
-            write_message(String::from(format!(
-                "\u{261d}\u{1f3fd} Failed to format block starting at Line {} in Configurations.md",
-                block.code_block_start_line
-            )));
-            failures += 1;
-        } else {
-            for &(ref _file_name, ref text) in &file_map {
-                let compare = make_diff(&block.code_block, text, DIFF_CONTEXT_SIZE);
-                if !compare.is_empty() {
-                    let mut mismatches = HashMap::new();
-                    mismatches.insert(PathBuf::from("Configurations.md"), compare);
-                    print_mismatches(mismatches, |line_num| {
-                        format!(
-                            "\nMismatch at Configurations.md:{}:",
-                            line_num + block.code_block_start_line - 1
-                        )
-                    });
-                    failures += 1;
-                }
-            }
+    let mut file_iter = filebuf.lines().map(|l| l.unwrap()).enumerate();
+    loop {
+        match ConfigCodeBlock::extract(&mut file_iter, code_blocks.last()) {
+            Some(cb) => code_blocks.push(cb),
+            None => break, // end of file was reached
         }
     }
 
-    // Display results.
-    println!("Ran {} configurations tests.", blocks.len());
-    assert_eq!(failures, 0, "{} configurations tests failed", failures);
+    code_blocks
 }
 
 #[test]
 #[ignore]
 fn configuration_snippet_tests() {
     let blocks = get_code_blocks();
-    check_blocks_idempotency(&blocks);
+    let failures = blocks
+        .iter()
+        .map(|b| b.formatted_is_idempotent())
+        .fold(0, |acc, r| acc + (!r as u32));
+
+    // Display results.
+    println!("Ran {} configurations tests.", blocks.len());
+    assert_eq!(failures, 0, "{} configurations tests failed", failures);
 }