forthic 0.2.0 → 0.3.0

data/lib/forthic/modules/standard/datetime_module.rb

@@ -0,0 +1,349 @@
+# frozen_string_literal: true
+
+require_relative '../../decorators/word'
+require_relative '../../literals'
+require 'time'
+require 'date'
+require 'tzinfo'
+
+module Forthic
+  module Modules
+    # DateTimeModule - Date and time operations
+    #
+    # Provides timezone-aware datetime manipulation using Ruby's Time and Date classes.
+    class DateTimeModule < Decorators::DecoratedModule
+      # Register module documentation
+      module_doc <<~DOC
+        Date and time operations using Ruby Time and Date classes for timezone-aware datetime manipulation.
+
+        ## Categories
+        - Current: TODAY, NOW
+        - Time adjustment: AM, PM
+        - Conversion to: >TIME, >DATE, >DATETIME, AT
+        - Conversion from: TIME>STR, DATE>STR, DATE>INT
+        - Timestamps: >TIMESTAMP, TIMESTAMP>DATETIME
+        - Date math: ADD-DAYS, SUBTRACT-DATES
+
+        ## Examples
+        TODAY
+        NOW
+        "14:30" >TIME
+        "2024-01-15" >DATE
+        TODAY "14:30" >TIME AT
+        TODAY 7 ADD-DAYS
+      DOC
+
+      def initialize
+        super("datetime")
+      end
+
+      # Helper method to get Time in specific timezone
+      def get_time_in_timezone(timezone_name)
+        tz = TZInfo::Timezone.get(timezone_name)
+        tz.now
+      end
+
+      # Helper method to convert Unix timestamp to Time in specific timezone
+      def timestamp_to_time(timestamp, timezone_name)
+        tz = TZInfo::Timezone.get(timezone_name)
+        tz.to_local(Time.at(timestamp).utc)
+      end
+
+      # Helper method to parse time string in specific timezone
+      def parse_time_in_timezone(str, timezone_name)
+        tz = TZInfo::Timezone.get(timezone_name)
+        utc_time = Time.parse(str).utc
+        tz.to_local(utc_time)
+      end
+
+      # ========================================
+      # Current Time/Date
+      # ========================================
+
+    forthic_direct_word :TODAY, "( -- date:Date )", "Get current date"
+      def TODAY(interp)
+        timezone = interp.get_timezone
+        # Get current time in timezone, then convert to Date
+        today = get_time_in_timezone(timezone)
+        date = Date.new(today.year, today.month, today.day)
+        interp.stack_push(date)
+      end
+
+    forthic_direct_word :NOW, "( -- datetime:Time )", "Get current datetime"
+      def NOW(interp)
+        timezone = interp.get_timezone
+        now = get_time_in_timezone(timezone)
+        interp.stack_push(now)
+      end
+
+      # ========================================
+      # Time Adjustment
+      # ========================================
+
+    forthic_direct_word :AM, "( time:SimpleTime -- time:SimpleTime )", "Convert time to AM (subtract 12 from hour if >= 12)"
+      def AM(interp)
+        time = interp.stack_pop
+        result = if time && time.respond_to?(:hour)
+                   if time.hour >= 12
+                     Forthic::SimpleTime.new(hour: time.hour - 12, minute: time.minute)
+                   else
+                     time
+                   end
+                 else
+                   time
+                 end
+        interp.stack_push(result)
+      end
+
+    forthic_direct_word :PM, "( time:SimpleTime -- time:SimpleTime )", "Convert time to PM (add 12 to hour if < 12)"
+      def PM(interp)
+        time = interp.stack_pop
+        result = if time && time.respond_to?(:hour)
+                   if time.hour < 12
+                     Forthic::SimpleTime.new(hour: time.hour + 12, minute: time.minute)
+                   else
+                     time
+                   end
+                 else
+                   time
+                 end
+        interp.stack_push(result)
+      end
+
+      # ========================================
+      # Conversion To Date/Time
+      # ========================================
+
+    forthic_direct_word :to_TIME, "( item:any -- time:SimpleTime )", "Convert string or datetime to SimpleTime", ">TIME"
+      def to_TIME(interp)
+        item = interp.stack_pop
+        result = nil
+
+        if item
+          # If already a SimpleTime, return it
+          if item.is_a?(Forthic::SimpleTime)
+            result = item
+          # If it's a Time, extract the hour and minute
+          elsif item.is_a?(Time)
+            result = Forthic::SimpleTime.new(hour: item.hour, minute: item.min)
+          else
+            # Otherwise, parse as string
+            str = item.to_s.strip
+
+            # Handle "HH:MM AM/PM" format
+            ampm_match = str.match(/^(\d{1,2}):(\d{2})\s*(AM|PM)$/i)
+            if ampm_match
+              hour = ampm_match[1].to_i
+              minute = ampm_match[2].to_i
+              meridiem = ampm_match[3].upcase
+
+              if meridiem == "PM" && hour < 12
+                hour += 12
+              elsif meridiem == "AM" && hour == 12
+                hour = 0
+              end
+
+              result = Forthic::SimpleTime.new(hour: hour, minute: minute)
+            else
+              # Try standard parsing (HH:MM or HH:MM:SS)
+              begin
+                match = str.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/)
+                if match
+                  hour = match[1].to_i
+                  minute = match[2].to_i
+                  result = Forthic::SimpleTime.new(hour: hour, minute: minute)
+                end
+              rescue StandardError
+                # Fall through
+              end
+            end
+          end
+        end
+
+        interp.stack_push(result)
+      end
+
+    forthic_direct_word :to_DATE, "( item:any -- date:Date )", "Convert string or datetime to Date", ">DATE"
+      def to_DATE(interp)
+        item = interp.stack_pop
+        result = nil
+
+        if item
+          # If already a Date, return it
+          if item.is_a?(Date)
+            result = item
+          # If it's a Time, extract the date
+          elsif item.is_a?(Time)
+            result = Date.new(item.year, item.month, item.day)
+          else
+            # Otherwise, parse as string
+            str = item.to_s.strip
+
+            # Try standard ISO format (YYYY-MM-DD)
+            begin
+              result = Date.parse(str)
+            rescue StandardError
+              # Fall through
+            end
+          end
+        end
+
+        interp.stack_push(result)
+      end
+
+    forthic_direct_word :to_DATETIME, "( str_or_timestamp:any -- datetime:Time )", "Convert string or timestamp to Time", ">DATETIME"
+      def to_DATETIME(interp)
+        item = interp.stack_pop
+
+        unless item
+          interp.stack_push(nil)
+          return
+        end
+
+        # If already a Time, return it
+        if item.is_a?(Time)
+          interp.stack_push(item)
+          return
+        end
+
+        # If it's a number, treat as Unix timestamp (seconds)
+        if item.is_a?(Numeric)
+          timezone = interp.get_timezone
+          time = timestamp_to_time(item, timezone)
+          interp.stack_push(time)
+          return
+        end
+
+        # Otherwise, parse as string
+        str = item.to_s.strip
+
+        begin
+          # Try parsing as ISO datetime string
+          timezone = interp.get_timezone
+          time = parse_time_in_timezone(str, timezone)
+          interp.stack_push(time)
+        rescue StandardError
+          interp.stack_push(nil)
+        end
+      end
+
+    forthic_direct_word :AT, "( date:Date time:SimpleTime -- datetime:Time )", "Combine date and time into datetime"
+      def AT(interp)
+        time = interp.stack_pop
+        date = interp.stack_pop
+
+        unless date && time
+          interp.stack_push(nil)
+          return
+        end
+
+        # Create Time from date and time components in the specified timezone
+        timezone_name = interp.get_timezone
+        hour = time.respond_to?(:hour) ? (time.hour || 0) : 0
+        minute = time.respond_to?(:minute) ? (time.minute || 0) : 0
+
+        # Create local time in the specified timezone
+        tz = TZInfo::Timezone.get(timezone_name)
+        local_time = Time.new(date.year, date.month, date.day, hour, minute, 0)
+        datetime = tz.to_local(tz.local_to_utc(local_time))
+
+        interp.stack_push(datetime)
+      end
+
+      # ========================================
+      # Conversion From Date/Time
+      # ========================================
+
+    forthic_word :TIME_to_STR, "( time:SimpleTime -- str:string )", "Convert time to HH:MM string", "TIME>STR"
+      def TIME_to_STR(time)
+        return "" unless time && time.respond_to?(:hour)
+
+        hour = time.hour.to_s.rjust(2, '0')
+        minute = time.minute.to_s.rjust(2, '0')
+        "#{hour}:#{minute}"
+      end
+
+    forthic_word :DATE_to_STR, "( date:Date -- str:string )", "Convert date to YYYY-MM-DD string", "DATE>STR"
+      def DATE_to_STR(date)
+        return "" unless date && date.respond_to?(:year)
+
+        date.to_s
+      end
+
+    forthic_word :DATE_to_INT, "( date:Date -- int:number )", "Convert date to integer (YYYYMMDD)", "DATE>INT"
+      def DATE_to_INT(date)
+        return nil unless date && date.respond_to?(:year)
+
+        year = date.year
+        month = date.month.to_s.rjust(2, '0')
+        day = date.day.to_s.rjust(2, '0')
+        "#{year}#{month}#{day}".to_i
+      end
+
+      # ========================================
+      # Timestamps
+      # ========================================
+
+    forthic_direct_word :to_TIMESTAMP, "( datetime:Time -- timestamp:number )", "Convert datetime to Unix timestamp (seconds)", ">TIMESTAMP"
+      def to_TIMESTAMP(interp)
+        datetime = interp.stack_pop
+
+        unless datetime
+          interp.stack_push(nil)
+          return
+        end
+
+        # Convert to Unix timestamp (seconds)
+        if datetime.is_a?(Time)
+          interp.stack_push(datetime.to_i)
+        else
+          interp.stack_push(nil)
+        end
+      end
+
+    forthic_direct_word :TIMESTAMP_to_DATETIME, "( timestamp:number -- datetime:Time )", "Convert Unix timestamp (seconds) to datetime", "TIMESTAMP>DATETIME"
+      def TIMESTAMP_to_DATETIME(interp)
+        timestamp = interp.stack_pop
+
+        unless timestamp.is_a?(Numeric)
+          interp.stack_push(nil)
+          return
+        end
+
+        # Convert timestamp (seconds) to Time
+        timezone = interp.get_timezone
+        datetime = timestamp_to_time(timestamp, timezone)
+        interp.stack_push(datetime)
+      end
+
+      # ========================================
+      # Date Math
+      # ========================================
+
+    forthic_direct_word :ADD_DAYS, "( date:Date num_days:number -- date:Date )", "Add days to a date", "ADD-DAYS"
+      def ADD_DAYS(interp)
+        num_days = interp.stack_pop
+        date = interp.stack_pop
+        result = if date && date.respond_to?(:year) && !num_days.nil?
+                   date + num_days
+                 else
+                   nil
+                 end
+        interp.stack_push(result)
+      end
+
+    forthic_direct_word :SUBTRACT_DATES, "( date1:Date date2:Date -- num_days:number )", "Get difference in days between dates (date1 - date2)", "SUBTRACT-DATES"
+      def SUBTRACT_DATES(interp)
+        date2 = interp.stack_pop
+        date1 = interp.stack_pop
+        result = if date1 && date2 && date1.respond_to?(:year) && date2.respond_to?(:year)
+                   # Get the difference in days: date1 - date2
+                   (date1 - date2).to_i
+                 else
+                   nil
+                 end
+        interp.stack_push(result)
+      end
+    end
+  end
+end

data/lib/forthic/modules/standard/json_module.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../../decorators/word'
+require 'json'
+
+module Forthic
+  module Modules
+    # JsonModule - JSON serialization, parsing, and formatting operations
+    #
+    # Provides operations for converting between Ruby objects and JSON strings.
+    class JsonModule < Decorators::DecoratedModule
+      # Register module documentation
+      module_doc <<~DOC
+        JSON serialization, parsing, and formatting operations.
+
+        ## Categories
+        - Conversion: >JSON, JSON>
+        - Formatting: JSON-PRETTIFY
+
+        ## Examples
+        {name: "Alice", age: 30} >JSON
+        '{"name":"Alice"}' JSON>
+        '{"a":1}' JSON-PRETTIFY
+      DOC
+
+      def initialize
+        super("json")
+      end
+
+    forthic_word :to_JSON, "( object:any -- json:string )", "Convert object to JSON string", ">JSON"
+      def to_JSON(object)
+        return "null" if object.nil?
+        JSON.generate(object)
+      end
+
+    forthic_direct_word :from_JSON, "( json:string -- object:any )", "Parse JSON string to object", "JSON>"
+      def from_JSON(interp)
+        json = interp.stack_pop
+        result = if json.nil? || json.strip.empty?
+                   nil
+                 else
+                   JSON.parse(json)
+                 end
+        interp.stack_push(result)
+      end
+
+    forthic_word :JSON_PRETTIFY, "( json:string -- pretty:string )", "Format JSON with 2-space indentation", "JSON-PRETTIFY"
+      def JSON_PRETTIFY(json)
+        return "" if json.nil? || json.strip.empty?
+        obj = JSON.parse(json)
+        JSON.pretty_generate(obj)
+      end
+    end
+  end
+end