Replace ignore with ignore-if.

`ignore` is a blunt tool. `ignore-if` allows users to be selective
if/when they ignore tests. `ignore-if: true` is equivalent to the old
`ignore`.

Author: ltratt

examples/rust_lang_tester/lang_tests/ignore.rs

@@ -1,4 +1,4 @@
-// ignore: this test is intentionally ignored
+// ignore-if: true
 // Compiler:
 //   status: success
 

examples/rust_lang_tester/lang_tests/not_ignore.rs

@@ -0,0 +1,7 @@
+// ignore-if: false
+// Run-time:
+//   stdout: check
+
+fn main() {
+    println!("check");
+}

src/lib.rs

@@ -159,11 +159,10 @@
 //! its `stderr` output should warn about an unused variable on line 12; and the resulting binary
 //! should succeed produce `Hello world` on `stdout`.
 //!
-//! A file's tests can be ignored entirely if a test command `ignore` is defined:
+//! A file's tests can be ignored entirely with:
 //!
-//!   * `ignore: [<string>]` specifies that this file should be ignored for the reason set out in
-//!     `<string>` (if any). Note that `<string>` is purely for user information and has no effect
-//!     on the running of tests.
+//!   * `ignore-if: <cmd>` defines a shell command that will be run to determine whether to ignore
+//!     this test or not. If `<cmd>` returns 0 the test will be ignored, otherwise it will be run.
 //!
 //! `lang_tester`'s output is deliberately similar to Rust's normal testing output. Running the
 //! example `rust_lang_tester` in this crate produces the following output:

src/parser.rs

@@ -10,16 +10,16 @@ pub(crate) fn parse_tests(test_str: &str) -> Tests {
     let lines = test_str.lines().collect::<Vec<_>>();
     let mut tests = HashMap::new();
     let mut line_off = 0;
-    let mut ignore = false;
+    let mut ignore_if = None;
     while line_off < lines.len() {
         let indent = indent_level(&lines, line_off);
         if indent == lines[line_off].len() {
             line_off += 1;
             continue;
         }
         let (test_name, val) = key_val(&lines, line_off, indent);
-        if test_name == "ignore" {
-            ignore = true;
+        if test_name == "ignore-if" {
+            ignore_if = Some(val.into());
             line_off += 1;
             continue;
         }
@@ -120,7 +120,7 @@ pub(crate) fn parse_tests(test_str: &str) -> Tests {
             }
         }
     }
-    Tests { ignore, tests }
+    Tests { ignore_if, tests }
 }
 
 fn indent_level(lines: &[&str], line_off: usize) -> usize {

src/tester.rs

@@ -550,7 +550,7 @@ impl<'a> TestCmd<'a> {
 
 /// A collection of tests.
 pub(crate) struct Tests<'a> {
-    pub ignore: bool,
+    pub ignore_if: Option<String>,
     pub tests: HashMap<String, TestCmd<'a>>,
 }
 
@@ -644,7 +644,18 @@ fn test_file(
                     }
 
                     let tests = parse_tests(&test_str);
-                    if (inner.ignored && !tests.ignore) || (!inner.ignored && tests.ignore) {
+                    let ignore = if let Some(ignore_if) = tests.ignore_if {
+                        Command::new(env::var("SHELL").unwrap_or_else(|_| "/bin/sh".to_owned()))
+                            .args(["-c", &ignore_if])
+                            .status()
+                            .unwrap_or_else(|_| {
+                                fatal(&format!("Couldn't run ignore-if '{ignore_if}'"))
+                            })
+                            .success()
+                    } else {
+                        false
+                    };
+                    if (inner.ignored && !ignore) || (!inner.ignored && ignore) {
                         write_ignored(test_fname.as_str(), "", inner);
                         num_ignored.fetch_add(1, Ordering::Relaxed);
                         return;