comments and eval_json

Signed-off-by: Nick Mitchell <[email protected]>

Author: starpit

pdl-live-react/src-tauri/src/pdl/interpreter.rs

@@ -165,20 +165,21 @@ impl<'a> Interpreter<'a> {
         }
     }
 
-    fn eval_complex(&self, expr: &Value) -> Result<PdlResult, PdlError> {
+    /// Traverse the given JSON Value, applying `self.eval()` to the value elements within.
+    fn eval_json(&self, expr: &Value) -> Result<PdlResult, PdlError> {
         match expr {
             Value::Null => Ok("".into()),
             Value::Bool(b) => Ok(PdlResult::Bool(*b)),
             Value::Number(n) => Ok(PdlResult::Number(n.clone())),
             Value::String(s) => self.eval(s),
             Value::Array(a) => Ok(PdlResult::List(
                 a.iter()
-                    .map(|v| self.eval_complex(v))
+                    .map(|v| self.eval_json(v))
                     .collect::<Result<_, _>>()?,
             )),
             Value::Object(o) => Ok(PdlResult::Dict(
                 o.iter()
-                    .map(|(k, v)| match self.eval_complex(v) {
+                    .map(|(k, v)| match self.eval_json(v) {
                         Ok(v) => Ok((k.clone(), v)),
                         Err(e) => Err(e),
                     })
@@ -197,7 +198,7 @@ impl<'a> Interpreter<'a> {
                     s, x
                 ))),
             },
-            ListOrString::List(l) => l.iter().map(|v| self.eval_complex(v)).collect(),
+            ListOrString::List(l) => l.iter().map(|v| self.eval_json(v)).collect(),
         }
     }
 
@@ -225,6 +226,7 @@ impl<'a> Interpreter<'a> {
         Ok((trace, messages, PdlBlock::String(msg.clone())))
     }
 
+    /// If `file_path` is not absolute, join it with self.cwd
     fn path_to(&self, file_path: &String) -> PathBuf {
         let mut path = self.cwd.clone();
         path.push(file_path);
@@ -247,7 +249,7 @@ impl<'a> Interpreter<'a> {
                 )))
             }
         } else {
-            //self.eval_complex(value)
+            //self.eval_json(value)
             Ok(value.clone())
         }?;
 
@@ -302,7 +304,7 @@ impl<'a> Interpreter<'a> {
         let res = match self.eval(&block.call)? {
             PdlResult::Closure(c) => {
                 if let Some(args) = &block.args {
-                    match self.eval_complex(args)? {
+                    match self.eval_json(args)? {
                         PdlResult::Dict(m) => {
                             self.push_and_extend_scope_with(m, c.scope);
                             Ok(())
@@ -572,6 +574,7 @@ impl<'a> Interpreter<'a> {
         }
     }
 
+    /// Transform a JSON Value into a PdlResult object
     fn resultify(&self, value: &Value) -> PdlResult {
         match value {
             Value::Null => "".into(),
@@ -589,6 +592,7 @@ impl<'a> Interpreter<'a> {
         }
     }
 
+    /// Run a PdlBlock::Data
     async fn run_data(&mut self, block: &DataBlock, _context: Context) -> Interpretation {
         if self.debug {
             eprintln!("Data raw={:?} {:?}", block.raw, block.data);
@@ -599,7 +603,7 @@ impl<'a> Interpreter<'a> {
             let result = self.def(&block.def, &self.resultify(&block.data), &block.parser)?;
             Ok((result, vec![], PdlBlock::Data(trace)))
         } else {
-            let result = self.def(&block.def, &self.eval_complex(&block.data)?, &block.parser)?;
+            let result = self.def(&block.def, &self.eval_json(&block.data)?, &block.parser)?;
             trace.data = from_str(to_string(&result)?.as_str())?;
             Ok((result, vec![], PdlBlock::Data(trace)))
         }
@@ -786,6 +790,7 @@ impl<'a> Interpreter<'a> {
         ))
     }
 
+    /// Run a PdlBlock::Array
     async fn run_array(&mut self, block: &ArrayBlock, context: Context) -> Interpretation {
         let mut result_items = vec![];
         let mut all_messages = vec![];
@@ -807,6 +812,7 @@ impl<'a> Interpreter<'a> {
         ))
     }
 
+    /// Run a PdlBlock::Message
     async fn run_message(&mut self, block: &MessageBlock, context: Context) -> Interpretation {
         let (content_result, content_messages, content_trace) =
             self.run(&block.content, context).await?;
@@ -865,6 +871,7 @@ pub fn run_sync(program: &PdlBlock, cwd: Option<PathBuf>, debug: bool) -> Interp
         .map_err(|err| Box::<dyn Error>::from(err.to_string()))
 }
 
+/// Read in a file from disk and parse it as a PDL program
 fn parse_file(path: &PathBuf) -> Result<PdlBlock, PdlError> {
     from_reader(File::open(path)?)
         .map_err(|err| Box::<dyn Error + Send + Sync>::from(err.to_string()))