predicates: introduce coercions

Author: vemv

README.md

@@ -5,7 +5,7 @@ Utilities for [clojure.spec](https://github.com/clojure/spec.alpha).
 ## Installation
 
 ```clojure
-[com.nedap.staffing-solutions/utils.spec "0.6.0"]
+[com.nedap.staffing-solutions/utils.spec "0.6.1"]
 ````
 
 ## ns organisation

project.clj

@@ -1,4 +1,4 @@
-(defproject com.nedap.staffing-solutions/utils.spec "0.6.0"
+(defproject com.nedap.staffing-solutions/utils.spec "0.6.1"
   :description "clojure.spec utilities"
   :url "https://github.com/nedap/utils.spec"
   :license {:name "Eclipse Public License"

src/nedap/utils/spec/impl/predicates.clj

@@ -0,0 +1,16 @@
+(ns nedap.utils.spec.impl.predicates)
+
+(defn coercer [pred]
+  (fn [x]
+    (cond
+      (pred x)          x
+      (not (string? x)) x
+      :else             (try
+                          (let [v (BigInteger. ^String x)]
+                            (if-not (pred v)
+                              x
+                              (if (<= Long/MIN_VALUE v Long/MAX_VALUE)
+                                (Long/parseLong x)
+                                v)))
+                          (catch Exception _
+                            x)))))

src/nedap/utils/spec/predicates.clj

@@ -1,6 +1,8 @@
 (ns nedap.utils.spec.predicates
   (:require
-   [nedap.utils.speced :as speced]))
+   [nedap.utils.spec.impl.predicates :as impl]
+   [nedap.utils.speced :as speced]
+   [spec-coerce.core :as spec-coerce]))
 
 (speced/defn ^Boolean neg-integer?
   "Is `x` negative (as per `clojure.core/neg?`) and integer (as per `clojure.core/integer?`)?
@@ -32,3 +34,15 @@
   (or (string? x)
       (symbol? x)
       (keyword? x)))
+
+(def neg-integer-coercer (impl/coercer neg-integer?))
+
+(def nat-integer-coercer (impl/coercer nat-integer?))
+
+(def pos-integer-coercer (impl/coercer pos-integer?))
+
+(defmethod spec-coerce/sym->coercer `neg-integer? [_] neg-integer-coercer)
+
+(defmethod spec-coerce/sym->coercer `nat-integer? [_] nat-integer-coercer)
+
+(defmethod spec-coerce/sym->coercer `pos-integer? [_] pos-integer-coercer)

test/unit/nedap/utils/speced/predicates.clj

@@ -1,7 +1,9 @@
 (ns unit.nedap.utils.speced.predicates
   (:require
+   [clojure.spec.alpha :as spec]
    [clojure.test :refer :all]
-   [nedap.utils.spec.predicates :as sut]))
+   [nedap.utils.spec.predicates :as sut]
+   [spec-coerce.core :as spec-coerce]))
 
 (deftest integers
   (are [v
@@ -68,3 +70,92 @@
     "a/a"              true
     ::a                true
     'a/a               true))
+
+(spec/def ::neg-integer? sut/neg-integer?)
+
+(spec/def ::nat-integer? sut/nat-integer?)
+
+(spec/def ::pos-integer? sut/pos-integer?)
+
+(deftest coercion
+  (testing "Valid values are coerced"
+    (are [input spec output] (= output
+                                (spec-coerce/coerce spec input))
+      -1   ::neg-integer? -1
+      "-1" ::neg-integer? -1
+
+      0    ::nat-integer? 0
+      "0"  ::nat-integer? 0
+      1    ::nat-integer? 1
+      "1"  ::nat-integer? 1
+
+      1    ::pos-integer? 1
+      "1"  ::pos-integer? 1))
+  (testing "Invalid values (as per the predicates themselves) are not coerced"
+    (are [input spec output] (= output
+                                (spec-coerce/coerce spec input))
+      nil  ::neg-integer? nil
+      "a"  ::neg-integer? "a"
+      0    ::neg-integer? 0
+      1    ::neg-integer? 1
+      "0"  ::neg-integer? "0"
+      "1"  ::neg-integer? "1"
+
+      nil  ::nat-integer? nil
+      "a"  ::nat-integer? "a"
+      -1   ::nat-integer? -1
+      "-1" ::nat-integer? "-1"
+
+      nil  ::pos-integer? nil
+      "a"  ::pos-integer? "a"
+      -1   ::pos-integer? -1
+      "-1" ::pos-integer? "-1"
+      0    ::pos-integer? 0
+      "1"  ::pos-integer? 1))
+
+  (testing "Types are preserved"
+    (are [input spec] (= input
+                         (spec-coerce/coerce spec input))
+      (Integer. -1)                     ::neg-integer?
+      (Long. -1)                        ::neg-integer?
+      (clojure.lang.BigInt/fromLong -1) ::neg-integer?
+      (BigInteger/valueOf -1)           ::neg-integer?
+      (Short. "-1")                     ::neg-integer?
+      (Long. -1)                        ::neg-integer?
+
+      (Integer. 0)                      ::nat-integer?
+      (Long. 0)                         ::nat-integer?
+      (clojure.lang.BigInt/fromLong 0)  ::nat-integer?
+      (BigInteger/valueOf 0)            ::nat-integer?
+      (Short. "0")                      ::nat-integer?
+      (Long. 0)                         ::nat-integer?
+
+      (Integer. 1)                      ::nat-integer?
+      (Long. 1)                         ::nat-integer?
+      (clojure.lang.BigInt/fromLong 1)  ::nat-integer?
+      (BigInteger/valueOf 1)            ::nat-integer?
+      (Short. "1")                      ::nat-integer?
+      (Long. 1)                         ::nat-integer?
+
+      (Integer. 1)                      ::pos-integer?
+      (Long. 1)                         ::pos-integer?
+      (clojure.lang.BigInt/fromLong 1)  ::pos-integer?
+      (BigInteger/valueOf 1)            ::pos-integer?
+      (Short. "1")                      ::pos-integer?
+      (Long. 1)                         ::pos-integer?))
+
+  (testing "Values which would overflow a Long are coerced to BigInteger"
+    (are [input spec expected-class] (= expected-class
+                                        (-> (spec-coerce/coerce spec input)
+                                            class))
+      "-1111"                             ::neg-integer? Long
+      "-11111111111111111111111111111111" ::neg-integer? BigInteger
+      (-> Long/MIN_VALUE str)             ::neg-integer? Long
+      (-> Long/MIN_VALUE dec' str)        ::neg-integer? BigInteger
+      "0"                                 ::nat-integer? Long
+      "1111"                              ::nat-integer? Long
+      "11111111111111111111111111111111"  ::nat-integer? BigInteger
+      "1111"                              ::pos-integer? Long
+      "11111111111111111111111111111111"  ::pos-integer? BigInteger
+      (-> Long/MAX_VALUE str)             ::pos-integer? Long
+      (-> Long/MAX_VALUE inc' str)        ::pos-integer? BigInteger)))