fix: sdk-uses-new-engine-methods

Author: Zaimwa9

lib/flagsmith.rb

@@ -217,15 +217,40 @@ def get_identity_segments(identifier, traits = {})
       end
 
       identity_model = get_identity_model(identifier, traits)
-      segment_models = engine.get_identity_segments(environment, identity_model)
-      segment_models.map { |sm| Flagsmith::Segments::Segment.new(id: sm.id, name: sm.name) }.compact
+
+      context = Flagsmith::Engine::EvaluationContext::Mappers.get_evaluation_context(
+        environment, identity_model
+      )
+
+      unless context
+        raise Flagsmith::ClientError,
+              'Local evaluation required to obtain identity segments'
+      end
+
+      evaluation_result = Flagsmith::Engine::Evaluation::Core.get_evaluation_result(context)
+
+      evaluation_result[:segments].map do |segment_result|
+        flagsmith_id = segment_result.dig(:metadata, :flagsmith_id)
+        next unless flagsmith_id
+
+        Flagsmith::Segments::Segment.new(id: flagsmith_id, name: segment_result[:name])
+      end.compact
     end
 
     private
 
     def environment_flags_from_document
-      Flagsmith::Flags::Collection.from_feature_state_models(
-        engine.get_environment_feature_states(environment),
+      context = Flagsmith::Engine::EvaluationContext::Mappers.get_evaluation_context(environment)
+
+      unless context
+        raise Flagsmith::ClientError,
+              'Unable to get flags. No environment present.'
+      end
+
+      evaluation_result = Flagsmith::Engine::Evaluation::Core.get_evaluation_result(context)
+
+      Flagsmith::Flags::Collection.from_evaluation_result(
+        evaluation_result,
         analytics_processor: analytics_processor,
         default_flag_handler: default_flag_handler,
         offline_handler: offline_handler
@@ -235,9 +260,19 @@ def environment_flags_from_document
     def get_identity_flags_from_document(identifier, traits = {})
       identity_model = get_identity_model(identifier, traits)
 
-      Flagsmith::Flags::Collection.from_feature_state_models(
-        engine.get_identity_feature_states(environment, identity_model),
-        identity_id: identity_model.composite_key,
+      context = Flagsmith::Engine::EvaluationContext::Mappers.get_evaluation_context(
+        environment, identity_model
+      )
+
+      unless context
+        raise Flagsmith::ClientError,
+              'Unable to get flags. No environment present.'
+      end
+
+      evaluation_result = Flagsmith::Engine::Evaluation::Core.get_evaluation_result(context)
+
+      Flagsmith::Flags::Collection.from_evaluation_result(
+        evaluation_result,
         analytics_processor: analytics_processor,
         default_flag_handler: default_flag_handler,
         offline_handler: offline_handler

lib/flagsmith/engine/core.rb

@@ -17,74 +17,11 @@
 module Flagsmith
   module Engine
     # Flags engine methods
+    # NOTE: This class is kept for backwards compatibility but no longer contains
+    # the old model-based evaluation methods. Use the context-based evaluation
+    # via Flagsmith::Engine::Evaluation::Core.get_evaluation_result instead.
     class Engine
       include Flagsmith::Engine::Segments::Evaluator
-
-      def get_identity_feature_state(environment, identity, feature_name, override_traits = nil)
-        feature_states = get_identity_feature_states_dict(environment, identity, override_traits).values
-
-        feature_state = feature_states.find { |f| f.feature.name == feature_name }
-
-        raise Flagsmith::FeatureStateNotFound, 'Feature State Not Found' if feature_state.nil?
-
-        feature_state
-      end
-
-      def get_identity_feature_states(environment, identity, override_traits = nil)
-        feature_states = get_identity_feature_states_dict(environment, identity, override_traits).values
-
-        return feature_states.select(&:enabled?) if environment.project.hide_disabled_flags
-
-        feature_states
-      end
-
-      def get_environment_feature_state(environment, feature_name)
-        features_state = environment.feature_states.find { |f| f.feature.name == feature_name }
-
-        raise Flagsmith::FeatureStateNotFound, 'Feature State Not Found' if features_state.nil?
-
-        features_state
-      end
-
-      def get_environment_feature_states(environment)
-        return environment.feature_states.select(&:enabled?) if environment.project.hide_disabled_flags
-
-        environment.feature_states
-      end
-
-      private
-
-      def get_identity_feature_states_dict(environment, identity, override_traits = nil)
-        # Get feature states from the environment
-        feature_states = {}
-        override = ->(fs) { feature_states[fs.feature.id] = fs }
-        environment.feature_states.each(&override)
-
-        override_by_matching_segments(environment, identity, override_traits) do |fs|
-          override.call(fs) unless higher_segment_priority?(feature_states, fs)
-        end
-
-        # Override with any feature states defined directly the identity
-        identity.identity_features.each(&override)
-        feature_states
-      end
-
-      # Override with any feature states defined by matching segments
-      def override_by_matching_segments(environment, identity, override_traits)
-        identity_segments = get_identity_segments(environment, identity, override_traits)
-        identity_segments.each do |matching_segment|
-          matching_segment.feature_states.each do |feature_state|
-            yield feature_state if block_given?
-          end
-        end
-      end
-
-      def higher_segment_priority?(collection, feature_state)
-        collection.key?(feature_state.feature.id) &&
-          collection[feature_state.feature.id].higher_segment_priority?(
-            feature_state
-          )
-      end
     end
   end
 end

lib/flagsmith/engine/evaluation/core.rb

@@ -33,7 +33,7 @@ def evaluate_segments(evaluation_context)
             return [], {}
           end
 
-          identity_segments = get_identity_segments_from_context(evaluation_context)
+          identity_segments = get_identity_segments(evaluation_context)
 
           segments = identity_segments.map do |segment|
             result = {

lib/flagsmith/engine/segments/evaluator.rb

@@ -13,12 +13,12 @@ module Evaluator
         include Flagsmith::Engine::Segments::Constants
         include Flagsmith::Engine::Utils::HashFunc
 
-        # Context-based segment evaluation (new approach)
+        # Context-based segment evaluation
         # 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_from_context(context)
+        def get_identity_segments(context)
           return [] unless context[:identity] && context[:segments]
 
           matching_segments = context[:segments].values.select do |segment|
@@ -31,13 +31,6 @@ def get_identity_segments_from_context(context)
           matching_segments
         end
 
-        # Model-based segment evaluation (existing approach)
-        def get_identity_segments(environment, identity, override_traits = nil)
-          environment.project.segments.select do |s|
-            evaluate_identity_in_segment(identity, s, override_traits)
-          end
-        end
-
         # Evaluates whether a given identity is in the provided segment.
         #
         # :param identity: identity model object to evaluate

lib/flagsmith/engine/segments/models.rb

@@ -103,6 +103,9 @@ 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)
 
+          # 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

lib/flagsmith/sdk/models/flags.rb

@@ -32,12 +32,13 @@ def initialize(enabled:, value:)
 
     # 'live' Flag class as returned by API or local evaluation
     class Flag < BaseFlag
-      attr_reader :feature_name, :feature_id
+      attr_reader :feature_name, :feature_id, :reason
 
-      def initialize(feature_name:, enabled:, value:, feature_id:)
+      def initialize(feature_name:, enabled:, value:, feature_id:, reason: nil)
         super(enabled: enabled, value: value, default: false)
         @feature_name = feature_name
         @feature_id = feature_id
+        @reason = reason
       end
 
       def <=>(other)
@@ -54,7 +55,8 @@ def to_h
           feature_name: feature_name,
           value: value,
           enabled: enabled,
-          default: default
+          default: default,
+          reason: reason
         }
       end
 
@@ -184,6 +186,31 @@ def from_feature_state_models(feature_states, identity_id: nil, **args)
           )
         end
 
+        def from_evaluation_result(evaluation_result, **args)
+          to_flag_object = lambda { |flag_result, acc|
+            flagsmith_id = flag_result.dig(:metadata, :flagsmith_id)
+
+            if flagsmith_id.nil?
+              raise Flagsmith::ClientError,
+                    "FlagResult metadata.flagsmith_id is missing for feature \"#{flag_result[:name]}\". " \
+                    "This indicates a bug in the SDK, please report it."
+            end
+
+            acc[normalize_key(flag_result[:name])] = Flagsmith::Flags::Flag.new(
+              feature_name: flag_result[:name],
+              enabled: flag_result[:enabled],
+              value: flag_result[:value],
+              feature_id: flagsmith_id,
+              reason: flag_result[:reason]
+            )
+          }
+
+          new(
+            evaluation_result[:flags].each_value.each_with_object({}, &to_flag_object),
+            **args
+          )
+        end
+
         def normalize_key(key)
           key.to_s.downcase
         end

spec/engine-test-data

@@ -8,8 +8,6 @@ def get_test_files
 end
 
 def parse_jsonc(content)
-  # Simple JSONC parser: remove single-line comments
-  # JSON.parse will handle the rest
   cleaned = content.lines.reject { |line| line.strip.start_with?('//') }.join
   JSON.parse(cleaned, symbolize_names: true)
 end
@@ -34,11 +32,8 @@ def load_test_file(filepath)
         test_evaluation_context = test_case[:context]
         test_expected_result = test_case[:result]
 
-        # TODO: Implement evaluation logic
         evaluation_result = Flagsmith::Engine::Evaluation::Core.get_evaluation_result(test_evaluation_context)
 
-
-        # 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