core,script: add Timestamp.fromisostring

core/extlib/timestamp.lua

@@ -1,7 +1,9 @@
 #lang lua
 
 local seconds_to_date = racket["seconds->date"]
+local date_to_seconds = racket.lib("racket/date", "date*->seconds")
 local date_to_string = _ENV["#%date->isostring"]
+local string_to_date = _ENV["#%isostring->date"]
 
 local Timestamp = Class {
     name = "Timestamp",
@@ -44,6 +46,14 @@ function Timestamp.at(year, month, day, hour, minute, second, localtime)
     return Timestamp(seconds, localtime)
 end
 
+function Timestamp.fromisostring(s)
+    local d = string_to_date(s or "")
+    if not d then
+        error(string.format("Timestamp.fromisostring: invalid date '%s'", s))
+    end
+    return Timestamp(date_to_seconds(d, false))
+end
+
 function Timestamp:components()
     return os.date(self.localtime and "*t" or "!*t", self.ts)
 end
@@ -66,6 +76,10 @@ function Timestamp:toutc()
     return Timestamp(self.ts, false)
 end
 
+function Timestamp:__eq(other)
+    return self.ts == other.ts
+end
+
 function Timestamp:__le(other)
     return self.ts <= other.ts
 end

core/fixtures/timestamp.lua

@@ -13,4 +13,6 @@ assert(components.min == 30, "minute component")
 assert(components.sec == 45, "second component")
 assert(not components.isdst, "isdst component")
 
+assert(t == Timestamp.fromisostring("2023-05-29T12:30:45Z"))
+
 return true

core/script.rkt

@@ -12,6 +12,7 @@
          racket/contract
          racket/date
          racket/file
+         racket/match
          racket/port
          racket/runtime-path
          "iterator.rkt"
@@ -365,6 +366,60 @@ SCRIPT
 
 ;; extlib ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
+(define nanos/second
+  (* 1 1000 1000 1000))
+
+(define (date->isostring d)
+  (parameterize ([date-display-format 'iso-8601])
+    (string->bytes/utf-8 (date->string d #t))))
+
+(define (isostring->date s)
+  (with-handlers ([(λ (e)
+                     (or (regexp-match? #rx"match-define: no matching clause" (exn-message e))
+                         (regexp-match? #rx"find-seconds: non-existent date" (exn-message e))))
+                   (λ (_) #f)])
+    (match-define
+      (regexp #px"^(....)-(..)-(..)[ T](..):(..):(..)(\\.([0-9]{1,9}))?(Z|([-+]..:..))?$"
+              (list _
+                    (app string->number year)
+                    (app string->number month)
+                    (app string->number day)
+                    (app string->number hour)
+                    (app string->number minute)
+                    (app string->number second)
+                    _ ;; nanosecond with prefix
+                    nanosecond-str
+                    timezone-str
+                    _ ;; +- offset
+                    ))
+      (bytes->string/utf-8 s))
+    (define nanosecond
+      (let ([n (or (and nanosecond-str (string->number nanosecond-str)) 0)])
+        (if (zero? n)
+            0
+            (inexact->exact
+             (* (/ n (expt 10 (add1 (floor (log n 10))))) nanos/second)))))
+    (define utc-seconds
+      (find-seconds second minute hour day month year #f))
+    (define utc-date
+      (struct-copy date*
+                   (seconds->date utc-seconds #f)
+                   [nanosecond nanosecond]))
+    (match timezone-str
+      [(or "" "Z" "+00:00" "-00:00") utc-date]
+      [(regexp #rx"([-+])([0-9]+):([0-9]+)"
+               (list _
+                     sign-str
+                     (app string->number hours)
+                     (app string->number minutes)))
+       (define offset
+         (let ([offset (+ (* hours 3600)
+                          (* minutes 60))])
+           (case sign-str
+             [("-")    offset]
+             [("+") (- offset)])))
+       (seconds->date (+ (date*->seconds utc-date #f) offset) #f)])))
+
 (define-syntax (defmod stx)
   (syntax-parse stx
     [(_ name:id)
@@ -433,9 +488,8 @@ SCRIPT
    (make-class-module class.lua #"class" #"Class")
    (make-class-module
     timestamp.lua #"timestamp" #"Timestamp"
-    `((#"#%date->isostring" ,(lambda (d)
-                               (parameterize ([date-display-format 'iso-8601])
-                                 (string->bytes/utf-8 (date->string d #t)))))))
+    `((#"#%date->isostring" ,date->isostring)
+      (#"#%isostring->date" ,isostring->date)))
    (make-table-module
     avro.lua #"avro"
     `((#"#%avro-make-codec" ,make-codec)

manual/index.scrbl

@@ -827,6 +827,10 @@ Confluent Schema Registry.
   argument defaults to @tt{true}.
 }
 
+@deflua[Timestamp.fromisostring (str) Timestamp]{
+  Parses the given ISO8601-formatted timestamp.
+}
+
 @deflua[Timestamp:tolocal () Timestamp]{
   Returns a new timestamp at the same instant as this timestamp, but
   set to local time.