Implement UFC configuration parsing with comprehensive Ruby data structures

Create complete Ruby data structures for Universal Flag Configuration (UFC) parsing, enabling InternalEvaluator to process the same JSON format used by Rust evaluation libraries. Includes comprehensive test coverage using UFC test data.

Features:
- Complete Ruby classes for Flag, Allocation, Split, Rule, Condition structures
- Support for all variation types: STRING, INTEGER, NUMERIC, BOOLEAN, JSON
- Full condition operators: MATCHES, GTE, ONE_OF, IS_NULL, etc.
- Timestamp parsing for both Unix timestamps and ISO8601 strings
- Graceful error handling with sensible defaults
- Support for both 'flags' and 'flagsV1' JSON structure variants

Test Coverage:
- Copy all UFC test data from Rust implementation (flags-v1.json + 19 test cases)
- Comprehensive RSpec tests validating parsing scenarios
- Verified compatibility with 17 real flags including complex allocations
- Tests edge cases, error conditions, and all variation types

Author: sameerank

lib/datadog/open_feature/binding.rb

@@ -10,3 +10,4 @@ module Binding
 
 require_relative 'binding/evaluator'
 require_relative 'binding/internal_evaluator'
+require_relative 'binding/configuration'

lib/datadog/open_feature/binding/configuration.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenFeature
+    module Binding
+      # Variation types supported by UFC
+      module VariationType
+        STRING = 'STRING'
+        INTEGER = 'INTEGER'
+        NUMERIC = 'NUMERIC'
+        BOOLEAN = 'BOOLEAN'
+        JSON = 'JSON'
+      end
+
+      # Condition operators for rule evaluation
+      module ConditionOperator
+        MATCHES = 'MATCHES'
+        NOT_MATCHES = 'NOT_MATCHES'
+        GTE = 'GTE'
+        GT = 'GT'
+        LTE = 'LTE'
+        LT = 'LT'
+        ONE_OF = 'ONE_OF'
+        NOT_ONE_OF = 'NOT_ONE_OF'
+        IS_NULL = 'IS_NULL'
+      end
+
+      # Assignment reasons returned in ResolutionDetails
+      module AssignmentReason
+        TARGETING_MATCH = 'TARGETING_MATCH'
+        SPLIT = 'SPLIT'
+        STATIC = 'STATIC'
+      end
+
+      # Represents a feature flag configuration
+      class Flag
+        attr_reader :key, :enabled, :variation_type, :variations, :allocations
+
+        def initialize(key:, enabled:, variation_type:, variations:, allocations:)
+          @key = key
+          @enabled = enabled
+          @variation_type = variation_type
+          @variations = variations || {}
+          @allocations = allocations || []
+        end
+
+        def self.from_json(key, flag_data)
+          new(
+            key: key,
+            enabled: flag_data['enabled'] || false,
+            variation_type: flag_data['variationType'],
+            variations: parse_variations(flag_data['variations'] || {}),
+            allocations: parse_allocations(flag_data['allocations'] || [])
+          )
+        end
+
+        private
+
+        def self.parse_variations(variations_data)
+          variations_data.transform_values do |variation_data|
+            Variation.from_json(variation_data)
+          end
+        end
+
+        def self.parse_allocations(allocations_data)
+          allocations_data.map { |allocation_data| Allocation.from_json(allocation_data) }
+        end
+      end
+
+      # Represents a variation value for a flag
+      class Variation
+        attr_reader :key, :value
+
+        def initialize(key:, value:)
+          @key = key
+          @value = value
+        end
+
+        def self.from_json(variation_data)
+          new(
+            key: variation_data['key'],
+            value: variation_data['value']
+          )
+        end
+      end
+
+      # Represents an allocation rule with traffic splits
+      class Allocation
+        attr_reader :key, :rules, :start_at, :end_at, :splits, :do_log
+
+        def initialize(key:, rules: nil, start_at: nil, end_at: nil, splits:, do_log: true)
+          @key = key
+          @rules = rules
+          @start_at = start_at
+          @end_at = end_at
+          @splits = splits || []
+          @do_log = do_log
+        end
+
+        def self.from_json(allocation_data)
+          new(
+            key: allocation_data['key'],
+            rules: parse_rules(allocation_data['rules']),
+            start_at: parse_timestamp(allocation_data['startAt']),
+            end_at: parse_timestamp(allocation_data['endAt']),
+            splits: parse_splits(allocation_data['splits'] || []),
+            do_log: allocation_data.fetch('doLog', true)
+          )
+        end
+
+        private
+
+        def self.parse_rules(rules_data)
+          return nil if rules_data.nil? || rules_data.empty?
+
+          rules_data.map { |rule_data| Rule.from_json(rule_data) }
+        end
+
+        def self.parse_splits(splits_data)
+          splits_data.map { |split_data| Split.from_json(split_data) }
+        end
+
+        def self.parse_timestamp(timestamp_data)
+          return nil if timestamp_data.nil?
+
+          # Handle both Unix timestamps and ISO8601 strings
+          case timestamp_data
+          when Numeric
+            Time.at(timestamp_data)
+          when String
+            Time.parse(timestamp_data)
+          else
+            nil
+          end
+        rescue StandardError
+          nil
+        end
+      end
+
+      # Represents a traffic split within an allocation
+      class Split
+        attr_reader :shards, :variation_key, :extra_logging
+
+        def initialize(shards:, variation_key:, extra_logging: nil)
+          @shards = shards || []
+          @variation_key = variation_key
+          @extra_logging = extra_logging || {}
+        end
+
+        def self.from_json(split_data)
+          new(
+            shards: parse_shards(split_data['shards'] || []),
+            variation_key: split_data['variationKey'],
+            extra_logging: split_data['extraLogging'] || {}
+          )
+        end
+
+        private
+
+        def self.parse_shards(shards_data)
+          shards_data.map { |shard_data| Shard.from_json(shard_data) }
+        end
+      end
+
+      # Represents a shard configuration for traffic splitting
+      class Shard
+        attr_reader :salt, :total_shards, :ranges
+
+        def initialize(salt:, total_shards:, ranges:)
+          @salt = salt
+          @total_shards = total_shards
+          @ranges = ranges || []
+        end
+
+        def self.from_json(shard_data)
+          new(
+            salt: shard_data['salt'],
+            total_shards: shard_data['totalShards'],
+            ranges: parse_ranges(shard_data['ranges'] || [])
+          )
+        end
+
+        private
+
+        def self.parse_ranges(ranges_data)
+          ranges_data.map { |range_data| ShardRange.from_json(range_data) }
+        end
+      end
+
+      # Represents a shard range for traffic allocation
+      class ShardRange
+        attr_reader :start, :end_value
+
+        def initialize(start:, end_value:)
+          @start = start
+          @end_value = end_value
+        end
+
+        def self.from_json(range_data)
+          new(
+            start: range_data['start'],
+            end_value: range_data['end']
+          )
+        end
+
+        # Alias for backward compatibility
+        def end
+          @end_value
+        end
+      end
+
+      # Represents a targeting rule
+      class Rule
+        attr_reader :conditions
+
+        def initialize(conditions:)
+          @conditions = conditions || []
+        end
+
+        def self.from_json(rule_data)
+          new(
+            conditions: parse_conditions(rule_data['conditions'] || [])
+          )
+        end
+
+        private
+
+        def self.parse_conditions(conditions_data)
+          conditions_data.map { |condition_data| Condition.from_json(condition_data) }
+        end
+      end
+
+      # Represents a single condition within a rule
+      class Condition
+        attr_reader :attribute, :operator, :value
+
+        def initialize(attribute:, operator:, value:)
+          @attribute = attribute
+          @operator = operator
+          @value = value
+        end
+
+        def self.from_json(condition_data)
+          new(
+            attribute: condition_data['attribute'],
+            operator: condition_data['operator'],
+            value: parse_condition_value(condition_data['value'])
+          )
+        end
+
+        private
+
+        def self.parse_condition_value(value_data)
+          # Handle both single values and arrays for ONE_OF/NOT_ONE_OF operators
+          case value_data
+          when Array
+            value_data
+          else
+            value_data
+          end
+        end
+      end
+
+      # Main configuration container
+      class Configuration
+        attr_reader :flags, :schema_version
+
+        def initialize(flags:, schema_version: nil)
+          @flags = flags || {}
+          @schema_version = schema_version
+        end
+
+        def self.from_json(config_data)
+          flags_data = config_data['flags'] || config_data['flagsV1'] || {}
+          
+          parsed_flags = flags_data.transform_values do |flag_data|
+            Flag.from_json(flag_data['key'] || '', flag_data)
+          end
+
+          new(
+            flags: parsed_flags,
+            schema_version: config_data['schemaVersion']
+          )
+        end
+
+        def get_flag(flag_key)
+          @flags[flag_key]
+        end
+      end
+    end
+  end
+end

lib/datadog/open_feature/binding/internal_evaluator.rb

@@ -35,7 +35,7 @@ def parse_and_validate_json(ufc_json)
           # Handle nil or empty input
           if ufc_json.nil? || ufc_json.strip.empty?
             # TODO: Add structured logging for debugging context
-            return create_error_result('CONFIGURATION_MISSING', 'flags configuration is missing')
+            return create_parse_error('CONFIGURATION_MISSING', 'flags configuration is missing')
           end
 
           # Parse JSON
@@ -44,26 +44,26 @@ def parse_and_validate_json(ufc_json)
           # Basic structure validation
           unless parsed_json.is_a?(Hash)
             # TODO: Add structured logging for debugging context
-            return create_error_result('CONFIGURATION_PARSE_ERROR', 'failed to parse configuration')
+            return create_parse_error('CONFIGURATION_PARSE_ERROR', 'failed to parse configuration')
           end
 
           # Check for required top-level fields (basic validation for now)
           unless parsed_json.key?('flags') || parsed_json.key?('flagsV1')
             # TODO: Add structured logging for debugging context
-            return create_error_result('CONFIGURATION_PARSE_ERROR', 'failed to parse configuration')
+            return create_parse_error('CONFIGURATION_PARSE_ERROR', 'failed to parse configuration')
           end
 
           # Return parsed configuration if valid
           parsed_json
         rescue JSON::ParserError => e
           # TODO: Add structured logging: "Invalid JSON syntax: #{e.message}"
-          create_error_result('CONFIGURATION_PARSE_ERROR', 'failed to parse configuration')
+          create_parse_error('CONFIGURATION_PARSE_ERROR', 'failed to parse configuration')
         rescue StandardError => e
           # TODO: Add structured logging: "Unexpected error: #{e.message}"
-          create_error_result('CONFIGURATION_PARSE_ERROR', 'failed to parse configuration')
+          create_parse_error('CONFIGURATION_PARSE_ERROR', 'failed to parse configuration')
         end
 
-        def create_error_result(error_code, error_message)
+        def create_parse_error(error_code, error_message)
           ResolutionDetails.new(
             value: nil,
             error_code: error_code,