decision_agent 0.3.0 → 1.1.0

data/lib/decision_agent/dsl/operators/date_arithmetic_operators.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Operators
+      # Handles date arithmetic operators: add_days, subtract_days, add_hours, subtract_hours, add_minutes, subtract_minutes
+      module DateArithmeticOperators
+        def self.handle(op, actual_value, expected_value, context_hash, param_cache: nil, param_cache_mutex: nil)
+          case op
+          when "add_days"
+            # Adds days to a date and compares
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_date_arithmetic_params(expected_value, :days, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            result_date = start_date + (params[:days] * 86_400)
+            target_date = if params[:target] == "now"
+                            Time.now
+                          else
+                            ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash, params[:target]))
+                          end
+            return false unless target_date
+
+            compare_date_result?(result_date, target_date, params)
+
+          when "subtract_days"
+            # Subtracts days from a date and compares
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_date_arithmetic_params(expected_value, :days, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            result_date = start_date - (params[:days] * 86_400)
+            target_date = if params[:target] == "now"
+                            Time.now
+                          else
+                            ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash, params[:target]))
+                          end
+            return false unless target_date
+
+            compare_date_result?(result_date, target_date, params)
+
+          when "add_hours"
+            # Adds hours to a date and compares
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_date_arithmetic_params(expected_value, :hours, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            result_date = start_date + (params[:hours] * 3600)
+            target_date = if params[:target] == "now"
+                            Time.now
+                          else
+                            ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash, params[:target]))
+                          end
+            return false unless target_date
+
+            compare_date_result?(result_date, target_date, params)
+
+          when "subtract_hours"
+            # Subtracts hours from a date and compares
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_date_arithmetic_params(expected_value, :hours, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            result_date = start_date - (params[:hours] * 3600)
+            target_date = if params[:target] == "now"
+                            Time.now
+                          else
+                            ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash, params[:target]))
+                          end
+            return false unless target_date
+
+            compare_date_result?(result_date, target_date, params)
+
+          when "add_minutes"
+            # Adds minutes to a date and compares
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_date_arithmetic_params(expected_value, :minutes, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            result_date = start_date + (params[:minutes] * 60)
+            target_date = if params[:target] == "now"
+                            Time.now
+                          else
+                            ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash, params[:target]))
+                          end
+            return false unless target_date
+
+            compare_date_result?(result_date, target_date, params)
+
+          when "subtract_minutes"
+            # Subtracts minutes from a date and compares
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_date_arithmetic_params(expected_value, :minutes, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            result_date = start_date - (params[:minutes] * 60)
+            target_date = if params[:target] == "now"
+                            Time.now
+                          else
+                            ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash, params[:target]))
+                          end
+            return false unless target_date
+
+            compare_date_result?(result_date, target_date, params)
+          end
+          # Returns nil if not handled by this module
+        end
+
+        # Parse date arithmetic parameters
+        def self.parse_date_arithmetic_params(value, unit = :days, param_cache: nil, param_cache_mutex: nil)
+          return nil unless value.is_a?(Hash)
+
+          # Normalize to hash (already a hash, but normalize keys)
+          normalized = Base.normalize_params_to_hash(value, [])
+
+          cache = param_cache
+          mutex = param_cache_mutex
+          if cache.nil? || mutex.nil?
+            cache = ConditionEvaluator.instance_variable_get(:@param_cache)
+            mutex = ConditionEvaluator.instance_variable_get(:@param_cache_mutex)
+          end
+
+          cache_key = Base.normalize_param_cache_key(normalized, "date_arithmetic_#{unit}")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_date_arithmetic_params_impl(normalized, unit)
+          end
+        end
+
+        def self.parse_date_arithmetic_params_impl(value, unit)
+          unit_value = value[unit.to_s] || value[unit]
+          return nil unless unit_value.is_a?(Numeric)
+
+          {
+            unit => unit_value.to_f,
+            target: value[:target] || value["target"] || "now",
+            compare: value[:compare] || value["compare"],
+            eq: value[:eq] || value["eq"],
+            gt: value[:gt] || value["gt"],
+            lt: value[:lt] || value["lt"],
+            gte: value[:gte] || value["gte"],
+            lte: value[:lte] || value["lte"]
+          }
+        end
+
+        # Compare date result
+        def self.compare_date_result?(actual, target, params)
+          if params[:compare]
+            case params[:compare].to_s
+            when "eq", "=="
+              (actual - target).abs < 1
+            when "gt", ">"
+              actual > target
+            when "lt", "<"
+              actual < target
+            when "gte", ">="
+              actual >= target
+            when "lte", "<="
+              actual <= target
+            else
+              false
+            end
+          elsif params[:eq]
+            (actual - target).abs < 1
+          elsif params[:gt]
+            actual > target
+          elsif params[:lt]
+            actual < target
+          elsif params[:gte]
+            actual >= target
+          elsif params[:lte]
+            actual <= target
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/dsl/operators/date_time_operators.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Operators
+      # Handles date/time operators: before_date, after_date, within_days, day_of_week
+      module DateTimeOperators
+        def self.handle(op, actual_value, expected_value, date_cache: nil, date_cache_mutex: nil) # rubocop:disable Lint/UnusedMethodArgument
+          case op
+          when "before_date"
+            # Checks if date is before specified date
+            ConditionEvaluator.compare_dates(actual_value, expected_value, :<)
+
+          when "after_date"
+            # Checks if date is after specified date
+            ConditionEvaluator.compare_dates(actual_value, expected_value, :>)
+
+          when "within_days"
+            # Checks if date is within N days from now (past or future)
+            return false unless actual_value
+            return false unless expected_value.is_a?(Numeric)
+
+            date = ConditionEvaluator.parse_date(actual_value)
+            return false unless date
+
+            now = Time.now
+            diff_days = ((date - now) / 86_400).abs # 86400 seconds in a day
+            diff_days <= expected_value
+
+          when "day_of_week"
+            # Checks if date falls on specified day of week
+            return false unless actual_value
+
+            date = ConditionEvaluator.parse_date(actual_value)
+            return false unless date
+
+            expected_day = ConditionEvaluator.normalize_day_of_week(expected_value)
+            return false unless expected_day
+
+            date.wday == expected_day
+          end
+          # Returns nil if not handled by this module
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/dsl/operators/duration_operators.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Operators
+      # Handles duration calculation operators: duration_seconds, duration_minutes, duration_hours, duration_days
+      module DurationOperators
+        def self.handle(op, actual_value, expected_value, context_hash, param_cache: nil, param_cache_mutex: nil)
+          case op
+          when "duration_seconds"
+            # Calculates duration between two dates in seconds
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_duration_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            end_date = if params[:end] == "now"
+                         Time.now
+                       else
+                         ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash,
+                                                                                           params[:end]))
+                       end
+            return false unless end_date
+
+            duration = (end_date - start_date).abs
+            compare_duration_result(duration, params)
+
+          when "duration_minutes"
+            # Calculates duration between two dates in minutes
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_duration_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            end_date = if params[:end] == "now"
+                         Time.now
+                       else
+                         ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash,
+                                                                                           params[:end]))
+                       end
+            return false unless end_date
+
+            duration = ((end_date - start_date).abs / 60.0)
+            compare_duration_result(duration, params)
+
+          when "duration_hours"
+            # Calculates duration between two dates in hours
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_duration_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            end_date = if params[:end] == "now"
+                         Time.now
+                       else
+                         ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash,
+                                                                                           params[:end]))
+                       end
+            return false unless end_date
+
+            duration = ((end_date - start_date).abs / 3600.0)
+            compare_duration_result(duration, params)
+
+          when "duration_days"
+            # Calculates duration between two dates in days
+            return false unless actual_value
+
+            start_date = ConditionEvaluator.parse_date(actual_value)
+            return false unless start_date
+
+            params = parse_duration_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            end_date = if params[:end] == "now"
+                         Time.now
+                       else
+                         ConditionEvaluator.parse_date(ConditionEvaluator.get_nested_value(context_hash,
+                                                                                           params[:end]))
+                       end
+            return false unless end_date
+
+            duration = ((end_date - start_date).abs / 86_400.0)
+            compare_duration_result(duration, params)
+          end
+          # Returns nil if not handled by this module
+        end
+
+        # Parse duration parameters
+        def self.parse_duration_params(value, param_cache: nil, param_cache_mutex: nil)
+          return nil unless value.is_a?(Hash)
+
+          # Normalize to hash (already a hash, but normalize keys)
+          normalized = Base.normalize_params_to_hash(value, [])
+
+          cache = param_cache
+          mutex = param_cache_mutex
+          if cache.nil? || mutex.nil?
+            cache = ConditionEvaluator.instance_variable_get(:@param_cache)
+            mutex = ConditionEvaluator.instance_variable_get(:@param_cache_mutex)
+          end
+
+          cache_key = Base.normalize_param_cache_key(normalized, "duration")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_duration_params_impl(normalized)
+          end
+        end
+
+        def self.parse_duration_params_impl(value)
+          end_field = value[:end] || value["end"]
+          return nil unless end_field
+
+          {
+            end: end_field.to_s,
+            min: value[:min] || value["min"],
+            max: value[:max] || value["max"],
+            gt: value[:gt] || value["gt"],
+            lt: value[:lt] || value["lt"],
+            gte: value[:gte] || value["gte"],
+            lte: value[:lte] || value["lte"]
+          }
+        end
+
+        # Compare duration result
+        def self.compare_duration_result(actual, params)
+          result = true
+          result &&= (actual >= params[:min]) if params[:min]
+          result &&= (actual <= params[:max]) if params[:max]
+          result &&= (actual > params[:gt]) if params[:gt]
+          result &&= (actual < params[:lt]) if params[:lt]
+          result &&= (actual >= params[:gte]) if params[:gte]
+          result &&= (actual <= params[:lte]) if params[:lte]
+          result
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/dsl/operators/financial_operators.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Operators
+      # Handles financial calculation operators: compound_interest, present_value, future_value, payment
+      module FinancialOperators
+        def self.handle(op, actual_value, expected_value, param_cache: nil, param_cache_mutex: nil)
+          case op
+          when "compound_interest"
+            # Calculates compound interest: A = P(1 + r/n)^(nt)
+            return false unless actual_value.is_a?(Numeric)
+
+            params = parse_compound_interest_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            principal = actual_value
+            rate = params[:rate]
+            periods = params[:periods]
+            result = principal * ((1 + (rate / periods))**periods)
+
+            if params[:result]
+              (result.round(2) == params[:result].round(2))
+            else
+              compare_financial_result(result, params)
+            end
+
+          when "present_value"
+            # Calculates present value: PV = FV / (1 + r)^n
+            return false unless actual_value.is_a?(Numeric)
+
+            params = parse_present_value_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            future_value = actual_value
+            rate = params[:rate]
+            periods = params[:periods]
+            present_value = future_value / ((1 + rate)**periods)
+
+            if params[:result]
+              (present_value.round(2) == params[:result].round(2))
+            else
+              compare_financial_result(present_value, params)
+            end
+
+          when "future_value"
+            # Calculates future value: FV = PV * (1 + r)^n
+            return false unless actual_value.is_a?(Numeric)
+
+            params = parse_future_value_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            present_value = actual_value
+            rate = params[:rate]
+            periods = params[:periods]
+            future_value = present_value * ((1 + rate)**periods)
+
+            if params[:result]
+              (future_value.round(2) == params[:result].round(2))
+            else
+              compare_financial_result(future_value, params)
+            end
+
+          when "payment"
+            # Calculates loan payment: PMT = P * [r(1+r)^n] / [(1+r)^n - 1]
+            return false unless actual_value.is_a?(Numeric)
+
+            params = parse_payment_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            principal = actual_value
+            rate = params[:rate]
+            periods = params[:periods]
+
+            return false if rate <= 0 || periods <= 0
+
+            payment = if rate.zero?
+                        principal / periods
+                      else
+                        principal * (rate * ((1 + rate)**periods)) / (((1 + rate)**periods) - 1)
+                      end
+
+            if params[:result]
+              (payment.round(2) == params[:result].round(2))
+            else
+              compare_financial_result(payment, params)
+            end
+          end
+          # Returns nil if not handled by this module
+        end
+
+        # Parse compound interest parameters
+        def self.parse_compound_interest_params(value, param_cache: nil, param_cache_mutex: nil)
+          return nil unless value.is_a?(Hash)
+
+          normalized = Base.normalize_params_to_hash(value, [])
+
+          cache = param_cache
+          mutex = param_cache_mutex
+          if cache.nil? || mutex.nil?
+            cache = ConditionEvaluator.instance_variable_get(:@param_cache)
+            mutex = ConditionEvaluator.instance_variable_get(:@param_cache_mutex)
+          end
+
+          cache_key = Base.normalize_param_cache_key(normalized, "compound_interest")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_compound_interest_params_impl(normalized)
+          end
+        end
+
+        def self.parse_compound_interest_params_impl(value)
+          rate = value[:rate] || value["rate"]
+          periods = value[:periods] || value["periods"]
+          return nil unless rate.is_a?(Numeric) && periods.is_a?(Numeric) && periods.positive?
+
+          {
+            rate: rate.to_f,
+            periods: periods.to_f,
+            result: value[:result] || value["result"],
+            compare: value[:compare] || value["compare"],
+            threshold: value[:threshold] || value["threshold"]
+          }
+        end
+
+        # Parse present value parameters
+        def self.parse_present_value_params(value, param_cache: nil, param_cache_mutex: nil)
+          return nil unless value.is_a?(Hash)
+
+          normalized = Base.normalize_params_to_hash(value, [])
+
+          cache = param_cache
+          mutex = param_cache_mutex
+          if cache.nil? || mutex.nil?
+            cache = ConditionEvaluator.instance_variable_get(:@param_cache)
+            mutex = ConditionEvaluator.instance_variable_get(:@param_cache_mutex)
+          end
+
+          cache_key = Base.normalize_param_cache_key(normalized, "present_value")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_present_value_params_impl(normalized)
+          end
+        end
+
+        def self.parse_present_value_params_impl(value)
+          rate = value[:rate] || value["rate"]
+          periods = value[:periods] || value["periods"]
+          return nil unless rate.is_a?(Numeric) && periods.is_a?(Numeric) && periods.positive?
+
+          {
+            rate: rate.to_f,
+            periods: periods.to_f,
+            result: value[:result] || value["result"]
+          }
+        end
+
+        # Parse future value parameters
+        def self.parse_future_value_params(value, param_cache: nil, param_cache_mutex: nil)
+          return nil unless value.is_a?(Hash)
+
+          normalized = Base.normalize_params_to_hash(value, [])
+
+          cache = param_cache
+          mutex = param_cache_mutex
+          if cache.nil? || mutex.nil?
+            cache = ConditionEvaluator.instance_variable_get(:@param_cache)
+            mutex = ConditionEvaluator.instance_variable_get(:@param_cache_mutex)
+          end
+
+          cache_key = Base.normalize_param_cache_key(normalized, "future_value")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_future_value_params_impl(normalized)
+          end
+        end
+
+        def self.parse_future_value_params_impl(value)
+          rate = value[:rate] || value["rate"]
+          periods = value[:periods] || value["periods"]
+          return nil unless rate.is_a?(Numeric) && periods.is_a?(Numeric) && periods.positive?
+
+          {
+            rate: rate.to_f,
+            periods: periods.to_f,
+            result: value[:result] || value["result"]
+          }
+        end
+
+        # Parse payment parameters
+        def self.parse_payment_params(value, param_cache: nil, param_cache_mutex: nil)
+          return nil unless value.is_a?(Hash)
+
+          normalized = Base.normalize_params_to_hash(value, [])
+
+          cache = param_cache
+          mutex = param_cache_mutex
+          if cache.nil? || mutex.nil?
+            cache = ConditionEvaluator.instance_variable_get(:@param_cache)
+            mutex = ConditionEvaluator.instance_variable_get(:@param_cache_mutex)
+          end
+
+          cache_key = Base.normalize_param_cache_key(normalized, "payment")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_payment_params_impl(normalized)
+          end
+        end
+
+        def self.parse_payment_params_impl(value)
+          rate = value[:rate] || value["rate"]
+          periods = value[:periods] || value["periods"]
+          return nil unless rate.is_a?(Numeric) && periods.is_a?(Numeric) && periods.positive?
+
+          {
+            rate: rate.to_f,
+            periods: periods.to_f,
+            result: value[:result] || value["result"]
+          }
+        end
+
+        # Compare financial result
+        def self.compare_financial_result(actual, params)
+          ConditionEvaluator.compare_financial_result(actual, params)
+        end
+      end
+    end
+  end
+end