CLJS-1978: port CLJ-2035

Author: anmonteiro

src/main/cljs/cljs/spec.cljc

@@ -201,6 +201,15 @@
   [& pred-forms]
   `(and-spec-impl '~(mapv #(res &env %) pred-forms) ~(vec pred-forms) nil))
 
+(defn- res-kind
+  [env opts]
+  (let [{kind :kind :as mopts} opts]
+    (->>
+      (if kind
+        (assoc mopts :kind `~(res env kind))
+        mopts)
+      (mapcat identity))))
+
 (defmacro every
   "takes a pred and validates collection elements against that pred.
 
@@ -231,7 +240,11 @@
   See also - coll-of, every-kv
 "
   [pred & {:keys [into kind count max-count min-count distinct gen-max gen-into gen] :as opts}]
-  (let [nopts (-> opts (dissoc :gen) (assoc ::kind-form `'~(res &env (:kind opts))))
+  (let [desc (::describe opts)
+        nopts (-> opts
+                (dissoc :gen ::describe)
+                (assoc ::kind-form `'~(res &env (:kind opts))
+                       ::describe (clojure.core/or desc `'(every ~(res &env pred) ~@(res-kind &env opts)))))
         gx (gensym)
         cpreds (cond-> [(list (clojure.core/or kind `coll?) gx)]
                  count (conj `(= ~count (c/bounded-count ~count ~gx)))
@@ -253,7 +266,8 @@
   See also - map-of"
 
   [kpred vpred & opts]
-  `(every (tuple ~kpred ~vpred) ::kfn (fn [i# v#] (nth v# 0)) :into {} ~@opts))
+  (let [desc `(every-kv ~(res &env kpred) ~(res &env vpred) ~@(res-kind &env opts))]
+    `(every (tuple ~kpred ~vpred) ::kfn (fn [i# v#] (nth v# 0)) :into {} ::describe '~desc ~@opts)))
 
 (defmacro coll-of
   "Returns a spec for a collection of items satisfying pred. Unlike
@@ -267,7 +281,8 @@
 
   See also - every, map-of"
   [pred & opts]
-  `(every ~pred ::conform-all true ~@opts))
+  (let [desc `(coll-of ~(res &env pred) ~@(res-kind &env opts))]
+    `(every ~pred ::conform-all true ::describe '~desc ~@opts)))
 
 (defmacro map-of
   "Returns a spec for a map whose keys satisfy kpred and vals satisfy
@@ -280,7 +295,8 @@
 
   See also - every-kv"
   [kpred vpred & opts]
-  `(every-kv ~kpred ~vpred ::conform-all true :kind map? ~@opts))
+  (let [desc `(map-of ~(res &env kpred) ~(res &env vpred) ~@(res-kind &env opts))]
+    `(every-kv ~kpred ~vpred ::conform-all true :kind map? ::describe '~desc ~@opts)))
 
 (defmacro *
   "Returns a regex op that matches zero or more values matching

src/main/cljs/cljs/spec.cljs

@@ -793,6 +793,7 @@
   "Do not call this directly, use 'every', 'every-kv', 'coll-of' or 'map-of'"
   ([form pred opts] (every-impl form pred opts nil))
   ([form pred {gen-into :into
+               describe-form ::describe
                :keys [kind ::kind-form count max-count min-count distinct gen-max ::kfn ::cpred
                       conform-keys ::conform-all]
                :or {gen-max 20}
@@ -906,7 +907,7 @@
                      (gen/vector pgen 0 gen-max))))))))
 
        (with-gen* [_ gfn] (every-impl form pred opts gfn))
-       (describe* [_] `(every ~form ~@(mapcat identity opts)))))))
+       (describe* [_] (c/or describe-form `(every ~(s/res form) ~@(mapcat identity opts))))))))
 
 ;;;;;;;;;;;;;;;;;;;;;;; regex ;;;;;;;;;;;;;;;;;;;
 ;;See:

src/test/cljs/cljs/spec_test.cljs

@@ -241,6 +241,30 @@
       ;;coll [:a "b"] ::s/invalid '[{:pred (coll-checker keyword?), :val [:a b]}]
       )))
 
+(deftest coll-form
+  (are [spec form]
+    (= (s/form spec) form)
+    (s/map-of int? any?)
+    '(cljs.spec/map-of cljs.core/int? cljs.core/any?)
+
+    (s/coll-of int?)
+    '(cljs.spec/coll-of cljs.core/int?)
+
+    (s/every-kv int? int?)
+    '(cljs.spec/every-kv cljs.core/int? cljs.core/int?)
+
+    (s/every int?)
+    '(cljs.spec/every cljs.core/int?)
+
+    (s/coll-of (s/tuple (s/tuple int?)))
+    '(cljs.spec/coll-of (cljs.spec/tuple (cljs.spec/tuple cljs.core/int?)))
+
+    (s/coll-of int? :kind vector?)
+    '(cljs.spec/coll-of cljs.core/int? :kind cljs.core/vector?)
+
+    (s/coll-of int? :gen #(gen/return [1 2]))
+    '(cljs.spec/coll-of cljs.core/int? :gen (fn* [] (gen/return [1 2])))))
+
 (comment
 
   (run-tests)