[#16] improve test coverage & fix discovered bugs.

src/claro/data/error.cljc

@@ -20,7 +20,7 @@
 
 (defmethod print-method ResolutionError
   [^ResolutionError value ^java.io.Writer writer]
-  (.write writer "<error ")
+  (.write writer "#<claro/error ")
   (print-method (.-message value) writer)
   (when-let [data (.-data value)]
     (.write writer ", ")

src/claro/data/ops/collections.cljc

@@ -64,7 +64,19 @@
     p/every-processable?
     (wrap-assert-coll
       (fn [[v n]]
-        (core/nth v n))
+        (try
+          (core/nth v n)
+          (catch java.lang.IndexOutOfBoundsException e
+            (throw
+              (IllegalArgumentException.
+                (format
+                  (str "index %d out of bounds when calling 'nth'.%n"
+                       "resolvable: %s%n"
+                       "collection: %s")
+                  n
+                  (pr-str value)
+                  (pr-str v))
+                e)))))
       sequential?
       "can only apply 'nth' to sequentials, given:")))
 

src/claro/middleware/observe.cljc

@@ -87,7 +87,7 @@
               (engine/impl engine)
               (resolver env batch)
               (fn [result]
-                (when (predicate result)
+                (when (predicate batch)
                   (observer-fn result))
                 result))))
         (engine/wrap-transform engine))))

src/claro/projection/bind.cljc

@@ -15,7 +15,7 @@
             [template' (bind-fn partial-value)]
             (pr/project template' value))))))
 
-(defrecord BindProjection [template bind-fn]
+(deftype BindProjection [template bind-fn]
   pr/Projection
   (project [_ value]
     (then value #(bind-template % template bind-fn))))

src/claro/projection/case.cljc

@@ -33,7 +33,7 @@
 
 ;; ## Records
 
-(defrecord CaseResolvableProjection [class->template]
+(deftype CaseResolvableProjection [class->template]
   pr/Projection
   (project [_ value]
     (with-error? value
@@ -51,7 +51,7 @@
   (print-method (.-class->template value) w)
   (.write w ">"))
 
-(defrecord CaseProjection [class->template]
+(deftype CaseProjection [class->template]
   pr/Projection
   (project [_ value]
     (with-error? value

src/claro/projection/conditional.cljc

@@ -19,16 +19,22 @@
         (if else-template
           [:done (pr/project else-template value)]))))
 
-(defrecord ConditionalProjection [template
-                                  condition->template
-                                  else-template]
+(deftype ConditionalProjection [template
+                                condition->template
+                                else-template]
   pr/Projection
   (project [_ value]
     (with-error? value
       (-> (pr/project template value)
           (then!
             #(project-match condition->template else-template value %))))))
 
+(defmethod print-method ConditionalProjection
+  [^ConditionalProjection value ^java.io.Writer w]
+  (.write w "#<claro/conditional ")
+  (print-method (.-template value) w)
+  (.write w " => ...>"))
+
 ;; ## Constructors
 
 (defn- make-conditional

src/claro/projection/juxt.cljc

@@ -6,7 +6,7 @@
 
 ;; ## Record
 
-(defrecord JuxtProjection [templates]
+(deftype JuxtProjection [templates]
   pr/Projection
   (project [_ value]
     (with-error? value

src/claro/projection/level.cljc

@@ -31,11 +31,17 @@
         (map? value)        (project-map value current-level)
         :else               (project-coll value current-level)))
 
-(defrecord LevelProjection [n]
+(deftype LevelProjection [n]
   pr/Projection
   (project [_ value]
     (then value #(project-level % n))))
 
+(defmethod print-method LevelProjection
+  [^LevelProjection value ^java.io.Writer w]
+  (.write w "#<claro/level")
+  (print-method (.-n value) w)
+  (.write w ">"))
+
 ;; ## Constructor
 
 (defn levels

src/claro/projection/maps.cljc

@@ -112,7 +112,7 @@
 ;;
 ;; This can be used directly in maps to indicate a renamed/copied key.
 
-(defrecord AliasKey [alias-key key]
+(deftype AliasKey [alias-key key]
   MapKeyProjection
   (target-key [this value]
     (assert-no-override! this value alias-key)

src/claro/projection/maybe.cljc

@@ -5,7 +5,7 @@
 
 ;; ## Maybe
 
-(defrecord MaybeProjection [template]
+(deftype MaybeProjection [template]
   pr/Projection
   (project [_ value]
     (then value
@@ -38,7 +38,7 @@
 
 ;; ## Default
 
-(defrecord DefaultProjection [template default-value]
+(deftype DefaultProjection [template default-value]
   pr/Projection
   (project [_ value]
     (then value

src/claro/projection/objects.cljc

@@ -20,7 +20,7 @@
 
 ;; ## Templates
 
-(defrecord LeafProjection []
+(deftype LeafProjection []
   Projection
   (project [_ value]
     (chain-eager value assert-leaf)))
@@ -35,7 +35,7 @@
   (project [_ value]
     (chain-eager value assert-leaf)))
 
-(defrecord UnsafeProjection []
+(deftype UnsafeProjection []
   Projection
   (project [_ value]
     value))
@@ -50,8 +50,8 @@
 
 (defmethod print-method LeafProjection
   [value ^java.io.Writer writer]
-  (.write writer "<claro/leaf>"))
+  (.write writer "#<claro/leaf>"))
 
 (defmethod print-method UnsafeProjection
   [value ^java.io.Writer writer]
-  (.write writer "<claro/unsafe>"))
+  (.write writer "#<claro/unsafe>"))

src/claro/projection/parameters.cljc

@@ -58,7 +58,7 @@
       (assert-resolvable! params)
       (p/set-parameters params)))
 
-(defrecord ParametersProjection [params rest-template]
+(deftype ParametersProjection [params rest-template]
   pr/Projection
   (project [_ value]
     (with-error? value
@@ -91,13 +91,14 @@
 
 ;; ## Parameter Injection (w/ Null Tolerance)
 
-(defrecord MaybeParametersProjection [params rest-template]
+(deftype MaybeParametersProjection [params rest-template]
   pr/Projection
   (project [_ value]
     (with-error? value
-      (->> #(some-> % (inject-params params))
-           (tree/transform-partial value)
-           (pr/project rest-template)))))
+      (->> #(some-> %
+                    (inject-params params)
+                    (->> (pr/project rest-template)))
+           (tree/transform-partial value)))))
 
 (defmethod print-method MaybeParametersProjection
   [^MaybeParametersProjection value ^java.io.Writer w]

src/claro/projection/remove_nil.clj

@@ -39,15 +39,23 @@
 
 ;; ## Implementation
 
-(defrecord RemoveNilProjection [template]
+(deftype RemoveNilProjection [template]
   p/Projection
   (project [_ original]
     (with-error? original
       (let [result (then original remove-nil-elements*)]
         (if template
-          (p/project template result)
+          (then result #(p/project template %))
           result)))))
 
+(defmethod print-method RemoveNilProjection
+  [^RemoveNilProjection value ^java.io.Writer w]
+  (.write w "#<claro/remove-nil-elements")
+  (when-let [template (.-template value)]
+    (.write w " ")
+    (print-method template w))
+  (.write w ">"))
+
 ;; ## Wrappers
 
 (defn remove-nil-elements

src/claro/projection/sort.cljc

@@ -7,7 +7,7 @@
              [error :refer [with-error?]]
              [ops :as ops]]))
 
-(defrecord SortProjection [sort-template output-template]
+(deftype SortProjection [sort-template output-template]
   p/Projection
   (project [_ original]
     (with-error? original

src/claro/projection/transform.cljc

@@ -12,7 +12,7 @@
     (->> (tree/transform-partial value f)
          (pr/project rest-template))))
 
-(defrecord Preparation [f rest-template]
+(deftype Preparation [f rest-template]
   pr/Projection
   (project [_ value]
     (apply-preparation value f rest-template)))
@@ -32,7 +32,7 @@
 
 ;; ## Transformation (after Resolution)
 
-(defrecord Transformation [f input-template output-template]
+(deftype Transformation [f input-template output-template]
   pr/Projection
   (project [_ value]
     (with-error? value
@@ -76,7 +76,7 @@
 
 ;; ## Transformation to Finite Value
 
-(defrecord FiniteTransformation [f input-template]
+(deftype FiniteTransformation [f input-template]
   pr/Projection
   (project [_ value]
     (with-error? value

src/claro/projection/union.cljc

@@ -32,7 +32,7 @@
       (into {} maps))
     (first maps)))
 
-(defrecord UnionProjection [templates]
+(deftype UnionProjection [templates]
   pr/Projection
   (project [_ value]
     (with-error? value
@@ -53,7 +53,7 @@
     (into {} maps)
     (first maps)))
 
-(defrecord MergeProjection [templates]
+(deftype MergeProjection [templates]
   pr/Projection
   (project [_ value]
     (with-error? value

src/claro/projection/value.cljc

@@ -7,7 +7,7 @@
 
 ;; ## Record
 
-(defrecord ValueProjection [value template]
+(deftype ValueProjection [value template]
   pr/Projection
   (project [_ value']
     (with-error? value'

test/claro/data/ops/collections_test.clj

@@ -45,3 +45,39 @@
       [{nums1 :nums, r1 :resolvable} gen-collection
        {nums2 :nums, r2 :resolvable} gen-collection]
       (= (map + nums1 nums2) (run!! (ops/map + r1 r2))))))
+
+(defspec t-first (test/times 50)
+  (let [run!! (comp deref (make-engine))]
+    (prop/for-all
+      [{:keys [nums resolvable]} gen-collection]
+      (= (first nums) (run!! (ops/first resolvable))))))
+
+(defspec t-nth (test/times 50)
+  (let [run!! (comp deref (make-engine))]
+    (prop/for-all
+      [{:keys [nums resolvable]} gen-collection
+       n       gen/pos-int
+       wrapper (gen/elements [identity ->Identity])]
+      (let [value (ops/nth resolvable (wrapper n))]
+        (if (< n (count nums))
+          (= (nth nums n) (run!! value))
+          (boolean
+            (is
+              (thrown-with-msg?
+                java.lang.IllegalArgumentException
+                #"index \d+ out of bounds when calling 'nth'"
+                (run!! value)))))))))
+
+(defspec t-take (test/times 50)
+  (let [run!! (comp deref (make-engine))]
+    (prop/for-all
+      [{:keys [nums resolvable]} gen-collection
+       n gen/pos-int]
+      (= (take n nums) (run!! (ops/take n resolvable))))))
+
+(defspec t-drop (test/times 50)
+  (let [run!! (comp deref (make-engine))]
+    (prop/for-all
+      [{:keys [nums resolvable]} gen-collection
+       n gen/pos-int]
+      (= (drop n nums) (run!! (ops/drop n resolvable))))))

test/claro/data/ops/fmap_test.clj

@@ -0,0 +1,51 @@
+(ns claro.data.ops.fmap-test
+  (:require [clojure.test.check :as tc]
+            [clojure.test.check
+             [clojure-test :refer [defspec]]
+             [generators :as gen]
+             [properties :as prop]]
+            [clojure.test :refer :all]
+            [claro.test :as test]
+            [claro.data :as data]
+            [claro.data.ops.fmap :as ops]
+            [claro.engine.fixtures :refer [make-engine]]))
+
+;; ## Resolvable
+
+(defrecord Identity [v]
+  data/Resolvable
+  (resolve! [_ _]
+    v))
+
+(def gen-nums
+  (gen/not-empty
+    (gen/vector
+      (gen/one-of
+        [gen/int
+         (gen/fmap ->Identity gen/int)]))))
+
+(def gen-op
+  (gen/elements [vector + hash-set]))
+
+;; ## Tests
+
+(defspec t-fmap (test/times 100)
+  (let [run!! (comp deref (make-engine))]
+    (prop/for-all
+      [nums gen-nums, op gen-op]
+      (let [value (apply ops/fmap op nums)]
+        (= (apply op (run!! nums)) (run!! value))))))
+
+(defspec t-fmap-on (test/times 100)
+  (let [run!! (comp deref (make-engine))]
+    (prop/for-all
+      [nums gen-nums, op gen-op]
+      (let [value (apply ops/fmap-on #(every? number? %&) op nums)]
+        (= (apply op (run!! nums)) (run!! value))))))
+
+(defspec t-fmap! (test/times 100)
+  (let [run!! (comp deref (make-engine))]
+    (prop/for-all
+      [nums gen-nums, op gen-op]
+      (let [value (apply ops/fmap! op nums)]
+        (= (apply op (run!! nums)) (run!! value))))))