featurevisor 0.1.1 → 0.3.0

data/bin/commands/test.rb

@@ -1,6 +1,7 @@
 require "json"
 require "find"
 require "open3"
+require "shellwords"
 
 module FeaturevisorCLI
   module Commands
@@ -19,17 +20,17 @@ module FeaturevisorCLI
 
         # Get project configuration
         config = get_config
-        environments = config["environments"] || []
+        environments = get_environments(config)
         segments_by_key = get_segments
 
         # Use CLI schemaVersion option or fallback to config
         schema_version = @options.schema_version
         if schema_version.nil? || schema_version.empty?
-          schema_version = config["schemaVersion"]
+          schema_version = config[:schemaVersion]
         end
 
-        # Build datafiles for all environments
-        datafiles_by_environment = build_datafiles(environments, schema_version, @options.inflate)
+        # Build datafiles for all environments (+ scoped/tagged variants)
+        datafiles_by_key = build_datafiles(config, environments, schema_version, @options.inflate)
 
         puts ""
 
@@ -42,22 +43,19 @@ module FeaturevisorCLI
           return
         end
 
-        # Create SDK instances for each environment
-        sdk_instances_by_environment = create_sdk_instances(environments, datafiles_by_environment, level)
-
         # Run tests
-        run_tests(tests, sdk_instances_by_environment, datafiles_by_environment, segments_by_key, level)
+        run_tests(tests, datafiles_by_key, segments_by_key, level, config)
       end
 
       private
 
       def get_config
         puts "Getting config..."
-        command = "(cd #{@project_path} && npx featurevisor config --json)"
+        command = "(cd #{Shellwords.escape(@project_path)} && npx featurevisor config --json)"
         config_output = execute_command(command)
 
         begin
-          JSON.parse(config_output)
+          JSON.parse(config_output, symbolize_names: true)
         rescue JSON::ParserError => e
           puts "Error: Failed to parse config JSON: #{e.message}"
           puts "Command output: #{config_output}"
@@ -67,15 +65,15 @@ module FeaturevisorCLI
 
       def get_segments
         puts "Getting segments..."
-        command = "(cd #{@project_path} && npx featurevisor list --segments --json)"
+        command = "(cd #{Shellwords.escape(@project_path)} && npx featurevisor list --segments --json)"
         segments_output = execute_command(command)
 
         begin
-          segments = JSON.parse(segments_output)
+          segments = JSON.parse(segments_output, symbolize_names: true)
           segments_by_key = {}
           segments.each do |segment|
-            if segment["key"]
-              segments_by_key[segment["key"]] = segment
+            if segment[:key]
+              segments_by_key[segment[:key]] = segment
             end
           end
           segments_by_key
@@ -86,40 +84,111 @@ module FeaturevisorCLI
         end
       end
 
-      def build_datafiles(environments, schema_version, inflate)
-        datafiles_by_environment = {}
+      def get_environments(config)
+        environments = config[:environments]
+
+        return [false] if environments == false
+        return environments if environments.is_a?(Array) && !environments.empty?
+
+        [false]
+      end
+
+      def base_datafile_key(environment)
+        environment == false ? false : environment
+      end
+
+      def scoped_datafile_key(environment, scope_name)
+        if environment == false
+          "scope-#{scope_name}"
+        else
+          "#{environment}-scope-#{scope_name}"
+        end
+      end
+
+      def tagged_datafile_key(environment, tag)
+        if environment == false
+          "tag-#{tag}"
+        else
+          "#{environment}-tag-#{tag}"
+        end
+      end
+
+      def build_datafiles(config, environments, schema_version, inflate)
+        datafiles_by_key = {}
 
         environments.each do |environment|
-          puts "Building datafile for environment: #{environment}..."
+          environment_label = environment == false ? "default (no environment)" : environment
+          puts "Building datafile for environment: #{environment_label}..."
 
-          command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--json"]
+          datafiles_by_key[base_datafile_key(environment)] = build_single_datafile(
+            environment: environment,
+            schema_version: schema_version,
+            inflate: inflate
+          )
 
-          if schema_version && !schema_version.empty?
-            command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--schemaVersion=#{schema_version}", "--json"]
+          if @options.with_scopes && config[:scopes].is_a?(Array)
+            config[:scopes].each do |scope|
+              next unless scope[:name]
+
+              puts "Building scoped datafile for scope: #{scope[:name]}..."
+              datafiles_by_key[scoped_datafile_key(environment, scope[:name])] = build_single_datafile(
+                environment: environment,
+                schema_version: schema_version,
+                inflate: inflate,
+                scope: scope[:name]
+              )
+            end
           end
 
-          if inflate && inflate > 0
-            if schema_version && !schema_version.empty?
-              command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--schemaVersion=#{schema_version}", "--inflate=#{inflate}", "--json"]
-            else
-              command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "build", "--environment=#{environment}", "--inflate=#{inflate}", "--json"]
+          if @options.with_tags && config[:tags].is_a?(Array)
+            config[:tags].each do |tag|
+              puts "Building tagged datafile for tag: #{tag}..."
+              datafiles_by_key[tagged_datafile_key(environment, tag)] = build_single_datafile(
+                environment: environment,
+                schema_version: schema_version,
+                inflate: inflate,
+                tag: tag
+              )
             end
           end
+        end
 
-          command = command_parts.join(" ")
-          datafile_output = execute_command(command)
+        datafiles_by_key
+      end
 
-          begin
-            datafile = JSON.parse(datafile_output)
-            datafiles_by_environment[environment] = datafile
-          rescue JSON::ParserError => e
-            puts "Error: Failed to parse datafile JSON for #{environment}: #{e.message}"
-            puts "Command output: #{datafile_output}"
-            exit 1
-          end
+      def build_single_datafile(environment:, schema_version:, inflate:, scope: nil, tag: nil)
+        command_parts = ["npx", "featurevisor", "build", "--json"]
+
+        if environment != false && !environment.nil?
+          command_parts << "--environment=#{Shellwords.escape(environment.to_s)}"
         end
 
-        datafiles_by_environment
+        if schema_version && !schema_version.empty?
+          command_parts << "--schemaVersion=#{Shellwords.escape(schema_version.to_s)}"
+        end
+
+        if inflate && inflate > 0
+          command_parts << "--inflate=#{inflate}"
+        end
+
+        if scope
+          command_parts << "--scope=#{Shellwords.escape(scope.to_s)}"
+        end
+
+        if tag
+          command_parts << "--tag=#{Shellwords.escape(tag.to_s)}"
+        end
+
+        command = "(cd #{Shellwords.escape(@project_path)} && #{command_parts.join(' ')})"
+        datafile_output = execute_command(command)
+
+        begin
+          JSON.parse(datafile_output, symbolize_names: true)
+        rescue JSON::ParserError => e
+          puts "Error: Failed to parse datafile JSON: #{e.message}"
+          puts "Command output: #{datafile_output}"
+          exit 1
+        end
       end
 
       def get_logger_level
@@ -133,21 +202,21 @@ module FeaturevisorCLI
       end
 
       def get_tests
-        command_parts = ["cd", @project_path, "&&", "npx", "featurevisor", "list", "--tests", "--applyMatrix", "--json"]
+        command_parts = ["npx", "featurevisor", "list", "--tests", "--applyMatrix", "--json"]
 
         if @options.key_pattern && !@options.key_pattern.empty?
-          command_parts << "--keyPattern=#{@options.key_pattern}"
+          command_parts << "--keyPattern=#{Shellwords.escape(@options.key_pattern)}"
         end
 
         if @options.assertion_pattern && !@options.assertion_pattern.empty?
-          command_parts << "--assertionPattern=#{@options.assertion_pattern}"
+          command_parts << "--assertionPattern=#{Shellwords.escape(@options.assertion_pattern)}"
         end
 
-        command = command_parts.join(" ")
+        command = "(cd #{Shellwords.escape(@project_path)} && #{command_parts.join(' ')})"
         tests_output = execute_command(command)
 
         begin
-          JSON.parse(tests_output)
+          JSON.parse(tests_output, symbolize_names: true)
         rescue JSON::ParserError => e
           puts "Error: Failed to parse tests JSON: #{e.message}"
           puts "Command output: #{tests_output}"
@@ -155,42 +224,66 @@ module FeaturevisorCLI
         end
       end
 
-      def create_sdk_instances(environments, datafiles_by_environment, level)
-        sdk_instances_by_environment = {}
+      def get_scope_context(config, scope_name)
+        return {} unless scope_name && config[:scopes].is_a?(Array)
 
-        environments.each do |environment|
-          datafile = datafiles_by_environment[environment]
+        scope = config[:scopes].find { |s| s[:name] == scope_name }
+        return {} unless scope && scope[:context].is_a?(Hash)
 
-          # Convert string keys to symbols for the SDK
-          symbolized_datafile = symbolize_keys(datafile)
-
-          # Create SDK instance
-          instance = Featurevisor.create_instance(
-            datafile: symbolized_datafile,
-            log_level: level,
-            hooks: [
-              {
-                name: "tester-hook",
-                bucket_value: ->(options) { options.bucket_value }
-              }
-            ]
-          )
+        parse_context(scope[:context])
+      end
+
+      def resolve_datafile_for_assertion(assertion, datafiles_by_key)
+        environment = assertion.key?(:environment) ? assertion[:environment] : false
+        environment = false if environment.nil?
+
+        scoped_key = assertion[:scope] ? scoped_datafile_key(environment, assertion[:scope]) : nil
+        tagged_key = assertion[:tag] ? tagged_datafile_key(environment, assertion[:tag]) : nil
+        base_key = base_datafile_key(environment)
+
+        if scoped_key && datafiles_by_key.key?(scoped_key)
+          return datafiles_by_key[scoped_key]
+        end
 
-          sdk_instances_by_environment[environment] = instance
+        if tagged_key && datafiles_by_key.key?(tagged_key)
+          return datafiles_by_key[tagged_key]
         end
 
-        sdk_instances_by_environment
+        datafiles_by_key[base_key]
       end
 
-      def run_tests(tests, sdk_instances_by_environment, datafiles_by_environment, segments_by_key, level)
+      def create_tester_instance(datafile, level, assertion)
+        sticky = parse_sticky(assertion[:sticky])
+
+        Featurevisor.create_instance(
+          datafile: datafile,
+          sticky: sticky,
+          log_level: level,
+          hooks: [
+            {
+              name: "tester-hook",
+              bucket_value: ->(options) do
+                at = assertion[:at]
+                if at.is_a?(Numeric)
+                  (at * 1000).to_i
+                else
+                  options.bucket_value
+                end
+              end
+            }
+          ]
+        )
+      end
+
+      def run_tests(tests, datafiles_by_key, segments_by_key, level, config)
         passed_tests_count = 0
         failed_tests_count = 0
         passed_assertions_count = 0
         failed_assertions_count = 0
 
         tests.each do |test|
-          test_key = test["key"]
-          assertions = test["assertions"] || []
+          test_key = test[:key]
+          assertions = test[:assertions] || []
           results = ""
           test_has_error = false
           test_duration = 0.0
@@ -199,47 +292,36 @@ module FeaturevisorCLI
             if assertion.is_a?(Hash)
               test_result = nil
 
-              if test["feature"]
-                environment = assertion["environment"]
-                instance = sdk_instances_by_environment[environment]
-
-                # Show datafile if requested
-                if @options.show_datafile
-                  datafile = datafiles_by_environment[environment]
-                  puts ""
-                  puts JSON.pretty_generate(datafile)
-                  puts ""
+              if test[:feature]
+                datafile = resolve_datafile_for_assertion(assertion, datafiles_by_key)
+                if datafile.nil?
+                  test_result = {
+                    has_error: true,
+                    errors: "      ✘ no datafile found for assertion scope/tag/environment combination\n",
+                    duration: 0
+                  }
                 end
 
-                # 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,
-                    log_level: level,
-                    hooks: [
-                      {
-                        name: "tester-hook",
-                        bucket_value: ->(options) do
-                          # Match JavaScript implementation: assertion.at * (MAX_BUCKETED_NUMBER / 100)
-                          # MAX_BUCKETED_NUMBER is 100000, so this becomes assertion.at * 1000
-                          at = assertion["at"]
-                          if at.is_a?(Numeric)
-                            (at * 1000).to_i
-                          else
-                            options.bucket_value
-                          end
-                        end
-                      }
-                    ]
-                  )
-                end
+                if datafile
+                  instance = create_tester_instance(datafile, level, assertion)
+                  scope_context = {}
+
+                  if assertion[:scope] && !@options.with_scopes
+                    # If not using scoped datafiles, mimic JS behavior by merging scope context.
+                    scope_context = get_scope_context(config, assertion[:scope])
+                  end
 
-                test_result = run_test_feature(assertion, test["feature"], instance, level)
-              elsif test["segment"]
-                segment_key = test["segment"]
+                  # Show datafile if requested
+                  if @options.show_datafile
+                    puts ""
+                    puts JSON.pretty_generate(datafile)
+                    puts ""
+                  end
+
+                  test_result = run_test_feature(assertion, test[:feature], instance, level, scope_context)
+                end
+              elsif test[:segment]
+                segment_key = test[:segment]
                 segment = segments_by_key[segment_key]
                 if segment.is_a?(Hash)
                   test_result = run_test_segment(assertion, segment, level)
@@ -250,12 +332,12 @@ module FeaturevisorCLI
                 test_duration += test_result[:duration]
 
                 if test_result[:has_error]
-                  results += "  ✘ #{assertion['description']} (#{(test_result[:duration] * 1000).round(2)}ms)\n"
+                  results += "  ✘ #{assertion[:description]} (#{(test_result[:duration] * 1000).round(2)}ms)\n"
                   results += test_result[:errors]
                   test_has_error = true
                   failed_assertions_count += 1
                 else
-                  results += "  ✔ #{assertion['description']} (#{(test_result[:duration] * 1000).round(2)}ms)\n"
+                  results += "  ✔ #{assertion[:description]} (#{(test_result[:duration] * 1000).round(2)}ms)\n"
                   passed_assertions_count += 1
                 end
               end
@@ -284,9 +366,10 @@ module FeaturevisorCLI
         end
       end
 
-      def run_test_feature(assertion, feature_key, instance, level)
-        context = parse_context(assertion["context"])
-        sticky = parse_sticky(assertion["sticky"])
+      def run_test_feature(assertion, feature_key, instance, level, scope_context = {})
+        context = parse_context(assertion[:context])
+        context = { **scope_context, **context } if scope_context && !scope_context.empty?
+        sticky = parse_sticky(assertion[:sticky])
 
         # Set context and sticky for this assertion
         instance.set_context(context, false)
@@ -302,8 +385,8 @@ module FeaturevisorCLI
         start_time = Time.now
 
         # Test expectedToBeEnabled
-        if assertion.key?("expectedToBeEnabled")
-          expected_to_be_enabled = assertion["expectedToBeEnabled"]
+        if assertion.key?(:expectedToBeEnabled)
+          expected_to_be_enabled = assertion[:expectedToBeEnabled]
           is_enabled = instance.is_enabled(feature_key, context, override_options)
 
           if is_enabled != expected_to_be_enabled
@@ -313,8 +396,8 @@ module FeaturevisorCLI
         end
 
         # Test expectedVariation
-        if assertion.key?("expectedVariation")
-          expected_variation = assertion["expectedVariation"]
+        if assertion.key?(:expectedVariation)
+          expected_variation = assertion[:expectedVariation]
           variation = instance.get_variation(feature_key, context, override_options)
 
           variation_value = variation.nil? ? nil : variation
@@ -325,12 +408,12 @@ module FeaturevisorCLI
         end
 
         # Test expectedVariables
-        if assertion["expectedVariables"]
-          expected_variables = assertion["expectedVariables"]
+        if assertion[:expectedVariables]
+          expected_variables = assertion[:expectedVariables]
           expected_variables.each do |variable_key, expected_value|
             # Set default variable value for this specific variable
-            if assertion["defaultVariableValues"] && assertion["defaultVariableValues"][variable_key]
-              override_options[:default_variable_value] = assertion["defaultVariableValues"][variable_key]
+            if assertion[:defaultVariableValues].is_a?(Hash) && assertion[:defaultVariableValues].key?(variable_key)
+              override_options[:default_variable_value] = assertion[:defaultVariableValues][variable_key]
             end
 
             actual_value = instance.get_variable(feature_key, variable_key, context, override_options)
@@ -369,13 +452,13 @@ module FeaturevisorCLI
         end
 
         # Test expectedEvaluations
-        if assertion["expectedEvaluations"]
-          expected_evaluations = assertion["expectedEvaluations"]
+        if assertion[:expectedEvaluations]
+          expected_evaluations = assertion[:expectedEvaluations]
 
           # Test flag evaluations
-          if expected_evaluations["flag"]
+          if expected_evaluations[:flag]
             evaluation = instance.evaluate_flag(feature_key, context, override_options)
-            expected_evaluations["flag"].each do |key, expected_value|
+            expected_evaluations[:flag].each do |key, expected_value|
               actual_value = get_evaluation_value(evaluation, key)
               if !compare_values(actual_value, expected_value)
                 has_error = true
@@ -385,9 +468,9 @@ module FeaturevisorCLI
           end
 
           # Test variation evaluations
-          if expected_evaluations["variation"]
+          if expected_evaluations[:variation]
             evaluation = instance.evaluate_variation(feature_key, context, override_options)
-            expected_evaluations["variation"].each do |key, expected_value|
+            expected_evaluations[:variation].each do |key, expected_value|
               actual_value = get_evaluation_value(evaluation, key)
               if !compare_values(actual_value, expected_value)
                 has_error = true
@@ -397,8 +480,8 @@ module FeaturevisorCLI
           end
 
           # Test variable evaluations
-          if expected_evaluations["variables"]
-            expected_evaluations["variables"].each do |variable_key, expected_eval|
+          if expected_evaluations[:variables]
+            expected_evaluations[:variables].each do |variable_key, expected_eval|
               if expected_eval.is_a?(Hash)
                 evaluation = instance.evaluate_variable(feature_key, variable_key, context, override_options)
                 expected_eval.each do |key, expected_value|
@@ -414,10 +497,10 @@ module FeaturevisorCLI
         end
 
         # Test children
-        if assertion["children"]
-          assertion["children"].each do |child|
+        if assertion[:children]
+          assertion[:children].each do |child|
             if child.is_a?(Hash)
-              child_context = parse_context(child["context"])
+              child_context = parse_context(child[:context])
 
               # Create override options for child with sticky values
               child_override_options = create_override_options(child)
@@ -452,7 +535,7 @@ module FeaturevisorCLI
       end
 
       def run_test_feature_child(assertion, feature_key, instance, level)
-        context = parse_context(assertion["context"])
+        context = parse_context(assertion[:context])
         override_options = create_override_options(assertion)
 
         has_error = false
@@ -460,8 +543,8 @@ module FeaturevisorCLI
         start_time = Time.now
 
         # Test expectedToBeEnabled
-        if assertion.key?("expectedToBeEnabled")
-          expected_to_be_enabled = assertion["expectedToBeEnabled"]
+        if assertion.key?(:expectedToBeEnabled)
+          expected_to_be_enabled = assertion[:expectedToBeEnabled]
           is_enabled = instance.is_enabled(feature_key, context, override_options)
 
           if is_enabled != expected_to_be_enabled
@@ -471,8 +554,8 @@ module FeaturevisorCLI
         end
 
         # Test expectedVariation
-        if assertion.key?("expectedVariation")
-          expected_variation = assertion["expectedVariation"]
+        if assertion.key?(:expectedVariation)
+          expected_variation = assertion[:expectedVariation]
           variation = instance.get_variation(feature_key, context, override_options)
 
           variation_value = variation.nil? ? nil : variation
@@ -483,12 +566,12 @@ module FeaturevisorCLI
         end
 
         # Test expectedVariables
-        if assertion["expectedVariables"]
-          expected_variables = assertion["expectedVariables"]
+        if assertion[:expectedVariables]
+          expected_variables = assertion[:expectedVariables]
           expected_variables.each do |variable_key, expected_value|
             # Set default variable value for this specific variable
-            if assertion["defaultVariableValues"] && assertion["defaultVariableValues"][variable_key]
-              override_options[:default_variable_value] = assertion["defaultVariableValues"][variable_key]
+            if assertion[:defaultVariableValues].is_a?(Hash) && assertion[:defaultVariableValues].key?(variable_key)
+              override_options[:default_variable_value] = assertion[:defaultVariableValues][variable_key]
             end
 
             actual_value = instance.get_variable(feature_key, variable_key, context, override_options)
@@ -526,6 +609,55 @@ module FeaturevisorCLI
           end
         end
 
+        # Test expectedEvaluations
+        if assertion[:expectedEvaluations]
+          expected_evaluations = assertion[:expectedEvaluations]
+
+          if expected_evaluations[:flag]
+            evaluation = evaluate_from_instance(instance, :flag, feature_key, context, override_options)
+            expected_evaluations[:flag].each do |key, expected_value|
+              actual_value = get_evaluation_value(evaluation, key)
+              if !compare_values(actual_value, expected_value)
+                has_error = true
+                errors += "      ✘ expectedEvaluations.flag.#{key}: expected #{expected_value} but received #{actual_value}\n"
+              end
+            end
+          end
+
+          if expected_evaluations[:variation]
+            evaluation = evaluate_from_instance(instance, :variation, feature_key, context, override_options)
+            expected_evaluations[:variation].each do |key, expected_value|
+              actual_value = get_evaluation_value(evaluation, key)
+              if !compare_values(actual_value, expected_value)
+                has_error = true
+                errors += "      ✘ expectedEvaluations.variation.#{key}: expected #{expected_value} but received #{actual_value}\n"
+              end
+            end
+          end
+
+          if expected_evaluations[:variables]
+            expected_evaluations[:variables].each do |variable_key, expected_eval|
+              if expected_eval.is_a?(Hash)
+                evaluation = evaluate_from_instance(
+                  instance,
+                  :variable,
+                  feature_key,
+                  context,
+                  override_options,
+                  variable_key
+                )
+                expected_eval.each do |key, expected_value|
+                  actual_value = get_evaluation_value(evaluation, key)
+                  if !compare_values(actual_value, expected_value)
+                    has_error = true
+                    errors += "      ✘ expectedEvaluations.variables.#{variable_key}.#{key}: expected #{expected_value} but received #{actual_value}\n"
+                  end
+                end
+              end
+            end
+          end
+        end
+
         duration = Time.now - start_time
 
         {
@@ -536,8 +668,8 @@ module FeaturevisorCLI
       end
 
       def run_test_segment(assertion, segment, level)
-        context = parse_context(assertion["context"])
-        conditions = segment["conditions"]
+        context = parse_context(assertion[:context])
+        conditions = segment[:conditions]
 
         # Create a minimal datafile for segment testing
         datafile = {
@@ -549,7 +681,7 @@ module FeaturevisorCLI
 
         # Create SDK instance for segment testing
         instance = Featurevisor.create_instance(
-          datafile: symbolize_keys(datafile),
+          datafile: datafile,
           log_level: level
         )
 
@@ -557,8 +689,8 @@ module FeaturevisorCLI
         errors = ""
         start_time = Time.now
 
-        if assertion.key?("expectedToMatch")
-          expected_to_match = assertion["expectedToMatch"]
+        if assertion.key?(:expectedToMatch)
+          expected_to_match = assertion[:expectedToMatch]
           actual = instance.instance_variable_get(:@datafile_reader).all_conditions_are_matched(conditions, context)
 
           if actual != expected_to_match
@@ -593,16 +725,16 @@ module FeaturevisorCLI
             if value.is_a?(Hash)
               evaluated_feature = {}
 
-              if value.key?("enabled")
-                evaluated_feature[:enabled] = value["enabled"]
+              if value.key?(:enabled)
+                evaluated_feature[:enabled] = value[:enabled]
               end
 
-              if value.key?("variation")
-                evaluated_feature[:variation] = value["variation"]
+              if value.key?(:variation)
+                evaluated_feature[:variation] = value[:variation]
               end
 
-              if value["variables"] && value["variables"].is_a?(Hash)
-                evaluated_feature[:variables] = value["variables"].transform_keys(&:to_sym)
+              if value[:variables] && value[:variables].is_a?(Hash)
+                evaluated_feature[:variables] = value[:variables].transform_keys(&:to_sym)
               end
 
               sticky_features[key.to_sym] = evaluated_feature
@@ -618,51 +750,87 @@ module FeaturevisorCLI
       def create_override_options(assertion)
         options = {}
 
-        if assertion["defaultVariationValue"]
-          options[:default_variation_value] = assertion["defaultVariationValue"]
+        if assertion.key?(:defaultVariationValue)
+          options[:default_variation_value] = assertion[:defaultVariationValue]
         end
 
         options
       end
 
+      def evaluate_from_instance(instance, type, feature_key, context, override_options, variable_key = nil)
+        method_name = :"evaluate_#{type}"
+
+        if instance.respond_to?(method_name)
+          if variable_key.nil?
+            return instance.send(method_name, feature_key, context, override_options)
+          end
+
+          return instance.send(method_name, feature_key, variable_key, context, override_options)
+        end
+
+        if instance.respond_to?(:parent) && instance.respond_to?(:sticky)
+          parent = instance.parent
+          combined_context = if instance.respond_to?(:context)
+            { **(instance.context || {}), **context }
+          else
+            context
+          end
+
+          combined_options = {
+            sticky: instance.sticky,
+            **override_options
+          }
+
+          if variable_key.nil?
+            return parent.send(method_name, feature_key, combined_context, combined_options)
+          end
+
+          return parent.send(method_name, feature_key, variable_key, combined_context, combined_options)
+        end
+
+        {}
+      end
+
       def get_evaluation_value(evaluation, key)
         case key
-        when "type"
+        when :type
           evaluation[:type]
-        when "featureKey"
+        when :featureKey
           evaluation[:feature_key]
-        when "reason"
+        when :reason
           evaluation[:reason]
-        when "bucketKey"
+        when :bucketKey
           evaluation[:bucket_key]
-        when "bucketValue"
+        when :bucketValue
           evaluation[:bucket_value]
-        when "ruleKey"
+        when :ruleKey
           evaluation[:rule_key]
-        when "error"
+        when :error
           evaluation[:error]
-        when "enabled"
+        when :enabled
           evaluation[:enabled]
-        when "traffic"
+        when :traffic
           evaluation[:traffic]
-        when "forceIndex"
+        when :forceIndex
           evaluation[:force_index]
-        when "force"
+        when :force
           evaluation[:force]
-        when "required"
+        when :required
           evaluation[:required]
-        when "sticky"
+        when :sticky
           evaluation[:sticky]
-        when "variation"
+        when :variation
           evaluation[:variation]
-        when "variationValue"
+        when :variationValue
           evaluation[:variation_value]
-        when "variableKey"
+        when :variableKey
           evaluation[:variable_key]
-        when "variableValue"
+        when :variableValue
           evaluation[:variable_value]
-        when "variableSchema"
+        when :variableSchema
           evaluation[:variable_schema]
+        when :variableOverrideIndex
+          evaluation[:variable_override_index]
         else
           nil
         end
@@ -765,16 +933,7 @@ module FeaturevisorCLI
         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)