synthra 0.1.0

data/lib/synthra/types/date_time/dates.rb

@@ -0,0 +1,387 @@
+# frozen_string_literal: true
+
+module Synthra
+  module Types
+    module DateTime
+      # DateType type
+      class DateType < Base
+        def generate_random(rng, context, args)
+          # When a TimeTravel context is active, re-base the "N days back from today"
+          # distribution onto the anchor date instead of the real Date.today. Same
+          # shape (uniform over the last 2 years), just relative to a different origin.
+          anchor = TimeTravel.anchor_date
+          return anchor - rng.int(0, 730) if anchor
+
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.date_backward(days: 365 * 2)
+
+          else
+            Faker::Date.backward(days: 365 * 2)
+          end
+
+        rescue StandardError
+          Date.today - rng.int(0, 730)
+        end
+
+
+        def generate_edge(rng, context, args)
+          anchor = TimeTravel.anchor_date || Date.today
+          [anchor, anchor - 730].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a date", 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # DatetimeType type
+      class DatetimeType < Base
+        # Generate random datetime
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol] :format format type (:standard, :iso8601, :rfc3339)
+        # @option args [Range] :date_range date range for generation
+        # @return [String] generated datetime string
+        #
+        def generate_random(rng, context, args)
+          format_type = args[:format] || :standard
+          reference_date = TimeTravel.anchor_date || Date.today
+          date_range = args[:date_range] || (reference_date - 365..reference_date + 365)
+
+          # Generate date
+          date = rng.sample(date_range.to_a)
+
+          # Generate time
+          hour = rng.int(0, 23)
+          minute = rng.int(0, 59)
+          second = rng.int(0, 59)
+
+          case format_type
+          when :iso8601, :rfc3339
+            "#{date}T#{format('%02d:%02d:%02d', hour, minute, second)}Z"
+          else # :standard
+            "#{date} #{format('%02d:%02d:%02d', hour, minute, second)}"
+          end
+        end
+
+        def generate_edge(rng, context, args)
+          ["1970-01-01T00:00:00Z", "2099-12-31T23:59:59Z"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a datetime", 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # TimeType type
+      class TimeType < Base
+        # Generate random time
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Symbol] :format time format (:full, :hour_minute, :hour_only)
+        # @return [String] generated time string
+        #
+        def generate_random(rng, context, args)
+          format_type = args[:format] || :full
+
+          hour = rng.int(0, 23)
+          minute = rng.int(0, 59)
+          second = rng.int(0, 59)
+
+          case format_type
+          when :hour_only
+            format("%02d:00:00", hour)
+          when :hour_minute
+            format("%02d:%02d:00", hour, minute)
+          else # :full
+            format("%02d:%02d:%02d", hour, minute, second)
+          end
+        end
+
+        def generate_edge(rng, context, args)
+          ["00:00:00", "23:59:59", "12:00:00"].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a time", 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Timestamp type
+      class Timestamp < Base
+        # Generate a random timestamp
+        #
+        # Generates a Time value in the past (up to 365 days ago).
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments (not used)
+        # @return [Time] time value in the past
+        #
+        def generate_random(rng, context, args)
+          # "timestamp" anchors exactly to the TimeTravel point-in-time (or a random
+          # point within it, if a range context is active) rather than a random past
+          # offset — the caller asked for data as it existed AT that moment.
+          return TimeTravel.current_time.current_time if TimeTravel.current_time
+
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.time_backward(days: 365)
+
+          else
+            Faker::Time.backward(days: 365)
+          end
+
+        rescue StandardError
+          Time.now - rng.int(0, 365 * 86400) # fallback
+        end
+
+
+        def generate_edge(rng, context, args)
+          reference = TimeTravel.current_time&.current_time || Time.now
+          [Time.at(0), reference].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a timestamp", 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # Now type
+      class Now < Base
+        # Generate a "current" date value
+        #
+        # Uses a fixed base date (2020-01-01) plus a random offset
+        # determined by the RNG for deterministic output.
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context (not used)
+        # @param args [Hash] type arguments (not used)
+        # @return [Date] date value representing "now"
+        #
+        # @example
+        #   generate_random(rng, context, {})
+        #   # => Date.new(2020, 1, 15)  # Base + random days
+        #
+        def generate_random(rng, context, args)
+          # "now" anchors exactly to the TimeTravel point-in-time when one is set —
+          # it represents "the current moment", so under time travel that moment
+          # IS the anchor (or a random point within an anchored range).
+          if TimeTravel.current_time
+            anchored = TimeTravel.current_time.current_time
+            return anchored.respond_to?(:to_date) ? anchored.to_date : anchored
+          end
+
+          # Otherwise: use RNG to generate deterministic timestamps.
+          # Base time is 2020-01-01, add random offset up to 5 years
+          base_time = Date.new(2020, 1, 1)
+          days_offset = rng.int(0, 365 * 5)
+          base_time + days_offset
+        end
+
+        def generate_edge(rng, context, args)
+          if TimeTravel.current_time
+            anchored = TimeTravel.current_time.current_time
+            return anchored.respond_to?(:to_date) ? anchored.to_date : anchored
+          end
+
+          [Date.new(2020, 1, 1), Date.new(2025, 1, 1)].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a date", 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+      end
+
+      # PastDate type
+      class PastDate < Base
+        # Generate a random past date
+        #
+        # Generates a date in the past using the specified duration.
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Integer, Hash] :value duration value
+        # @option args [String] :suffix duration unit (d, m, y, h)
+        # @return [Date] date in the past
+        #
+        def generate_random(rng, context, args)
+          duration = parse_duration(args)
+          anchor = TimeTravel.anchor_date
+          return anchor - duration if anchor
+
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.date_backward(days: duration)
+
+          else
+            Faker::Date.backward(days: duration)
+          end
+
+        rescue StandardError
+          Date.today - duration
+        end
+
+
+        def generate_edge(rng, context, args)
+          anchor = TimeTravel.anchor_date || Date.today
+          [anchor - 1, anchor - 365].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a date", 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        private
+
+        def parse_duration(args)
+          # Handle nested value hash like {value: {value: 2, suffix: "y"}}
+          if args[:value].is_a?(Hash)
+            value = args[:value][:value] || 1
+            suffix = args[:value][:suffix] || "d"
+          else
+            value = args[:value] || 365
+            suffix = args[:suffix] || "d"
+          end
+
+          case suffix.to_s.downcase
+          when "y", "year", "years"
+            value * 365
+          when "m", "month", "months"
+            value * 30
+          when "d", "day", "days"
+            value
+          when "h", "hour", "hours"
+            (value / 24.0).ceil
+          else
+            value
+          end
+        end
+      end
+
+      # FutureDate type
+      class FutureDate < Base
+        # Generate a random future date
+        #
+        # Generates a date in the future using the specified duration.
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [Integer, Hash] :value duration value
+        # @option args [String] :suffix duration unit (d, m, y)
+        # @return [Date] date in the future
+        #
+        def generate_random(rng, context, args)
+          duration = parse_duration(args)
+          anchor = TimeTravel.anchor_date
+          return anchor + duration if anchor
+
+          adapter = faker_adapter(context)
+          if adapter
+            adapter.date_forward(days: duration)
+
+          else
+            Faker::Date.forward(days: duration)
+          end
+
+        rescue StandardError
+          Date.today + duration
+        end
+
+
+        def generate_edge(rng, context, args)
+          anchor = TimeTravel.anchor_date || Date.today
+          [anchor + 1, anchor + 365].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a date", 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        private
+
+        def parse_duration(args)
+          # Handle nested value hash like {value: {value: 7, suffix: "d"}}
+          if args[:value].is_a?(Hash)
+            value = args[:value][:value] || 1
+            suffix = args[:value][:suffix] || "d"
+          else
+            value = args[:value] || 365
+            suffix = args[:suffix] || "d"
+          end
+
+          case suffix.to_s.downcase
+          when "y", "year", "years"
+            value * 365
+          when "m", "month", "months"
+            value * 30
+          when "d", "day", "days"
+            value
+          else
+            value
+          end
+        end
+      end
+
+      # DateBetween type
+      class DateBetween < Base
+        # Generate random date between range
+        #
+        # @param rng [Generator::RNG] random number generator
+        # @param context [Generator::Context] generation context
+        # @param args [Hash] type arguments
+        # @option args [String, Date] :start start date
+        # @option args [String, Date] :from alias for :start
+        # @option args [String, Date] :end end date
+        # @option args [String, Date] :to alias for :end
+        # @return [Date] generated date
+        #
+        def generate_random(rng, context, args)
+          reference_date = TimeTravel.anchor_date || Date.today
+          start_date = parse_date(args[:start] || args[:from] || (reference_date - 365))
+          end_date = parse_date(args[:end] || args[:to] || reference_date)
+
+          # Ensure valid range
+          start_date, end_date = end_date, start_date if start_date > end_date
+
+          # Generate random date in range
+          days = (end_date - start_date).to_i
+          start_date + rng.int(0, days)
+        end
+
+        def generate_edge(rng, context, args)
+          anchor = TimeTravel.anchor_date || Date.today
+          [anchor - 365, anchor].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        def generate_invalid(rng, context, args)
+          [nil, "not a date", 123, [], {}].sample(random: rng.instance_variable_get(:@random))
+        end
+
+        private
+
+        def parse_date(date)
+          case date
+          when Date
+            date
+          when String
+            Date.parse(date)
+          else
+            TimeTravel.anchor_date || Date.today
+          end
+
+        rescue StandardError
+          TimeTravel.anchor_date || Date.today
+        end
+
+      end
+    end
+  end
+end