feat: added-engine-function-signatures

Author: Zaimwa9

dev_test.rb

@@ -3,12 +3,13 @@
 module Flagsmith
   module Engine
     module Evaluation
+      # Core evaluation logic module
       module Core
         # Get evaluation result from evaluation context
         #
         # @param evaluation_context [Hash] The evaluation context
         # @return [Hash] Evaluation result with flags and segments
-        def self.get_evaluation_result(evaluation_context)
+        def self.get_evaluation_result(_evaluation_context)
           # TODO: Implement core evaluation logic
           {
             flags: {},

lib/flagsmith/engine/evaluation/core.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Flagsmith
+  module Engine
+    module Evaluation
+      class Engine
+        # returns EvaluationResultWithMetadata
+        def get_evaluation_result(_evaluation_context)
+          {
+            flags: {},
+            segments: []
+          }
+        end
+
+        # Returns { segments: EvaluationResultSegments; segmentOverrides: Record<string, SegmentOverride>; }
+        def evaluate_segments(evaluation_context); end
+
+        # Returns Record<string: override.nae, SegmentOverride>
+        def process_segment_overrides(identity_segments); end
+
+        # returns EvaluationResultFlags<Metadata>
+        def evalute_features(evaluation_context, segment_overrides); end
+
+        # Returns {value: any; reason?: string}
+        def evaluate_feature_value(feature, identity_key); end
+
+        # Returns {value: any; reason?: string}
+        def get_multivariate_feature_value(feature, identity_key); end
+
+        # returns boolean
+        def should_apply_override(override, existing_overrides); end
+
+        private
+
+        # returns boolean
+        def higher_priority?(priority_a, priority_b)
+          priority_a || priority_b > Float::INFINITY || Float::INFINITY
+        end
+
+        def get_targeting_match_reason(match_object)
+          type = match_object.type
+
+          if type == 'SEGMENT'
+            return match_object.override ? "TARGETING_MATCH; segment=#{match_object.override.segment_name}" : 'DEFAULT'
+          end
+
+          return "SPLIT; weight=#{match_object.weight}" if type == 'SPLIT'
+
+          'DEFAULT'
+        end
+      end
+    end
+  end
+end

lib/flagsmith/engine/evaluation/engine.rb

@@ -14,13 +14,13 @@ module Mappers
         def self.get_evaluation_context(environment, identity = nil, override_traits = nil)
           environment_context = map_environment_model_to_evaluation_context(environment)
           identity_context = identity ? map_identity_model_to_identity_context(identity, override_traits) : nil
-  
+
           context = environment_context.dup
           context[:identity] = identity_context if identity_context
-  
+
           context
         end
-  
+
         # Maps environment model to evaluation context
         #
         # @param environment [Flagsmith::Engine::Environment] The environment model
@@ -105,7 +105,7 @@ def self.map_environment_model_to_evaluation_context(environment)
         def self.uuid_to_big_int(uuid)
           uuid.gsub('-', '').to_i(16)
         end
-  
+
         # Maps identity model to identity context
         #
         # @param identity [Flagsmith::Engine::Identity] The identity model
@@ -127,7 +127,7 @@ def self.map_identity_model_to_identity_context(identity, override_traits = nil)
             traits: traits_hash
           }
         end
-  
+
         # Maps segment rule model to rule hash
         #
         # @param rule [Flagsmith::Engine::Segments::Rule] The segment rule model
@@ -138,38 +138,37 @@ def self.map_segment_rule_model_to_rule(rule)
           }
 
           # Map conditions if present
-          if rule.conditions&.any?
-            result[:conditions] = rule.conditions.map do |condition|
-              {
-                property: condition.property,
-                operator: condition.operator,
-                value: condition.value
-              }
-            end
-          else
-            result[:conditions] = []
-          end
-
-          if rule.rules&.any?
-            result[:rules] = rule.rules.map { |nested_rule| map_segment_rule_model_to_rule(nested_rule) }
-          else
-            result[:rules] = []
-          end
+          result[:conditions] = if rule.conditions&.any?
+                                  rule.conditions.map do |condition|
+                                    {
+                                      property: condition.property,
+                                      operator: condition.operator,
+                                      value: condition.value
+                                    }
+                                  end
+                                else
+                                  []
+                                end
+
+          result[:rules] = if rule.rules&.any?
+                             rule.rules.map { |nested_rule| map_segment_rule_model_to_rule(nested_rule) }
+                           else
+                             []
+                           end
 
           result
         end
-  
+
         # Maps identity overrides to segments
         #
         # @param identity_overrides [Array<Flagsmith::Engine::Identity>] Array of identity override models
         # @return [Hash] Segments hash for identity overrides
         def self.map_identity_overrides_to_segments(identity_overrides)
-
           segments = {}
           features_to_identifiers = {}
 
           identity_overrides.each do |identity|
-            next if identity.identity_features.nil? || !identity.identity_features.any?
+            next if identity.identity_features.nil? || identity.identity_features.none?
 
             # Sort features by name for consistent hashing
             sorted_features = identity.identity_features.to_a.sort_by { |fs| fs.feature.name }
@@ -228,4 +227,3 @@ def self.map_identity_overrides_to_segments(identity_overrides)
     end
   end
 end
-