simple implementation of unwrapping dataspecs from specs created usin…

docs/02_data_specs.md

@@ -133,3 +133,38 @@ All generated specs are wrapped into Specs Records so transformations works out
 ; :description "Liisa is a valid boss"
 ; :address nil}
 ```
+
+In clojure, you can also go from the other way around, providing a
+`spec` created by `ds/spec` to an `ds/unspec` function which will
+recover the original data definitions.
+
+```clj
+(def person-spec
+ (ds/spec
+ {:name ::person
+ :spec person}))
+
+(ds/unspec person-spec)
+;; {::id integer?
+;; ::age #'clojure.core/pos-int?
+;; :boss boolean?
+;; :name string?
+;; (ds/opt :description) string?
+;; :languages #{keyword?}
+;; :aliases [(ds/or {:maps {:alias string?}
+;; :strings string?})]
+;; :orders [{:id int?
+;; :description string?}]
+;; :address (ds/maybe
+;; {:street string?
+;; :zip string?})}
+
+
+```
+
+The main differences here is related to `ds/req` and full-qualified
+keywords, as we recover the values associated with these vars, the
+function `pos-int?` will be returned instead of `::age`. The `ds/req`
+function will not be returned because `data spec` understand the lack
+of the `ds/opt` always required, therefore we have an equivalent
+answer.

src/spec_tools/data_spec.cljc

@@ -193,3 +193,46 @@
  :else (maybe-named-spec (st/create-spec {:spec data})))))
  ([name data]
  (spec {:name name, :spec data})))
+
+
+(defmulti unwalk (fn [{:keys [type]}]
+ (parse/type-dispatch-value type)) :default ::default)
+
+(defmethod unwalk ::default [{:keys [form]}]
+ #?(:clj (var-get (resolve form))
+ :cljs @(resolve (quote form))))
+
+(defmethod unwalk :nilable [{:keys [form]}]
+ (maybe (unwalk (st/create-spec (second (second form))))))
+
+(defmethod unwalk :vector [{:keys [::parse/item form]}]
+ (if (= (parse/type-dispatch-value (:type item)) :or)
+ [(unwalk (st/create-spec {:spec (second form)}))]
+ [(unwalk (st/create-spec item))]))
+
+(defmethod unwalk :map [{:keys [::parse/key->spec ::parse/keys-opt]}]
+ (reduce-kv
+ (fn [acc key val]
+ (if (qualified-keyword? val)
+ (let [maybe-key (if (contains? keys-opt key) (opt key) key)
+ spec (s/get-spec val)
+ -spec (if (st/spec? spec) spec {:spec val})]
+ (assoc acc maybe-key (unwalk (st/create-spec -spec))))
+ val))
+ {}
+ key->spec))
+
+(defmethod unwalk :set [{:keys [::parse/item]}]
+ #{(unwalk (st/create-spec item))})
+
+(defmethod unwalk :or [{:keys [form ::parse/items]}]
+ (let [labels (take-nth 2 (rest form))]
+ (or (reduce
+ (fn [acc [k spec]]
+ (assoc acc k (unwalk (st/create-spec (parse/parse-spec spec)))))
+ {}
+ (map vector labels items)))))
+
+(defn unspec [spec]
+ (let [-spec (if (st/spec? spec) spec (st/create-spec {:spec spec}))]
+ (unwalk -spec)))

test/cljc/spec_tools/data_spec_test.cljc

@@ -2,13 +2,16 @@
  (:require [clojure.test :refer [deftest testing is]]
  [clojure.spec.alpha :as s]
  [spec-tools.data-spec :as ds]
+ #?(:clj [clojure.test.check.generators :as gen])
+ #?(:clj [com.gfredericks.test.chuck.clojure-test :refer [checking]])
  [spec-tools.core :as st]
  [spec-tools.spec :as spec])
  #?(:clj
  (:import clojure.lang.ExceptionInfo)))
 
 (s/def ::age (s/and spec/integer? #(> % 10)))
 
+
 (deftest data-spec-tests
  (testing "nested data-spec"
  (let [person {::id integer?
@@ -302,3 +305,79 @@
  (testing "nested maps have a name"
  (let [spec (st/get-spec :spec-tools.data-spec-test$named3/map)]
  (is (and spec (:name spec)))))))
+
+#?(:clj
+ (deftest unspecing
+ (testing "simpler possible specs"
+ (is (= int? (ds/unspec (ds/spec {:name ::t1 :spec int?}))))
+ (is (= string? (ds/unspec (ds/spec {:name ::t1 :spec string?}))))
+ (is (= float? (ds/unspec (ds/spec {:name ::t1 :spec float?}))))
+ (is (= boolean? (ds/unspec (ds/spec {:name ::t1 :spec boolean?}))))
+ (is (= keyword? (ds/unspec (ds/spec {:name ::t1 :spec keyword?})))))
+
+ (testing "simple map using data-spec"
+ (let [ds1 {:street string?
+ :number int?
+ :value float?
+ :is_main? boolean?
+ :clj-programmer? keyword?}]
+ (is (= ds1 (ds/unspec (ds/spec {:name ::ds1 :spec ds1}))))
+
+ (testing "we can handle nillable keywords"
+ (let [ds2 (merge ds1 {:address (ds/maybe {:street string?
+ :number int?})
+ :city string?})]
+ (is (= ds2 (ds/unspec (ds/spec {:name ::ds2 :spec ds2}))))))
+
+ (testing "also vector field, that also should be homogeneous."
+ (let [ds3 (merge ds1 {:orders [{:id int?
+ :description string?}]})]
+ (is (= ds3 (ds/unspec (ds/spec {:name ::ds3 :spec ds3}))))))
+
+ (testing "support for a set"
+ (let [ds4 (assoc ds1 :languages #{keyword?})
+ ds5 (assoc ds1 :languages #{string?})
+ ds6 (assoc ds1 :languages #{int?})
+ ds7 (assoc ds1 :languages #{boolean?})]
+ (is (= ds4 (ds/unspec (ds/spec {:name ::ds4 :spec ds4}))))
+ (is (= ds5 (ds/unspec (ds/spec {:name ::ds5 :spec ds5}))))
+ (is (= ds6 (ds/unspec (ds/spec {:name ::ds6 :spec ds6}))))
+ (is (= ds7 (ds/unspec (ds/spec {:name ::ds7 :spec ds7}))))))
+
+ (testing "support for or operator"
+ (let [ds8 (merge ds1 {:aliases [(or {:maps {:alias string?}
+ :strings string?})]})
+ ds9 (merge ds1 {:testing [(or {:ints int?
+ :bol boolean?
+ :val float?
+ :key keyword?})]})]
+ (is (= ds8 (ds/unspec (ds/spec {:name ::ds8 :spec ds8}))))
+ (is (= ds9 (ds/unspec (ds/spec {:name ::ds9 :spec ds9}))))))))))
+
+#?(:clj
+ (def unspec-gen (let [-kw? (gen/return keyword?)
+ -str? (gen/return string?)
+ -bol? (gen/return boolean?)
+ -flt? (gen/return float?)
+ -int? (gen/return integer?)
+ -compound [-kw? -str? -bol? -flt? -int?]
+ -vec? (gen/vector (gen/one-of -compound) 1)
+ -set? (gen/set (gen/one-of -compound) {:num-elements 1})
+ -map? (fn [inner-gen] (gen/not-empty (gen/map gen/keyword inner-gen)))
+ -map-opt? (fn [inner-gen] (gen/not-empty (gen/map (gen/bind gen/keyword
+ (fn [k]
+ (gen/return (ds/opt k))))
+ inner-gen)))]
+ (gen/recursive-gen (fn [inner-gen]
+ (gen/frequency
+ [[3 (-map? inner-gen)]
+ [3 (-map-opt? inner-gen)]
+ [2 (gen/fmap (fn [v] (ds/or v)) (-map? inner-gen))]
+ [2 (gen/fmap (fn [v] (ds/maybe v)) (-map? inner-gen))]]))
+ (gen/one-of (concat -compound [-vec? -set?]))))))
+
+#?(:clj
+ (deftest property-spec->unspec->spec
+ (checking "able to perform a complete round-trip going from data-spec -> spec -> data-spec again" 200
+ [data-spec unspec-gen]
+ (is (ds/unspec (ds/spec {:name ::property-based :spec data-spec}))))))