Whitespace / cleanup

dev-resources/bad_invariant.edn

@@ -26,4 +26,4 @@
             $before $after $txn $txs)
   [[?sum-before ?sum-after ?sum-change]]]
  [(= ?sum-before ?sum-after)]
- [(= ?sum-change 0) ?matches]])]]]
+ [(= ?sum-change 0) ?matches]]

src/invariant/datahike.clj

@@ -1,12 +1,12 @@
 (ns invariant.datahike
   (:refer-clojure :exclude [+])
-  (:require [datahike.api   :as d]
+  (:require [clojure.edn    :as edn]
+            [datahike.api   :as d]
             [datahike.core  :as dc]
             [datahike.query :as dq]
             [invariant.core]
             [invariant.query
-             :refer [assert-valid-query invariant-query]]
-            [clojure.edn :as edn]))
+             :refer [assert-valid-query invariant-query]]))
 
 (alter-var-root #'dq/built-ins assoc 'subquery datahike.api/q)
 
@@ -45,11 +45,11 @@
                    [(get-attribute tx) tx])
         attrs    (distinct (map first attr-txs))]
     (doseq [[a tx] attr-txs
-            :when (= a :invariant/query)
-            :let  [[_ _ _ v] tx]]
+            :when  (= a :invariant/query)
+            :let   [[_ _ _ v] tx]]
       (assert-valid-query (edn/read-string v)))
 
-    (doseq [a attrs
+    (doseq [a     attrs
             :let  [inv-qs (d/q invariant-query @conn a)]
             :when inv-qs]
       (when-not (invariant-holds? inv-qs conn tx-data schema)

src/invariant/datomic.clj

@@ -1,12 +1,15 @@
 (ns invariant.datomic
   (:refer-clojure :exclude [+])
-  (:require [datomic.api     :as api]
+  (:require [clojure.edn     :as edn]
+            [datomic.api     :as api]
             [datalog.parser  :as p]
-            [clojure.edn     :as edn]
+            [datalog.unparser
+             :refer [unparse]]
             [invariant.core]
             [invariant.query
-             :refer [assert-valid-query invariant-query]]
-            [datalog.unparser :refer [unparse]]))
+             :refer [assert-valid-query invariant-query]])
+  (:import  [datalog.parser.type
+             Function]))
 
 (defn get-attribute-dispatch [v]
   (first v))
@@ -22,7 +25,7 @@
   a)
 
 (let [subq-selector (comp #{'subquery} :symbol :fn)
-      fn-selector   (comp #{datalog.parser.type.Function} type)]
+      fn-selector   (comp #{Function} type)]
   (defn unnest-deep-queries [[_ [_ query] & sources]]
     (let [res              (p/parse query)
           clean-clauses    (remove subq-selector (:qwhere res))
@@ -89,12 +92,12 @@
                    [(get-attribute tx) tx])
         attrs    (distinct (map first attr-txs))]
     (doseq [[a tx] attr-txs
-            :when (= a :invariant/query)
-            :let [[_ _ _ v] tx]]
+            :when  (= a :invariant/query)
+            :let   [[_ _ _ v] tx]]
       (assert-valid-query (edn/read-string v)))
 
-    (doseq [a attrs
-            :let [inv-qs (api/q invariant-query (api/db conn) a)]
+    (doseq [a     attrs
+            :let  [inv-qs (api/q invariant-query (api/db conn) a)]
             :when inv-qs]
       (when-not (invariant-holds? inv-qs conn tx-data schema)
         (throw (ex-info "Invariant mismatch."

src/invariant/query.clj

@@ -1,19 +1,21 @@
 (ns invariant.query
   (:require [datalog.parser :as p]
             [datalog.parser.type]
-            [datahike.query]))
+            [datahike.query])
+  (:import  [datalog.parser.type
+             Function
+             Predicate]))
 
 (def invariant-query '[:find ?q .
-                       :in $ ?a
+                       :in   $ ?a
                        :where
-                       [?e :invariant/rule ?a]
+                       [?e :invariant/rule  ?a]
                        [?e :invariant/query ?q]])
 
 (def ^:dynamic *allowed-fns*
   (into #{'subquery} (keys datahike.query/built-ins)))
 
-(def ^:private fn-selector (comp #{datalog.parser.type.Function
-                                   datalog.parser.type.Predicate} type))
+(def ^:private fn-selector (comp #{Function Predicate} type))
 
 (defn assert-safe-query [query]
   (doseq [c    (filter fn-selector (:qwhere (p/parse query)))

test/invariant/datahike_test.clj

@@ -12,7 +12,7 @@
              :refer [read-resource]]
             [datahike.api                :as d
              :refer [q]]
-            [datahike.core  :as dc]))
+            [datahike.core               :as dc]))
 
 (deftest attribute-test
   (testing "Attribute extraction."

test/invariant/test/common.clj

@@ -1,11 +1,11 @@
 (ns invariant.test.common
-  (:require [datalog.parser]
+  (:require [clojure.walk
+             :refer [prewalk-replace]]
+            [datalog.parser]
             [datalog.parser.type]
             [invariant.test.util
              :refer [read-resource]]
-            [invariant.backend :as backend]
-            [clojure.walk
-             :refer [prewalk-replace]]))
+            [invariant.backend :as backend]))
 
 (def example-txs (read-resource "example_txs.edn"))
 
@@ -58,16 +58,11 @@
     (let [tid (backend/tempid backend -1)
           txn [[:db/add tid :invariant/rule  :account/balance]
                [:db/add tid :invariant/query (pr-str bad-invariant)]]]
-      (= '{:type :invariant/invalid-function-call,
-           :call #datalog.parser.type.Predicate
-           {:fn   #datalog.parser.type.PlainSymbol{:symbol evil-haha},
-            :args [#datalog.parser.type.Constant{:value 1}
-                   #datalog.parser.type.Constant{:value 2}
-                   #datalog.parser.type.Constant{:value 3}]}}
+      (= :invariant/invalid-function-call
          (try
            (backend/assert-invariants backend txn schema)
            (catch Exception e
-             (ex-data e)))))))
+             (-> e ex-data :type)))))))
 
 (defn- adjust-invariant [q {bigdec? :bigdec?}]
   (prewalk-replace {'sum-change-expected (cond-> 0 bigdec? bigdec)} q))