Check for rustc version incompatibility when building codegen.

codegen/Cargo.toml

@@ -9,6 +9,7 @@ repository = "https://github.com/SergioBenitez/Rocket"
 readme = "../README.md"
 keywords = ["rocket", "web", "framework", "code", "generation"]
 license = "MIT/Apache-2.0"
+build = "build.rs"
 
 [lib]
 plugin = true
@@ -19,3 +20,6 @@ log = "^0.3"
 
 [dev-dependencies]
 compiletest_rs = "^0.2"
+
+[build-dependencies]
+ansi_term = "^0.9"

codegen/build.rs

@@ -0,0 +1,71 @@
+#![feature(slice_patterns)]
+
+//! This tiny build script ensures that rocket_codegen is not compiled with an
+//! incompatible version of rust. It does this by executing `rustc --version`
+//! and comparing the version to `MIN_VERSION`, the minimum required version. If
+//! the installed version is less than the minimum required version, an error is
+//! printed out to the console and compilation is halted.
+
+extern crate ansi_term;
+
+use std::env;
+use std::process::Command;
+
+use ansi_term::Colour::{Red, Yellow, Blue, White};
+
+// Specifies the minimum nightly version needed to compile Rocket's codegen.
+const MIN_VERSION: &'static str = "2016-12-28";
+
+// Convenience macro for writing to stderr.
+macro_rules! printerr {
+    ($($arg:tt)*) => ({
+        use std::io::prelude::*;
+        write!(&mut ::std::io::stderr(), "{}\n", format_args!($($arg)*))
+            .expect("Failed to write to stderr.")
+    })
+}
+
+// Convert a string of %Y-%m-%d to a single u32 maintaining ordering.
+fn str_to_ymd(ymd: &str) -> Option<u32> {
+    let ymd: Vec<_> = ymd.split("-").filter_map(|s| s.parse::<u32>().ok()).collect();
+    match ymd.as_slice() {
+        &[y, m, d] => Some((y << 9) | (m << 5) | d),
+        _ => None,
+    }
+}
+
+fn main() {
+    // Run rustc to get the version information.
+    let output = env::var("RUSTC").ok()
+        .and_then(|rustc| Command::new(rustc).arg("--version").output().ok())
+        .and_then(|output| String::from_utf8(output.stdout).ok())
+        .and_then(|s| s.split(" ").nth(3).map(|s| s.to_string()))
+        .map(|s| s.trim_right().trim_right_matches(")").to_string());
+
+    if let Some(ref version) = output {
+        let needed = str_to_ymd(MIN_VERSION);
+        let actual = str_to_ymd(version);
+        if let (Some(needed), Some(actual)) = (needed, actual) {
+            if actual < needed {
+                printerr!("{} {}",
+                          Red.bold().paint("Error:"),
+                          White.paint("Rocket codegen requires a newer version of rustc."));
+                printerr!("{}{}{}",
+                          Blue.paint("Use `"),
+                          White.paint("rustup update"),
+                          Blue.paint("` or your preferred method to update Rust."));
+                printerr!("{} {}. {} {}.",
+                          White.paint("Installed version is:"),
+                          Yellow.paint(version.as_str()),
+                          White.paint("Minimum required:"),
+                          Yellow.paint(MIN_VERSION));
+                panic!("Aborting compilation due to incompatible compiler.")
+            } else {
+                return;
+            }
+        }
+    }
+
+    printerr!("{}", Yellow.paint("Warning: Rocket was unable to check rustc compatbility."));
+    printerr!("{}", Yellow.paint("Build may fail due to incompatible rustc version."));
+}