decision_agent 0.3.0 → 1.1.0

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Operators
+      # Handles geospatial operators: within_radius, in_polygon
+      module GeospatialOperators
+        def self.handle(op, actual_value, expected_value, geospatial_cache: nil, geospatial_cache_mutex: nil)
+          case op
+          when "within_radius"
+            # Checks if point is within radius of center point
+            point = parse_coordinates(actual_value)
+            return false unless point
+
+            params = parse_radius_params(expected_value)
+            return false unless params
+
+            # Cache geospatial distance calculations
+            distance = get_cached_distance(point, params[:center], geospatial_cache: geospatial_cache,
+                                                                   geospatial_cache_mutex: geospatial_cache_mutex)
+            distance <= params[:radius]
+
+          when "in_polygon"
+            # Checks if point is inside a polygon using ray casting algorithm
+            point = parse_coordinates(actual_value)
+            return false unless point
+
+            polygon = parse_polygon(expected_value)
+            return false unless polygon
+            return false if polygon.size < 3 # Need at least 3 vertices
+
+            point_in_polygon?(point, polygon)
+          end
+          # Returns nil if not handled by this module
+        end
+
+        # Parse coordinates from various formats
+        def self.parse_coordinates(value)
+          case value
+          when Hash
+            lat = value[:lat] || value["lat"]
+            lon = value[:lon] || value["lon"]
+            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
+
+        # Parse radius parameters
+        def self.parse_radius_params(value)
+          return nil unless value.is_a?(Hash)
+
+          center = value[:center] || value["center"]
+          radius = value[:radius] || value["radius"]
+          return nil unless center && radius
+
+          center_coords = parse_coordinates(center)
+          return nil unless center_coords
+
+          { center: center_coords, radius: radius.to_f }
+        end
+
+        # Parse polygon from various formats
+        def self.parse_polygon(value)
+          return nil unless value.is_a?(Array)
+          return nil if value.empty?
+
+          value.map { |v| parse_coordinates(v) }.compact
+        end
+
+        # Get cached distance between two points
+        def self.get_cached_distance(point1, point2, geospatial_cache: nil, geospatial_cache_mutex: nil)
+          cache = geospatial_cache
+          mutex = geospatial_cache_mutex
+          if cache.nil? || mutex.nil?
+            cache = ConditionEvaluator.instance_variable_get(:@geospatial_cache)
+            mutex = ConditionEvaluator.instance_variable_get(:@geospatial_cache_mutex)
+          end
+
+          # Create cache key from sorted coordinates
+          key = [[point1[:lat], point1[:lon]], [point2[:lat], point2[:lon]]].sort.hash
+          cached = cache[key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[key] ||= calculate_distance(point1, point2)
+          end
+        end
+
+        # Calculate distance between two points using Haversine formula
+        def self.calculate_distance(point1, point2)
+          Helpers::GeospatialHelpers.haversine_distance(point1, point2)
+        end
+
+        # Check if point is inside polygon using ray casting algorithm
+        def self.point_in_polygon?(point, polygon)
+          Helpers::GeospatialHelpers.point_in_polygon?(point, polygon)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Operators
+      # Handles mathematical operators: trigonometric, exponential, logarithmic, rounding, etc.
+      module MathematicalOperators
+        def self.handle(op, actual_value, expected_value, param_cache: nil, param_cache_mutex: nil)
+          case op
+          # Trigonometric functions
+          when "sin"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            Base.epsilon_equal?(Math.sin(actual_value), expected_value)
+          when "cos"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            Base.epsilon_equal?(Math.cos(actual_value), expected_value)
+          when "tan"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            Base.epsilon_equal?(Math.tan(actual_value), expected_value)
+          when "asin"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+            return false if actual_value < -1 || actual_value > 1
+
+            Base.epsilon_equal?(Math.asin(actual_value), expected_value)
+          when "acos"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+            return false if actual_value < -1 || actual_value > 1
+
+            Base.epsilon_equal?(Math.acos(actual_value), expected_value)
+          when "atan"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            Base.epsilon_equal?(Math.atan(actual_value), expected_value)
+          when "atan2"
+            return false unless actual_value.is_a?(Numeric)
+
+            params = parse_atan2_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            Base.epsilon_equal?(Math.atan2(actual_value, params[:y]), params[:result])
+          when "sinh"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            Base.epsilon_equal?(Math.sinh(actual_value), expected_value)
+          when "cosh"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            Base.epsilon_equal?(Math.cosh(actual_value), expected_value)
+          when "tanh"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            Base.epsilon_equal?(Math.tanh(actual_value), expected_value)
+
+          # Exponential and logarithmic functions
+          when "sqrt"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+            return false if actual_value.negative?
+
+            Base.epsilon_equal?(Math.sqrt(actual_value), expected_value)
+          when "cbrt"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            result = if actual_value.negative?
+                       -((-actual_value)**(1.0 / 3))
+                     else
+                       actual_value**(1.0 / 3)
+                     end
+            Base.epsilon_equal?(result, expected_value)
+          when "power"
+            return false unless actual_value.is_a?(Numeric)
+
+            params = parse_power_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            Base.epsilon_equal?(actual_value**params[:exponent], params[:result])
+          when "exp"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            Base.epsilon_equal?(Math.exp(actual_value), expected_value)
+          when "log"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+            return false if actual_value <= 0
+
+            Base.epsilon_equal?(Math.log(actual_value), expected_value)
+          when "log10"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+            return false if actual_value <= 0
+
+            Base.epsilon_equal?(Math.log10(actual_value), expected_value)
+          when "log2"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+            return false if actual_value <= 0
+
+            Base.epsilon_equal?(Math.log(actual_value) / Math.log(2), expected_value)
+
+          # Rounding and absolute value functions
+          when "round"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            actual_value.round == expected_value
+          when "floor"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            actual_value.floor == expected_value
+          when "ceil"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            actual_value.ceil == expected_value
+          when "abs"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            actual_value.abs == expected_value
+          when "truncate"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+
+            actual_value.truncate == expected_value
+
+          # Advanced mathematical functions
+          when "factorial"
+            return false unless actual_value.is_a?(Numeric) && expected_value.is_a?(Numeric)
+            return false if actual_value.negative? || !actual_value.integer?
+
+            (1..actual_value.to_i).reduce(1, :*) == expected_value
+          when "gcd"
+            return false unless actual_value.is_a?(Numeric) && actual_value.integer?
+
+            params = parse_gcd_lcm_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params && params[:other].integer?
+
+            actual_value.to_i.gcd(params[:other].to_i) == params[:result]
+          when "lcm"
+            return false unless actual_value.is_a?(Numeric) && actual_value.integer?
+
+            params = parse_gcd_lcm_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params && params[:other].integer?
+
+            actual_value.to_i.lcm(params[:other].to_i) == params[:result]
+          end
+          # Returns nil if not handled by this module
+        end
+
+        # Parse atan2 parameters
+        def self.parse_atan2_params(value, param_cache: nil, param_cache_mutex: nil)
+          normalized = Base.normalize_params_to_hash(value, %i[y result])
+          return nil unless normalized.is_a?(Hash)
+
+          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, "atan2")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_atan2_params_impl(normalized)
+          end
+        end
+
+        def self.parse_atan2_params_impl(value)
+          y = value[:y] || value["y"]
+          result = value[:result] || value["result"]
+          return nil unless y && !result.nil?
+
+          { y: y, result: result }
+        end
+
+        # Parse power parameters
+        def self.parse_power_params(value, param_cache: nil, param_cache_mutex: nil)
+          normalized = Base.normalize_params_to_hash(value, %i[exponent result])
+          return nil unless normalized.is_a?(Hash)
+
+          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, "power")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_power_params_impl(normalized)
+          end
+        end
+
+        def self.parse_power_params_impl(value)
+          exponent = value[:exponent] || value["exponent"]
+          result = value[:result] || value["result"]
+          return nil unless exponent && !result.nil?
+
+          { exponent: exponent, result: result }
+        end
+
+        # Parse gcd/lcm parameters
+        def self.parse_gcd_lcm_params(value, param_cache: nil, param_cache_mutex: nil)
+          normalized = Base.normalize_params_to_hash(value, %i[other result])
+          return nil unless normalized.is_a?(Hash)
+
+          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, "gcd_lcm")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_gcd_lcm_params_impl(normalized)
+          end
+        end
+
+        def self.parse_gcd_lcm_params_impl(value)
+          other = value[:other] || value["other"]
+          result = value[:result] || value["result"]
+          return nil unless other && !result.nil?
+
+          { other: other, result: result }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Operators
+      # Handles moving window calculation operators: moving_average, moving_sum, moving_max, moving_min
+      module MovingWindowOperators
+        def self.handle(op, actual_value, expected_value, param_cache: nil, param_cache_mutex: nil)
+          case op
+          when "moving_average"
+            # Calculates moving average over window
+            return false unless actual_value.is_a?(Array)
+            return false if actual_value.empty?
+
+            numeric_array = actual_value.select { |v| v.is_a?(Numeric) }
+            return false if numeric_array.empty?
+
+            params = parse_moving_window_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            window = [params[:window], numeric_array.size].min
+            return false if window < 1
+
+            window_array = numeric_array.slice(-window, window)
+            moving_avg = window_array.sum.to_f / window
+            compare_moving_window_result(moving_avg, params)
+
+          when "moving_sum"
+            # Calculates moving sum over window
+            return false unless actual_value.is_a?(Array)
+            return false if actual_value.empty?
+
+            numeric_array = actual_value.select { |v| v.is_a?(Numeric) }
+            return false if numeric_array.empty?
+
+            params = parse_moving_window_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            window = [params[:window], numeric_array.size].min
+            return false if window < 1
+
+            window_array = numeric_array.slice(-window, window)
+            moving_sum = window_array.sum
+            compare_moving_window_result(moving_sum, params)
+
+          when "moving_max"
+            # Calculates moving max over window
+            return false unless actual_value.is_a?(Array)
+            return false if actual_value.empty?
+
+            numeric_array = actual_value.select { |v| v.is_a?(Numeric) }
+            return false if numeric_array.empty?
+
+            params = parse_moving_window_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            window = [params[:window], numeric_array.size].min
+            return false if window < 1
+
+            window_array = numeric_array.slice(-window, window)
+            moving_max = window_array.max
+            compare_moving_window_result(moving_max, params)
+
+          when "moving_min"
+            # Calculates moving min over window
+            return false unless actual_value.is_a?(Array)
+            return false if actual_value.empty?
+
+            numeric_array = actual_value.select { |v| v.is_a?(Numeric) }
+            return false if numeric_array.empty?
+
+            params = parse_moving_window_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+            return false unless params
+
+            window = [params[:window], numeric_array.size].min
+            return false if window < 1
+
+            window_array = numeric_array.slice(-window, window)
+            moving_min = window_array.min
+            compare_moving_window_result(moving_min, params)
+          end
+          # Returns nil if not handled by this module
+        end
+
+        # Parse moving window parameters
+        def self.parse_moving_window_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, "moving_window")
+          cached = cache[cache_key]
+          return cached if cached
+
+          mutex.synchronize do
+            cache[cache_key] ||= parse_moving_window_params_impl(normalized)
+          end
+        end
+
+        def self.parse_moving_window_params_impl(value)
+          window = value[:window] || value["window"]
+          return nil unless window.is_a?(Numeric) && window.positive?
+
+          {
+            window: window.to_i,
+            threshold: value[:threshold] || value["threshold"],
+            gt: value[:gt] || value["gt"],
+            lt: value[:lt] || value["lt"],
+            gte: value[:gte] || value["gte"],
+            lte: value[:lte] || value["lte"]
+          }
+        end
+
+        # Compare moving window result
+        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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Operators
+      # Handles numeric operators: between, modulo
+      module NumericOperators
+        def self.handle(op, actual_value, expected_value, param_cache: nil, param_cache_mutex: nil)
+          case op
+          when "between"
+            # Checks if numeric value is between min and max (inclusive)
+            # expected_value should be [min, max] or {min: x, max: y}
+            if actual_value.is_a?(Numeric)
+              range = parse_range(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+              range ? actual_value.between?(range[:min], range[:max]) : false
+            else
+              false
+            end
+
+          when "modulo"
+            # Checks if value modulo divisor equals remainder
+            # expected_value should be [divisor, remainder] or {divisor: x, remainder: y}
+            if actual_value.is_a?(Numeric)
+              params = parse_modulo_params(expected_value, param_cache: param_cache, param_cache_mutex: param_cache_mutex)
+              params ? (actual_value % params[:divisor]) == params[:remainder] : false
+            else
+              false
+            end
+          end
+          # Returns nil if not handled by this module
+        end
+
+        # Parse range for 'between' operator
+        # Accepts [min, max] or {min: x, max: y}
+        # Converts arrays to hash for consistency and better performance
+        def self.parse_range(value, param_cache: nil, param_cache_mutex: nil)
+          # Normalize to hash if array (for large params, hash is more efficient)
+          normalized_value = normalize_params_to_hash(value, %i[min max])
+
+          # Use provided caches or access ConditionEvaluator class variables
+          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 = normalize_param_cache_key(normalized_value, "range")
+
+          # Fast path: check cache without lock
+          cached = cache[cache_key]
+          return cached if cached
+
+          # Slow path: parse and cache
+          mutex.synchronize do
+            cache[cache_key] ||= parse_range_impl(normalized_value)
+          end
+        end
+
+        def self.parse_range_impl(value)
+          return nil unless value.is_a?(Hash)
+
+          min = value[:min] || value["min"]
+          max = value[:max] || value["max"]
+          return nil unless min && max
+
+          { min: min, max: max }
+        end
+
+        # Parse modulo parameters
+        # Accepts [divisor, remainder] or {divisor: x, remainder: y}
+        # Converts arrays to hash for consistency and better performance
+        def self.parse_modulo_params(value, param_cache: nil, param_cache_mutex: nil)
+          # Normalize to hash if array (for large params, hash is more efficient)
+          normalized_value = normalize_params_to_hash(value, %i[divisor remainder])
+
+          # Use provided caches or access ConditionEvaluator class variables
+          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 = normalize_param_cache_key(normalized_value, "modulo")
+
+          # Fast path: check cache without lock
+          cached = cache[cache_key]
+          return cached if cached
+
+          # Slow path: parse and cache
+          mutex.synchronize do
+            cache[cache_key] ||= parse_modulo_params_impl(normalized_value)
+          end
+        end
+
+        def self.parse_modulo_params_impl(value)
+          return nil unless value.is_a?(Hash)
+
+          divisor = value[:divisor] || value["divisor"]
+          remainder = value[:remainder] || value["remainder"]
+          return nil unless divisor && !remainder.nil?
+
+          { divisor: divisor, remainder: remainder }
+        end
+
+        # Use Base utilities
+        def self.normalize_params_to_hash(value, keys)
+          Base.normalize_params_to_hash(value, keys)
+        end
+
+        def self.normalize_param_cache_key(value, prefix)
+          Base.normalize_param_cache_key(value, prefix)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module DecisionAgent
+  module Dsl
+    module Operators
+      # Handles rate calculation operators: rate_per_second, rate_per_minute, rate_per_hour
+      module RateOperators
+        def self.handle(op, actual_value, expected_value)
+          case op
+          when "rate_per_second"
+            # Calculates rate per second from array of timestamps
+            return false unless actual_value.is_a?(Array)
+            return false if actual_value.empty?
+
+            timestamps = actual_value.map { |ts| ConditionEvaluator.parse_date(ts) }.compact
+            return false if timestamps.size < 2
+
+            sorted_timestamps = timestamps.sort
+            time_span = sorted_timestamps.last - sorted_timestamps.first
+            return false if time_span <= 0
+
+            rate = timestamps.size.to_f / time_span
+            compare_rate_result(rate, expected_value)
+
+          when "rate_per_minute"
+            # Calculates rate per minute from array of timestamps
+            return false unless actual_value.is_a?(Array)
+            return false if actual_value.empty?
+
+            timestamps = actual_value.map { |ts| ConditionEvaluator.parse_date(ts) }.compact
+            return false if timestamps.size < 2
+
+            sorted_timestamps = timestamps.sort
+            time_span = sorted_timestamps.last - sorted_timestamps.first
+            return false if time_span <= 0
+
+            rate = (timestamps.size.to_f / time_span) * 60.0
+            compare_rate_result(rate, expected_value)
+
+          when "rate_per_hour"
+            # Calculates rate per hour from array of timestamps
+            return false unless actual_value.is_a?(Array)
+            return false if actual_value.empty?
+
+            timestamps = actual_value.map { |ts| ConditionEvaluator.parse_date(ts) }.compact
+            return false if timestamps.size < 2
+
+            sorted_timestamps = timestamps.sort
+            time_span = sorted_timestamps.last - sorted_timestamps.first
+            return false if time_span <= 0
+
+            rate = (timestamps.size.to_f / time_span) * 3600.0
+            compare_rate_result(rate, expected_value)
+          end
+          # Returns nil if not handled by this module
+        end
+
+        # Compare rate result
+        def self.compare_rate_result(actual, expected)
+          ConditionEvaluator.compare_rate_result(actual, expected)
+        end
+      end
+    end
+  end
+end