odin-foundation 1.0.4 → 1.2.0

data/lib/odin/transform/verbs/datetime_verbs.rb

@@ -21,6 +21,19 @@ module Odin
           end
         end
 
+        # Strict yyyy-MM-dd parse; returns nil for any other shape or invalid date.
+        def parse_iso_date(s)
+          s = s.to_string if s.is_a?(Types::DynValue)
+          return nil unless s.is_a?(String)
+          m = s.match(/\A(\d{4})-(\d{2})-(\d{2})\z/)
+          return nil unless m
+          begin
+            Date.new(m[1].to_i, m[2].to_i, m[3].to_i)
+          rescue ArgumentError
+            nil
+          end
+        end
+
         def parse_timestamp(s)
           return nil if s.nil?
           s = s.to_string if s.is_a?(Types::DynValue)
@@ -69,6 +82,34 @@ module Odin
           end
         end
 
+        # Extract date and time components positionally from a pattern, returning
+        # a UTC Time. Recognizes YYYY/YY/MM/DD/HH/mm/ss tokens.
+        def parse_timestamp_with_pattern(value, pattern)
+          pos = ->(pat) { pattern.index(pat) }
+          slice = ->(p, len) { p ? value[p, len]&.to_i : nil }
+
+          yyyy = pos.call("YYYY")
+          yy = pos.call("YY")
+          year = if yyyy
+                   slice.call(yyyy, 4)
+                 elsif yy
+                   2000 + (slice.call(yy, 2) || 0)
+                 end
+          return nil unless year
+
+          month = slice.call(pos.call("MM"), 2) || 1
+          day = slice.call(pos.call("DD"), 2) || 1
+          hour = slice.call(pos.call("HH"), 2) || 0
+          minute = slice.call(pos.call("mm"), 2) || 0
+          second = slice.call(pos.call("ss"), 2) || 0
+
+          begin
+            Time.utc(year, month, day, hour, minute, second)
+          rescue ArgumentError
+            nil
+          end
+        end
+
         def apply_date_pattern(dt, pattern)
           result = pattern.dup
           if dt.is_a?(Date) && !dt.is_a?(Time)
@@ -168,11 +209,16 @@ module Odin
           }
 
           registry["parseTimestamp"] = ->(args, _ctx) {
-            s = args[0]&.to_string
-            return dv.of_null if s.nil? || s.empty?
-            t = DateTimeVerbs.parse_timestamp(s)
+            return dv.of_null if args.length < 2
+
+            value = args[0]&.to_string
+            pattern = args[1]&.to_string
+            return dv.of_null if value.nil? || value.empty? || pattern.nil?
+
+            t = DateTimeVerbs.parse_timestamp_with_pattern(value, pattern)
             return dv.of_null unless t
-            dv.of_timestamp(DateTimeVerbs.format_timestamp_str(t))
+            dv.of_string(format("%04d-%02d-%02dT%02d:%02d:%02d",
+                                t.year, t.month, t.day, t.hour, t.min, t.sec))
           }
 
           registry["addDays"] = ->(args, _ctx) {
@@ -342,7 +388,7 @@ module Odin
             return dv.of_null if v.nil? || v.null?
             d = DateTimeVerbs.parse_date(v)
             return dv.of_null unless d
-            dv.of_date(DateTimeVerbs.format_date_str(Date.new(d.year, d.month, 1)))
+            dv.of_string(DateTimeVerbs.format_date_str(Date.new(d.year, d.month, 1)))
           }
 
           registry["endOfMonth"] = ->(args, _ctx) {
@@ -351,7 +397,7 @@ module Odin
             d = DateTimeVerbs.parse_date(v)
             return dv.of_null unless d
             last = Date.new(d.year, d.month, -1)
-            dv.of_date(DateTimeVerbs.format_date_str(last))
+            dv.of_string(DateTimeVerbs.format_date_str(last))
           }
 
           registry["startOfYear"] = ->(args, _ctx) {
@@ -359,7 +405,7 @@ module Odin
             return dv.of_null if v.nil? || v.null?
             d = DateTimeVerbs.parse_date(v)
             return dv.of_null unless d
-            dv.of_date(DateTimeVerbs.format_date_str(Date.new(d.year, 1, 1)))
+            dv.of_string(DateTimeVerbs.format_date_str(Date.new(d.year, 1, 1)))
           }
 
           registry["endOfYear"] = ->(args, _ctx) {
@@ -367,7 +413,7 @@ module Odin
             return dv.of_null if v.nil? || v.null?
             d = DateTimeVerbs.parse_date(v)
             return dv.of_null unless d
-            dv.of_date(DateTimeVerbs.format_date_str(Date.new(d.year, 12, 31)))
+            dv.of_string(DateTimeVerbs.format_date_str(Date.new(d.year, 12, 31)))
           }
 
           registry["dayOfWeek"] = ->(args, _ctx) {
@@ -478,7 +524,7 @@ module Odin
             d1 = DateTimeVerbs.parse_date(v1)
             d2 = DateTimeVerbs.parse_date(v2)
             return dv.of_null unless d1 && d2
-            dv.of_integer((d2 - d1).to_i.abs)
+            dv.of_integer((d2 - d1).to_i)
           }
 
           registry["ageFromDate"] = ->(args, _ctx) {
@@ -499,8 +545,12 @@ module Odin
           registry["isValidDate"] = ->(args, _ctx) {
             s = args[0]&.to_string
             return dv.of_bool(false) if s.nil? || s.empty?
-            d = DateTimeVerbs.parse_date(s)
-            dv.of_bool(!d.nil?)
+            return dv.of_bool(true) unless DateTimeVerbs.parse_iso_date(s).nil?
+            if args.length >= 2
+              pattern = args[1]&.to_string || ""
+              return dv.of_bool(true) unless DateTimeVerbs.parse_date_with_pattern(s, pattern).nil?
+            end
+            dv.of_bool(false)
           }
 
           registry["formatLocaleDate"] = ->(args, _ctx) {
@@ -544,17 +594,38 @@ module Odin
             return dv.of_null if v.nil? || v.null?
             d = DateTimeVerbs.parse_date(v)
             return dv.of_null unless d
-            if d.saturday?
-              d += 2
-            elsif d.sunday?
+            loop do
               d += 1
+              break unless d.saturday? || d.sunday?
             end
             dv.of_string(DateTimeVerbs.format_date_str(d))
           }
 
           registry["formatDuration"] = ->(args, _ctx) {
             return dv.of_null if args.empty?
-            iso = args[0]&.to_string
+            arg = args[0]
+            return dv.of_null if arg.nil? || arg.null?
+
+            iso = arg.to_string
+
+            # Numeric seconds (typed or numeric string): expand into d/h/m/s.
+            if arg.numeric? || iso.match?(/\A\d+(?:\.\d+)?\z/)
+              total = arg.numeric? ? arg.to_number.to_f : iso.to_f
+              return dv.of_null if total < 0
+              days = (total / 86400).floor
+              total -= days * 86400
+              hours = (total / 3600).floor
+              total -= hours * 3600
+              minutes = (total / 60).floor
+              seconds = total - minutes * 60
+              parts = []
+              parts << DateTimeVerbs.duration_part(days, "day") unless days == 0
+              parts << DateTimeVerbs.duration_part(hours, "hour") unless hours == 0
+              parts << DateTimeVerbs.duration_part(minutes, "minute") unless minutes == 0
+              parts << DateTimeVerbs.duration_part(seconds, "second") unless seconds == 0
+              return dv.of_string(parts.empty? ? "0 seconds" : parts.join(", "))
+            end
+
             return dv.of_null if iso.nil? || !iso.start_with?("P")
             parts = []
             in_time = false