Messing more with scripting

Cargo.toml

@@ -23,6 +23,7 @@ serializer-json = ["common/json"]
 serializer-ron = ["common/ron"]
 serializer-xml = ["common/xml"]
 serializer-yaml = ["common/yaml"]
+lang-basic = ["scripting/basic"]
 lang-wren = ["scripting/wren"]
 lang-lua = ["scripting/lua"]
 

crates/scripting/Cargo.toml

@@ -9,5 +9,6 @@ version.workspace = true
 common = { package = "surreal-common", path = "../common" }
 
 [features]
+basic = []
 wren = []
 lua = []

crates/scripting/src/lang.rs

@@ -1,15 +1,19 @@
 //! Scripting language abstractions
 
-use common::ToVirtualPath;
-#[cfg(feature = "lua")]
-pub use lua::*;
-#[cfg(feature = "wren")]
-pub use wren::*;
+use common::{Singleton, ToVirtualPath};
+
+use super::*;
 
+#[cfg(feature = "basic")]
+pub mod basic;
 #[cfg(feature = "lua")]
-mod lua;
+pub mod lua;
 #[cfg(feature = "wren")]
-mod wren;
+pub mod wren;
+
+/// The shared virtual machine for all scripts
+#[derive(Singleton, Default)]
+struct ScriptVirtualMachine {}
 
 /// Represents a scripting language
 pub trait ScriptLanguage {
@@ -22,7 +26,30 @@ pub struct Script {
   module: ast::Module,
 }
 
+impl Script {
+  /// Loads a script from the given path
+  pub fn from_path<L: ScriptLanguage>(path: impl ToVirtualPath) -> Result<Self, ScriptError> {
+    L::load(path)
+  }
+
+  /// Executes the script
+  pub fn execute(&self) {
+    todo!()
+  }
+
+  /// Evaluates the script with the given arguments
+  pub fn evaluate(&self, _arguments: &[Variant]) -> Vec<Variant> {
+    todo!()
+  }
+
+  /// Calls the given top-level function with the given arguments
+  pub fn call(&self, _name: &str, _arguments: &[Variant]) -> Vec<Variant> {
+    todo!()
+  }
+}
+
 /// Represents an error that occurred while parsing a script
+#[derive(Debug, Eq, PartialEq)]
 pub enum ScriptError {
   NotFound,
   ParseError,
@@ -31,7 +58,10 @@ pub enum ScriptError {
 mod ast {
   //! The internal AST representation of a script
 
-  pub struct Module {}
+  pub struct Module {
+    pub name: String,
+  }
+
   pub enum Statement {}
   pub enum Expression {}
   pub enum Literal {}

crates/scripting/src/lang/basic.rs

@@ -0,0 +1,24 @@
+//! BASIC language support for Surreal
+
+use super::*;
+
+/// The BASIC script language
+pub struct BASIC;
+
+impl ScriptLanguage for BASIC {
+  fn load(_path: impl ToVirtualPath) -> Result<Script, ScriptError> {
+    todo!()
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test_load_basic_files_from_file_system() {
+    let script = Script::from_path::<BASIC>("tests/test.basic").unwrap();
+
+    assert_eq!(script.module.name, "test");
+  }
+}

crates/scripting/src/lang/wren.rs

@@ -2,24 +2,67 @@
 
 use super::*;
 
-/// The Wren scripting language and virtual machine.
+/// The Wren scripting language.
 pub struct Wren;
 
 impl ScriptLanguage for Wren {
   fn load(path: impl ToVirtualPath) -> Result<Script, ScriptError> {
     let path = path.to_virtual_path();
-    let text = path.read_all_text().map_err(|_| ScriptError::ParseError)?;
 
-    parser::parse(&text).map_err(|_| ScriptError::ParseError)?;
+    let text = path.read_all_text().map_err(|_| ScriptError::ParseError)?;
+    let module = parser::parse(&text).map_err(|_| ScriptError::ParseError)?;
 
-    todo!()
+    Ok(Script { module })
   }
 }
 
 mod parser {
+  use common::{StringSpan, ToStringSpan};
+
   use super::*;
 
+  struct Token<'a> {
+    span: StringSpan<'a>,
+    kind: TokenKind,
+  }
+
+  enum TokenKind {
+    Identifier,
+    Keyword,
+    Operator,
+    Literal,
+    Comment,
+  }
+
   pub fn parse(text: &str) -> Result<ast::Module, ()> {
+    let mut tokens = Vec::new();
+    let mut start = 0;
+
+    for (i, c) in text.chars().enumerate() {
+      if c.is_alphabetic() {
+        if start < i {
+          tokens.push(Token {
+            span: text.to_string_span().slice(start, i),
+            kind: TokenKind::Identifier,
+          });
+        }
+
+        start = i + 1;
+      }
+    }
+
     todo!()
   }
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn test_load_wren_files_from_file_system() {
+    let script = Script::from_path::<Wren>("tests/test.wren").unwrap();
+
+    assert_eq!(script.module.name, "test");
+  }
+}