:map-of now works with an entry model instead of separated key model and value model. (Fixes #8)

Author: green-coder

CHANGELOG.md

@@ -11,6 +11,8 @@ Versions prior to v0.1.0 are considered experimental, their API may change.
 
 - `describe` on a tuple where at least one entry has a defined :key will return
   a map of the entries with a key instead of a vector of all the entries.
+- :map-of no longer work with a key model and/or a value model. It works with an entry model insead.
+  `describe` on a :map-of returns a vector of the description of its entries.
 
 ## [0.0.7] - 2020-09-20
 

src/minimallist/core.cljc

@@ -105,10 +105,8 @@
                                              (-valid? context (:model entry) (get data (:key entry)))
                                              (:optional entry)))
                                          (:entries model)))
-                        (implies (contains? model :keys)
-                                 (every? (partial -valid? context (-> model :keys :model)) (keys data)))
-                        (implies (contains? model :values)
-                                 (every? (partial -valid? context (-> model :values :model)) (vals data)))
+                        (implies (contains? model :entry-model)
+                                 (every? (partial -valid? context (:entry-model model)) data))
                         (implies (contains? model :condition-model)
                                  (-valid? context (:condition-model model) data)))
     (:sequence-of :sequence) (and (sequential? data)
@@ -218,9 +216,7 @@
          :desc data}
     :set-of (if (set? data)
               (let [entries (when (contains? model :elements-model)
-                              (into #{}
-                                    (map (partial -describe context (:elements-model model)))
-                                    data))
+                              (mapv (partial -describe context (:elements-model model)) data))
                     valid? (and (implies (contains? model :elements-model)
                                          (every? :valid? entries))
                                 (implies (contains? model :count-model)
@@ -230,25 +226,12 @@
                 {:valid? valid?
                  :desc (into #{} (map :desc) entries)}))
     :map-of (if (map? data)
-              (let [key-model (-> model :keys :model)
-                    values-model (-> model :values :model)
-                    entries (into {}
-                                  (map (fn [[key value]]
-                                         [(if key-model
-                                            (-describe context key-model key)
-                                            {:valid? true, :desc key})
-                                          (if values-model
-                                            (-describe context values-model value)
-                                            {:valid? true, :desc key})]))
-                                  data)
-                    valid? (and (implies (contains? model :keys)
-                                         (every? :valid? (keys entries)))
-                                (implies (contains? model :values)
-                                         (every? :valid? (vals entries)))
+              (let [entries (mapv (partial -describe context (:entry-model model)) data)
+                    valid? (and (every? :valid? entries)
                                 (implies (contains? model :condition-model)
                                          (:valid? (-describe context (:condition-model model) data))))]
                 {:valid? valid?
-                 :desc (into {} (map (fn [[k v]] [(:desc k) (:desc v)])) entries)})
+                 :desc (mapv :desc entries)})
               {:valid? false})
     :map (if (map? data)
            (let [entries (into {}

src/minimallist/generator.cljc

@@ -87,8 +87,7 @@
                                    (contains? model :elements-model)
                                    (reduce-update :elements-model walk (conj path :elements-model)))
                        :map-of (-> [[stack walked-bindings] model]
-                                   (reduce-update-in [:keys :model] walk (conj path :keys :model))
-                                   (reduce-update-in [:values :model] walk (conj path :values :model)))
+                                   (reduce-update :entry-model walk (conj path :entry-model)))
                        (:and :or
                         :map :sequence
                         :alt :cat) (cond-> [[stack walked-bindings] model]
@@ -144,11 +143,10 @@
   [model stack path]
   (let [distance (case (:type model)
                    (:fn :enum) 0
-                   :map-of (let [key-distance (-> model :keys :model ::leaf-distance)
-                                 value-distance (-> model :values :model ::leaf-distance)]
+                   :map-of (let [entry-distance (-> model :entry-model ::leaf-distance)]
                              (cond
                                (zero? (min-count-value model)) 0
-                               (and key-distance value-distance) (inc (max key-distance value-distance))))
+                               (some? entry-distance) (inc entry-distance)))
                    (:set-of
                     :sequence-of
                     :repeat) (if (or (not (contains? model :elements-model))
@@ -186,11 +184,12 @@
                    (:fn :enum) (::min-cost model 1)
                    :map-of (let [container-cost 1
                                  min-count (min-count-value model)
-                                 key-min-cost (-> model :keys :model ::min-cost)
-                                 value-min-cost (-> model :values :model ::min-cost)
+                                 entry-min-cost (-> model :entry-model ::min-cost
+                                                    ; cancel the cost of the entry's vector
+                                                    (some-> dec))
                                  content-cost (if (zero? min-count) 0
-                                                (when (and min-count key-min-cost value-min-cost)
-                                                  (* min-count (+ key-min-cost value-min-cost))))]
+                                                (when (and min-count entry-min-cost)
+                                                  (* min-count entry-min-cost)))]
                              (some-> content-cost (+ container-cost)))
                    (:set-of
                     :sequence-of
@@ -392,10 +391,8 @@
 
         :map-of (cond->> (let [budget (max 0 (dec budget)) ; the collection itself costs 1
                                count-model (:count-model model)
-                               keys-model (-> model :keys :model)
-                               values-model (-> model :values :model)
-                               entry-min-cost (+ (::min-cost keys-model)
-                                                 (::min-cost values-model))
+                               entry-model (:entry-model model)
+                               entry-min-cost (::min-cost entry-model)
                                coll-max-size (int (/ budget entry-min-cost))
                                coll-size-gen (if count-model
                                                (generator context count-model 0)
@@ -407,10 +404,7 @@
                                entries-gen (gen/bind budgets-gen
                                                      (fn [entry-budgets]
                                                        (apply gen/tuple
-                                                              (mapv (fn [entry-budget]
-                                                                      (gen/tuple
-                                                                        (generator context keys-model entry-budget)
-                                                                        (generator context values-model entry-budget)))
+                                                              (mapv (partial generator context entry-model)
                                                                     entry-budgets))))
                                map-gen (gen/fmap (fn [entries]
                                                    (into {} entries))

src/minimallist/helper.cljc

@@ -121,12 +121,10 @@
    :elements-model elements-model})
 
 (defn map-of
-  "Model of a hashmap associating values of a specific model
-   to values of another specific model."
-  [keys-model values-model]
+  "Model of a hashmap made of entries (2-vector) of a specific model."
+  [entry-model]
   {:type :map-of
-   :keys {:model keys-model}
-   :values {:model values-model}})
+   :entry-model entry-model})
 
 (defn sequence-of
   "Model of a sequence of values, all matching a specific model."

src/minimallist/minimap.cljc

@@ -16,10 +16,9 @@
                                      (h/with-optional-entries [:count-model (h/ref 'model)]
                                                               [:elements-model (h/ref 'model)]
                                                               [:condition-model (h/ref 'model)]))]
-                        [:map-of (-> (h/map [:type (h/val :map-of)])
-                                     (h/with-optional-entries [:keys (h/map [:model (h/ref 'model)])]
-                                                              [:values (h/map [:model (h/ref 'model)])]
-                                                              [:condition-model (h/ref 'model)]))]
+                        [:map-of (-> (h/map [:type (h/val :map-of)]
+                                            [:entry-model (h/ref 'model)])
+                                     (h/with-optional-entries [:condition-model (h/ref 'model)]))]
                         [:map (-> (h/map [:type (h/val :map)])
                                   (h/with-optional-entries [:entries (h/vector-of (-> (h/map [:key (h/fn any?)]
                                                                                              [:model (h/ref 'model)])

test/minimallist/core_test.cljc

@@ -89,8 +89,7 @@
                     {:a 1, :b 'bar, [1 2 3] "soleil !"}]
 
                    ;; map, keys and values
-                   (h/map-of (h/fn keyword?)
-                             (h/fn int?))
+                   (h/map-of (h/vector (h/fn keyword?) (h/fn int?)))
                    [{} {:a 1, :b 2}]
                    [{:a 1, :b "2"} [[:a 1] [:b 2]] {true 1, false 2}]
 
@@ -317,15 +316,23 @@
                     ; extra entry
                     {:a 1, :b 2, :c 3} {:a 1, :b 2}]
 
-                   ;; map-of - :keys
-                   (h/map-of (h/fn keyword?) (h/fn any?))
-                   [{:a 1, :b 2} {:a 1, :b 2}
+                   ;; map-of - entry-model
+                   (h/map-of (h/vector (h/fn keyword?) (h/fn int?)))
+                   [{:a 1, :b 2} [[:a 1] [:b 2]]
                     {"a" 1} :invalid]
 
-                   ;; map-of - :values
-                   (h/map-of (h/fn any?) (h/fn int?))
-                   [{:a 1, "b" 2} {:a 1, "b" 2}
-                    {:a "1"} :invalid]
+                   ;; map-of - real world use case
+                   (h/map-of (h/alt [:symbol (h/vector (h/fn simple-symbol?) (h/fn keyword?))]
+                                    [:keys (h/vector (h/val :keys) (h/vector-of (h/fn symbol?)))]
+                                    [:as (h/vector (h/val :as) (h/fn simple-symbol?))]))
+                   '[{first-name :first-name
+                      last-name :last-name
+                      :keys [foo bar]
+                      :as foobar}
+                     [[:symbol [first-name :first-name]]
+                      [:symbol [last-name :last-name]]
+                      [:keys [:keys [foo bar]]]
+                      [:as [:as foobar]]]]
 
                    ;; sequence - :elements-model
                    (h/sequence-of (h/fn int?))

test/minimallist/generator_test.cljc

@@ -220,21 +220,27 @@
                         ::mg/min-cost 1}}]
      ::mg/min-cost 2}
 
-    (h/map-of (h/fn keyword?) (h/fn int?))
+    (h/map-of (h/vector (h/fn keyword?) (h/fn int?)))
     {:type :map-of
-     :keys {:model {:type :fn
-                    ::mg/min-cost 1}}
-     :values {:model {:type :fn
-                      ::mg/min-cost 1}}
+     :entry-model {:type :sequence
+                   :coll-type :vector
+                   :entries [{:model {:type :fn
+                                      ::mg/min-cost 1}}
+                             {:model {:type :fn
+                                      ::mg/min-cost 1}}]
+                   ::mg/min-cost 3}
      ::mg/min-cost 1}
 
-    (-> (h/map-of (h/fn keyword?) (h/fn int?))
+    (-> (h/map-of (h/vector (h/fn keyword?) (h/fn int?)))
         (h/with-count (h/enum #{3 4})))
     {:type :map-of
-     :keys {:model {:type :fn
-                    ::mg/min-cost 1}}
-     :values {:model {:type :fn
-                      ::mg/min-cost 1}}
+     :entry-model {:type :sequence
+                   :coll-type :vector
+                   :entries [{:model {:type :fn
+                                      ::mg/min-cost 1}}
+                             {:model {:type :fn
+                                      ::mg/min-cost 1}}]
+                   ::mg/min-cost 3}
      :count-model {:type :enum
                    :values #{3 4}}
      ::mg/min-cost 7}
@@ -292,7 +298,7 @@
                        (h/with-count (h/enum #{1 2 3 10}))
                        (h/with-condition (h/fn (comp #{1 2 3} count))))))
 
-  (tcg/sample (gen (h/map-of fn-int? fn-string?)))
+  (tcg/sample (gen (h/map-of (h/vector fn-int? fn-simple-symbol?))))
 
   (tcg/sample (gen (-> (h/map [:a fn-int?])
                        (h/with-optional-entries [:b fn-string?]))))
@@ -324,10 +330,10 @@
   (tcg/sample (gen (h/let ['node (h/set-of (h/ref 'node))]
                           (h/ref 'node))))
 
-  (tcg/sample (gen (h/let ['node (h/map-of fn-int? (h/ref 'node))]
+  (tcg/sample (gen (h/let ['node (h/map-of (h/vector fn-int? (h/ref 'node)))]
                           (h/ref 'node)) 50))
 
-  (tcg/sample (gen (h/let ['node (h/map-of fn-keyword? (h/ref 'node))]
+  (tcg/sample (gen (h/let ['node (h/map-of (h/vector fn-keyword? (h/ref 'node)))]
                           (h/ref 'node)) 100) 1)
 
   (tcg/sample (gen (h/map [:a fn-int?])))
@@ -372,7 +378,7 @@
     (is (every? (partial valid? model)
                 (tcg/sample (gen model)))))
 
-  (let [model (h/map-of fn-int? fn-string?)]
+  (let [model (h/map-of (h/vector fn-int? fn-string?))]
     (is (every? (partial valid? model)
                 (tcg/sample (gen model)))))
 
@@ -455,7 +461,7 @@
                 (tcg/sample (gen model)))))
 
   ;; Budget-based limit on variable map size.
-  (let [model (h/let ['node (h/map-of fn-int? (h/ref 'node))]
+  (let [model (h/let ['node (h/map-of (h/vector fn-int? (h/ref 'node)))]
                 (h/ref 'node))]
     (is (every? (partial valid? model)
                 (tcg/sample (gen model)))))