started error support; minor clean up

frontend/src/js/index.js

@@ -15,7 +15,11 @@ function getVariables(expression) {
     try {
         const expressionObject = parse(expression);
         console.log('now returning', expressionObject);
-        return expressionObject.filter(x => x.isSymbolNode).map(x => x.name);
+        return expressionObject
+            .filter(x => x.isSymbolNode)
+            .map(x => x.name)
+            .map(x => x.toUpperCase())
+            .filter(x => /^[A-Z]+[0-9]+$/.test(x));
     }
     catch(e) {
         console.error('error in parsing or filtering for variables', e.message || e);
@@ -23,5 +27,15 @@ function getVariables(expression) {
     }
 }
 
-window.mathjs = {parse, evaluate, getVariables};
+function customEval(...args) {
+    try {
+        return evaluate(...args);
+    }
+    catch(e) {
+        console.error('error in evaluating expression', e.message || e);
+        return {error: e.message};
+    }
+}
+
+window.mathjs = {parse, evaluate: customEval, getVariables};
 

frontend/src/microtables_frontend/core.cljs

@@ -27,14 +27,14 @@
 (defn highest [dir data] (apply max (map dir data)))
 
 ; COLUMN NAMES
-(defn upgrade-letter-code [s]
+(defn increment-letter-code [s]
   (let [l (last s)]
     (cond
       (empty? s) [65]
-      (= l 90) (conj (upgrade-letter-code (subvec s 0 (dec (count s)))) 65)
+      (= l 90) (conj (increment-letter-code (subvec s 0 (dec (count s)))) 65)
       :else (conj (subvec s 0 (dec (count s))) (inc l)))))
 (defn next-letter [lc]
-  (apply str (map char (upgrade-letter-code (mapv #(.charCodeAt % 0) lc)))))
+  (apply str (map char (increment-letter-code (mapv #(.charCodeAt % 0) lc)))))
 (def col-letters (iterate next-letter "A"))
 
 
@@ -54,7 +54,10 @@
 (def parse-variables (memoize (fn [expression]
                                 (js->clj (.getVariables mathjs expression)))))
 (def evaluate-expression (memoize (fn [expression variables]
-                                    (.evaluate mathjs expression (clj->js variables)))))
+                                    (let [answer (.evaluate mathjs expression (clj->js variables))]
+                                      (if (nil? (.-error answer))
+                                        answer
+                                        :calc-error)))))
 
 (def str->rc (memoize (fn [s]
                         (let [c (re-find #"^[A-Z]+" s)
@@ -129,6 +132,8 @@
 (defn on-enter-cell [c r e]
   (println (str "entering cell " c r))
   (swap! data-atom #(toggle-display % c r :value)))
+(defn on-change [c r datum e]
+  (update-value c r datum (.. e -target -value)))
 (defn on-leave-cell [c r e]
   (println (str "leaving cell " c r))
   (swap! data-atom #(as-> % data
@@ -145,7 +150,7 @@
     ^{:key (str c r)} [:td [:input {:value (if (= (get datum :view nil) :value)
                                              (get datum :value "")
                                              (get datum :error (get datum :display (get datum :value ""))))
-                                    :on-change #(update-value c r datum (.. % -target -value))
+                                    :on-change (partial on-change c r datum)
                                     :on-blur (partial on-leave-cell c r)
                                     :on-focus (partial on-enter-cell c r)}]]))
 (defn row [r cols data]