decision_agent 0.3.0 → 1.1.0

data/lib/decision_agent/dsl/helpers/cache_helpers.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Helpers
+      # Cache management helpers for ConditionEvaluator
+      module CacheHelpers
+        def self.get_cached_regex(pattern, regex_cache:, regex_cache_mutex:)
+          return pattern if pattern.is_a?(Regexp)
+
+          # Fast path: check cache without lock
+          cached = regex_cache[pattern]
+          return cached if cached
+
+          # Slow path: compile and cache
+          regex_cache_mutex.synchronize do
+            regex_cache[pattern] ||= Regexp.new(pattern.to_s)
+          end
+        end
+
+        def self.get_cached_path(key_path, path_cache:, path_cache_mutex:)
+          # Fast path: check cache without lock
+          cached = path_cache[key_path]
+          return cached if cached
+
+          # Slow path: split and cache
+          path_cache_mutex.synchronize do
+            path_cache[key_path] ||= key_path.to_s.split(".").freeze
+          end
+        end
+
+        def self.get_cached_date(date_string, date_cache:, date_cache_mutex:, parse_date_fast:)
+          # Fast path: check cache without lock
+          cached = date_cache[date_string]
+          return cached if cached
+
+          # Slow path: parse and cache
+          date_cache_mutex.synchronize do
+            date_cache[date_string] ||= parse_date_fast.call(date_string)
+          end
+        end
+
+        def self.get_cached_distance(point1, point2, geospatial_cache:, geospatial_cache_mutex:, haversine_distance:)
+          # Round coordinates to 4 decimal places (~11m precision) for cache key
+          key = [
+            point1[:lat].round(4),
+            point1[:lon].round(4),
+            point2[:lat].round(4),
+            point2[:lon].round(4)
+          ].join(",")
+
+          # Fast path: check cache without lock
+          cached = geospatial_cache[key]
+          return cached if cached
+
+          # Slow path: calculate and cache
+          geospatial_cache_mutex.synchronize do
+            geospatial_cache[key] ||= haversine_distance.call(point1, point2)
+          end
+        end
+
+        def self.clear_caches!(regex_cache:, path_cache:, date_cache:, geospatial_cache:, param_cache:)
+          regex_cache.clear
+          path_cache.clear
+          date_cache.clear
+          geospatial_cache.clear
+          param_cache.clear
+        end
+
+        def self.cache_stats(regex_cache:, path_cache:, date_cache:, geospatial_cache:, param_cache:)
+          {
+            regex: regex_cache.size,
+            path: path_cache.size,
+            date: date_cache.size,
+            geospatial: geospatial_cache.size,
+            param: param_cache.size
+          }
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/dsl/helpers/comparison_helpers.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Helpers
+      # Comparison helpers for ConditionEvaluator
+      module ComparisonHelpers
+        def self.compare_percentile_result(actual, params)
+          result = true
+          result &&= (actual >= params[:threshold]) if params[:threshold]
+          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 &&= (actual == params[:eq]) if params[:eq]
+          result
+        end
+
+        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
+
+        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
+
+        def self.compare_moving_window_result(actual, params)
+          result = true
+          result &&= (actual >= params[:threshold]) if params[:threshold]
+          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
+
+        def self.compare_financial_result(actual, params)
+          result = true
+          result &&= (actual >= params[:threshold]) if params[:threshold]
+          result &&= (actual > params[:gt]) if params[:gt]
+          result &&= (actual < params[:lt]) if params[:lt]
+          result
+        end
+
+        def self.compare_numeric_with_hash(actual, expected)
+          comparisons = [
+            [:min, ->(val, threshold) { val >= threshold }],
+            [:max, ->(val, threshold) { val <= threshold }],
+            [:gt, ->(val, threshold) { val > threshold }],
+            [:lt, ->(val, threshold) { val < threshold }],
+            [:gte, ->(val, threshold) { val >= threshold }],
+            [:lte, ->(val, threshold) { val <= threshold }],
+            [:eq, ->(val, threshold) { val == threshold }]
+          ]
+
+          comparisons.all? do |key, comparison|
+            threshold = expected[key] || expected[key.to_s]
+            threshold.nil? || comparison.call(actual, threshold)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/dsl/helpers/date_helpers.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Helpers
+      # Date/time helper methods for ConditionEvaluator
+      module DateHelpers
+        def self.parse_date_fast(date_string)
+          return nil unless date_string.is_a?(String)
+
+          # Fast-path: ISO8601 date format (YYYY-MM-DD)
+          if date_string.match?(/^\d{4}-\d{2}-\d{2}$/)
+            year, month, day = date_string.split("-").map(&:to_i)
+            begin
+              return Time.new(year, month, day)
+            rescue StandardError => e
+              warn "[DecisionAgent] Failed to parse date '#{date_string}': #{e.message}"
+              nil
+            end
+          end
+
+          # Fast-path: ISO8601 datetime format (YYYY-MM-DDTHH:MM:SS or YYYY-MM-DDTHH:MM:SSZ)
+          if date_string.match?(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
+            begin
+              # Try ISO8601 parsing first (faster than Time.parse for this format)
+              return Time.iso8601(date_string)
+            rescue ArgumentError
+              # Fall through to Time.parse
+            end
+          end
+
+          # Fallback to Time.parse for other formats
+          Time.parse(date_string)
+        rescue ArgumentError, TypeError
+          nil
+        end
+
+        def self.parse_date(value, get_cached_date:)
+          case value
+          when Time, Date, DateTime
+            value
+          when String
+            get_cached_date.call(value)
+          end
+        rescue ArgumentError
+          nil
+        end
+
+        ALLOWED_COMPARISON_OPERATORS = %i[< > <= >= ==].freeze
+
+        def self.compare_dates(actual_value, expected_value, operator, parse_date:)
+          return false unless actual_value && expected_value
+
+          op = operator.to_sym
+          raise ArgumentError, "Unsupported comparison operator: #{operator}" unless ALLOWED_COMPARISON_OPERATORS.include?(op)
+
+          # Fast path: Both are already Time/Date objects (no parsing needed)
+          actual_is_date = actual_value.is_a?(Time) || actual_value.is_a?(Date) || actual_value.is_a?(DateTime)
+          expected_is_date = expected_value.is_a?(Time) || expected_value.is_a?(Date) || expected_value.is_a?(DateTime)
+          return actual_value.public_send(op, expected_value) if actual_is_date && expected_is_date
+
+          # Slow path: Parse dates (with caching)
+          actual_date = parse_date.call(actual_value)
+          expected_date = parse_date.call(expected_value)
+
+          return false unless actual_date && expected_date
+
+          actual_date.public_send(op, expected_date)
+        end
+
+        def self.normalize_day_of_week(value)
+          case value
+          when Numeric
+            value.to_i % 7
+          when String
+            day_map = {
+              "sunday" => 0, "sun" => 0,
+              "monday" => 1, "mon" => 1,
+              "tuesday" => 2, "tue" => 2,
+              "wednesday" => 3, "wed" => 3,
+              "thursday" => 4, "thu" => 4,
+              "friday" => 5, "fri" => 5,
+              "saturday" => 6, "sat" => 6
+            }
+            day_map[value.downcase]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/dsl/helpers/geospatial_helpers.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Helpers
+      # Geospatial helper methods for ConditionEvaluator
+      module GeospatialHelpers
+        def self.parse_coordinates(value)
+          case value
+          when Hash
+            lat = value["lat"] || value[:lat] || value["latitude"] || value[:latitude]
+            lon = value["lon"] || value[:lon] || value["lng"] || value[:lng] ||
+                  value["longitude"] || value[:longitude]
+            return nil unless lat && lon
+
+            { lat: lat.to_f, lon: lon.to_f }
+          when Array
+            return nil unless value.size == 2
+
+            { lat: value[0].to_f, lon: value[1].to_f }
+          end
+        end
+
+        def self.parse_radius_params(value, parse_coordinates:)
+          return nil unless value.is_a?(Hash)
+
+          center_data = value["center"] || value[:center]
+          radius = value["radius"] || value[:radius]
+
+          return nil unless center_data && radius
+
+          center = parse_coordinates.call(center_data)
+          return nil unless center
+
+          { center: center, radius: radius.to_f }
+        end
+
+        def self.parse_polygon(value, parse_coordinates:)
+          return nil unless value.is_a?(Array)
+
+          value.map { |vertex| parse_coordinates.call(vertex) }.compact
+        end
+
+        def self.haversine_distance(point1, point2)
+          earth_radius_km = 6371.0
+
+          lat1_rad = (point1[:lat] * Math::PI) / 180
+          lat2_rad = (point2[:lat] * Math::PI) / 180
+          delta_lat = ((point2[:lat] - point1[:lat]) * Math::PI) / 180
+          delta_lon = ((point2[:lon] - point1[:lon]) * Math::PI) / 180
+
+          haversine_a = (Math.sin(delta_lat / 2)**2) +
+                        (Math.cos(lat1_rad) * Math.cos(lat2_rad) *
+                         (Math.sin(delta_lon / 2)**2))
+
+          haversine_c = 2 * Math.atan2(Math.sqrt(haversine_a), Math.sqrt(1 - haversine_a))
+
+          earth_radius_km * haversine_c
+        end
+
+        def self.point_in_polygon?(point, polygon)
+          return false if polygon.size < 3
+
+          inside = false
+          j = polygon.size - 1
+
+          (0...polygon.size).each do |i|
+            xi = polygon[i][:lat]
+            yi = polygon[i][:lon]
+            xj = polygon[j][:lat]
+            yj = polygon[j][:lon]
+
+            intersect = ((yi > point[:lon]) != (yj > point[:lon])) &&
+                        (point[:lat] < ((xj - xi) * (point[:lon] - yi) / (yj - yi)) + xi)
+
+            inside = !inside if intersect
+            j = i
+          end
+
+          inside
+        end
+      end
+    end
+  end
+end

data/lib/decision_agent/dsl/helpers/operator_evaluation_helpers.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Helpers
+      # Operator evaluation helpers for ConditionEvaluator
+      module OperatorEvaluationHelpers
+        # Evaluates operator using mixins (in order of most common to least common)
+        # Returns the result from the first mixin that handles the operator, or false if unknown
+        def self.evaluate_operator(op, actual_value, expected_value, context_hash, regex_cache:, regex_cache_mutex:, param_cache:,
+                                   param_cache_mutex:, geospatial_cache:, geospatial_cache_mutex:)
+          # Try basic operators first (most common)
+          result = try_basic_operators(
+            op, actual_value, expected_value,
+            regex_cache: regex_cache,
+            regex_cache_mutex: regex_cache_mutex,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          # Try mathematical and statistical operators
+          result = try_math_and_statistical_operators(
+            op, actual_value, expected_value,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          # Try date/time operators
+          result = try_datetime_operators(
+            op, actual_value, expected_value, context_hash,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          # Try advanced operators (rate, moving window, financial)
+          result = try_advanced_operators(
+            op, actual_value, expected_value,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          # Try collection and aggregation operators
+          result = try_collection_and_aggregation_operators(
+            op, actual_value, expected_value,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          # Try special operators (geospatial, data enrichment)
+          result = try_special_operators(
+            op, actual_value, expected_value, context_hash,
+            geospatial_cache: geospatial_cache,
+            geospatial_cache_mutex: geospatial_cache_mutex
+          )
+          return result unless result.nil?
+
+          # Unknown operator - returns false (fail-safe)
+          # Note: Validation should catch this earlier
+          false
+        end
+
+        def self.try_basic_operators(op, actual_value, expected_value, regex_cache:, regex_cache_mutex:, param_cache:, param_cache_mutex:)
+          result = Operators::BasicComparisonOperators.handle(op, actual_value, expected_value)
+          return result unless result.nil?
+
+          result = Operators::StringOperators.handle(
+            op, actual_value, expected_value,
+            regex_cache: regex_cache,
+            regex_cache_mutex: regex_cache_mutex
+          )
+          return result unless result.nil?
+
+          Operators::NumericOperators.handle(
+            op, actual_value, expected_value,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+        end
+
+        def self.try_math_and_statistical_operators(op, actual_value, expected_value, param_cache:, param_cache_mutex:)
+          result = Operators::MathematicalOperators.handle(
+            op, actual_value, expected_value,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          Operators::StatisticalAggregations.handle(
+            op, actual_value, expected_value,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+        end
+
+        def self.try_datetime_operators(op, actual_value, expected_value, context_hash, param_cache:, param_cache_mutex:)
+          result = Operators::DateTimeOperators.handle(op, actual_value, expected_value)
+          return result unless result.nil?
+
+          result = Operators::DurationOperators.handle(
+            op, actual_value, expected_value, context_hash,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          result = Operators::DateArithmeticOperators.handle(
+            op, actual_value, expected_value, context_hash,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          Operators::TimeComponentOperators.handle(op, actual_value, expected_value)
+        end
+
+        def self.try_advanced_operators(op, actual_value, expected_value, param_cache:, param_cache_mutex:)
+          result = Operators::RateOperators.handle(op, actual_value, expected_value)
+          return result unless result.nil?
+
+          result = Operators::MovingWindowOperators.handle(
+            op, actual_value, expected_value,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          Operators::FinancialOperators.handle(
+            op, actual_value, expected_value,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+        end
+
+        def self.try_collection_and_aggregation_operators(op, actual_value, expected_value, param_cache:, param_cache_mutex:)
+          result = Operators::StringAggregations.handle(
+            op, actual_value, expected_value,
+            param_cache: param_cache,
+            param_cache_mutex: param_cache_mutex
+          )
+          return result unless result.nil?
+
+          Operators::CollectionOperators.handle(op, actual_value, expected_value)
+        end
+
+        def self.try_special_operators(op, actual_value, expected_value, _context_hash, geospatial_cache:, geospatial_cache_mutex:)
+          Operators::GeospatialOperators.handle(
+            op, actual_value, expected_value,
+            geospatial_cache: geospatial_cache,
+            geospatial_cache_mutex: geospatial_cache_mutex
+          )
+        end
+      end
+    end
+  end
+end