Reorder get_assignment method parameters

Author: sameerank

lib/datadog/open_feature/binding/internal_evaluator.rb

@@ -37,15 +37,15 @@ def initialize(ufc_json)
         # traffic splitting, and allocation matching.
         #
         # @param flag_key [String] The unique identifier for the feature flag
+        # @param default_value [Object] Default value to return when flag evaluation fails or no allocation matches
         # @param evaluation_context [Hash, nil] Context data for flag evaluation.
         #   When using OpenFeature SDK, pass evaluation_context&.fields to extract
         #   the hash representation. Common fields include 'targeting_key' and custom attributes.
         # @param expected_type [String] Expected value type: "string", "integer", "float", "boolean", or "object"
-        # @param default_value [Object] Default value to return when flag evaluation fails or no allocation matches
         # @return [ResolutionDetails] Evaluation result where result.value is ensured to never be nil.
         #   For successful evaluations, contains the flag's assigned value and metadata.
         #   For errors or disabled flags, contains the provided default_value.
-        def get_assignment(flag_key, evaluation_context, expected_type, default_value)
+        def get_assignment(flag_key, default_value, evaluation_context, expected_type)
           # Return error result if JSON parsing failed during initialization
           if @parse_error
             return create_evaluation_error(

lib/datadog/open_feature/evaluation_engine.rb

@@ -45,7 +45,7 @@ def fetch_value(flag_key:, expected_type:, evaluation_context: nil, default_valu
 
         string_expected_type = TYPE_MAP[expected_type] || expected_type
 
-        result = @evaluator.get_assignment(flag_key, evaluation_context&.fields, string_expected_type, default_value)
+        result = @evaluator.get_assignment(flag_key, default_value, evaluation_context&.fields, string_expected_type)
         @reporter.report(result, flag_key: flag_key, context: evaluation_context)
 
         result

lib/datadog/open_feature/noop_evaluator.rb

@@ -11,7 +11,7 @@ def initialize(_configuration)
         # no-op
       end
 
-      def get_assignment(_flag_key, _evaluation_context, _expected_type, default_value)
+      def get_assignment(_flag_key, default_value, _evaluation_context, _expected_type)
         Binding::ResolutionDetails.new(
           value: default_value,
           error_code: Ext::PROVIDER_NOT_READY,

sig/datadog/open_feature/binding/internal_evaluator.rbs

@@ -14,9 +14,9 @@ module Datadog
 
         def get_assignment: (
           ::String flag_key,
+          untyped default_value,
           untyped _evaluation_context,
-          ::String? expected_type,
-          untyped default_value
+          ::String? expected_type
         ) -> ResolutionDetails
 
         private

sig/datadog/open_feature/noop_evaluator.rbs

@@ -5,9 +5,9 @@ module Datadog
 
       def get_assignment: (
         ::String,
+        untyped,
         ::OpenFeature::SDK::EvaluationContext?,
-        ::String,
-        untyped
+        ::String
       ) -> Binding::ResolutionDetails
     end
   end

spec/datadog/open_feature/binding/allocation_matching_spec.rb

@@ -42,7 +42,7 @@
     let(:evaluator) { Datadog::OpenFeature::Binding::InternalEvaluator.new(flag_config.to_json) }
 
     it 'skips expired allocations and uses active ones' do
-      result = evaluator.get_assignment("time_test_flag", {}, 'string', 'test_default')
+      result = evaluator.get_assignment("time_test_flag", 'test_default', {}, 'string')
 
       expect(result.error_code).to be_nil  # nil for successful evaluation
       expect(result.value).to eq("treatment_value") # Should use active allocation
@@ -52,7 +52,7 @@
     end
 
     it 'returns assignment reason based on allocation properties' do
-      result = evaluator.get_assignment("time_test_flag", {}, 'string', 'test_default')
+      result = evaluator.get_assignment("time_test_flag", 'test_default', {}, 'string')
 
       expect(result.reason).to eq("STATIC") # Single split with no shards = static
     end
@@ -62,7 +62,7 @@
     let(:evaluator) { Datadog::OpenFeature::Binding::InternalEvaluator.new('{"flags": {}}') }
 
     it 'returns error result on flag lookup errors' do
-      result = evaluator.get_assignment("missing_flag", {}, 'string', 'test_default')
+      result = evaluator.get_assignment("missing_flag", 'test_default', {}, 'string')
 
       expect(result.error_code).to eq('FLAG_UNRECOGNIZED_OR_DISABLED')
       expect(result.value).to eq('test_default')  # Internal evaluator returns default_value for errors
@@ -71,9 +71,9 @@
     end
 
     it 'returns consistent error results for different types' do
-      string_result = evaluator.get_assignment("missing", {}, 'string', 'test_default')
-      number_result = evaluator.get_assignment("missing", {}, 'float', 'test_default')
-      bool_result = evaluator.get_assignment("missing", {}, 'boolean', 'test_default')
+      string_result = evaluator.get_assignment("missing", 'test_default', {}, 'string')
+      number_result = evaluator.get_assignment("missing", 'test_default', {}, 'float')
+      bool_result = evaluator.get_assignment("missing", 'test_default', {}, 'boolean')
 
       expect(string_result.value).to eq('test_default')  # Internal evaluator returns default_value
       expect(number_result.value).to eq('test_default')
@@ -107,7 +107,7 @@
       }
 
       evaluator = Datadog::OpenFeature::Binding::InternalEvaluator.new(config_with_time_bounds.to_json)
-      result = evaluator.get_assignment("timed_flag", {}, 'boolean', 'test_default')
+      result = evaluator.get_assignment("timed_flag", 'test_default', {}, 'boolean')
 
       expect(result.error_code).to be_nil  # nil for successful evaluation
       expect(result.reason).to eq("TARGETING_MATCH") # Has time bounds

spec/datadog/open_feature/binding/internal_evaluator_spec.rb

@@ -28,7 +28,7 @@
     context 'with invalid UFC JSON' do
       it 'stores parse error for malformed JSON' do
         evaluator = described_class.new('invalid json')
-        result = evaluator.get_assignment('any_flag', {}, 'string', 'test_default')
+        result = evaluator.get_assignment('any_flag', 'test_default', {}, 'string')
 
         expect(result.error_code).to eq('CONFIGURATION_PARSE_ERROR')
         expect(result.error_message).to eq('failed to parse configuration')
@@ -38,7 +38,7 @@
 
       it 'stores configuration missing error for empty JSON' do
         evaluator = described_class.new('')
-        result = evaluator.get_assignment('any_flag', {}, 'string', 'test_default')
+        result = evaluator.get_assignment('any_flag', 'test_default', {}, 'string')
 
         expect(result.error_code).to eq('CONFIGURATION_MISSING')
         expect(result.error_message).to eq('flags configuration is missing')
@@ -55,7 +55,7 @@
       let(:bad_evaluator) { described_class.new('invalid json') }
 
       it 'returns the initialization error' do
-        result = bad_evaluator.get_assignment('any_flag', {}, 'string', 'test_default')
+        result = bad_evaluator.get_assignment('any_flag', 'test_default', {}, 'string')
 
         expect(result.error_code).to eq('CONFIGURATION_PARSE_ERROR')
         expect(result.error_message).to eq('failed to parse configuration')
@@ -67,7 +67,7 @@
 
     context 'with type validation' do
       it 'returns TYPE_MISMATCH when types do not match' do
-        result = evaluator.get_assignment('numeric_flag', {}, 'boolean', 'test_default')
+        result = evaluator.get_assignment('numeric_flag', 'test_default', {}, 'boolean')
 
         expect(result.error_code).to eq('TYPE_MISMATCH')
         expect(result.error_message).to eq('invalid flag type (expected: boolean, found: NUMERIC)')
@@ -77,7 +77,7 @@
       end
 
       it 'succeeds when types match' do
-        result = evaluator.get_assignment('numeric_flag', {}, 'float', 'test_default')
+        result = evaluator.get_assignment('numeric_flag', 'test_default', {}, 'float')
 
         expect(result.error_code).to be_nil  # nil for successful allocation match
         expect(result.error_message).to be_nil  # nil for successful cases
@@ -89,7 +89,7 @@
       end
 
       it 'succeeds when expected_type is nil (no validation)' do
-        result = evaluator.get_assignment('numeric_flag', {}, nil, 'test_default')
+        result = evaluator.get_assignment('numeric_flag', 'test_default', {}, nil)
 
         expect(result.error_code).to be_nil  # nil for successful allocation match
         expect(result.error_message).to be_nil  # nil for successful cases
@@ -123,7 +123,7 @@
       it 'accepts hash evaluation contexts including from OpenFeature SDK fields' do
         # Test with hash-based evaluation context
         hash_context = {'targeting_key' => 'user123', 'attr1' => 'value1'}
-        hash_result = evaluator.get_assignment('numeric_flag', hash_context, 'float', 'test_default')
+        hash_result = evaluator.get_assignment('numeric_flag', 'test_default', hash_context, 'float')
 
         expect(hash_result.error_code).to be_nil
         expect(hash_result.value).not_to be_nil
@@ -135,7 +135,7 @@
           fields: {'attr1' => 'value1'}
         )
 
-        sdk_result = evaluator.get_assignment('numeric_flag', sdk_context.fields, 'float', 'test_default')
+        sdk_result = evaluator.get_assignment('numeric_flag', 'test_default', sdk_context.fields, 'float')
 
         expect(sdk_result.error_code).to be_nil
         expect(sdk_result.value).not_to be_nil
@@ -174,35 +174,35 @@
 
     it 'uses consistent error codes matching Rust implementation' do
       # Test all error types
-      flag_not_found = evaluator.get_assignment('missing', {}, 'string', 'test_default')
+      flag_not_found = evaluator.get_assignment('missing', 'test_default', {}, 'string')
       expect(flag_not_found.error_code).to eq('FLAG_UNRECOGNIZED_OR_DISABLED')
       expect(flag_not_found.value).to eq('test_default')
       expect(flag_not_found.variant).to be_nil
       expect(flag_not_found.flag_metadata).to eq({})
 
-      flag_disabled = evaluator.get_assignment('disabled_flag', {}, 'integer', 'test_default')
+      flag_disabled = evaluator.get_assignment('disabled_flag', 'test_default', {}, 'integer')
       expect(flag_disabled.error_code).to be_nil  # Disabled flags are successful cases with nil error_code
       expect(flag_disabled.error_message).to be_nil  # nil for successful disabled cases
       expect(flag_disabled.reason).to eq('DISABLED')  # Disabled reason
       expect(flag_disabled.value).to eq('test_default')
       expect(flag_disabled.variant).to be_nil
       expect(flag_disabled.flag_metadata).to eq({})
 
-      type_mismatch = evaluator.get_assignment('numeric_flag', {}, 'boolean', 'test_default')
+      type_mismatch = evaluator.get_assignment('numeric_flag', 'test_default', {}, 'boolean')
       expect(type_mismatch.error_code).to eq('TYPE_MISMATCH')
       expect(type_mismatch.value).to eq('test_default')
       expect(type_mismatch.variant).to be_nil
       expect(type_mismatch.flag_metadata).to eq({})
     end
 
     it 'provides descriptive error messages matching Rust format' do
-      result = evaluator.get_assignment('missing_flag', {}, 'string', 'test_default')
+      result = evaluator.get_assignment('missing_flag', 'test_default', {}, 'string')
       expect(result.error_message).to eq('flag is missing in configuration, it is either unrecognized or disabled')
       expect(result.value).to eq('test_default')
       expect(result.variant).to be_nil
       expect(result.flag_metadata).to eq({})
 
-      type_result = evaluator.get_assignment('numeric_flag', {}, 'boolean', 'test_default')
+      type_result = evaluator.get_assignment('numeric_flag', 'test_default', {}, 'boolean')
       expect(type_result.error_message).to match(/invalid flag type \(expected: .*, found: .*\)/)
       expect(type_result.value).to eq('test_default')
       expect(type_result.variant).to be_nil
@@ -241,7 +241,7 @@
             evaluation_context['targeting_key'] = targeting_key if targeting_key  # Convert camelCase to snake_case
 
             # Execute test case
-            result = evaluator.get_assignment(flag_key, evaluation_context, expected_type, 'test_default')
+            result = evaluator.get_assignment(flag_key, 'test_default', evaluation_context, expected_type)
 
             # Wrap expectations in aggregate_failures for better error reporting
             aggregate_failures "Test case ##{index + 1}: #{targeting_key} with #{attributes.keys.join(", ")}" do

spec/datadog/open_feature/binding/rule_evaluation_spec.rb

@@ -66,7 +66,7 @@
 
     it 'matches allocation when first rule passes' do
       admin_context = {"user_type" => "admin", "age" => 30}
-      result = evaluator.get_assignment("multi_rule_flag", admin_context, 'string', 'test_default')
+      result = evaluator.get_assignment("multi_rule_flag", 'test_default', admin_context, 'string')
 
       expect(result.error_code).to be_nil
       expect(result.value).to eq("special_value")
@@ -75,7 +75,7 @@
 
     it 'matches allocation when second rule passes' do
       senior_context = {"user_type" => "regular", "age" => 70}
-      result = evaluator.get_assignment("multi_rule_flag", senior_context, 'string', 'test_default')
+      result = evaluator.get_assignment("multi_rule_flag", 'test_default', senior_context, 'string')
 
       expect(result.error_code).to be_nil
       expect(result.value).to eq("special_value")
@@ -84,7 +84,7 @@
 
     it 'matches allocation when both rules pass' do
       admin_senior_context = {"user_type" => "admin", "age" => 70}
-      result = evaluator.get_assignment("multi_rule_flag", admin_senior_context, 'string', 'test_default')
+      result = evaluator.get_assignment("multi_rule_flag", 'test_default', admin_senior_context, 'string')
 
       expect(result.error_code).to be_nil
       expect(result.value).to eq("special_value")
@@ -93,7 +93,7 @@
 
     it 'uses fallback allocation when no rules pass' do
       regular_context = {"user_type" => "regular", "age" => 30}
-      result = evaluator.get_assignment("multi_rule_flag", regular_context, 'string', 'test_default')
+      result = evaluator.get_assignment("multi_rule_flag", 'test_default', regular_context, 'string')
 
       expect(result.error_code).to be_nil
       expect(result.value).to eq("default_value")

spec/datadog/open_feature/noop_evaluator_spec.rb

@@ -7,7 +7,7 @@
   subject(:evaluator) { described_class.new(nil) }
 
   describe '#get_assignment' do
-    let(:result) { evaluator.get_assignment('flag', nil, :string, 'default_value') }
+    let(:result) { evaluator.get_assignment('flag', 'default_value', nil, :string) }
 
     it 'returns provider not ready result' do
       expect(result.do_log).to be(false)