Update wrap-0.1 Branch

.github/workflows/cd.yaml

@@ -36,14 +36,14 @@ jobs:
 
       - name: Check for changes in URI.txt
         run: |
+          git add .
           git diff --name-only | grep ^URI.txt$
           echo "changed=$?" >> $GITHUB_ENV
 
       - name: Commit files
         run: |
           git config --local user.email "[email protected]"
           git config --local user.name "GitHub Action"
-          git add .
           git commit -m "Add deployments" -a
         if: env.changed == 0
 
@@ -101,14 +101,14 @@ jobs:
 
       - name: Check for changes in URI.txt
         run: |
+          git add .
           git diff --name-only | grep ^URI.txt$
           echo "changed=$?" >> $GITHUB_ENV
 
       - name: Commit files
         run: |
           git config --local user.email "[email protected]"
           git config --local user.name "GitHub Action"
-          git add .
           git commit -m "Add deployments" -a
         if: env.changed == 0
 

implementations/app-typescript/URI.txt

@@ -1 +1 @@
-wrap://ipfs/QmNhvrKWXkkvLBknymaoGUpAnd7sE17HTmabDCtyLKFrLa
+wrap://ipfs/QmekvC2sggWkuJcK5eKvVWeSNLJmmNzMphsbm3ZT6FfofZ

implementations/app-typescript/src/helpers/mod.rs

@@ -10,6 +10,9 @@ mod to_graphql_type;
 mod to_typescript;
 mod pretty;
 
+// helpers for helpers
+mod util;
+
 pub fn register(handlebars: &mut Handlebars) -> () {
     handlebars.register_helper(
         "array_has_length",

implementations/app-typescript/src/helpers/to_typescript.rs

@@ -1,6 +1,7 @@
 use handlebars::handlebars_helper;
 use serde_json::value::Value;
 use crate::helpers::detect_keyword::_detect_keyword;
+use crate::helpers::util::{array_type, map_types};
 
 handlebars_helper!(to_typescript: |value: Value| {
     _to_typescript(value.as_str().unwrap(), false)
@@ -17,11 +18,11 @@ fn _to_typescript(value: &str, undefinable: bool) -> String {
     }
 
     if type_val.starts_with("[") {
-        return to_typescript_array(&type_val, optional);
+        return to_typescript_array(&type_val, optional).unwrap();
     }
 
     if type_val.starts_with("Map<") {
-        return to_typescript_map(&type_val, optional);
+        return to_typescript_map(&type_val, optional).unwrap();
     }
 
     match type_val.as_str() {
@@ -42,32 +43,19 @@ fn _to_typescript(value: &str, undefinable: bool) -> String {
     }
 }
 
-fn to_typescript_array(type_val: &str, optional: bool) -> String {
-    let mut iter = type_val.char_indices();
-
-    let first_bracket = iter.find(|&(_, c)| c == '[').map(|(i, _)| i).unwrap();
-    let last_bracket = iter.rfind(|&(_, c)| c == ']').map(|(i, _)| i).unwrap();
-
-    let inner_type = &type_val[(first_bracket+1)..last_bracket];
-    let ts_type = _to_typescript(inner_type, false);
-
-    apply_optional(&format!("Array<{}>", ts_type), optional)
+fn to_typescript_array(value: &str, optional: bool) -> Result<String, String> {
+    let inner_type = array_type(value)?;
+    let ts_type = _to_typescript(&inner_type, false);
+    let ts_array = format!("Array<{}>", ts_type);
+    Ok(apply_optional(&ts_array, optional))
 }
 
-fn to_typescript_map(type_val: &str, optional: bool) -> String {
-    let open_angle_bracket_idx = type_val.find('<').unwrap();
-    let close_angle_bracket_idx = type_val.rfind('>').unwrap();
-
-    let key_val_types = &type_val[(open_angle_bracket_idx+1)..close_angle_bracket_idx];
-
-    let first_comma_idx = key_val_types.find(',').unwrap();
-    let key_type = key_val_types[..first_comma_idx].trim();
-    let val_type = key_val_types[(first_comma_idx+1)..].trim();
-
-    let ts_key_type = _to_typescript(key_type, false);
-    let ts_val_type = _to_typescript(val_type, true);
-
-    apply_optional(&format!("Map<{}, {}>", ts_key_type, ts_val_type), optional)
+fn to_typescript_map(value: &str, optional: bool) -> Result<String, String> {
+    let (key_type, val_type) = map_types(value)?;
+    let ts_key_type = _to_typescript(&key_type, false);
+    let ts_val_type = _to_typescript(&val_type, true);
+    let ts_map = format!("Map<{}, {}>", ts_key_type, ts_val_type);
+    Ok(apply_optional(&ts_map, optional))
 }
 
 fn apply_optional(type_val: &str, optional: bool) -> String {

implementations/app-typescript/src/helpers/util.rs

@@ -0,0 +1,38 @@
+pub fn array_type(value: &str) -> Result<String, String> {
+    let mut iter = value.char_indices();
+
+    let first_bracket = match iter.find(|&(_, c)| c == '[').map(|(i, _)| i) {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Array: {}", value)),
+    };
+    let last_bracket = match iter.rfind(|&(_, c)| c == ']').map(|(i, _)| i) {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Array: {}", value)),
+    };
+
+    let inner_type = &value[(first_bracket+1)..last_bracket];
+    Ok(inner_type.to_string())
+}
+
+pub fn map_types(value: &str) -> Result<(String, String), String> {
+    let first_open_bracket_idx = match value.find('<') {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Map: {}", value)),
+    };
+    let last_close_bracket_idx = match value.rfind('>') {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Map: {}", value)),
+    };
+
+    let key_val_types = &value[(first_open_bracket_idx + 1)..last_close_bracket_idx];
+
+    let first_comma_idx = match key_val_types.find(',') {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Map: {}", value)),
+    };
+
+    let key_type = key_val_types[..first_comma_idx].trim();
+    let val_type = key_val_types[(first_comma_idx + 1)..].trim();
+
+    Ok((key_type.to_string(), val_type.to_string()))
+}

implementations/plugin-kotlin/URI.txt

@@ -1 +1 @@
-wrap://ipfs/QmcLWEBAgFaNRzSj7aYxyKNm9bRC172kibLPgd2yob18fW
+wrap://ipfs/QmYbzNmcXaFEAuWQP6f9cBiZbcKoLQbwNjKQMDEbATaefq

implementations/plugin-kotlin/src/helpers/mod.rs

@@ -16,6 +16,9 @@ mod to_kotlin_byte_array;
 mod to_package_id;
 mod to_upper;
 
+// helpers for helpers
+mod util;
+
 pub fn register(handlebars: &mut Handlebars) -> () {
     handlebars.register_helper(
         "array_has_length",

implementations/plugin-kotlin/src/helpers/to_kotlin.rs

@@ -2,6 +2,7 @@ use handlebars::handlebars_helper;
 use serde_json::value::Value;
 use crate::helpers::detect_keyword::_detect_keyword;
 use crate::helpers::to_upper::_to_upper;
+use crate::helpers::util::{array_type, map_types};
 
 handlebars_helper!(to_kotlin: |value: Value| {
     _to_kotlin(value.as_str().unwrap())
@@ -53,47 +54,16 @@ fn _to_kotlin(value: &str) -> String {
 }
 
 fn to_kotlin_array(value: &str, optional: bool) -> Result<String, String> {
-    let mut iter = value.char_indices();
-
-    let first_bracket = match iter.find(|&(_, c)| c == '[').map(|(i, _)| i) {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Array: {}", value)),
-    };
-    let last_bracket = match iter.rfind(|&(_, c)| c == ']').map(|(i, _)| i) {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Array: {}", value)),
-    };
-
-    let inner_type = &value[(first_bracket+1)..last_bracket];
-    let kt_type = _to_kotlin(inner_type);
-
+    let inner_type = array_type(value)?;
+    let kt_type = _to_kotlin(&inner_type);
     let kt_array = format!("List<{}>", kt_type);
     Ok(apply_optional(&kt_array, optional))
 }
 
 fn to_kotlin_map(value: &str, optional: bool) -> Result<String, String> {
-    let first_open_bracket_idx = match value.find('<') {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Map: {}", value)),
-    };
-    let last_close_bracket_idx = match value.rfind('>') {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Map: {}", value)),
-    };
-
-    let key_val_types = &value[(first_open_bracket_idx + 1)..last_close_bracket_idx];
-
-    let first_comma_idx = match key_val_types.find(',') {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Map: {}", value)),
-    };
-
-    let key_type = key_val_types[..first_comma_idx].trim();
-    let val_type = key_val_types[(first_comma_idx+1)..].trim();
-
-    let kt_key_type = _to_kotlin(key_type);
-    let kt_val_type = _to_kotlin(val_type);
-
+    let (key_type, val_type) = map_types(value)?;
+    let kt_key_type = _to_kotlin(&key_type);
+    let kt_val_type = _to_kotlin(&val_type);
     let kt_map = format!("MsgPackMap<{}, {}>", kt_key_type, kt_val_type);
     Ok(apply_optional(&kt_map, optional))
 }

implementations/plugin-kotlin/src/helpers/util.rs

@@ -0,0 +1,38 @@
+pub fn array_type(value: &str) -> Result<String, String> {
+    let mut iter = value.char_indices();
+
+    let first_bracket = match iter.find(|&(_, c)| c == '[').map(|(i, _)| i) {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Array: {}", value)),
+    };
+    let last_bracket = match iter.rfind(|&(_, c)| c == ']').map(|(i, _)| i) {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Array: {}", value)),
+    };
+
+    let inner_type = &value[(first_bracket+1)..last_bracket];
+    Ok(inner_type.to_string())
+}
+
+pub fn map_types(value: &str) -> Result<(String, String), String> {
+    let first_open_bracket_idx = match value.find('<') {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Map: {}", value)),
+    };
+    let last_close_bracket_idx = match value.rfind('>') {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Map: {}", value)),
+    };
+
+    let key_val_types = &value[(first_open_bracket_idx + 1)..last_close_bracket_idx];
+
+    let first_comma_idx = match key_val_types.find(',') {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Map: {}", value)),
+    };
+
+    let key_type = key_val_types[..first_comma_idx].trim();
+    let val_type = key_val_types[(first_comma_idx + 1)..].trim();
+
+    Ok((key_type.to_string(), val_type.to_string()))
+}

implementations/plugin-python/URI.txt

@@ -1 +1 @@
-wrap://ipfs/Qmap4wqfZoFbQxZdMUC4z7Y3YdK6NbXixGM939ofEuwLFU
+wrap://ipfs/QmV9xedSz6Y4tc1qUSVcrQSF63wfibWhB18oao99mByghK

implementations/plugin-python/src/helpers/to_python.rs

@@ -2,6 +2,7 @@ use handlebars::handlebars_helper;
 use serde_json::value::Value;
 use crate::helpers::detect_keyword::_detect_keyword;
 use crate::helpers::to_upper::_to_upper;
+use crate::helpers::util::{array_type, map_types};
 
 handlebars_helper!(to_python: |value: Value| {
     _to_python(value.as_str().unwrap())
@@ -45,47 +46,16 @@ fn _to_python(value: &str) -> String {
 }
 
 fn to_python_array(value: &str, optional: bool) -> Result<String, String> {
-    let mut iter = value.char_indices();
-
-    let first_bracket = match iter.find(|&(_, c)| c == '[').map(|(i, _)| i) {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Array: {}", value)),
-    };
-    let last_bracket = match iter.rfind(|&(_, c)| c == ']').map(|(i, _)| i) {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Array: {}", value)),
-    };
-
-    let inner_type = &value[(first_bracket+1)..last_bracket];
-    let py_type = _to_python(inner_type);
-
+    let inner_type = array_type(value)?;
+    let py_type = _to_python(&inner_type);
     let py_array = format!("list[{}]", py_type);
     Ok(apply_optional(&py_array, optional))
 }
 
 fn to_python_map(value: &str, optional: bool) -> Result<String, String> {
-    let first_open_bracket_idx = match value.find('<') {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Map: {}", value)),
-    };
-    let last_close_bracket_idx = match value.rfind('>') {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Map: {}", value)),
-    };
-
-    let key_val_types = &value[(first_open_bracket_idx + 1)..last_close_bracket_idx];
-
-    let first_comma_idx = match key_val_types.find(',') {
-        Some(idx) => idx,
-        None => return Err(format!("Invalid Map: {}", value)),
-    };
-
-    let key_type = key_val_types[..first_comma_idx].trim();
-    let val_type = key_val_types[(first_comma_idx+1)..].trim();
-
-    let py_key_type = _to_python(key_type);
-    let py_val_type = _to_python(val_type);
-
+    let (key_type, val_type) = map_types(value)?;
+    let py_key_type = _to_python(&key_type);
+    let py_val_type = _to_python(&val_type);
     let py_map = format!("GenericMap[{}, {}]", py_key_type, py_val_type);
     Ok(apply_optional(&py_map, optional))
 }

implementations/plugin-python/src/helpers/util.rs

@@ -16,3 +16,41 @@ pub fn remove_at(s: &str, idx: usize) -> String {
     format!("{}{}", start, end)
 }
 
+pub fn array_type(value: &str) -> Result<String, String> {
+    let mut iter = value.char_indices();
+
+    let first_bracket = match iter.find(|&(_, c)| c == '[').map(|(i, _)| i) {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Array: {}", value)),
+    };
+    let last_bracket = match iter.rfind(|&(_, c)| c == ']').map(|(i, _)| i) {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Array: {}", value)),
+    };
+
+    let inner_type = &value[(first_bracket+1)..last_bracket];
+    Ok(inner_type.to_string())
+}
+
+pub fn map_types(value: &str) -> Result<(String, String), String> {
+    let first_open_bracket_idx = match value.find('<') {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Map: {}", value)),
+    };
+    let last_close_bracket_idx = match value.rfind('>') {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Map: {}", value)),
+    };
+
+    let key_val_types = &value[(first_open_bracket_idx + 1)..last_close_bracket_idx];
+
+    let first_comma_idx = match key_val_types.find(',') {
+        Some(idx) => idx,
+        None => return Err(format!("Invalid Map: {}", value)),
+    };
+
+    let key_type = key_val_types[..first_comma_idx].trim();
+    let val_type = key_val_types[(first_comma_idx + 1)..].trim();
+
+    Ok((key_type.to_string(), val_type.to_string()))
+}

implementations/plugin-rust/URI.txt

@@ -1 +1 @@
-wrap://ipfs/QmTC8oqchRJMqNeKtvRdF2pQc6TMLNS9LFiXwefHaUfUF5
+wrap://ipfs/QmSYCtTtHMyenvFu7b4J914LTZLPNkyme2Dfa9QLvNWUiV