empty blocks, import blocks, and chained cwd for includes, too

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

Author: starpit

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

@@ -524,13 +524,27 @@ pub struct IncludeBlock {
     pub include: String,
 }
 
+/// Import a PDL file
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct ImportBlock {
+    /// Name of the file to include.
+    pub import: String,
+}
+
+/// Block containing only defs
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct EmptyBlock {
+    pub defs: IndexMap<String, PdlBlock>,
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone)]
 #[serde(untagged)]
 pub enum PdlBlock {
     Bool(bool),
     Number(Number),
     String(String),
     If(IfBlock),
+    Import(ImportBlock),
     Include(IncludeBlock),
     Data(DataBlock),
     Object(ObjectBlock),
@@ -544,6 +558,9 @@ pub enum PdlBlock {
     Function(FunctionBlock),
     PythonCode(PythonCodeBlock),
     Read(ReadBlock),
+
+    // must be last to prevent serde from aggressively matching on it, since other block types also (may) have a `defs`
+    Empty(EmptyBlock),
 }
 
 impl From<&str> for PdlBlock {

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

@@ -25,9 +25,10 @@ use serde_json::{from_str, to_string, Value};
 use serde_norway::{from_reader, from_str as from_yaml_str};
 
 use crate::pdl::ast::{
-    ArrayBlock, CallBlock, Closure, DataBlock, FunctionBlock, IfBlock, IncludeBlock, ListOrString,
-    MessageBlock, ModelBlock, ObjectBlock, PdlBlock, PdlParser, PdlResult, PdlUsage,
-    PythonCodeBlock, ReadBlock, RepeatBlock, Role, Scope, SequencingBlock, StringOrBoolean,
+    ArrayBlock, CallBlock, Closure, DataBlock, EmptyBlock, FunctionBlock, IfBlock, ImportBlock,
+    IncludeBlock, ListOrString, MessageBlock, ModelBlock, ObjectBlock, PdlBlock, PdlParser,
+    PdlResult, PdlUsage, PythonCodeBlock, ReadBlock, RepeatBlock, Role, Scope, SequencingBlock,
+    StringOrBoolean,
 };
 
 type Context = Vec<ChatMessage>;
@@ -99,7 +100,9 @@ impl<'a> Interpreter<'a> {
             )),
             PdlBlock::String(s) => self.run_string(s, context).await,
             PdlBlock::Call(block) => self.run_call(block, context).await,
+            PdlBlock::Empty(block) => self.run_empty(block, context).await,
             PdlBlock::If(block) => self.run_if(block, context).await,
+            PdlBlock::Import(block) => self.run_import(block, context).await,
             PdlBlock::Include(block) => self.run_include(block, context).await,
             PdlBlock::Model(block) => self.run_model(block, context).await,
             PdlBlock::Data(block) => self.run_data(block, context).await,
@@ -230,7 +233,11 @@ impl<'a> Interpreter<'a> {
     fn path_to(&self, file_path: &String) -> PathBuf {
         let mut path = self.cwd.clone();
         path.push(file_path);
-        path
+        if path.extension().is_none() {
+            path.with_extension("pdl")
+        } else {
+            path
+        }
     }
 
     fn def(
@@ -299,6 +306,7 @@ impl<'a> Interpreter<'a> {
     async fn run_call(&mut self, block: &CallBlock, context: Context) -> Interpretation {
         if self.debug {
             eprintln!("Call {:?}({:?})", block.call, block.args);
+            eprintln!("Call scope {:?}", self.scope.last());
         }
 
         let res = match self.eval(&block.call)? {
@@ -328,6 +336,21 @@ impl<'a> Interpreter<'a> {
         res
     }
 
+    /// Run a PdlBlock::Empty
+    async fn run_empty(&mut self, block: &EmptyBlock, _context: Context) -> Interpretation {
+        if self.debug {
+            eprintln!("Empty");
+        }
+
+        let trace = block.clone();
+        self.process_defs(&Some(block.defs.clone())).await?;
+        Ok((
+            PdlResult::Dict(self.scope.last().unwrap_or(&HashMap::new()).clone()),
+            vec![],
+            PdlBlock::Empty(trace),
+        ))
+    }
+
     /// Run a PdlBlock::Call
     async fn run_if(&mut self, block: &IfBlock, context: Context) -> Interpretation {
         if self.debug {
@@ -362,8 +385,30 @@ impl<'a> Interpreter<'a> {
             eprintln!("Include {:?}", block.include);
         }
 
-        self.run_quiet(&parse_file(&self.path_to(&block.include))?, context.clone())
-            .await
+        let path = self.path_to(&block.include);
+        let old_cwd = self.cwd.clone();
+        if let Some(cwd) = path.parent() {
+            self.cwd = cwd.to_path_buf()
+        }
+        let res = self.run_quiet(&parse_file(&path)?, context.clone()).await;
+        self.cwd = old_cwd;
+        res
+    }
+
+    /// Run a PdlBlock::Import
+    async fn run_import(&mut self, block: &ImportBlock, context: Context) -> Interpretation {
+        if self.debug {
+            eprintln!("Import {:?}", block.import);
+        }
+
+        let path = self.path_to(&block.import);
+        let old_cwd = self.cwd.clone();
+        if let Some(cwd) = path.parent() {
+            self.cwd = cwd.to_path_buf()
+        }
+        let res = self.run_quiet(&parse_file(&path)?, context.clone()).await;
+        self.cwd = old_cwd;
+        res
     }
 
     fn to_ollama_model_options(

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

@@ -458,7 +458,7 @@ mod tests {
     }
 
     #[test]
-    fn text_include() -> Result<(), Box<dyn Error>> {
+    fn include() -> Result<(), Box<dyn Error>> {
         let program = json!({
             "include": "./tests/cli/call-with-args.pdl"
         });
@@ -471,7 +471,7 @@ mod tests {
     }
 
     #[test]
-    fn text_data_1() -> Result<(), Box<dyn Error>> {
+    fn data_1() -> Result<(), Box<dyn Error>> {
         let program = json!({
             "include": "./tests/cli/data1.pdl"
         });
@@ -484,7 +484,7 @@ mod tests {
     }
 
     #[test]
-    fn text_data_2() -> Result<(), Box<dyn Error>> {
+    fn data_2() -> Result<(), Box<dyn Error>> {
         let program = json!({
             "include": "./tests/cli/data2.pdl"
         });
@@ -497,7 +497,7 @@ mod tests {
     }
 
     #[test]
-    fn text_data_3() -> Result<(), Box<dyn Error>> {
+    fn data_3() -> Result<(), Box<dyn Error>> {
         let program = json!({
             "include": "./tests/cli/data3.pdl"
         });
@@ -509,8 +509,8 @@ mod tests {
         Ok(())
     }
 
-    /*#[test]
-    fn text_data_4() -> Result<(), Box<dyn Error>> {
+    #[test]
+    fn data_4() -> Result<(), Box<dyn Error>> {
         let program = json!({
             "include": "./tests/cli/data4.pdl"
         });
@@ -520,5 +520,18 @@ mod tests {
         assert_eq!(messages[0].role, MessageRole::User);
         assert_eq!(messages[0].content, "yyyyxxxx3true");
         Ok(())
-    }*/
+    }
+
+    #[test]
+    fn import_1() -> Result<(), Box<dyn Error>> {
+        let program = json!({
+            "include": "../../examples/tutorial/import.pdl"
+        });
+
+        let (_, messages, _) = run_json(program, false)?;
+        assert_eq!(messages.len(), 1);
+        assert_eq!(messages[0].role, MessageRole::User);
+        assert_eq!(messages[0].content, "Bye!");
+        Ok(())
+    }
 }