Import files from 'compiler' project

Author: Dylan McKay

.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "lit"
+version = "0.1.0"
+authors = ["Dylan McKay <dylanmckay34@gmail.com>"]
+
+[dependencies]
+walkdir = "0.1"
+term = "*"
+regex = "0.1.71"
+

src/find.rs

@@ -0,0 +1,57 @@
+use std;
+use walkdir::WalkDir;
+
+/// Recursively finds tests for the given paths.
+pub fn in_paths<'a,P>(paths: P) -> Result<Vec<String>,String>
+    where P: IntoIterator<Item=&'a str> {
+    let mut tests = Vec::new();
+
+    for path in paths.into_iter() {
+        let path_tests = try!(in_path(path));
+        tests.extend(path_tests.into_iter());
+    }
+
+    Ok(tests)
+}
+
+pub fn in_path(path: &str)
+    -> Result<Vec<String>,String> {
+    let metadata = match std::fs::metadata(path) {
+        Ok(meta) => meta,
+        Err(e) => return Err(format!("failed to open '{}': {}",
+                                     path, e)),
+    };
+
+    if metadata.is_dir() {
+        find_tests_in_dir(path)
+    } else {
+        Ok(vec![path.to_owned()])
+    }
+}
+
+fn find_tests_in_dir(path: &str) -> Result<Vec<String>,String> {
+    let tests = try!(find_files_in_dir(path)).into_iter()
+                     .filter(|f| f.ends_with(".ir"))
+                     .collect();
+    Ok(tests)
+}
+
+fn find_files_in_dir(path: &str) -> Result<Vec<String>,String> {
+    let mut dir_tests = Vec::new();
+
+    for entry in WalkDir::new(path) {
+        let entry = entry.unwrap();
+
+        // don't go into an infinite loop
+        if entry.path().to_str().unwrap() == path {
+            continue;
+        }
+
+        if entry.metadata().unwrap().is_file() {
+            dir_tests.push(entry.path().to_str().unwrap().to_owned());
+        }
+    }
+
+    Ok(dir_tests)
+}
+

src/instance.rs

@@ -0,0 +1,194 @@
+use {Context, Test, Directive, Command, TestResultKind};
+use std::process;
+use std::collections::HashMap;
+use regex::Regex;
+
+use tool;
+use std;
+
+pub struct Instance
+{
+    pub invocation: tool::Invocation,
+}
+
+impl Instance
+{
+    pub fn new(invocation: tool::Invocation) -> Self {
+        Instance { invocation: invocation }
+    }
+
+    pub fn run(self, test: &Test, context: &Context) -> TestResultKind {
+        let exe_path = context.executable_path(&self.invocation.executable);
+        let mut cmd = self.build_command(test, context);
+
+        let output = match cmd.output() {
+            Ok(o) => o,
+            Err(e) => match e.kind() {
+                std::io::ErrorKind::NotFound => {
+                    return TestResultKind::Fail(
+                        format!("executable not found: {}",
+                                exe_path), "".to_owned());
+                },
+                _ => {
+                    return TestResultKind::Fail(
+                        format!("could not execute: '{}', {}",
+                                exe_path, e), "".to_owned());
+                },
+            },
+        };
+
+        if !output.status.success() {
+            let stderr = String::from_utf8(output.stderr).unwrap();
+
+            return TestResultKind::Fail(format!(
+                "{} exited with code {}", exe_path,
+                output.status.code().unwrap()),
+                stderr
+            );
+        }
+
+        let stdout = String::from_utf8(output.stdout).unwrap();
+
+        let stdout_lines: Vec<_> = stdout.lines().map(|l| l.trim().to_owned()).collect();
+        let stdout: String = stdout_lines.join("\n");
+
+        Checker::new(stdout).run(&test)
+    }
+
+    pub fn build_command(&self, test: &Test, context: &Context) -> process::Command {
+        let exe_path = context.executable_path(&self.invocation.executable);
+        let mut cmd = process::Command::new(&exe_path);
+
+        for arg in self.invocation.arguments.iter() {
+            let arg_str = arg.resolve(test);
+            cmd.arg(arg_str);
+        }
+
+        cmd
+    }
+}
+
+struct Checker
+{
+    stdout: String,
+    variables: HashMap<String, String>,
+}
+
+impl Checker
+{
+    fn new(stdout: String) -> Self {
+        Checker {
+            stdout: stdout,
+            variables: HashMap::new(),
+        }
+    }
+
+    fn run(&mut self, test: &Test) -> TestResultKind {
+        for directive in test.directives.iter() {
+            match directive.command {
+                Command::Run(..) => (),
+                Command::Check(ref regex) => {
+                    let regex = self.resolve_variables(regex.clone());
+
+                    let beginning_line = match self.stdout.lines().next() {
+                        Some(l) => l.to_owned(),
+                        None => return TestResultKind::fail(
+                            format_check_error(test, directive, "reached end of file", "")
+                        ),
+                    };
+
+                    let mut matched_line = None;
+                    let tmp: Vec<_> = self.stdout.lines().map(|l| l.to_owned()).skip_while(|line| {
+                        if regex.is_match(&line) {
+                            matched_line = Some(line.to_owned());
+                            false // stop processing lines
+                        } else {
+                            true
+                        }
+                    }).skip(1).collect();
+                    self.stdout = tmp.join("\n");
+
+                    if let Some(matched_line) = matched_line {
+                        self.process_captures(&regex, &matched_line);
+                    } else {
+                        return TestResultKind::fail(
+                            format_check_error(test,
+                                               directive,
+                                               &format!("could not find match: '{}'", regex),
+                                               &beginning_line,
+                            )
+                        );
+                    }
+                },
+                Command::CheckNext(ref regex) => {
+                    let regex = self.resolve_variables(regex.clone());
+
+                    if let Some(ref next_line) = self.stdout.lines().next().map(|l| l.to_owned()) {
+                        if regex.is_match(&next_line) {
+                            let lines: Vec<_> = self.stdout.lines().skip(1).map(|l| l.to_owned()).collect();
+                            self.stdout = lines.join("\n");
+
+                            self.process_captures(&regex, &next_line);
+                        } else {
+                            return TestResultKind::fail(
+                                format_check_error(test,
+                                                   directive,
+                                                   &format!("could not find match: '{}'", regex),
+                                                   &next_line)
+                                );
+                        }
+                    } else {
+                        return TestResultKind::fail(format!("check-next reached the end of file"));
+                    }
+                },
+            }
+        }
+
+        TestResultKind::Pass
+    }
+
+    pub fn process_captures(&mut self, regex: &Regex, line: &str) {
+        // We shouldn't be calling this function if it didn't match.
+        debug_assert_eq!(regex.is_match(line), true);
+        let captures = if let Some(captures) = regex.captures(line) {
+            captures
+        } else {
+            return;
+        };
+
+        for capture_name in regex.capture_names() {
+            // we only care about named captures.
+            if let Some(name) = capture_name {
+                let captured_value = captures.name(name).unwrap();
+
+                self.variables.insert(name.to_owned(), captured_value.to_owned());
+            }
+        }
+    }
+
+    pub fn resolve_variables(&self, mut regex: Regex) -> Regex {
+        for (name, value) in self.variables.iter() {
+            let subst_expr = format!("[[{}]]", name);
+            let regex_str = format!("{}", regex);
+            let regex_str = regex_str.replace(&subst_expr, value);
+            regex = Regex::new(&regex_str).unwrap();
+        }
+
+        regex
+    }
+}
+
+fn format_check_error(test: &Test,
+                      directive: &Directive,
+                      msg: &str,
+                      next_line: &str) -> String {
+    self::format_error(test, directive, msg, next_line)
+}
+
+fn format_error(test: &Test,
+                directive: &Directive,
+                msg: &str,
+                next_line: &str) -> String {
+    format!("{}:{}: {}\nnext line: '{}'", test.path, directive.line, msg, next_line)
+}
+

src/lib.rs

@@ -0,0 +1,13 @@
+pub use self::tool::*;
+pub use self::test::*;
+pub use self::instance::Instance;
+
+pub mod tool;
+pub mod test;
+pub mod find;
+pub mod print;
+pub mod instance;
+
+extern crate walkdir;
+extern crate term;
+extern crate regex;

src/print.rs

@@ -0,0 +1,79 @@
+use {TestResult,TestResultKind};
+
+use std;
+use term;
+
+pub fn result(result: &TestResult) {
+    match result.kind {
+        TestResultKind::Pass => {
+            success(format!("PASS :: {}", result.path));
+        },
+        TestResultKind::Skip => {
+            line();
+            warning(format!(
+                "SKIP :: {} (test does not contain any directives)",
+                     result.path));
+            line();
+        },
+        TestResultKind::Fail(ref msg, ref desc) => {
+            line();
+
+            failure(format!("FAIL :: {}", result.path));
+            text(msg.clone());
+
+            // Only print stderr if there was output
+            if !desc.is_empty() {
+                line();
+                text("stderr:");
+                line();
+                text(desc.clone());
+            }
+
+            line();
+        },
+    }
+}
+
+
+pub fn line() {
+    with("\n",
+         term::stdout().unwrap(),
+         term::color::WHITE);
+}
+
+pub fn text<S>(msg: S)
+    where S: Into<String> {
+    with(format!("{}\n", msg.into()),
+         term::stdout().unwrap(),
+         term::color::WHITE);
+}
+
+pub fn success<S>(msg: S)
+    where S: Into<String> {
+    with(format!("{}\n", msg.into()),
+         term::stdout().unwrap(),
+         term::color::GREEN);
+}
+
+pub fn warning<S>(msg: S)
+    where S: Into<String> {
+    with(format!("{}\n", msg.into()),
+         term::stderr().unwrap(),
+         term::color::YELLOW);
+}
+
+pub fn failure<S>(msg: S)
+    where S: Into<String> {
+    with(format!("{}\n", msg.into()),
+         term::stderr().unwrap(),
+         term::color::RED);
+}
+
+pub fn with<S,W>(msg: S,
+                 mut term: Box<term::Terminal<Output=W>>,
+                 color: term::color::Color)
+    where S: Into<String>, W: std::io::Write {
+
+    term.fg(color).unwrap();
+    write!(term, "{}", msg.into()).unwrap();
+}