Use more of serde's superpowers

Author: Bruce Adams

rust1.32/src/Cargo.lock

@@ -4,6 +4,8 @@ version = "0.1.0"
 authors = ["Roberto Diaz <roberto@theagilemonkeys.com>"]
 
 [dependencies]
+serde = "1.0"
+serde_derive = "1.0"
 serde_json = "1.0"
 libc = "0.2.49"
-actions = { path = "../actions" }
+actions = { path = "../actions" }

rust1.32/src/action_loop/Cargo.toml

@@ -1,52 +1,48 @@
 extern crate actions;
 extern crate libc;
+extern crate serde;
+extern crate serde_derive;
 extern crate serde_json;
 
 use actions::main as actionMain;
+use serde_derive::Deserialize;
+
 use serde_json::{Error, Value};
 use std::collections::HashMap;
 use std::env;
 use std::fs::File;
-use std::io::{self, stderr, stdout, Write};
+use std::io::{stderr, stdin, stdout, Write};
 use std::os::unix::io::FromRawFd;
 
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+struct Input {
+    value: HashMap<String, Value>,
+    #[serde(flatten)]
+    environment: HashMap<String, Value>,
+}
+
 fn main() {
     let mut fd3 = unsafe { File::from_raw_fd(3) };
     loop {
         let mut buffer = String::new();
-        io::stdin().read_line(&mut buffer).unwrap();
-        let parsed_input: Result<HashMap<String, Value>, Error> = serde_json::from_str(&buffer);
-        let mut payload: HashMap<String, Value> = HashMap::new();
+        stdin().read_line(&mut buffer).unwrap();
+        let parsed_input: Result<Input, Error> = serde_json::from_str(&buffer);
         match parsed_input {
-            Ok(n) => {
-                for (key, val) in n {
-                    if key == "value" {
-                        let mut unparsed_payload: Result<HashMap<String, Value>, Error> =
-                            serde_json::from_value(val);
-                        match unparsed_payload {
-                            Ok(value) => payload = value,
-                            Err(err) => {
-                                eprintln!("Error parsing value json: {}", err);
-                                continue;
-                            }
-                        }
-                    } else {
-                        env::set_var(format!("__OW_{}", key.to_uppercase()), val.to_string());
+            Ok(input) => {
+                for (key, val) in input.environment {
+                    env::set_var(format!("__OW_{}", key.to_uppercase()), val.to_string());
+                }
+                match serde_json::to_string(&actionMain(input.value)) {
+                    Ok(result) => {
+                        writeln!(&mut fd3, "{}", result).expect("Error writing on fd3");
+                    }
+                    Err(err) => {
+                        eprintln!("Error formatting result value json: {}", err);
                     }
                 }
             }
-            Err(e) => {
-                eprintln!("Error: {}", e);
-                continue;
-            }
-        }
-
-        match serde_json::to_string(&actionMain(payload)) {
-            Ok(result) => {
-                writeln!(&mut fd3, "{}", result).expect("Error writing on fd3");
-            }
             Err(err) => {
-                eprintln!("Error formatting result value json: {}", err);
+                eprintln!("Error parsing input: {}", err);
             }
         }
         stdout().flush().expect("Error flushing stdout");