decision_agent 0.1.3 → 0.1.6

data/lib/decision_agent/dsl/condition_evaluator.rb

@@ -7,6 +7,18 @@ module DecisionAgent
     # - Nested field access via dot notation (e.g., "user.profile.role")
     # - Logical operators (all/any)
     class ConditionEvaluator
+      # Thread-safe caches for performance optimization
+      @regex_cache = {}
+      @regex_cache_mutex = Mutex.new
+      @path_cache = {}
+      @path_cache_mutex = Mutex.new
+      @date_cache = {}
+      @date_cache_mutex = Mutex.new
+
+      class << self
+        attr_reader :regex_cache, :path_cache, :date_cache
+      end
+
       def self.evaluate(condition, context)
         return false unless condition.is_a?(Hash)
 
@@ -38,6 +50,7 @@ module DecisionAgent
         conditions.any? { |cond| evaluate(cond, context) }
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       def self.evaluate_field_condition(condition, context)
         field = condition["field"]
         op = condition["op"]
@@ -98,12 +111,158 @@ module DecisionAgent
           # - Non-empty values: false
           actual_value.nil? || (actual_value.respond_to?(:empty?) ? actual_value.empty? : false)
 
+        # STRING OPERATORS
+        when "contains"
+          # Checks if string contains substring (case-sensitive)
+          string_operator?(actual_value, expected_value) &&
+            actual_value.include?(expected_value)
+
+        when "starts_with"
+          # Checks if string starts with prefix (case-sensitive)
+          string_operator?(actual_value, expected_value) &&
+            actual_value.start_with?(expected_value)
+
+        when "ends_with"
+          # Checks if string ends with suffix (case-sensitive)
+          string_operator?(actual_value, expected_value) &&
+            actual_value.end_with?(expected_value)
+
+        when "matches"
+          # Matches string against regular expression
+          # expected_value can be a string (converted to regex) or Regexp object
+          return false unless actual_value.is_a?(String)
+          return false if expected_value.nil?
+
+          begin
+            regex = get_cached_regex(expected_value)
+            !regex.match(actual_value).nil?
+          rescue RegexpError
+            false
+          end
+
+        # NUMERIC OPERATORS
+        when "between"
+          # Checks if numeric value is between min and max (inclusive)
+          # expected_value should be [min, max] or {min: x, max: y}
+          return false unless actual_value.is_a?(Numeric)
+
+          range = parse_range(expected_value)
+          return false unless range
+
+          actual_value.between?(range[:min], range[:max])
+
+        when "modulo"
+          # Checks if value modulo divisor equals remainder
+          # expected_value should be [divisor, remainder] or {divisor: x, remainder: y}
+          return false unless actual_value.is_a?(Numeric)
+
+          params = parse_modulo_params(expected_value)
+          return false unless params
+
+          (actual_value % params[:divisor]) == params[:remainder]
+
+        # DATE/TIME OPERATORS
+        when "before_date"
+          # Checks if date is before specified date
+          compare_dates(actual_value, expected_value, :<)
+
+        when "after_date"
+          # Checks if date is after specified date
+          compare_dates(actual_value, expected_value, :>)
+
+        when "within_days"
+          # Checks if date is within N days from now (past or future)
+          # expected_value is number of days
+          return false unless actual_value
+          return false unless expected_value.is_a?(Numeric)
+
+          date = 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
+          # expected_value can be: "monday", "tuesday", etc. or 0-6 (Sunday=0)
+          return false unless actual_value
+
+          date = parse_date(actual_value)
+          return false unless date
+
+          expected_day = normalize_day_of_week(expected_value)
+          return false unless expected_day
+
+          date.wday == expected_day
+
+        # COLLECTION OPERATORS
+        when "contains_all"
+          # Checks if array contains all specified elements
+          # expected_value should be an array
+          return false unless actual_value.is_a?(Array)
+          return false unless expected_value.is_a?(Array)
+
+          expected_value.all? { |item| actual_value.include?(item) }
+
+        when "contains_any"
+          # Checks if array contains any of the specified elements
+          # expected_value should be an array
+          return false unless actual_value.is_a?(Array)
+          return false unless expected_value.is_a?(Array)
+
+          expected_value.any? { |item| actual_value.include?(item) }
+
+        when "intersects"
+          # Checks if two arrays have any common elements
+          # expected_value should be an array
+          return false unless actual_value.is_a?(Array)
+          return false unless expected_value.is_a?(Array)
+
+          !(actual_value & expected_value).empty?
+
+        when "subset_of"
+          # Checks if array is a subset of another array
+          # All elements in actual_value must be in expected_value
+          return false unless actual_value.is_a?(Array)
+          return false unless expected_value.is_a?(Array)
+
+          actual_value.all? { |item| expected_value.include?(item) }
+
+        # GEOSPATIAL OPERATORS
+        when "within_radius"
+          # Checks if point is within radius of center point
+          # actual_value: {lat: y, lon: x} or [lat, lon]
+          # expected_value: {center: {lat: y, lon: x}, radius: distance_in_km}
+          point = parse_coordinates(actual_value)
+          return false unless point
+
+          params = parse_radius_params(expected_value)
+          return false unless params
+
+          distance = haversine_distance(point, params[:center])
+          distance <= params[:radius]
+
+        when "in_polygon"
+          # Checks if point is inside a polygon using ray casting algorithm
+          # actual_value: {lat: y, lon: x} or [lat, lon]
+          # expected_value: array of vertices [{lat: y, lon: x}, ...] or [[lat, lon], ...]
+          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)
+
         else
           # Unknown operator - returns false (fail-safe)
           # Note: Validation should catch this earlier
           false
         end
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
       # Retrieves nested values from a hash using dot notation
       #
@@ -114,7 +273,7 @@ module DecisionAgent
       #
       # Supports both string and symbol keys in the hash
       def self.get_nested_value(hash, key_path)
-        keys = key_path.to_s.split(".")
+        keys = get_cached_path(key_path)
         keys.reduce(hash) do |memo, key|
           return nil unless memo.is_a?(Hash)
 
@@ -129,6 +288,224 @@ module DecisionAgent
           (val2.is_a?(Numeric) || val2.is_a?(String)) &&
           val1.instance_of?(val2.class)
       end
+
+      # Helper methods for new operators
+
+      # String operator validation
+      def self.string_operator?(actual_value, expected_value)
+        actual_value.is_a?(String) && expected_value.is_a?(String)
+      end
+
+      # Parse range for 'between' operator
+      # Accepts [min, max] or {min: x, max: y}
+      def self.parse_range(value)
+        if value.is_a?(Array) && value.size == 2
+          { min: value[0], max: value[1] }
+        elsif value.is_a?(Hash)
+          min = value["min"] || value[:min]
+          max = value["max"] || value[:max]
+          return nil unless min && max
+
+          { min: min, max: max }
+        end
+      end
+
+      # Parse modulo parameters
+      # Accepts [divisor, remainder] or {divisor: x, remainder: y}
+      def self.parse_modulo_params(value)
+        if value.is_a?(Array) && value.size == 2
+          { divisor: value[0], remainder: value[1] }
+        elsif 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
+      end
+
+      # Parse date from string, Time, Date, or DateTime (with caching)
+      def self.parse_date(value)
+        case value
+        when Time, Date, DateTime
+          value
+        when String
+          get_cached_date(value)
+        end
+      rescue ArgumentError
+        nil
+      end
+
+      # Compare two dates with given operator
+      def self.compare_dates(actual_value, expected_value, operator)
+        return false unless actual_value && expected_value
+
+        actual_date = parse_date(actual_value)
+        expected_date = parse_date(expected_value)
+
+        return false unless actual_date && expected_date
+
+        actual_date.send(operator, expected_date)
+      end
+
+      # Normalize day of week to 0-6 (Sunday=0)
+      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
+
+      # Parse coordinates from hash or array
+      # Accepts {lat: y, lon: x}, {latitude: y, longitude: x}, or [lat, lon]
+      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
+
+      # Parse radius parameters
+      # expected_value: {center: {lat: y, lon: x}, radius: distance_in_km}
+      def self.parse_radius_params(value)
+        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(center_data)
+        return nil unless center
+
+        { center: center, radius: radius.to_f }
+      end
+
+      # Parse polygon vertices
+      # Accepts array of coordinate hashes or arrays
+      def self.parse_polygon(value)
+        return nil unless value.is_a?(Array)
+
+        value.map { |vertex| parse_coordinates(vertex) }.compact
+      end
+
+      # Calculate distance between two points using Haversine formula
+      # Returns distance in kilometers
+      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
+
+        a = (Math.sin(delta_lat / 2)**2) +
+            (Math.cos(lat1_rad) * Math.cos(lat2_rad) *
+            (Math.sin(delta_lon / 2)**2))
+
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+
+        earth_radius_km * c
+      end
+
+      # Check if point is inside polygon using ray casting algorithm
+      def self.point_in_polygon?(point, polygon)
+        x = point[:lon]
+        y = point[:lat]
+        inside = false
+
+        j = polygon.size - 1
+        polygon.size.times do |i|
+          xi = polygon[i][:lon]
+          yi = polygon[i][:lat]
+          xj = polygon[j][:lon]
+          yj = polygon[j][:lat]
+
+          intersect = ((yi > y) != (yj > y)) &&
+                      (x < ((((xj - xi) * (y - yi)) / (yj - yi)) + xi))
+          inside = !inside if intersect
+
+          j = i
+        end
+
+        inside
+      end
+
+      # Cache management methods
+
+      # Get or compile regex with caching
+      def self.get_cached_regex(pattern)
+        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
+
+      # Get cached split path
+      def self.get_cached_path(key_path)
+        # 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
+
+      # Get cached parsed date
+      def self.get_cached_date(date_string)
+        # 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] ||= Time.parse(date_string)
+        end
+      end
+
+      # Clear all caches (useful for testing or memory management)
+      def self.clear_caches!
+        @regex_cache_mutex.synchronize { @regex_cache.clear }
+        @path_cache_mutex.synchronize { @path_cache.clear }
+        @date_cache_mutex.synchronize { @date_cache.clear }
+      end
+
+      # Get cache statistics
+      def self.cache_stats
+        {
+          regex_cache_size: @regex_cache.size,
+          path_cache_size: @path_cache.size,
+          date_cache_size: @date_cache.size
+        }
+      end
     end
   end
 end

data/lib/decision_agent/dsl/schema_validator.rb

@@ -3,7 +3,14 @@ module DecisionAgent
     # JSON Schema validator for Decision Agent rule DSL
     # Provides comprehensive validation with detailed error messages
     class SchemaValidator
-      SUPPORTED_OPERATORS = %w[eq neq gt gte lt lte in present blank].freeze
+      SUPPORTED_OPERATORS = %w[
+        eq neq gt gte lt lte in present blank
+        contains starts_with ends_with matches
+        between modulo
+        before_date after_date within_days day_of_week
+        contains_all contains_any intersects subset_of
+        within_radius in_polygon
+      ].freeze
 
       CONDITION_TYPES = %w[all any field].freeze
 

data/lib/decision_agent/errors.rb

@@ -74,4 +74,42 @@ module DecisionAgent
 
   # Alias for backward compatibility and clearer naming
   ConfigurationError = InvalidConfigurationError
+
+  # Testing-specific errors
+  class ImportError < Error
+    def initialize(message = "Failed to import test scenarios")
+      super
+    end
+  end
+
+  class InvalidTestDataError < Error
+    attr_reader :row_number, :errors
+
+    def initialize(message = "Invalid test data", row_number: nil, errors: [])
+      @row_number = row_number
+      @errors = errors
+      full_message = message.dup
+      full_message += " (row #{row_number})" if row_number
+      full_message += ": #{errors.join(', ')}" if errors.any?
+      super(full_message)
+    end
+  end
+
+  class BatchTestError < Error
+    def initialize(message = "Batch test execution failed")
+      super
+    end
+  end
+
+  class AuthenticationError < Error
+    def initialize(message = "Authentication failed")
+      super
+    end
+  end
+
+  class PermissionDeniedError < Error
+    def initialize(message = "Permission denied")
+      super
+    end
+  end
 end

data/lib/decision_agent/evaluation.rb

@@ -41,14 +41,21 @@ module DecisionAgent
     end
 
     def deep_freeze(obj)
+      return obj if obj.frozen?
+
       case obj
       when Hash
-        obj.transform_values { |v| deep_freeze(v) }.freeze
+        obj.each_value { |v| deep_freeze(v) }
+        obj.freeze
       when Array
-        obj.map { |v| deep_freeze(v) }.freeze
-      else
+        obj.each { |v| deep_freeze(v) }
         obj.freeze
+      when String, Symbol, Numeric, TrueClass, FalseClass, NilClass
+        obj.freeze
+      else
+        obj.freeze if obj.respond_to?(:freeze)
       end
+      obj
     end
   end
 end

data/lib/decision_agent/evaluation_validator.rb

@@ -40,7 +40,8 @@ module DecisionAgent
     private_class_method def self.validate_decision!(decision)
       raise ValidationError, "Decision cannot be nil" if decision.nil?
       raise ValidationError, "Decision must be a String" unless decision.is_a?(String)
-      raise ValidationError, "Decision cannot be empty" if decision.strip.empty?
+      # Fast path: skip strip if string is clearly not empty (length > 0)
+      raise ValidationError, "Decision cannot be empty" if decision.empty? || decision.strip.empty?
     end
 
     private_class_method def self.validate_weight!(weight)
@@ -52,7 +53,8 @@ module DecisionAgent
     private_class_method def self.validate_reason!(reason)
       raise ValidationError, "Reason cannot be nil" if reason.nil?
       raise ValidationError, "Reason must be a String" unless reason.is_a?(String)
-      raise ValidationError, "Reason cannot be empty" if reason.strip.empty?
+      # Fast path: skip strip if string is clearly not empty (length > 0)
+      raise ValidationError, "Reason cannot be empty" if reason.empty? || reason.strip.empty?
     end
 
     private_class_method def self.validate_evaluator_name!(name)
@@ -61,18 +63,11 @@ module DecisionAgent
     end
 
     private_class_method def self.validate_frozen!(evaluation)
-      raise ValidationError, "Evaluation must be frozen for thread-safety (call .freeze)" unless evaluation.frozen?
+      # Fast path: if evaluation is frozen, assume nested structures are also frozen
+      # (they are frozen in Evaluation#initialize)
+      return true if evaluation.frozen?
 
-      # Verify nested structures are also frozen
-      raise ValidationError, "Evaluation decision must be frozen" unless evaluation.decision.frozen?
-
-      raise ValidationError, "Evaluation reason must be frozen" unless evaluation.reason.frozen?
-
-      raise ValidationError, "Evaluation evaluator_name must be frozen" unless evaluation.evaluator_name.frozen?
-
-      return unless evaluation.metadata && !evaluation.metadata.frozen?
-
-      raise ValidationError, "Evaluation metadata must be frozen"
+      raise ValidationError, "Evaluation must be frozen for thread-safety (call .freeze)"
     end
   end
 end

data/lib/decision_agent/monitoring/dashboard_server.rb

@@ -69,6 +69,7 @@ module DecisionAgent
 
         def broadcast_to_clients(message)
           return unless WEBSOCKET_AVAILABLE
+          return if @websocket_clients.empty? # Skip if no clients connected
 
           json_message = message.to_json
           @websocket_clients.each do |client|