handle symbolizing internally in SDK

Author: fahad19

bin/commands/assess_distribution.rb

@@ -160,27 +160,13 @@ def execute_command(command)
       end
 
       def create_instance(datafile)
-        # Convert datafile to proper format for the SDK
-        symbolized_datafile = symbolize_keys(datafile)
-
         # Create SDK instance
         Featurevisor.create_instance(
-          datafile: symbolized_datafile,
+          datafile: datafile,
           log_level: get_logger_level
         )
       end
 
-      def symbolize_keys(obj)
-        case obj
-        when Hash
-          obj.transform_keys(&:to_sym).transform_values { |v| symbolize_keys(v) }
-        when Array
-          obj.map { |item| symbolize_keys(item) }
-        else
-          obj
-        end
-      end
-
       def get_logger_level
         if @options.verbose
           "debug"

bin/commands/benchmark.rb

@@ -143,16 +143,13 @@ def execute_command(command)
       end
 
       def create_instance(datafile)
-        # Convert string keys to symbols for the SDK
-        symbolized_datafile = symbolize_keys(datafile)
-
         # Create a real Featurevisor instance
         instance = Featurevisor.create_instance(
           log_level: get_logger_level
         )
 
         # Explicitly set the datafile
-        instance.set_datafile(symbolized_datafile)
+        instance.set_datafile(datafile)
 
         instance
       end
@@ -167,17 +164,6 @@ def get_logger_level
         end
       end
 
-      def symbolize_keys(obj)
-        case obj
-        when Hash
-          obj.transform_keys(&:to_sym).transform_values { |v| symbolize_keys(v) }
-        when Array
-          obj.map { |item| symbolize_keys(item) }
-        else
-          obj
-        end
-      end
-
       def benchmark_feature_flag(instance, feature_key, context, n)
         start_time = Time.now
 

bin/commands/test.rb

@@ -161,12 +161,9 @@ def create_sdk_instances(environments, datafiles_by_environment, level)
         environments.each do |environment|
           datafile = datafiles_by_environment[environment]
 
-          # Convert string keys to symbols for the SDK
-          symbolized_datafile = symbolize_keys(datafile)
-
           # Create SDK instance
           instance = Featurevisor.create_instance(
-            datafile: symbolized_datafile,
+            datafile: datafile,
             log_level: level,
             hooks: [
               {
@@ -214,10 +211,9 @@ def run_tests(tests, sdk_instances_by_environment, datafiles_by_environment, seg
                 # If "at" parameter is provided, create a new instance with the specific hook
                 if assertion["at"]
                   datafile = datafiles_by_environment[environment]
-                  symbolized_datafile = symbolize_keys(datafile)
 
                   instance = Featurevisor.create_instance(
-                    datafile: symbolized_datafile,
+                    datafile: datafile,
                     log_level: level,
                     hooks: [
                       {
@@ -549,7 +545,7 @@ def run_test_segment(assertion, segment, level)
 
         # Create SDK instance for segment testing
         instance = Featurevisor.create_instance(
-          datafile: symbolize_keys(datafile),
+          datafile: datafile,
           log_level: level
         )
 
@@ -765,16 +761,7 @@ def normalize_hash_keys(obj)
         end
       end
 
-      def symbolize_keys(obj)
-        case obj
-        when Hash
-          obj.transform_keys(&:to_sym).transform_values { |v| symbolize_keys(v) }
-        when Array
-          obj.map { |v| symbolize_keys(v) }
-        else
-          obj
-        end
-      end
+
 
       def execute_command(command)
         stdout, stderr, status = Open3.capture3(command)

lib/featurevisor/instance.rb

@@ -42,7 +42,7 @@ def initialize(options = {})
 
       if options[:datafile]
         @datafile_reader = Featurevisor::DatafileReader.new(
-          datafile: options[:datafile].is_a?(String) ? JSON.parse(options[:datafile]) : options[:datafile],
+          datafile: parse_datafile(options[:datafile]),
           logger: @logger
         )
       end
@@ -61,7 +61,7 @@ def set_log_level(level)
     def set_datafile(datafile)
       begin
         new_datafile_reader = Featurevisor::DatafileReader.new(
-          datafile: datafile.is_a?(String) ? JSON.parse(datafile) : datafile,
+          datafile: parse_datafile(datafile),
           logger: @logger
         )
 
@@ -409,6 +409,32 @@ def get_all_evaluations(context = {}, feature_keys = [], options = {})
 
     private
 
+    # Parse and symbolize datafile keys
+    # @param datafile [Hash, String] Datafile content or JSON string
+    # @return [Hash] Datafile with symbolized keys
+    def parse_datafile(datafile)
+      if datafile.is_a?(String)
+        parsed = JSON.parse(datafile)
+        symbolize_keys(parsed)
+      else
+        symbolize_keys(datafile)
+      end
+    end
+
+    # Recursively symbolize hash keys
+    # @param obj [Object] Object to symbolize keys for
+    # @return [Object] Object with symbolized keys
+    def symbolize_keys(obj)
+      case obj
+      when Hash
+        obj.transform_keys(&:to_sym).transform_values { |v| symbolize_keys(v) }
+      when Array
+        obj.map { |v| symbolize_keys(v) }
+      else
+        obj
+      end
+    end
+
     # Get evaluation dependencies
     # @param context [Hash] Context
     # @param options [Hash] Override options

spec/instance_spec.rb

@@ -1197,4 +1197,74 @@
     expect(sdk.is_enabled("test", { userId: "123", country: "nl" })).to be true
     expect(sdk.is_enabled("test", { userId: "123", country: "us", device: "iphone" })).to be true
   end
+
+  it "should automatically symbolize keys when parsing JSON string datafile" do
+    json_datafile = '{
+      "schemaVersion": "2",
+      "revision": "1.0",
+      "features": {
+        "test": {
+          "key": "test",
+          "bucketBy": "userId",
+          "variations": [
+            { "value": "control" },
+            { "value": "treatment" }
+          ],
+          "traffic": [
+            {
+              "key": "1",
+              "segments": "*",
+              "percentage": 100000,
+              "allocation": [
+                { "variation": "control", "range": [0, 100000] },
+                { "variation": "treatment", "range": [0, 0] }
+              ]
+            }
+          ]
+        }
+      },
+      "segments": {}
+    }'
+
+    sdk = Featurevisor.create_instance(datafile: json_datafile)
+
+    expect(sdk.get_revision).to eq("1.0")
+    expect(sdk.get_feature("test")).to be_a(Hash)
+    expect(sdk.get_feature("test")[:key]).to eq("test")
+    expect(sdk.get_feature("test")[:bucketBy]).to eq("userId")
+    expect(sdk.is_enabled("test", { userId: "123" })).to be true
+    expect(sdk.get_variation("test", { userId: "123" })).to eq("control")
+  end
+
+  it "should automatically symbolize keys when setting JSON string datafile" do
+    sdk = Featurevisor.create_instance
+
+    json_datafile = '{
+      "schemaVersion": "2",
+      "revision": "2.0",
+      "features": {
+        "newFeature": {
+          "key": "newFeature",
+          "bucketBy": "userId",
+          "traffic": [
+            {
+              "key": "1",
+              "segments": "*",
+              "percentage": 100000,
+              "allocation": []
+            }
+          ]
+        }
+      },
+      "segments": {}
+    }'
+
+    sdk.set_datafile(json_datafile)
+
+    expect(sdk.get_revision).to eq("2.0")
+    expect(sdk.get_feature("newFeature")).to be_a(Hash)
+    expect(sdk.get_feature("newFeature")[:key]).to eq("newFeature")
+    expect(sdk.get_feature("newFeature")[:bucketBy]).to eq("userId")
+    expect(sdk.is_enabled("newFeature", { userId: "123" })).to be true
+  end
 end