Merge pull request #81 from calcit-lang/process-error

emit process error inside js

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "calcit_runner"
-version = "0.4.14"
+version = "0.4.16"
 authors = ["jiyinyiyong <jiyinyiyong@gmail.com>"]
 edition = "2018"
 license = "MIT"

calcit/snapshots/test-record.cirru

@@ -130,6 +130,10 @@
                 [] :color :red
                 .nth kitty 0
 
+              &let
+                persian $ .extend-as kitty :Persian :age 10
+                assert= 10 $ .get persian :age
+                assert= |Persian $ .get-name persian
 
         |main! $ quote
           defn main! ()

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.4.14",
+  "version": "0.4.16",
   "main": "./lib/calcit.procs.js",
   "devDependencies": {
     "@types/node": "^16.4.13",

src/bin/cr.rs

@@ -235,6 +235,13 @@ fn run_codegen(
     builtins::effects::modify_cli_running_mode(builtins::effects::CliRunningMode::Js)?;
   }
 
+  let code_emit_path = Path::new(emit_path);
+  if !code_emit_path.exists() {
+    let _ = fs::create_dir(code_emit_path);
+  }
+
+  let js_file_path = code_emit_path.join(format!("{}.js", COMPILE_ERRORS_FILE)); // TODO mjs_mode
+
   let check_warnings: &RefCell<Vec<String>> = &RefCell::new(vec![]);
 
   // preprocess to init
@@ -243,17 +250,19 @@ fn run_codegen(
     Err(failure) => {
       println!("\nfailed preprocessing, {}", failure);
       call_stack::display_stack(&failure)?;
+
+      let _ = fs::write(
+        &js_file_path,
+        format!(
+          "export default \"Preprocessing failed:\\n{}\";",
+          failure.trim().escape_default()
+        ),
+      );
+
       return Err(failure);
     }
   }
 
-  let code_emit_path = Path::new(emit_path);
-  if !code_emit_path.exists() {
-    let _ = fs::create_dir(code_emit_path);
-  }
-
-  let js_file_path = code_emit_path.join(format!("{}.js", COMPILE_ERRORS_FILE)); // TODO mjs_mode
-
   // preprocess to reload
   match runner::preprocess::preprocess_ns_def(&reload_ns, &reload_def, &program_code, &init_def, None, check_warnings) {
     Ok(_) => (),

src/builtins.rs

@@ -184,6 +184,7 @@ pub fn is_proc_name(s: &str) -> bool {
       | "&record:nth"
       | "&record:get"
       | "&record:assoc"
+      | "&record:extend-as"
   )
 }
 
@@ -355,6 +356,7 @@ pub fn handle_proc(name: &str, args: &CalcitItems) -> Result<Calcit, String> {
     "&record:nth" => records::nth(args),
     "&record:get" => records::get(args),
     "&record:assoc" => records::assoc(args),
+    "&record:extend-as" => records::extend_as(args),
     a => Err(format!("No such proc: {}", a)),
   }
 }

src/builtins/records.rs

@@ -230,3 +230,64 @@ pub fn assoc(xs: &CalcitItems) -> Result<Calcit, String> {
     (None, ..) => Err(format!("record:assoc expected 3 arguments, got: {:?}", xs)),
   }
 }
+
+pub fn extend_as(xs: &CalcitItems) -> Result<Calcit, String> {
+  if xs.len() != 4 {
+    return Err(format!("record:extend-as expected 4 arguments, got: {:?}", xs));
+  }
+  match (xs.get(0), xs.get(1), xs.get(2), xs.get(3)) {
+    (Some(Calcit::Record(_name, fields, values)), Some(n), Some(a), Some(new_value)) => match a {
+      Calcit::Str(s) | Calcit::Keyword(s) | Calcit::Symbol(s, ..) => match find_in_fields(fields, s) {
+        Some(_pos) => Err(format!("field `{}` already existed", s)),
+        None => {
+          let mut next_fields: Vec<String> = vec![];
+          let mut next_values: Vec<Calcit> = vec![];
+          let mut inserted: bool = false;
+
+          for (i, k) in fields.iter().enumerate() {
+            if inserted {
+              next_fields.push(k.to_owned());
+              next_values.push(values[i].to_owned());
+            } else {
+              match s.cmp(k) {
+                Ordering::Less => {
+                  next_fields.push(s.to_owned());
+                  next_values.push(new_value.to_owned());
+
+                  next_fields.push(k.to_owned());
+                  next_values.push(values[i].to_owned());
+                  inserted = true;
+                }
+                Ordering::Greater => {
+                  next_fields.push(k.to_owned());
+                  next_values.push(values[i].to_owned());
+                }
+                Ordering::Equal => {
+                  unreachable!("does not equal")
+                }
+              }
+            }
+          }
+          if !inserted {
+            next_fields.push(s.to_owned());
+            next_values.push(new_value.to_owned());
+          }
+
+          let new_name: Result<String, String> = match n {
+            Calcit::Str(s) | Calcit::Keyword(s) | Calcit::Symbol(s, ..) => Ok(s.to_owned()),
+            _ => Err(format!("")),
+          };
+
+          Ok(Calcit::Record(
+            new_name?.to_owned(),
+            next_fields.to_owned(),
+            next_values.to_owned(),
+          ))
+        }
+      },
+      a => Err(format!("invalid field `{}` for {:?}", a, fields)),
+    },
+    (Some(a), ..) => Err(format!("record:extend-as expected a record, got: {}", a)),
+    (None, ..) => Err(format!("record:extend-as expected 4 arguments, got: {:?}", xs)),
+  }
+}

src/cirru/calcit-core.cirru

@@ -1310,6 +1310,7 @@
             :nth &record:nth
             :assoc &record:assoc
             :from-map &record:from-map
+            :extend-as &record:extend-as
 
         |&core-list-class $ quote
           defrecord! &core-list-class

ts-src/calcit.procs.ts

@@ -1,5 +1,5 @@
 // CALCIT VERSION
-export const calcit_version = "0.4.14";
+export const calcit_version = "0.4.16";
 
 import { overwriteComparator, initTernaryTreeMap } from "@calcit/ternary-tree";
 import { parse } from "@cirru/parser.ts";

ts-src/js-record.ts

@@ -1,4 +1,4 @@
-import { initTernaryTreeMap, Hash } from "@calcit/ternary-tree";
+import { initTernaryTreeMap, Hash, insert } from "@calcit/ternary-tree";
 import { CalcitValue } from "./js-primes";
 import { kwd, toString, getStringName, findInFields } from "./calcit-data";
 
@@ -203,3 +203,40 @@ export let _$n_record_$o_matches_$q_ = (x: CalcitValue, y: CalcitValue): boolean
   }
   return fieldsEqual(x.fields, y.fields);
 };
+
+export function _$n_record_$o_extend_as(obj: CalcitValue, new_name: CalcitValue, new_key: CalcitValue, new_value: CalcitValue) {
+  if (arguments.length !== 4) throw new Error(`Expected 4 arguments, got ${arguments.length}`);
+  if (!(obj instanceof CalcitRecord)) throw new Error("Expected record");
+  let field = getStringName(new_key);
+  let new_name_string = getStringName(new_name);
+  let new_fields: string[] = [];
+  let new_values: CalcitValue[] = [];
+  let inserted = false;
+
+  for (let i in new_fields) {
+    let k = new_fields[i];
+    if (inserted) {
+      new_fields.push(k);
+      new_values.push(obj.values[i]);
+    } else {
+      if (field < k) {
+        new_fields.push(field);
+        new_values.push(new_value);
+
+        new_fields.push(k);
+        new_values.push(obj.values[i]);
+      } else if (field > k) {
+        new_fields.push(k);
+        new_values.push(obj.values[i]);
+      } else {
+        throw new Error("Does not extend existed record field");
+      }
+    }
+  }
+  if (!inserted) {
+    new_fields.push(field);
+    new_values.push(new_value);
+  }
+
+  return new CalcitRecord(new_name_string, new_fields, new_values);
+}