Idiomatic rust

Author: saeed-zil

src/contract.rs

@@ -1,12 +1,35 @@
-use std::path::PathBuf;
+use std::{path::Path, str::FromStr};
 
-use crate::{FieldList, Transition};
+use crate::{run_scilla_fmt, Error, FieldList, TransitionList};
 
 #[derive(Debug, PartialEq)]
 pub struct Contract {
-    pub path: PathBuf,
     pub name: String,
     pub init_params: FieldList,
     pub fields: FieldList,
-    pub transitions: Vec<Transition>,
+    pub transitions: TransitionList,
+}
+
+impl FromStr for Contract {
+    type Err = Error;
+
+    fn from_str(sexp: &str) -> Result<Self, Self::Err> {
+        let v = lexpr::from_str(sexp)?;
+        let name = v["contr"][0]["cname"]["Ident"][0][1].to_string();
+        let transitions = (&v["contr"][0]["ccomps"][0]).try_into()?;
+        let init_params = (&v["contr"][0]["cparams"][0]).try_into()?;
+        let fields = (&v["contr"][0]["cfields"][0]).try_into()?;
+        Ok(Contract {
+            name,
+            transitions,
+            init_params,
+            fields,
+        })
+    }
+}
+
+impl Contract {
+    pub fn from_path(contract_path: &Path) -> Result<Self, Error> {
+        run_scilla_fmt(contract_path)?.replace("\\0", "").parse()
+    }
 }

src/error.rs

@@ -7,6 +7,9 @@ pub enum Error {
     #[error("The requested entry {0} does not exist in the given S-expression")]
     NoSuchEntryInSexp(String),
 
+    #[error("Comptype is not transition. It's {0}")]
+    CompTypeIsNotTransition(String),
+
     #[error(transparent)]
     IoError(#[from] std::io::Error),
 

src/field.rs

@@ -47,3 +47,21 @@ impl std::ops::Deref for FieldList {
         &self.0
     }
 }
+
+impl TryFrom<&Value> for FieldList {
+    type Error = Error;
+
+    fn try_from(value: &Value) -> Result<Self, Self::Error> {
+        if !value.is_list() {
+            return Ok(FieldList::default());
+        }
+
+        let fields: Result<Vec<Field>, Error> = value
+            .list_iter()
+            .unwrap()
+            .map(|elem| elem.try_into())
+            .collect();
+
+        Ok(FieldList(fields?))
+    }
+}

src/lib.rs

@@ -1,14 +1,12 @@
 pub mod contract;
 pub mod error;
 pub mod field;
-pub mod parser;
 pub mod transition;
 pub mod r#type;
 
 pub use contract::*;
 pub use error::Error;
 pub use field::*;
-pub use parser::*;
 pub use r#type::*;
 pub use transition::*;
 

src/parser.rs

@@ -1,4 +1,6 @@
-use crate::FieldList;
+use lexpr::Value;
+
+use crate::{Error, FieldList};
 
 #[derive(Debug, PartialEq)]
 pub struct Transition {
@@ -21,3 +23,49 @@ impl Transition {
         }
     }
 }
+
+impl TryFrom<&Value> for Transition {
+    type Error = Error;
+
+    fn try_from(value: &Value) -> Result<Self, Self::Error> {
+        let comp_type = value["comp_type"][0].as_symbol().unwrap();
+        if comp_type == "CompTrans" {
+            let transition_name = value["comp_name"][0]["SimpleLocal"][0].to_string();
+            Ok(Transition {
+                name: transition_name,
+                params: (&value["comp_params"][0]).try_into()?,
+            })
+        } else {
+            Err(Error::CompTypeIsNotTransition(comp_type.to_string()))
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Default)]
+pub struct TransitionList(pub Vec<Transition>);
+
+impl std::ops::Deref for TransitionList {
+    type Target = Vec<Transition>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl TryFrom<&Value> for TransitionList {
+    type Error = Error;
+
+    fn try_from(value: &Value) -> Result<Self, Self::Error> {
+        if !value.is_list() {
+            return Ok(TransitionList::default());
+        }
+
+        Ok(TransitionList(
+            value
+                .list_iter()
+                .unwrap()
+                .filter_map(|elem| Transition::try_from(elem).ok())
+                .collect(),
+        ))
+    }
+}