feat: rebased

Author: Zaimwa9

lib/flagsmith.rb

@@ -218,7 +218,7 @@ def get_identity_segments(identifier, traits = {})
 
       identity_model = get_identity_model(identifier, traits)
 
-      context = Flagsmith::Engine::EvaluationContext::Mappers.get_evaluation_context(
+      context = Flagsmith::Engine::Evaluation::Mappers.get_evaluation_context(
         environment, identity_model
       )
 
@@ -240,7 +240,7 @@ def get_identity_segments(identifier, traits = {})
     private
 
     def environment_flags_from_document
-      context = Flagsmith::Engine::EvaluationContext::Mappers.get_evaluation_context(environment)
+      context = Flagsmith::Engine::Evaluation::Mappers.get_evaluation_context(environment)
 
       unless context
         raise Flagsmith::ClientError,
@@ -260,7 +260,7 @@ def environment_flags_from_document
     def get_identity_flags_from_document(identifier, traits = {})
       identity_model = get_identity_model(identifier, traits)
 
-      context = Flagsmith::Engine::EvaluationContext::Mappers.get_evaluation_context(
+      context = Flagsmith::Engine::Evaluation::Mappers.get_evaluation_context(
         environment, identity_model
       )
 

lib/flagsmith/engine/evaluation/core.rb

@@ -23,15 +23,13 @@ def get_evaluation_result(evaluation_context)
           flags = evaluate_features(evaluation_context, segment_overrides)
           {
             flags: flags,
-            segments: segments,
+            segments: segments
           }
         end
 
         # Returns { segments: EvaluationResultSegments; segmentOverrides: Record<string, SegmentOverride>; }
         def evaluate_segments(evaluation_context)
-          if evaluation_context[:identity].nil? || evaluation_context[:segments].nil?
-            return [], {}
-          end
+          return [], {} if evaluation_context[:identity].nil? || evaluation_context[:segments].nil?
 
           identity_segments = get_identity_segments(evaluation_context)
 
@@ -40,16 +38,14 @@ def evaluate_segments(evaluation_context)
               name: segment[:name]
             }
 
-            if segment[:metadata]
-              result[:metadata] = segment[:metadata].dup
-            end
+            result[:metadata] = segment[:metadata].dup if segment[:metadata]
 
             result
           end
 
           segment_overrides = process_segment_overrides(identity_segments)
 
-          return segments, segment_overrides
+          [segments, segment_overrides]
         end
 
         # Returns Record<string: override.name, SegmentOverride>
@@ -62,12 +58,12 @@ def process_segment_overrides(identity_segments)
             overrides_list = segment[:overrides].is_a?(Array) ? segment[:overrides] : []
 
             overrides_list.each do |override|
-              if should_apply_override(override, segment_overrides)
-                segment_overrides[override[:name]] = {
-                  feature: override,
-                  segment_name: segment[:name]
-                }
-              end
+              next unless should_apply_override(override, segment_overrides)
+
+              segment_overrides[override[:name]] = {
+                feature: override,
+                segment_name: segment[:name]
+              }
             end
           end
 
@@ -102,7 +98,7 @@ 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].to_sym] = flag_result
           end
@@ -112,9 +108,7 @@ def evaluate_features(evaluation_context, segment_overrides)
 
         # Returns {value: any; reason?: string}
         def evaluate_feature_value(feature, identity_key = nil)
-          if feature[:variants]&.any? && identity_key
-            return get_multivariate_feature_value(feature, identity_key)
-          end
+          return get_multivariate_feature_value(feature, identity_key) if feature[:variants]&.any? && identity_key
 
           { value: feature[:value], reason: nil }
         end

lib/flagsmith/engine/evaluation/mappers.rb

@@ -2,7 +2,7 @@
 
 module Flagsmith
   module Engine
-    module EvaluationContext
+    module Evaluation
       module Mappers
         STRONGEST_PRIORITY = Float::INFINITY
         WEAKEST_PRIORITY = -Float::INFINITY
@@ -55,7 +55,8 @@ def self.map_environment_model_to_evaluation_context(environment)
             }
 
             feature_hash[:variants] = variants if variants
-            feature_hash[:priority] = fs.feature_segment.priority if fs.feature_segment&.priority
+            priority = fs.feature_segment&.priority
+            feature_hash[:priority] = priority unless priority.nil?
             feature_hash[:metadata] = { flagsmith_id: fs.feature.id }
 
             features[fs.feature.name] = feature_hash
@@ -138,17 +139,9 @@ def self.map_segment_rule_model_to_rule(rule)
           }
 
           # Map conditions if present
-          result[:conditions] = if rule.conditions&.any?
-                                  rule.conditions.map do |condition|
-                                    {
-                                      property: condition.property,
-                                      operator: condition.operator,
-                                      value: condition.value
-                                    }
-                                  end
-                                else
-                                  []
-                                end
+          result[:conditions] = (rule.conditions || []).map do |condition|
+            { property: condition.property, operator: condition.operator, value: condition.value }
+          end
 
           result[:rules] = if rule.rules&.any?
                              rule.rules.map { |nested_rule| map_segment_rule_model_to_rule(nested_rule) }
@@ -188,7 +181,7 @@ def self.map_identity_overrides_to_segments(identity_overrides)
             end
 
             # Create hash of the overrides to group identities with same overrides
-            overrides_hash = overrides_key.hash
+            overrides_hash = Digest::SHA1.hexdigest(overrides_key.inspect)
 
             features_to_identifiers[overrides_hash] ||= { identifiers: [], overrides: overrides_key }
             features_to_identifiers[overrides_hash][:identifiers] << identity.identifier

lib/flagsmith/engine/segments/evaluator.rb

@@ -11,26 +11,24 @@ module Engine
     module Segments
       # Evaluator methods
       module Evaluator
-        extend self
         include Flagsmith::Engine::Segments::Constants
         include Flagsmith::Engine::Utils::HashFunc
 
-        # Context-based segment evaluation
+        module_function
+        # Context-based segment evaluation (new approach)
         # Returns all segments that the identity belongs to based on segment rules evaluation
         #
         # @param context [Hash] Evaluation context containing identity and segment definitions
         # @return [Array<Hash>] Array of segments that the identity matches
         def get_identity_segments(context)
           return [] unless context[:identity] && context[:segments]
 
-          matching_segments = context[:segments].values.select do |segment|
+          context[:segments].values.select do |segment|
             next false if segment[:rules].nil? || segment[:rules].empty?
 
             matches = segment[:rules].all? { |rule| traits_match_segment_rule_from_context(rule, segment[:key], context) }
             matches
           end
-
-          matching_segments
         end
 
         # Context-based helper functions
@@ -55,7 +53,7 @@ def traits_match_segment_rule_from_context(rule, segment_key, context)
         # @param context [Hash] The evaluation context
         # @return [Boolean] True if conditions match according to rule type
         def evaluate_conditions_from_context(rule, segment_key, context)
-          return true if rule[:conditions].nil? || rule[:conditions].empty?
+          return true unless rule[:conditions]&.any?
 
           condition_results = rule[:conditions].map do |condition|
             traits_match_segment_condition_from_context(condition, segment_key, context)
@@ -93,10 +91,10 @@ def traits_match_segment_condition_from_context(condition, segment_key, context)
 
           return false if condition[:property].nil?
           trait_value = get_trait_value(condition[:property], context)
-          return trait_value != nil if condition[:operator] == IS_SET
+          return !trait_value.nil? if condition[:operator] == IS_SET
           return trait_value.nil? if condition[:operator] == IS_NOT_SET
 
-          if !trait_value.nil?
+          unless trait_value.nil?
             # Reuse existing Condition class logic
             condition_obj = Flagsmith::Engine::Segments::Condition.new(
               operator: condition[:operator],
@@ -135,9 +133,7 @@ def evaluate_rule_conditions(rule_type, condition_results)
         def get_trait_value(property, context)
           if property.start_with?('$.')
             context_value = get_context_value(property, context)
-            if !context_value.nil? && !non_primitive?(context_value)
-              return context_value
-            end
+            return context_value if !context_value.nil? && !non_primitive?(context_value)
           end
 
           traits = context.dig(:identity, :traits) || {}

lib/flagsmith/engine/segments/models.rb

@@ -58,7 +58,7 @@ def match_trait_value?(trait_value)
           if @value.is_a?(String) && @value.match?(/:semver$/)
             begin
               trait_value = Semantic::Version.new(trait_value.to_s.gsub(/:semver$/, ''))
-            rescue StandardError
+            rescue ArgumentError, Semantic::Version::ValidationFailed => _e
               return false
             end
           end
@@ -81,12 +81,12 @@ def format_to_type_of(input)
             # 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].include?(v) },
-            'Integer' => ->(v) {
-              i = v.to_i;
+            'Integer' => lambda { |v|
+              i = v.to_i
               i.to_s == v.to_s ? i : v
             },
-            'Float' => ->(v) {
-              f = v.to_f;
+            'Float' => lambda { |v|
+              f = v.to_f
               f.to_s == v.to_s ? f : v
             }
           }[input.class.to_s]
@@ -103,19 +103,21 @@ def match_modulo_value(trait_value)
         def match_in_value(trait_value)
           return false if trait_value.nil? || trait_value.is_a?(TrueClass) || trait_value.is_a?(FalseClass)
 
+<<<<<<< HEAD
           # Floats/doubles are not supported by the engine due to ambiguous serialization across supported platforms. (segments/models_spec.rb)
           return false unless trait_value.is_a?(String) || trait_value.is_a?(Integer)
 
           if @value.is_a?(Array)
             return @value.include?(trait_value.to_s)
           end
+=======
+          return @value.include?(trait_value.to_s) if @value.is_a?(Array)
+>>>>>>> 6a6a129d14a0f15bbf3252a2c6b539681dfa7e85
 
           if @value.is_a?(String)
             begin
               parsed = JSON.parse(@value)
-              if parsed.is_a?(Array)
-                return parsed.include?(trait_value.to_s)
-              end
+              return parsed.include?(trait_value.to_s) if parsed.is_a?(Array)
             rescue JSON::ParserError
             end
           end

spec/engine/unit/evaluation_context_mappers_spec.rb

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-RSpec.describe Flagsmith::Engine::EvaluationContext::Mappers do
+RSpec.describe Flagsmith::Engine::Evaluation::Mappers do
   describe '.get_evaluation_context' do
     let(:environment_json) do
       JSON.parse(
@@ -72,7 +72,7 @@
       expect(override[:name]).to eq('some_feature')
       expect(override[:enabled]).to be false
       expect(override[:value]).to eq('some-overridden-value')
-      expect(override[:priority]).to eq(Flagsmith::Engine::EvaluationContext::Mappers::STRONGEST_PRIORITY)
+      expect(override[:priority]).to eq(Flagsmith::Engine::Evaluation::Mappers::STRONGEST_PRIORITY)
       expect(override[:metadata][:flagsmith_id]).to eq(1)
 
       # Verify features