feat: implemented-new-in-and-fixed-remaining-tests

Author: Zaimwa9

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "spec/engine-test-data"]
 	path = spec/engine-test-data
 	url = [email protected]:Flagsmith/engine-test-data.git
-	branch = v3.1.0
+	branch = main

lib/flagsmith/engine/evaluation/core.rb

@@ -37,7 +37,6 @@ def evaluate_segments(evaluation_context)
 
           segments = identity_segments.map do |segment|
             result = {
-              key: segment[:key],
               name: segment[:name]
             }
 
@@ -103,9 +102,9 @@ def evaluate_features(evaluation_context, segment_overrides)
 
             # Set reason
             flag_result[:reason] = evaluated[:reason] ||
-                                   get_targeting_match_reason({ type: 'SEGMENT', override: segment_override })
+              get_targeting_match_reason({ type: 'SEGMENT', override: segment_override })
 
-            flags[final_feature[:name]] = flag_result
+            flags[final_feature[:name].to_sym] = flag_result
           end
 
           flags
@@ -153,7 +152,10 @@ def should_apply_override(override, existing_overrides)
         # @param evaluation_context [Hash] The evaluation context
         # @return [String, nil] The identity key or nil if no identity
         def get_identity_key(evaluation_context)
-          evaluation_context.dig(:identity, :key)
+          return nil unless evaluation_context[:identity]
+
+          evaluation_context[:identity][:key] ||
+            "#{evaluation_context[:environment][:key]}_#{evaluation_context[:identity][:identifier]}"
         end
 
         # returns boolean

lib/flagsmith/engine/segments/evaluator.rb

@@ -21,11 +21,14 @@ module Evaluator
         def get_identity_segments_from_context(context)
           return [] unless context[:identity] && context[:segments]
 
-          context[:segments].values.select do |segment|
+          matching_segments = context[:segments].values.select do |segment|
             next false if segment[:rules].nil? || segment[:rules].empty?
 
-            segment[:rules].all? { |rule| traits_match_segment_rule_from_context(rule, segment[:key], context) }
+            matches = segment[:rules].all? { |rule| traits_match_segment_rule_from_context(rule, segment[:key], context) }
+            matches
           end
+
+          matching_segments
         end
 
         # Model-based segment evaluation (existing approach)
@@ -190,15 +193,15 @@ def evaluate_rule_conditions(rule_type, condition_results)
         # @param context [Hash] The evaluation context
         # @return [Object, nil] The trait value or nil
         def get_trait_value(property, context)
-          # Check if it's a JSONPath expression
           if property.start_with?('$.')
             context_value = get_context_value(property, context)
-            return context_value unless non_primitive?(context_value)
+            if !context_value.nil? && !non_primitive?(context_value)
+              return context_value
+            end
           end
 
-          # Otherwise look in traits
           traits = context.dig(:identity, :traits) || {}
-          traits[property]
+          traits[property] || traits[property.to_sym]
         end
 
         # Get value from context using JSONPath-like syntax

lib/flagsmith/engine/segments/models.rb

@@ -45,7 +45,7 @@ class Condition
           CONTAINS => ->(other_value, self_value) { (other_value || false) && other_value.include?(self_value) },
 
           NOT_CONTAINS => ->(other_value, self_value) { (other_value || false) && !other_value.include?(self_value) },
-          REGEX => ->(other_value, self_value) { (other_value || false) && other_value.match?(self_value) }
+          REGEX => ->(other_value, self_value) { (other_value || false) && other_value.to_s.match?(self_value) }
         }.freeze
 
         def initialize(operator:, value:, property: nil)
@@ -55,11 +55,17 @@ def initialize(operator:, value:, property: nil)
         end
 
         def match_trait_value?(trait_value)
-          # handle some exceptions
-          trait_value = Semantic::Version.new(trait_value.gsub(/:semver$/, '')) if @value.is_a?(String) && @value.match?(/:semver$/)
+          if @value.is_a?(String) && @value.match?(/:semver$/)
+            begin
+              trait_value = Semantic::Version.new(trait_value.to_s.gsub(/:semver$/, ''))
+            rescue StandardError
+              return false
+            end
+          end
 
           return match_in_value(trait_value) if @operator == IN
           return match_modulo_value(trait_value) if @operator == MODULO
+          return MATCHING_FUNCTIONS[REGEX]&.call(trait_value, @value) if @operator == REGEX
 
           type_as_trait_value = format_to_type_of(trait_value)
           formatted_value = type_as_trait_value ? type_as_trait_value.call(@value) : @value
@@ -72,10 +78,17 @@ def format_to_type_of(input)
           {
             'String' => ->(v) { v.to_s },
             'Semantic::Version' => ->(v) { Semantic::Version.new(v.to_s.gsub(/:semver$/, '')) },
+            # Double check this is the desired behavior between SDKs
             'TrueClass' => ->(v) { ['True', 'true', 'TRUE', true, 1, '1'].include?(v) },
-            'FalseClass' => ->(v) { !['False', 'false', 'FALSE', false, 0, '0'].include?(v) },
-            'Integer' => ->(v) { v.to_i },
-            'Float' => ->(v) { v.to_f }
+            'FalseClass' => ->(v) { !['False', 'false', 'FALSE', false].include?(v) },
+            'Integer' => ->(v) {
+              i = v.to_i;
+              i.to_s == v.to_s ? i : v
+            },
+            'Float' => ->(v) {
+              f = v.to_f;
+              f.to_s == v.to_s ? f : v
+            }
           }[input.class.to_s]
         end
         # rubocop:enable Metrics/AbcSize
@@ -88,9 +101,23 @@ def match_modulo_value(trait_value)
         end
 
         def match_in_value(trait_value)
-          return @value.split(',').include?(trait_value.to_s) if trait_value.is_a?(String) || trait_value.is_a?(Integer)
+          return false if trait_value.nil? || trait_value.is_a?(TrueClass) || trait_value.is_a?(FalseClass)
 
-          false
+          if @value.is_a?(Array)
+            return @value.include?(trait_value.to_s)
+          end
+
+          if @value.is_a?(String)
+            begin
+              parsed = JSON.parse(@value)
+              if parsed.is_a?(Array)
+                return parsed.include?(trait_value.to_s)
+              end
+            rescue JSON::ParserError
+            end
+          end
+
+          @value.to_s.split(',').include?(trait_value.to_s)
         end
 
         class << self

spec/engine-test-data

@@ -40,6 +40,7 @@ def load_test_file(filepath)
 
         # TODO: Uncomment when evaluation is implemented
         expect(evaluation_result[:flags]).to eq(test_expected_result[:flags])
+        expect(evaluation_result[:segments]).to eq(test_expected_result[:segments])
       end
     end
   end