CLJS-3348: Implement new functions for parity with Clojure 1.11 (#165)

Co-authored-by: Paula Gearon <gearon@gmail.com>

Author: swannodette

src/main/cljs/cljs/core.cljs

@@ -12025,6 +12025,66 @@ reduces them without incurring seq initialization"
   [x]
   (instance? goog.Uri x))
 
+(defn ^boolean NaN?
+  "Returns true if num is NaN, else false"
+  [val]
+  (js/isNaN val))
+
+(defn ^:private parsing-err
+  "Construct message for parsing for non-string parsing error"
+  [val]
+  (str "Expected string, got: " (if (nil? val) "nil" (goog/typeOf val))))
+
+(defn ^number parse-long
+  "Parse string of decimal digits with optional leading -/+ and return an
+  integer value, or nil if parse fails"
+  [s]
+  (if (string? s)
+    (and (re-matches #"[+-]?\d+" s)
+         (let [i (js/parseInt s)]
+           (when (and (<= i js/Number.MAX_SAFE_INTEGER)
+                      (>= i js/Number.MIN_SAFE_INTEGER))
+             i)))
+    (throw (js/Error. (parsing-err s)))))
+
+(defn ^number parse-double
+  "Parse string with floating point components and return a floating point value,
+  or nil if parse fails.
+  Grammar: https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html#valueOf-java.lang.String-"
+  [s]
+  (if (string? s)
+    (cond
+      ^boolean (re-matches #"[\x00-\x20]*[+-]?NaN[\x00-\x20]*" s) ##NaN
+      ^boolean (re-matches
+                #"[\x00-\x20]*[+-]?(Infinity|((\d+\.?\d*|\.\d+)([eE][+-]?\d+)?)[dDfF]?)[\x00-\x20]*"
+                s) (js/parseFloat s)
+      :default nil)
+    (throw (js/Error. (parsing-err s)))))
+
+(def ^:private uuid-regex
+  #"^[0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z]-[0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z]-[0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z]-[0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z]-[0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z][0-9a-zA-Z]$")
+
+(defn parse-uuid
+  "Parse a string representing a UUID and return a UUID instance,
+  or nil if parse fails.
+  Grammar: https://docs.oracle.com/javase/8/docs/api/java/util/UUID.html#toString--"
+  [s]
+  (if (string? s)
+    (when ^boolean (re-matches uuid-regex s)
+      (uuid s))
+    (throw (js/Error. (parsing-err s)))))
+
+(defn parse-boolean
+  "Parse strings \"true\" or \"false\" and return a boolean, or nil if invalid. Note that this explicitly
+  excludes strings with different cases, or space characters."
+  [s]
+  (if (string? s)
+    (case s
+      "true" true
+      "false" false
+      nil)
+    (throw (js/Error. (parsing-err s)))))
+
 (defn- maybe-enable-print! []
   (cond
     (exists? js/console)

src/test/cljs/cljs/parse_test.cljs

@@ -0,0 +1,101 @@
+(ns cljs.parse-test
+  (:require
+    [clojure.test :refer [deftest is are]]
+    [clojure.test.check :as chk]
+    [clojure.test.check.generators :as gen]
+    [clojure.test.check.properties :as prop]))
+
+(deftest test-parse-long
+  (are [s expected]
+    (= expected (parse-long s))
+    "100" 100
+    "+100" 100
+    "0" 0
+    "+0" 0
+    "-0" 0
+    "-42" -42
+    "9007199254740991" js/Number.MAX_SAFE_INTEGER  ;; largest parsable: 999999999999999934463
+    "+9007199254740991" js/Number.MAX_SAFE_INTEGER
+    "-9007199254740991" js/Number.MIN_SAFE_INTEGER
+    "077" 77) ;; leading 0s are ignored! (not octal)
+
+  (are [s] ;; do not parse
+    (nil? (parse-long s))
+    "0.3" ;; no float
+    "9007199254740992" ;; past max long
+    "-9007199254740992" ;; past min long
+    "0xA0" ;; no hex
+    "2r010")) ;; no radix support
+
+;; generative test - gen long -> str -> parse, compare
+(deftest test-gen-parse-long
+  (let [res (chk/quick-check
+              100000
+              (prop/for-all* [gen/large-integer]
+                #(= % (-> % str parse-long))))]
+    (if (:result res)
+      (is true) ;; pass
+      (is (:result res) (pr-str res)))))
+
+(deftest test-parse-double
+  (are [s expected]
+    (= expected (parse-double s))
+    "1.234" 1.234
+    "+1.234" 1.234
+    "-1.234" -1.234
+    "+0" +0.0
+    "-0.0" -0.0
+    "0.0" 0.0
+    "5" 5.0
+    ".5" 0.5
+    "Infinity" ##Inf
+    "-Infinity" ##-Inf
+    "1.7976931348623157E308" js/Number.MAX_VALUE
+    "4.9E-324" js/Number.MIN_VALUE
+    "1.7976931348623157E309" js/Number.POSITIVE_INFINITY  ;; past max double
+    "2.5e-324" js/Number.MIN_VALUE  ;; past min double, above half minimum
+    "2.4e-324" 0.0)  ;; below minimum double
+  (is (js/isNaN (parse-double "NaN")))
+  (are [s] ;; nil on invalid string
+    (nil? (parse-double s))
+    "double" ;; invalid string
+    "1.7976931348623157G309")) ;; close, but not valid
+
+;; generative test - gen double -> str -> parse, compare
+(deftest test-gen-parse-double
+  (let [res (chk/quick-check
+              100000
+              (prop/for-all* [gen/double]
+                #(let [parsed (-> % str parse-double)]
+                   (if (js/isNaN %)
+                     (js/isNaN parsed)
+                     (= % parsed)))))]
+    (if (:result res)
+      (is true) ;; pass
+      (is (:result res) (pr-str res)))))
+
+(deftest test-parse-uuid
+  (is (parse-uuid (str (random-uuid))))
+  (is (nil? (parse-uuid "BOGUS"))) ;; nil on invalid uuid string
+  (are [s] ;; throw on invalid type (not string)
+    (try (parse-uuid s) (is false) (catch :default _ (is true)))
+    123
+    nil))
+
+(deftest test-parse-boolean
+  (is (identical? true (parse-boolean "true")))
+  (is (identical? false (parse-boolean "false")))
+
+  (are [s] ;; nil on invalid string
+    (nil? (parse-boolean s))
+    "abc"
+    "TRUE"
+    "FALSE"
+    " true ")
+
+  (are [s] ;; throw on invalid type (not string)
+    (try (parse-boolean s) (is false) (catch :default _ (is true)))
+    nil
+    false
+    true
+    100))

src/test/cljs/test_runner.cljs

@@ -19,6 +19,7 @@
             [cljs.core-test :as core-test]
             [cljs.reader-test]
             [cljs.binding-test]
+            [cljs.parse-test]
             [cljs.ns-test]
             [clojure.set-test]
             [clojure.string-test]
@@ -76,6 +77,7 @@
   'cljs.hashing-test
   'cljs.core-test
   'cljs.reader-test
+  'cljs.parse-test
   'clojure.set-test
   'clojure.string-test
   'clojure.data-test

src/test/self/self_parity/test.cljs

@@ -280,6 +280,7 @@
                  [cljs.core-test :as core-test]
                  [cljs.reader-test]
                  [cljs.binding-test]
+                 [cljs.parse-test]
                  #_[cljs.ns-test]
                  [clojure.set-test]
                  [clojure.string-test]
@@ -331,6 +332,7 @@
              'cljs.hashing-test
              'cljs.core-test
              'cljs.reader-test
+             'cljs.parse-test
              'clojure.set-test
              'clojure.string-test
              'clojure.data-test