updates

Author: fahad19

bin/commands/assess_distribution.rb

@@ -78,9 +78,9 @@ def run
           # Evaluate flag
           flag_evaluation = instance.is_enabled(@options.feature, context_copy)
           if flag_evaluation
-            flag_evaluations["enabled"] += 1
+            flag_evaluations[:enabled] += 1
           else
-            flag_evaluations["disabled"] += 1
+            flag_evaluations[:disabled] += 1
           end
 
           # Evaluate variation if feature has variations

bin/commands/test.rb

@@ -246,12 +246,12 @@ def run_tests(tests, sdk_instances_by_environment, datafiles_by_environment, seg
                 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
@@ -448,7 +448,7 @@ def run_test_feature(assertion, feature_key, instance, level)
       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
@@ -623,41 +623,41 @@ def create_override_options(assertion)
 
       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]
         else
           nil

lib/featurevisor/conditions.rb

@@ -53,12 +53,12 @@ def self.condition_is_matched(condition, context, get_regex)
         if value.is_a?(Array) && (context_value_from_path.is_a?(String) || context_value_from_path.is_a?(Numeric) || context_value_from_path.nil?)
           # Check if the attribute key actually exists in the context
           key_exists = context.key?(attribute.to_sym) || context.key?(attribute.to_s)
-          
+
           # If key doesn't exist, notIn should fail (return false), in should also fail
           if !key_exists
             return false
           end
-          
+
           value_in_context = context_value_from_path.to_s
 
           if operator == "in"

lib/featurevisor/datafile_reader.rb

@@ -183,6 +183,8 @@ def all_conditions_are_matched(conditions, context)
         end
       end
 
+
+
       if conditions.is_a?(Array)
         return conditions.all? { |c| all_conditions_are_matched(c, context) }
       end
@@ -245,6 +247,8 @@ def all_segments_are_matched(group_segments, context)
             all_segments_are_matched({ "and" => group_segments["not"] }, context) == false
           end
         end
+
+
       end
 
       if group_segments.is_a?(Array)