backend: Rust 1.10 stable でコンパイルできるように

5 files changed, 26 insertions, 30 deletions

diff --git a/backend/src/compiler.rs b/backend/src/compiler.rs
index ebd6c79..84328f7 100644
--- a/backend/src/compiler.rs
+++ b/backend/src/compiler.rs
@@ -17,12 +17,12 @@ pub struct Compiler {
 
 impl Compiler {
     pub fn run(&self, snippet: &Snippet) -> Result<(), PoeError> {
-        let output = Command::new(config::runner())
+        let output = try!(Command::new(config::runner())
                           .arg(config::basedir())
                           .arg(self.overlay_path())
                           .arg(snippet.code_file())
                           .args(&self.commandline)
-                          .output()?;
+                          .output());
         run_result::parse_and_save(&snippet, &self, output)
     }
 
diff --git a/backend/src/main.rs b/backend/src/main.rs
index 64748b5..1b14eda 100644
--- a/backend/src/main.rs
+++ b/backend/src/main.rs
@@ -1,7 +1,3 @@
-#![feature(plugin)]
-#![feature(custom_derive)]
-#![feature(question_mark)]
-
 extern crate byteorder;
 extern crate iron;
 extern crate router;
@@ -44,15 +40,15 @@ fn read_post_form(req: &mut Request) -> Result<HashMap<String, String>, RequestE
         return Err(RequestError::BadRequest);
     }
 
-    Ok(utils::parse_post(&body)?)
+    Ok(try!(utils::parse_post(&body)))
 }
 
 fn snippet_create(req: &mut Request) -> IronResult<Response> {
-    let form = read_post_form(req)?;
+    let form = try!(read_post_form(req));
     match (form.get("lang"), form.get("code")) {
         (Some(lang_), Some(code)) => {
             let lang = lang_.to_ascii_lowercase();
-            let snip = Snippet::create(&lang, &code)?;
+            let snip = try!(Snippet::create(&lang, &code));
             Ok(Response::with((status::Created, snip)))
         },
         _ => Err(RequestError::BadRequest.into())
@@ -62,18 +58,18 @@ fn snippet_create(req: &mut Request) -> IronResult<Response> {
 fn snippet_show(req: &mut Request) -> IronResult<Response> {
     let router = req.extensions.get::<Router>().unwrap();
     match router.find("sid") {
-        Some(sid) => Ok(Response::with((status::Ok, Snippet::find(sid)?))),
+        Some(sid) => Ok(Response::with((status::Ok, try!(Snippet::find(sid))))),
         None => Err(RequestError::BadRequest.into())
     }
 }
 
 fn snippet_run(req: &mut Request) -> IronResult<Response> {
-    let form = read_post_form(req)?;
+    let form = try!(read_post_form(req));
     match (form.get("sid"), form.get("cid")) {
         (Some(sid), Some(cid)) => {
-            let snip = Snippet::find(&sid)?;
-            let comp = config::compiler(&snip.metadata.lang, &cid).ok_or(RequestError::NotFound)?;
-            comp.run(&snip)?;
+            let snip = try!(Snippet::find(&sid));
+            let comp = try!(config::compiler(&snip.metadata.lang, &cid).ok_or(RequestError::NotFound));
+            try!(comp.run(&snip));
             Ok(Response::with((status::Ok, run_result::open_render(&snip, &comp).to_string())))
         },
         _ => Err(RequestError::BadRequest.into())
@@ -84,8 +80,8 @@ fn results_stdout(req: &mut Request) -> IronResult<Response> {
     let router = req.extensions.get::<Router>().unwrap();
     match (router.find("sid"), router.find(":cid")) {
         (Some(sid), Some(cid)) => {
-            let snip = Snippet::find(sid)?;
-            let comp = config::compiler(&snip.metadata.lang, cid).ok_or(RequestError::NotFound)?;
+            let snip = try!(Snippet::find(sid));
+            let comp = try!(config::compiler(&snip.metadata.lang, cid).ok_or(RequestError::NotFound));
             let stdout = run_result::read_stdout_raw(&snip, &comp);
             Ok(Response::with((status::Ok, stdout)))
         },
diff --git a/backend/src/run_result.rs b/backend/src/run_result.rs
index 1ee07c9..60e6f23 100644
--- a/backend/src/run_result.rs
+++ b/backend/src/run_result.rs
@@ -95,11 +95,11 @@ pub fn parse_and_save(snip: &Snippet, comp: &Compiler, output: Output) -> Result
         let trunc = output.stdout.len() > output_limit;
         let meta = RunResultMetadata { exit: exit, result: reason, message: msg_str.into_owned(), truncated: trunc, elapsed_ms: elapsed_ms };
 
-        let mut meta_file = fs::File::create(format!("{}/results/{}.json", &snip.basedir(), &comp.id))?;
-        meta_file.write(json::encode(&meta).unwrap().as_bytes())?;
+        let mut meta_file = try!(fs::File::create(format!("{}/results/{}.json", &snip.basedir(), &comp.id)));
+        try!(meta_file.write(json::encode(&meta).unwrap().as_bytes()));
 
-        let mut out_file = fs::File::create(format!("{}/results/{}.output", &snip.basedir(), &comp.id))?;
-        out_file.write(if trunc { &output.stdout[..output_limit] } else { &output.stdout })?;
+        let mut out_file = try!(fs::File::create(format!("{}/results/{}.output", &snip.basedir(), &comp.id)));
+        try!(out_file.write(if trunc { &output.stdout[..output_limit] } else { &output.stdout }));
 
         Ok(())
     } else {
diff --git a/backend/src/snippet.rs b/backend/src/snippet.rs
index 965a71e..a6732b9 100644
--- a/backend/src/snippet.rs
+++ b/backend/src/snippet.rs
@@ -31,22 +31,22 @@ impl Snippet {
         let snip_meta = SnippetMetadata { lang: lang.to_string(), created: created };
         let snip = Snippet { id: id, metadata: snip_meta };
 
-        fs::create_dir(snip.basedir())?;
-        fs::create_dir(snip.basedir() + "/results")?;
-        let mut metafile = fs::File::create(snip.basedir() + "/metadata.json")?;
-        metafile.write(json::encode(&snip.metadata).unwrap().as_bytes())?;
-        let mut codefile = fs::File::create(snip.code_file())?;
-        codefile.write(code.as_bytes())?;
+        try!(fs::create_dir(snip.basedir()));
+        try!(fs::create_dir(snip.basedir() + "/results"));
+        let mut metafile = try!(fs::File::create(snip.basedir() + "/metadata.json"));
+        try!(metafile.write(json::encode(&snip.metadata).unwrap().as_bytes()));
+        let mut codefile = try!(fs::File::create(snip.code_file()));
+        try!(codefile.write(code.as_bytes()));
 
         Ok(snip)
     }
 
     pub fn find(id: &str) -> Result<Snippet, PoeError> {
         let metafile_path = config::datadir() + "/snippets/" + &id + "/metadata.json";
-        let mut metafile = fs::File::open(metafile_path)?;
+        let mut metafile = try!(fs::File::open(metafile_path));
         let mut encoded = String::new();
-        metafile.read_to_string(&mut encoded)?;
-        Ok(Snippet { id: id.to_string(), metadata: json::decode(&encoded)? })
+        try!(metafile.read_to_string(&mut encoded));
+        Ok(Snippet { id: id.to_string(), metadata: try!(json::decode(&encoded)) })
     }
 
     pub fn code_file(&self) -> String {
diff --git a/backend/src/utils.rs b/backend/src/utils.rs
index 8ebc3ee..86ac5c1 100644
--- a/backend/src/utils.rs
+++ b/backend/src/utils.rs
@@ -55,7 +55,7 @@ pub fn parse_post(orig: &str) -> Result<HashMap<String, String>, RequestError> {
                 Err(RequestError::BadRequest.into())
             }
         }).collect();
-    Ok(HashMap::from_iter(vals?))
+    Ok(HashMap::from_iter(try!(vals)))
 }
 
 pub fn uuid() -> String {