Add bounded Date runtime for Spinel

docs/pipeline/runtime.md

@@ -207,6 +207,23 @@ undocumented one reads as intent to the next session precisely because
 it is applied consistently, and the emit gives no signal that anyone
 weighed it.
 
+### Spinel `Date` is a bounded runtime value
+
+The Spinel target defines a small `Date` class in
+`runtime/spinel/date.rb` for Rails date columns. It stores a Gregorian
+year, month, and day; database storage and JSON use `YYYY-MM-DD`, with
+no clock or zone. Its ISO parser accepts only that exact format and
+validates the calendar date.
+
+This is not Ruby's stdlib `date` package. `DateTime`, Julian/Italian
+calendar modes, natural-language and non-ISO parsing, schema date
+defaults, ActiveSupport date extensions, date picker helpers, and date
+predicates are not included. `strftime` implements the date directives
+used by the admitted runtime contract and raises on other directives.
+The compiler continues diagnosing those unsupported paths. JRuby and
+other targets keep their existing Date boundary until they have their
+own runtime.
+
 ### `id` is `0` before save, not `nil` (`""` for a string key)
 
 Each model's own `initialize` seeds `self.id = attrs[:id] || 0` — `||

runtime/ruby/active_record/base.rb

@@ -307,6 +307,10 @@ def self.schema_time_columns
       []
     end
 
+    def self.schema_date_columns
+      []
+    end
+
     def self.instantiate(_row)
       raise NotImplementedError, "#{name}.instantiate must be overridden"
     end

runtime/ruby/active_record/base.rbs

@@ -115,6 +115,7 @@ module ActiveRecord
     def self._string_primary_key: () -> bool
     def self.schema_columns: () -> Array[Symbol]
     def self.schema_time_columns: () -> Array[Symbol]
+    def self.schema_date_columns: () -> Array[Symbol]
     def self.instantiate: (Hash[String, untyped] _row) -> Base
 
     # Eager-load hook consumed by `Relation#to_a`; the Ruby emit path

runtime/ruby/active_record/connection.rb

@@ -311,9 +311,12 @@ def _as_json_only(only)
       h = {}
       columns = self.class.schema_columns
       time_columns = self.class.schema_time_columns
+      date_columns = self.class.schema_date_columns
       only.each do |k|
         next unless columns.include?(k)
-        h[k.to_s] = if time_columns.include?(k)
+        h[k.to_s] = if date_columns.include?(k)
+          ActiveSupport.format_db_date(self[k])
+        elsif time_columns.include?(k)
           ActiveSupport.json_time(self[k])
         else
           self[k]

runtime/spinel/active_record_date_serialization.rb

@@ -0,0 +1,12 @@
+# Default ActiveRecord JSON shape for the Spinel runtime. This is kept
+# beside the bounded Date rather than in the shared runtime because the
+# Ruby-family overlay supplies its own reflection-aware implementation.
+module ActiveRecord
+  class Base
+    def as_json(options = {})
+      only = options && options[:only]
+      only ||= self.class.schema_columns
+      _as_json_only(only)
+    end
+  end
+end

runtime/spinel/active_support_time_parsing.rb

@@ -20,6 +20,20 @@
 # corpus are second-granularity, and JSON serializes from the raw
 # string (`<col>_raw`), not the parsed Time.
 module ActiveSupport
+  # SQL DATE has no clock or zone. The empty string is the SQLite
+  # adapter's nil representation for a nullable column.
+  def self.parse_db_date(value)
+    return nil if value.nil? || value == ""
+    Date.iso8601(value)
+  end
+
+  def self.format_db_date(value)
+    return nil if value.nil?
+    return value.iso8601 if value.is_a?(Date)
+    return Date.iso8601(value).iso8601 if value.is_a?(String)
+    raise TypeError, "expected Date, String, or nil"
+  end
+
   # Rails zone name → IANA identifier. TWIN of the constant in the
   # CRuby/JRuby overlay's sibling file, which shadows this whole file on
   # those trees — the two must agree, so extend both together. Names not

runtime/spinel/active_support_time_parsing.rbs

@@ -2,6 +2,8 @@
 # raw TEXT column value the synthesized reader passes — nil/"" for
 # absent storage (the nil-guard narrows before the positional parse).
 module ActiveSupport
+  def self.parse_db_date: (String? value) -> Date?
+  def self.format_db_date: (untyped value) -> String?
   def self.parse_db_time: (String? str) -> Time?
   def self.json_time: (String? str) -> String?
   def self.db_now: () -> String

runtime/spinel/date.rb

@@ -0,0 +1,237 @@
+# A deliberately small, program-defined Date for the Spinel target.
+# This is not Ruby's stdlib `date` package. The supported API is the
+# surface analyzed for Rails date columns; unsupported formats fail
+# loudly instead of being interpreted as timestamps or guessed dates.
+class Date
+  class Error < ArgumentError
+  end
+
+  MONTHS = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+  WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+  SHORT_WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"]
+  MONTH_NAMES = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"]
+  SHORT_MONTH_NAMES = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+
+  def initialize(year, month, day)
+    unless year >= 1 && year <= 9999 && month >= 1 && month <= 12 && day >= 1 && day <= Date.month_length(year, month)
+      raise Date::Error, "invalid date"
+    end
+    @year = year
+    @month = month
+    @day = day
+  end
+
+  def self.civil(year, month = 1, day = 1)
+    Date.new(year, month, day)
+  end
+
+  def self.leap_year?(year)
+    year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
+  end
+
+  def self.month_length(year, month)
+    return 29 if month == 2 && Date.leap_year?(year)
+    MONTHS[month - 1]
+  end
+
+  def self.iso8601(value)
+    unless value.is_a?(String) && value.length == 10 && value[4, 1] == "-" && value[7, 1] == "-"
+      raise Date::Error, "invalid date: #{value}"
+    end
+    year = value[0, 4].to_i
+    month = value[5, 2].to_i
+    day = value[8, 2].to_i
+    date = Date.new(year, month, day)
+    raise Date::Error, "invalid date: #{value}" unless date.iso8601 == value
+    date
+  rescue ArgumentError
+    raise Date::Error, "invalid date: #{value}"
+  end
+
+  def self.parse(value, _comp = true)
+    Date.iso8601(value)
+  end
+
+  def self.strptime(value, format)
+    raise Date::Error, "unsupported date format" unless format == "%Y-%m-%d"
+    Date.iso8601(value)
+  end
+
+  def self.today
+    now = Time.now
+    Date.new(now.year, now.month, now.day)
+  end
+
+  def year
+    @year
+  end
+
+  def month
+    @month
+  end
+
+  def mon
+    @month
+  end
+
+  def day
+    @day
+  end
+
+  def mday
+    @day
+  end
+
+  def leap?
+    Date.leap_year?(@year)
+  end
+
+  def wday
+    offsets = [0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4]
+    year = @year
+    year -= 1 if @month < 3
+    (year + year / 4 - year / 100 + year / 400 + offsets[@month - 1] + @day) % 7
+  end
+
+  def yday
+    total = @day
+    month = 1
+    while month < @month
+      total += Date.month_length(@year, month)
+      month += 1
+    end
+    total
+  end
+
+  def sunday?
+    wday == 0
+  end
+
+  def monday?
+    wday == 1
+  end
+
+  def tuesday?
+    wday == 2
+  end
+
+  def wednesday?
+    wday == 3
+  end
+
+  def thursday?
+    wday == 4
+  end
+
+  def friday?
+    wday == 5
+  end
+
+  def saturday?
+    wday == 6
+  end
+
+  def >>(months)
+    shift_months(months)
+  end
+
+  def <<(months)
+    shift_months(-months)
+  end
+
+  def shift_months(amount)
+    index = @year * 12 + @month - 1 + amount
+    year = index / 12
+    month = index % 12 + 1
+    year -= 1 if month == 0
+    month = 12 if month == 0
+    day = @day
+    last = Date.month_length(year, month)
+    day = last if day > last
+    Date.new(year, month, day)
+  end
+
+  def to_date
+    self
+  end
+
+  def to_time
+    Time.local(@year, @month, @day, 0, 0, 0)
+  end
+
+  def iso8601
+    format("%04d-%02d-%02d", @year, @month, @day)
+  end
+
+  def to_s
+    iso8601
+  end
+
+  def as_json(_options = {})
+    iso8601
+  end
+
+  def strftime(pattern)
+    result = ""
+    index = 0
+    while index < pattern.length
+      char = pattern[index, 1]
+      if char == "%"
+        index += 1
+        code = pattern[index, 1]
+        value = case code
+        when "%" then "%"
+        when "Y" then format("%04d", @year)
+        when "m" then format("%02d", @month)
+        when "d" then format("%02d", @day)
+        when "e" then format("%2d", @day)
+        when "F" then iso8601
+        when "j" then format("%03d", yday)
+        when "w" then wday.to_s
+        when "u" then (wday == 0 ? 7 : wday).to_s
+        when "a" then SHORT_WEEKDAYS[wday]
+        when "A" then WEEKDAYS[wday]
+        when "b", "h" then SHORT_MONTH_NAMES[@month - 1]
+        when "B" then MONTH_NAMES[@month - 1]
+        else raise Date::Error, "unsupported strftime directive: %#{code}"
+        end
+        result += value
+      else
+        result += char
+      end
+      index += 1
+    end
+    result
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(Date)
+    return -1 if @year < other.year
+    return 1 if @year > other.year
+    return -1 if @month < other.month
+    return 1 if @month > other.month
+    return -1 if @day < other.day
+    return 1 if @day > other.day
+    0
+  end
+
+  def ==(other)
+    (self <=> other) == 0
+  end
+
+  def <(other)
+    (self <=> other) == -1
+  end
+
+  def <=(other)
+    (self <=> other) <= 0
+  end
+
+  def >(other)
+    (self <=> other) == 1
+  end
+
+  def >=(other)
+    (self <=> other) >= 0
+  end
+end

runtime/spinel/date.rbs

@@ -0,0 +1,51 @@
+# Bounded Date value used by the Spinel runtime for Rails date columns.
+class Date
+  class Error < ArgumentError
+  end
+
+  def initialize: (Integer year, Integer month, Integer day) -> void
+  def self.civil: (Integer year, ?Integer month, ?Integer day) -> Date
+  def self.iso8601: (String value) -> Date
+  def self.parse: (String value, ?bool comp) -> Date
+  def self.strptime: (String value, String format) -> Date
+  def self.today: () -> Date
+  def self.leap_year?: (Integer year) -> bool
+  def self.month_length: (Integer year, Integer month) -> Integer
+
+  def year: () -> Integer
+  def month: () -> Integer
+  def mon: () -> Integer
+  def day: () -> Integer
+  def mday: () -> Integer
+  def leap?: () -> bool
+  def wday: () -> Integer
+  def yday: () -> Integer
+  def sunday?: () -> bool
+  def monday?: () -> bool
+  def tuesday?: () -> bool
+  def wednesday?: () -> bool
+  def thursday?: () -> bool
+  def friday?: () -> bool
+  def saturday?: () -> bool
+  def >>: (Integer months) -> Date
+  def <<: (Integer months) -> Date
+  def shift_months: (Integer amount) -> Date
+  def to_date: () -> Date
+  def to_time: () -> Time
+  def iso8601: () -> String
+  def to_s: () -> String
+  def as_json: (?Hash[untyped, untyped] options) -> String
+  def strftime: (String pattern) -> String
+  def <=>: (Date? other) -> Integer?
+  def ==: (Date? other) -> bool
+  def <: (Date? other) -> bool
+  def <=: (Date? other) -> bool
+  def >: (Date? other) -> bool
+  def >=: (Date? other) -> bool
+end
+
+module ActiveRecord
+  class Base
+    def as_json: (?Hash[Symbol, untyped] options) -> Hash[String, untyped]
+  end
+end