featurevisor 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 984dcbada7b55c304a639cf58935c7b1dd561db2d6159b178a3829709473925a
-  data.tar.gz: 2a4068e17a151e671b45befb743be0935b19432e91411a243e2b3f8cbfa2c1e2
+  metadata.gz: 42c8ec3e5bf6293eeae189365b0383588a8cf7fdd5a5ee249a6fd44a2676403c
+  data.tar.gz: ce5794865b3dd5a057b9e0841814dab1c276b52237f230e23da6317f8dea3f70
 SHA512:
-  metadata.gz: b813718a6962bd78a1142e5cd7758c3a0ea176d6fc8943114bfb6c630ece7e2dc160281ec7ca661d9de012366ba7b1e3ceeff9af6f6e7bfcdc4b53d89e3ac04b
-  data.tar.gz: 3fcc3e23b3b773c7780e5d018679c74a453e263797342b0912b02c74d634d60b4029c7e042f74225ba6550d7f293ab9819ff657f51a318f90a026b145fc896bb
+  metadata.gz: 41aefa056806a97bc1f5bf13d847007fd4b38fb176f97d1a09868434644fda2ed8cd58698ad9f5002a6ef5d30f7fc105accf7d505eb41fb71abe28a5bda6e47c
+  data.tar.gz: e4376d46699b8fe730d4dc4f73890fd43c6e879c446bc484dc6a47cc6b2c31f715af41b83b5f6189f9b8eeed3fd61b48213ec589855d909fe7ebccb702c04303

data/README.md

@@ -41,6 +41,7 @@ This SDK is compatible with [Featurevisor](https://featurevisor.com/) v2.0 proje
 - [Close](#close)
 - [CLI usage](#cli-usage)
   - [Test](#test)
+  - [Test against local monorepo's example-1](#test-against-local-monorepos-example-1)
   - [Benchmark](#benchmark)
   - [Assess distribution](#assess-distribution)
 - [Development](#development)
@@ -49,6 +50,8 @@ This SDK is compatible with [Featurevisor](https://featurevisor.com/) v2.0 proje
   - [Releasing](#releasing)
 - [License](#license)
 
+<!-- FEATUREVISOR_DOCS_BEGIN -->
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -381,7 +384,7 @@ require 'json'
 def update_datafile(f, datafile_url)
   loop do
     sleep(5 * 60) # 5 minutes
-    
+
     begin
       response = Net::HTTP.get_response(URI(datafile_url))
       datafile_content = JSON.parse(response.body)
@@ -681,10 +684,27 @@ Additional options that are available:
 ```bash
 $ bundle exec featurevisor test \
   --projectDirectoryPath="/absolute/path/to/your/featurevisor/project" \
-  --quiet|verbose \
+  --quiet|--verbose \
   --onlyFailures \
   --keyPattern="myFeatureKey" \
-  --assertionPattern="#1"
+  --assertionPattern="#1" \
+  --with-scopes \
+  --with-tags
+```
+
+`--with-scopes` and `--with-tags` make the Ruby test runner build scoped/tagged datafiles in memory (via `npx featurevisor build --json`) and evaluate matching assertions against those exact datafiles.
+
+If an assertion references `scope` and `--with-scopes` is not provided, the runner still evaluates the assertion by merging that scope's configured context into the assertion context (without building scoped datafiles).
+
+For compatibility, camelCase aliases are also supported: `--withScopes` and `--withTags`.
+
+### Test against local monorepo's example-1
+
+```bash
+$ cd /absolute/path/to/featurevisor-ruby
+$ bundle exec featurevisor test --projectDirectoryPath=./monorepo/examples/example-1
+$ bundle exec featurevisor test --projectDirectoryPath=./monorepo/examples/example-1 --with-scopes
+$ bundle exec featurevisor test --projectDirectoryPath=./monorepo/examples/example-1 --with-tags
 ```
 
 ### Benchmark
@@ -716,6 +736,8 @@ $ bundle exec featurevisor assess-distribution \
   --n=1000
 ```
 
+<!-- FEATUREVISOR_DOCS_END -->
+
 ## Development
 
 ### Setting up

data/bin/cli.rb

@@ -7,7 +7,7 @@ module FeaturevisorCLI
     attr_accessor :command, :assertion_pattern, :context, :environment, :feature,
                  :key_pattern, :n, :only_failures, :quiet, :variable, :variation,
                  :verbose, :inflate, :show_datafile, :schema_version, :project_directory_path,
-                 :populate_uuid
+                 :populate_uuid, :with_scopes, :with_tags
 
     def initialize
       @n = 1000
@@ -86,6 +86,14 @@ module FeaturevisorCLI
           options.schema_version = v
         end
 
+        opts.on("--with-scopes", "--withScopes", "Test scoped assertions against scoped datafiles") do
+          options.with_scopes = true
+        end
+
+        opts.on("--with-tags", "--withTags", "Test tagged assertions against tagged datafiles") do
+          options.with_tags = true
+        end
+
         opts.on("--projectDirectoryPath=PATH", "Project directory path") do |v|
           options.project_directory_path = v
         end

data/bin/commands/test.rb

@@ -1,6 +1,7 @@
 require "json"
 require "find"
 require "open3"
+require "shellwords"
 
 module FeaturevisorCLI
   module Commands
@@ -19,7 +20,7 @@ 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
@@ -28,8 +29,8 @@ module FeaturevisorCLI
           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,18 +43,15 @@ 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
@@ -67,7 +65,7 @@ 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
@@ -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, symbolize_names: true)
-            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
+
+        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
 
-        datafiles_by_environment
+        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,17 +202,17 @@ 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
@@ -155,31 +224,58 @@ 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]
-
-          # Create SDK instance
-          instance = Featurevisor.create_instance(
-            datafile: datafile,
-            log_level: level,
-            hooks: [
-              {
-                name: "tester-hook",
-                bucket_value: ->(options) { options.bucket_value }
-              }
-            ]
-          )
+        scope = config[:scopes].find { |s| s[:name] == scope_name }
+        return {} unless scope && scope[:context].is_a?(Hash)
+
+        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
@@ -197,43 +293,33 @@ module FeaturevisorCLI
               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 ""
+                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]
-
-                  instance = Featurevisor.create_instance(
-                    datafile: 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
+
+                  # 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)
+                  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]
@@ -280,8 +366,9 @@ module FeaturevisorCLI
         end
       end
 
-      def run_test_feature(assertion, feature_key, instance, level)
+      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
@@ -325,7 +412,7 @@ module FeaturevisorCLI
           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]
+            if assertion[:defaultVariableValues].is_a?(Hash) && assertion[:defaultVariableValues].key?(variable_key)
               override_options[:default_variable_value] = assertion[:defaultVariableValues][variable_key]
             end
 
@@ -483,7 +570,7 @@ module FeaturevisorCLI
           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]
+            if assertion[:defaultVariableValues].is_a?(Hash) && assertion[:defaultVariableValues].key?(variable_key)
               override_options[:default_variable_value] = assertion[:defaultVariableValues][variable_key]
             end
 
@@ -522,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
 
         {
@@ -614,13 +750,47 @@ module FeaturevisorCLI
       def create_override_options(assertion)
         options = {}
 
-        if 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
@@ -659,6 +829,8 @@ module FeaturevisorCLI
           evaluation[:variable_value]
         when :variableSchema
           evaluation[:variable_schema]
+        when :variableOverrideIndex
+          evaluation[:variable_override_index]
         else
           nil
         end

data/lib/featurevisor/evaluate.rb

@@ -17,7 +17,8 @@ module Featurevisor
     VARIABLE_NOT_FOUND = "variable_not_found" # variable's schema is not defined in the feature
     VARIABLE_DEFAULT = "variable_default" # default variable value used
     VARIABLE_DISABLED = "variable_disabled" # feature is disabled, and variable's disabledValue is used
-    VARIABLE_OVERRIDE = "variable_override" # variable overridden from inside a variation
+    VARIABLE_OVERRIDE_VARIATION = "variable_override_variation" # variable overridden from inside a variation
+    VARIABLE_OVERRIDE_RULE = "variable_override_rule" # variable overridden from inside a rule
 
     # Common
     NO_MATCH = "no_match" # no rules matched
@@ -55,14 +56,14 @@ module Featurevisor
         evaluation = evaluate(result_options)
 
         # Default: variation
-        if options[:default_variation_value] &&
+        if options.key?(:default_variation_value) &&
            evaluation[:type] == "variation" &&
            evaluation[:variation_value].nil?
           evaluation[:variation_value] = options[:default_variation_value]
         end
 
         # Default: variable
-        if options[:default_variable_value] &&
+        if options.key?(:default_variable_value) &&
            evaluation[:type] == "variable" &&
            evaluation[:variable_value].nil?
           evaluation[:variable_value] = options[:default_variable_value]
@@ -132,10 +133,10 @@ module Featurevisor
             if type == "variable"
               if feature && variable_key &&
                  feature[:variablesSchema] &&
-                 (feature[:variablesSchema][variable_key] || feature[:variablesSchema][variable_key.to_sym])
-                variable_schema = feature[:variablesSchema][variable_key] || feature[:variablesSchema][variable_key.to_sym]
+                 has_key?(feature[:variablesSchema], variable_key)
+                variable_schema = fetch_with_symbol_key(feature[:variablesSchema], variable_key)
 
-                if variable_schema[:disabledValue]
+                if variable_schema.key?(:disabledValue)
                   # disabledValue: <value>
                   evaluation = {
                     type: type,
@@ -179,8 +180,8 @@ module Featurevisor
         end
 
         # Sticky
-        if sticky && (sticky[feature_key] || sticky[feature_key.to_sym])
-          sticky_feature = sticky[feature_key] || sticky[feature_key.to_sym]
+        if sticky && has_key?(sticky, feature_key)
+          sticky_feature = fetch_with_symbol_key(sticky, feature_key)
 
           # flag
           if type == "flag" && sticky_feature.key?(:enabled)
@@ -201,7 +202,7 @@ module Featurevisor
           if type == "variation"
             variation_value = sticky_feature[:variation]
 
-            if variation_value
+            unless variation_value.nil?
               evaluation = {
                 type: type,
                 feature_key: feature_key,
@@ -219,8 +220,8 @@ module Featurevisor
           if type == "variable" && variable_key
             variables = sticky_feature[:variables]
 
-            if variables && (variables[variable_key] || variables[variable_key.to_sym])
-              variable_value = variables[variable_key] || variables[variable_key.to_sym]
+            if variables && has_key?(variables, variable_key)
+              variable_value = fetch_with_symbol_key(variables, variable_key)
               evaluation = {
                 type: type,
                 feature_key: feature_key,
@@ -261,8 +262,8 @@ module Featurevisor
         variable_schema = nil
 
         if variable_key
-          if feature[:variablesSchema] && (feature[:variablesSchema][variable_key] || feature[:variablesSchema][variable_key.to_sym])
-            variable_schema = feature[:variablesSchema][variable_key] || feature[:variablesSchema][variable_key.to_sym]
+          if feature[:variablesSchema] && has_key?(feature[:variablesSchema], variable_key)
+            variable_schema = fetch_with_symbol_key(feature[:variablesSchema], variable_key)
           end
 
           # variable schema not found
@@ -343,8 +344,8 @@ module Featurevisor
           end
 
           # variable
-          if variable_key && force[:variables] && (force[:variables][variable_key] || force[:variables][variable_key.to_sym])
-            variable_value = force[:variables][variable_key] || force[:variables][variable_key.to_sym]
+          if variable_key && force[:variables] && has_key?(force[:variables], variable_key)
+            variable_value = fetch_with_symbol_key(force[:variables], variable_key)
             evaluation = {
               type: type,
               feature_key: feature_key,
@@ -385,8 +386,8 @@ module Featurevisor
 
               required_variation_value = nil
 
-              if required_variation_evaluation[:variation_value]
-                required_variation_value = required_variation_evaluation[:variation_value]
+              if has_key?(required_variation_evaluation, :variation_value)
+                required_variation_value = fetch_with_symbol_key(required_variation_evaluation, :variation_value)
               elsif required_variation_evaluation[:variation]
                 required_variation_value = required_variation_evaluation[:variation][:value]
               end
@@ -601,10 +602,50 @@ module Featurevisor
         # variable
         if type == "variable" && variable_key
           # override from rule
+          if matched_traffic &&
+             matched_traffic[:variableOverrides] &&
+             has_key?(matched_traffic[:variableOverrides], variable_key)
+            overrides = fetch_with_symbol_key(matched_traffic[:variableOverrides], variable_key)
+
+            override_index = overrides.find_index do |o|
+              if o[:conditions]
+                conditions = o[:conditions].is_a?(String) && o[:conditions] != "*" ? JSON.parse(o[:conditions]) : o[:conditions]
+                datafile_reader.all_conditions_are_matched(conditions, context)
+              elsif o[:segments]
+                segments = datafile_reader.parse_segments_if_stringified(o[:segments])
+                datafile_reader.all_segments_are_matched(segments, context)
+              else
+                false
+              end
+            end
+
+            unless override_index.nil?
+              override = overrides[override_index]
+
+              evaluation = {
+                type: type,
+                feature_key: feature_key,
+                reason: Featurevisor::EvaluationReason::VARIABLE_OVERRIDE_RULE,
+                bucket_key: bucket_key,
+                bucket_value: bucket_value,
+                rule_key: matched_traffic[:key],
+                traffic: matched_traffic,
+                variable_key: variable_key,
+                variable_schema: variable_schema,
+                variable_value: override[:value],
+                variable_override_index: override_index
+              }
+
+              logger.debug("variable override from rule", evaluation)
+
+              return evaluation
+            end
+          end
+
           if matched_traffic &&
              matched_traffic[:variables] &&
-             (matched_traffic[:variables][variable_key] || matched_traffic[:variables][variable_key.to_sym])
-            variable_value = matched_traffic[:variables][variable_key] || matched_traffic[:variables][variable_key.to_sym]
+             has_key?(matched_traffic[:variables], variable_key)
+            variable_value = fetch_with_symbol_key(matched_traffic[:variables], variable_key)
             evaluation = {
               type: type,
               feature_key: feature_key,
@@ -637,81 +678,38 @@ module Featurevisor
           if variation_value && feature[:variations].is_a?(Array)
             variation = feature[:variations].find { |v| v[:value] == variation_value }
 
-            if variation && variation[:variableOverrides] && (variation[:variableOverrides][variable_key] || variation[:variableOverrides][variable_key.to_sym])
-              overrides = variation[:variableOverrides][variable_key] || variation[:variableOverrides][variable_key.to_sym]
+            if variation && variation[:variableOverrides] && has_key?(variation[:variableOverrides], variable_key)
+              overrides = fetch_with_symbol_key(variation[:variableOverrides], variable_key)
 
-              logger.debug("checking variableOverrides", {
-                feature_key: feature_key,
-                variable_key: variable_key,
-                overrides: overrides,
-                context: context
-              })
-
-              override = overrides.find do |o|
-                logger.debug("evaluating override", {
-                  feature_key: feature_key,
-                  variable_key: variable_key,
-                  override: o,
-                  context: context
-                })
-
-                result = if o[:conditions]
-                  matched = datafile_reader.all_conditions_are_matched(
-                    o[:conditions].is_a?(String) && o[:conditions] != "*" ?
-                      JSON.parse(o[:conditions]) : o[:conditions],
-                    context
-                  )
-                  logger.debug("conditions match result", {
-                    feature_key: feature_key,
-                    variable_key: variable_key,
-                    conditions: o[:conditions],
-                    matched: matched
-                  })
-                  matched
+              override_index = overrides.find_index do |o|
+                if o[:conditions]
+                  conditions = o[:conditions].is_a?(String) && o[:conditions] != "*" ? JSON.parse(o[:conditions]) : o[:conditions]
+                  datafile_reader.all_conditions_are_matched(conditions, context)
                 elsif o[:segments]
                   segments = datafile_reader.parse_segments_if_stringified(o[:segments])
-                  matched = datafile_reader.all_segments_are_matched(segments, context)
-                  logger.debug("segments match result", {
-                    feature_key: feature_key,
-                    variable_key: variable_key,
-                    segments: o[:segments],
-                    parsed_segments: segments,
-                    matched: matched
-                  })
-                  matched
+                  datafile_reader.all_segments_are_matched(segments, context)
                 else
-                  logger.debug("override has no conditions or segments", {
-                    feature_key: feature_key,
-                    variable_key: variable_key,
-                    override: o
-                  })
                   false
                 end
-
-                logger.debug("override evaluation result", {
-                  feature_key: feature_key,
-                  variable_key: variable_key,
-                  result: result
-                })
-
-                result
               end
 
-              if override
+              unless override_index.nil?
+                override = overrides[override_index]
                 evaluation = {
                   type: type,
                   feature_key: feature_key,
-                  reason: Featurevisor::EvaluationReason::VARIABLE_OVERRIDE,
+                  reason: Featurevisor::EvaluationReason::VARIABLE_OVERRIDE_VARIATION,
                   bucket_key: bucket_key,
                   bucket_value: bucket_value,
                   rule_key: matched_traffic&.[](:key),
                   traffic: matched_traffic,
                   variable_key: variable_key,
                   variable_schema: variable_schema,
-                  variable_value: override[:value]
+                  variable_value: override[:value],
+                  variable_override_index: override_index
                 }
 
-                logger.debug("variable override", evaluation)
+                logger.debug("variable override from variation", evaluation)
 
                 return evaluation
               end
@@ -719,8 +717,8 @@ module Featurevisor
 
             if variation &&
                variation[:variables] &&
-               (variation[:variables][variable_key] || variation[:variables][variable_key.to_sym])
-              variable_value = variation[:variables][variable_key] || variation[:variables][variable_key.to_sym]
+               has_key?(variation[:variables], variable_key)
+              variable_value = fetch_with_symbol_key(variation[:variables], variable_key)
               evaluation = {
                 type: type,
                 feature_key: feature_key,
@@ -814,5 +812,20 @@ module Featurevisor
         evaluation
       end
     end
+
+    def self.fetch_with_symbol_key(obj, key)
+      return obj[key] if obj.is_a?(Hash) && obj.key?(key)
+
+      symbol_key = key.to_sym
+      return obj[symbol_key] if obj.is_a?(Hash) && obj.key?(symbol_key)
+
+      nil
+    end
+
+    def self.has_key?(obj, key)
+      return false unless obj.is_a?(Hash)
+
+      obj.key?(key) || obj.key?(key.to_sym)
+    end
   end
 end

data/lib/featurevisor/version.rb

@@ -1,3 +1,3 @@
 module Featurevisor
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: featurevisor
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Fahad Heylaal