refactor

zokrates_ast/src/common/variable.rs

@@ -47,30 +47,6 @@ impl Variable {
             id: isize::from_le_bytes(buf),
         })
     }
-
-    pub fn try_from_human_readable(s: &str) -> Result<Self, &str> {
-        if s == "~one" {
-            return Ok(Variable::one());
-        }
-
-        let mut public = s.split("~out_");
-        match public.nth(1) {
-            Some(v) => {
-                let v = v.parse().map_err(|_| s)?;
-                Ok(Variable::public(v))
-            }
-            None => {
-                let mut private = s.split('_');
-                match private.nth(1) {
-                    Some(v) => {
-                        let v = v.parse().map_err(|_| s)?;
-                        Ok(Variable::new(v))
-                    }
-                    None => Err(s),
-                }
-            }
-        }
-    }
 }
 
 impl fmt::Display for Variable {

zokrates_ast/src/ir/witness.rs

@@ -80,40 +80,6 @@ impl<T: Field> Witness<T> {
         serde_json::to_writer_pretty(writer, &map)?;
         Ok(())
     }
-
-    pub fn read_json<R: Read>(reader: R) -> io::Result<Self> {
-        let json: serde_json::Value = serde_json::from_reader(reader)?;
-        let object = json
-            .as_object()
-            .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "Witness must be an object"))?;
-
-        let mut witness = Witness::empty();
-        for (k, v) in object {
-            let variable = Variable::try_from_human_readable(k).map_err(|why| {
-                io::Error::new(
-                    io::ErrorKind::Other,
-                    format!("Invalid variable in witness: {}", why),
-                )
-            })?;
-
-            let value = v
-                .as_str()
-                .ok_or_else(|| {
-                    io::Error::new(io::ErrorKind::Other, "Witness value must be a string")
-                })
-                .and_then(|v| {
-                    T::try_from_dec_str(v).map_err(|_| {
-                        io::Error::new(
-                            io::ErrorKind::Other,
-                            format!("Invalid value in witness: {}", v),
-                        )
-                    })
-                })?;
-
-            witness.insert(variable, value);
-        }
-        Ok(witness)
-    }
 }
 
 impl<T: Field> fmt::Display for Witness<T> {
@@ -160,5 +126,31 @@ mod tests {
 
             assert_eq!(w, r);
         }
+
+        #[test]
+        fn serialize_json() {
+            let w = Witness(
+                vec![
+                    (Variable::new(42), Bn128Field::from(42)),
+                    (Variable::public(8), Bn128Field::from(8)),
+                    (Variable::one(), Bn128Field::from(1)),
+                ]
+                .into_iter()
+                .collect(),
+            );
+
+            let mut buf = Cursor::new(vec![]);
+            w.write_json(&mut buf).unwrap();
+
+            let output = String::from_utf8(buf.into_inner()).unwrap();
+            assert_eq!(
+                output.as_str(),
+                r#"{
+  "~out_8": "8",
+  "~one": "1",
+  "_42": "42"
+}"#
+            )
+        }
     }
 }

zokrates_cli/tests/integration.rs

@@ -27,6 +27,67 @@ mod integration {
         to_token::ToToken, Marlin, Proof, SolidityCompatibleScheme, G16, GM17,
     };
 
+    mod helpers {
+        use super::*;
+        use zokrates_ast::common::Variable;
+        use zokrates_field::Field;
+
+        pub fn parse_variable(s: &str) -> Result<Variable, &str> {
+            if s == "~one" {
+                return Ok(Variable::one());
+            }
+
+            let mut public = s.split("~out_");
+            match public.nth(1) {
+                Some(v) => {
+                    let v = v.parse().map_err(|_| s)?;
+                    Ok(Variable::public(v))
+                }
+                None => {
+                    let mut private = s.split('_');
+                    match private.nth(1) {
+                        Some(v) => {
+                            let v = v.parse().map_err(|_| s)?;
+                            Ok(Variable::new(v))
+                        }
+                        None => Err(s),
+                    }
+                }
+            }
+        }
+
+        pub fn parse_witness_json<T: Field, R: Read>(reader: R) -> std::io::Result<Witness<T>> {
+            use std::io::{Error, ErrorKind};
+
+            let json: serde_json::Value = serde_json::from_reader(reader)?;
+            let object = json
+                .as_object()
+                .ok_or_else(|| Error::new(ErrorKind::Other, "Witness must be an object"))?;
+
+            let mut witness = Witness::empty();
+            for (k, v) in object {
+                let variable = parse_variable(k).map_err(|why| {
+                    Error::new(
+                        ErrorKind::Other,
+                        format!("Invalid variable in witness: {}", why),
+                    )
+                })?;
+
+                let value = v
+                    .as_str()
+                    .ok_or_else(|| Error::new(ErrorKind::Other, "Witness value must be a string"))
+                    .and_then(|v| {
+                        T::try_from_dec_str(v).map_err(|_| {
+                            Error::new(ErrorKind::Other, format!("Invalid value in witness: {}", v))
+                        })
+                    })?;
+
+                witness.insert(variable, value);
+            }
+            Ok(witness)
+        }
+    }
+
     macro_rules! map(
     {
         $($key:expr => $value:expr),+ } => {
@@ -253,8 +314,8 @@ mod integration {
 
         // load the expected witness
         let expected_witness_file = File::open(&expected_witness_path).unwrap();
-        let expected_witness =
+        let expected_witness: Witness<zokrates_field::Bn128Field> =
-            Witness::<zokrates_field::Bn128Field>::read_json(expected_witness_file).unwrap();
+            helpers::parse_witness_json(expected_witness_file).unwrap();
 
         // load the actual witness
         let witness_file = File::open(&witness_path).unwrap();