update

diff.patch

@@ -1,3 +1,64 @@
+diff --git a/crates/ssd/src/generators/rhai.rs b/crates/ssd/src/generators/rhai.rs
+index d4ba8e3..178d4bb 100644
+--- a/crates/ssd/src/generators/rhai.rs
++++ b/crates/ssd/src/generators/rhai.rs
+@@ -45,6 +45,10 @@ fn error_to_runtime_error<E: std::error::Error>(e: E) -> Box<EvalAltResult> {
+ 
+ use rhai::Token;
+ 
++fn script_count_vec<T>(v: &Vec<T>) -> usize {
++    v.len()
++}
++
+ fn script_exists(path: &str) -> bool {
+     PathBuf::from(path).exists()
+ }
+@@ -281,21 +285,31 @@ pub fn build_engine(messages: Rc<RefCell<Vec<String>>>, debug: bool) -> Engine {
+     engine.register_global_module(package.as_shared_module());
+ 
+     engine.register_iterator::<Vec<serde_value::Value>>();
++    engine.register_iterator::<Namespace>();
++    engine.register_type::<Namespace>();
+ 
+-    engine
+-        .register_iterator::<Vec<SsdModule>>()
+-        .register_iterator::<Vec<Import>>()
+-        .register_iterator::<OrderedMap<Namespace>>()
+-        .register_iterator::<Namespace>()
+-        .register_iterator::<OrderedMap<Enum>>()
+-        .register_iterator::<OrderedMap<EnumValue>>()
+-        .register_iterator::<OrderedMap<DataType>>()
+-        .register_iterator::<OrderedMap<Service>>()
+-        .register_iterator::<Vec<Attribute>>()
+-        .register_iterator::<OrderedMap<TypeName>>()
+-        .register_iterator::<Vec<Dependency>>()
+-        .register_iterator::<Vec<Parameter>>()
+-        .register_iterator::<OrderedMap<Function>>();
++    macro_rules! register_vec {
++        ($T: ty) => {
++            engine
++                .register_type::<Vec<$T>>()
++                .register_fn("len", Vec::<$T>::len)
++                .register_iterator::<Vec<$T>>();
++        };
++    }
++
++    register_vec!(SsdModule);
++    register_vec!(Import);
++    register_vec!(Attribute);
++    register_vec!(Dependency);
++    register_vec!(Parameter);
++    register_vec!((String, Namespace));
++    register_vec!((String, Event));
++    register_vec!((String, Enum));
++    register_vec!((String, EnumValue));
++    register_vec!((String, DataType));
++    register_vec!((String, Service));
++    register_vec!((String, TypeName));
++    register_vec!((String, Function));
+ 
+     engine.register_fn("to_string", |this: &mut Import| this.path.clone());
+     #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
 diff --git a/crates/ssd/src/generators/tera.rs b/crates/ssd/src/generators/tera.rs
 index 2cfb3eb..251a225 100644
 --- a/crates/ssd/src/generators/tera.rs

ssd_to_acme/ssd_to_acme.rhai

@@ -0,0 +1,112 @@
+fn get_attr(atts, name) {
+  for att in atts {
+    if att.name.join(".") == name {
+      return att;
+    }
+  }
+}
+
+fn get_param(params, name) {
+  for param in params {
+    if param.name == name {
+      return param;
+    }
+  }
+}
+
+"packages:" ++ NL;
+IND ++ "- name: " ++ module.name.join(".") ++ NL;
+IND ++ "  interfaces:" ++ NL;
+
+for service in module.services {
+  IND(2) ++ "- name: " ++ service.first ++ NL;
+
+  let version = get_attr(service.second.attributes, "version");
+  IND(2) ++ "  version:" + NL;
+  let major = "1";
+  let minor = "0";
+  if version != () {
+    major = get_param(version.parameters, "major").value.unwrap_or(major);
+    minor = get_param(version.parameters, "minor").value.unwrap_or(minor);
+  }
+  IND(3) ++ "major: " ++ major ++ NL;
+  IND(3) ++ "minor: " ++ minor ++ NL;
+
+  if service.second.functions.len() > 0 {
+    IND(2) ++ "  methods:" ++ NL;
+
+    for function in service.second.functions {
+      IND(3) ++ "- name: " ++ function.first ++ NL;
+
+      if function.second.arguments.len() > 0 {
+        IND(3) ++ "  arguments:" + NL;
+        for argument in function.second.arguments {
+          IND(4) ++ "- name: " ++ argument.first ++ NL;
+          IND(4) ++ "  type: " ++ argument.second.typ.join("::") ++ NL;
+        }
+      }
+
+      if is_some(function.second.return_type) {
+        let return_type = unwrap(function.second.return_type);
+        IND(3) ++ "  return: " ++ return_type.typ.join("::");
+      }
+    }
+  }
+
+  -(to_string(service.second.events.len()));
+  if service.second.events.len() > 0 {
+    IND(2) ++ "  events:" ++ NL;
+    for event in service.second.events {
+      let is_field = get_attr(event, "field") != ();
+      debug(is_field);
+    }
+  }
+
+}
+
+
+/*
+
+for enum in module.enums {
+    "enum " ++ enum.first ++ " {";
+        let prefix = "";
+        for enum_value in enum.second.values {
+            let name = enum_value.first;
+            let enum_value = enum_value.second;
+            if is_some(enum_value.value) {
+                prefix ++ NL ++ IND ++ name ++ " = " ++ unwrap(enum_value.value);
+            } else {
+                prefix ++ NL ++ IND ++ name;
+            }
+            prefix = ","
+        }
+    NL ++ "};" ++ NL(2);
+}
+
+end("ENUMS");
+
+-(NL);
+
+begin("DATATYPES");
+
+for data_type in module.data_types {
+    "struct " ++ data_type.first ++ " {" ++ NL;
+        for property in data_type.second.properties {
+            if property.second.is_list {
+                let count = property.second.count;
+                if is_some(count) {
+                    let count = unwrap(count);
+                    IND ++ property.second.typ.join("::") ++ " " ++ property.first ++ "[" ++ count ++ "];" ++ NL;
+                } else {
+                    IND ++ property.second.typ.join("::") ++ " " ++ property.first ++ "[]" ++ ";" ++ NL;
+                }
+            } else {
+                IND ++ property.second.typ.join("::") ++ " " ++ property.first ++ ";" ++ NL;
+            }
+        }
+    "};" ++ NL(2);
+}
+end("DATATYPES");
+
+"}" ++ NL
+*/

ssd_to_acme/test.svc

@@ -0,0 +1,23 @@
+data FullName {
+	firstname: String,
+	surname: String,
+};
+
+#[list(item="FullName")]
+data NameList {};
+
+#[error]
+enum ApiError {
+	EmptyNameError,
+};
+
+#[version(major = "1", minor = "0")]
+service Greetings {
+
+	#[throws(ApiError::EmptyNameError)]
+	fn GenerateGreeting(names: NameList) -> String;
+
+	event VIPGreeted(name: FullName);
+	#[field]
+	event GreetingsRequested(count: u16);
+};