From 2aeb65a5db7252e396c7bbcdcb78eb7319497e6e Mon Sep 17 00:00:00 2001 From: wadii Date: Fri, 24 Oct 2025 16:51:37 +0200 Subject: [PATCH 01/28] feat: added-engine-function-signatures --- dev_test.rb | 31 ------------- lib/flagsmith/engine/evaluation/core.rb | 3 +- lib/flagsmith/engine/evaluation/engine.rb | 54 ++++++++++++++++++++++ lib/flagsmith/engine/evaluation/mappers.rb | 50 ++++++++++---------- 4 files changed, 80 insertions(+), 58 deletions(-) delete mode 100644 dev_test.rb create mode 100644 lib/flagsmith/engine/evaluation/engine.rb diff --git a/dev_test.rb b/dev_test.rb deleted file mode 100644 index 4358309..0000000 --- a/dev_test.rb +++ /dev/null @@ -1,31 +0,0 @@ -#!/usr/bin/env ruby -# frozen_string_literal: true - -require 'bundler/setup' -require_relative 'lib/flagsmith' - -flagsmith = Flagsmith::Client.new( - environment_key: '' -) - -begin - flags = flagsmith.get_environment_flags - - beta_users_flag = flags['beta_users'] - - if beta_users_flag - puts "Flag found!" - else - puts "error getting flag environment" - end - - puts "-" * 50 - puts "All flags" - flags.all_flags.each do |flag| - puts " - #{flag.feature_name}: enabled=#{flag.enabled?}, value=#{flag.value.inspect}" - end - -rescue StandardError => e - puts "Error: #{e.message}" - puts e.backtrace.join("\n") -end diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 4d8fd0a..bbb9154 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.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: {}, diff --git a/lib/flagsmith/engine/evaluation/engine.rb b/lib/flagsmith/engine/evaluation/engine.rb new file mode 100644 index 0000000..62a1f9a --- /dev/null +++ b/lib/flagsmith/engine/evaluation/engine.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; } + def evaluate_segments(evaluation_context); end + + # Returns Record + def process_segment_overrides(identity_segments); end + + # returns EvaluationResultFlags + 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 diff --git a/lib/flagsmith/engine/evaluation/mappers.rb b/lib/flagsmith/engine/evaluation/mappers.rb index 396fffe..3a87516 100644 --- a/lib/flagsmith/engine/evaluation/mappers.rb +++ b/lib/flagsmith/engine/evaluation/mappers.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] 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 - \ No newline at end of file From ba057cbb85432823fc49ec83da2887a86fc830cc Mon Sep 17 00:00:00 2001 From: wadii Date: Fri, 24 Oct 2025 17:30:50 +0200 Subject: [PATCH 02/28] feat: moved-engine-to-core --- lib/flagsmith/engine/evaluation/core.rb | 65 +++++++++++++++++++++-- lib/flagsmith/engine/evaluation/engine.rb | 54 ------------------- 2 files changed, 61 insertions(+), 58 deletions(-) delete mode 100644 lib/flagsmith/engine/evaluation/engine.rb diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index bbb9154..c59881e 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -9,13 +9,70 @@ module Core # # @param evaluation_context [Hash] The evaluation context # @return [Hash] Evaluation result with flags and segments - def self.get_evaluation_result(_evaluation_context) - # TODO: Implement core evaluation logic + # returns EvaluationResultWithMetadata + def get_evaluation_result(evaluation_context) + segments, segment_overrides = evaluate_segments(evaluation_context) + flags = evaluate_features(evaluation_context, segment_overrides) { - flags: {}, - segments: [] + flags: flags, + segments: segments, } end + + # Returns { segments: EvaluationResultSegments; segmentOverrides: Record; } + def evaluate_segments(evaluation_context) + if evaluation_context.identities.nil? || evaluation_context.segments.nil? + return [], {} + end + segments = [] + segment_overrides = process_segment_overrides(evaluation_context.identities) + return segments, segment_overrides + end + + # Returns Record + def process_segment_overrides(_identity_segments) + segment_overrides = {} + return segment_overrides + end + + # returns EvaluationResultFlags + def evaluate_features(evaluation_context, _segment_overrides) + raise NotImplementedError + end + + # Returns {value: any; reason?: string} + def evaluate_feature_value(_feature, _identity_key) + raise NotImplementedError + end + + # Returns {value: any; reason?: string} + def get_multivariate_feature_value(_feature, _identity_key) + raise NotImplementedError + end + + # returns boolean + def should_apply_override(_override, _existing_overrides) + raise NotImplementedError + end + + private + + # returns boolean + def higher_priority?(priority_a, priority_b) + (priority_a || Float::INFINITY) < (priority_b || 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 diff --git a/lib/flagsmith/engine/evaluation/engine.rb b/lib/flagsmith/engine/evaluation/engine.rb deleted file mode 100644 index 62a1f9a..0000000 --- a/lib/flagsmith/engine/evaluation/engine.rb +++ /dev/null @@ -1,54 +0,0 @@ -# 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; } - def evaluate_segments(evaluation_context); end - - # Returns Record - def process_segment_overrides(identity_segments); end - - # returns EvaluationResultFlags - 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 From bb96eb173bab343744825dfc817684ed9acb5fa9 Mon Sep 17 00:00:00 2001 From: wadii Date: Fri, 24 Oct 2025 17:45:58 +0200 Subject: [PATCH 03/28] feat: implemented-process-segment-overrides --- lib/flagsmith/engine/evaluation/core.rb | 20 ++++++++++++++++++-- 1 file changed, 18 insertions(+), 2 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index c59881e..af6d6e8 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -30,9 +30,25 @@ def evaluate_segments(evaluation_context) end # Returns Record - def process_segment_overrides(_identity_segments) + def process_segment_overrides(identity_segments) segment_overrides = {} - return segment_overrides + + identity_segments.each do |segment| + next unless segment[:overrides] + + overrides_list = segment[:overrides].is_a?(Array) ? segment[:overrides] : [] + + overrides_list.each do |override| + if should_apply_override(override, segment_overrides) + segment_overrides[override[:feature_key]] = { + feature: override, + segment_name: segment[:name] + } + end + end + end + + segment_overrides end # returns EvaluationResultFlags From a2fd5a894b5abd10c5ba19ed595f9cb481c6f22c Mon Sep 17 00:00:00 2001 From: wadii Date: Fri, 24 Oct 2025 17:49:13 +0200 Subject: [PATCH 04/28] feat: implemented-evalute-segments-partially --- lib/flagsmith/engine/evaluation/core.rb | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index af6d6e8..94889f1 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -21,11 +21,27 @@ def get_evaluation_result(evaluation_context) # Returns { segments: EvaluationResultSegments; segmentOverrides: Record; } def evaluate_segments(evaluation_context) - if evaluation_context.identities.nil? || evaluation_context.segments.nil? + if evaluation_context[:identity].nil? || evaluation_context[:segments].nil? return [], {} end - segments = [] - segment_overrides = process_segment_overrides(evaluation_context.identities) + + identity_segments = [] # To be getIdentitySegments when implemented + + segments = identity_segments.map do |segment| + result = { + key: segment[:key], + name: segment[:name] + } + + if segment[:metadata] + result[:metadata] = segment[:metadata].dup + end + + result + end + + segment_overrides = process_segment_overrides(identity_segments) + return segments, segment_overrides end From 0f08fb1c88733028a695e7e32f5f4ddb92373946 Mon Sep 17 00:00:00 2001 From: wadii Date: Fri, 24 Oct 2025 17:50:13 +0200 Subject: [PATCH 05/28] feat: implemented-should-apply-override --- lib/flagsmith/engine/evaluation/core.rb | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 94889f1..ff30a3a 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -56,7 +56,7 @@ def process_segment_overrides(identity_segments) overrides_list.each do |override| if should_apply_override(override, segment_overrides) - segment_overrides[override[:feature_key]] = { + segment_overrides[override[:name]] = { feature: override, segment_name: segment[:name] } @@ -83,8 +83,9 @@ def get_multivariate_feature_value(_feature, _identity_key) end # returns boolean - def should_apply_override(_override, _existing_overrides) - raise NotImplementedError + def should_apply_override(override, existing_overrides) + current_override = existing_overrides[override[:name]] + !current_override || higher_priority?(override[:priority], current_override[:feature][:priority]) end private From da08e8ec5658e8d11eeb7b88997c3c008709565d Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 27 Oct 2025 11:35:43 +0100 Subject: [PATCH 06/28] feat: implemented-get-identity-segments --- .gitmodules | 2 +- lib/flagsmith/engine/core.rb | 1 + lib/flagsmith/engine/evaluation/core.rb | 88 +++++++++-- lib/flagsmith/engine/features/constants.rb | 14 ++ lib/flagsmith/engine/segments/evaluator.rb | 175 +++++++++++++++++++++ spec/engine/e2e/engine_spec.rb | 4 +- 6 files changed, 270 insertions(+), 14 deletions(-) create mode 100644 lib/flagsmith/engine/features/constants.rb diff --git a/.gitmodules b/.gitmodules index da6957d..1fca970 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,4 +1,4 @@ [submodule "spec/engine-test-data"] path = spec/engine-test-data url = git@github.com:Flagsmith/engine-test-data.git - branch = main + branch = v3.1.0 diff --git a/lib/flagsmith/engine/core.rb b/lib/flagsmith/engine/core.rb index 530a3f4..cb872b0 100644 --- a/lib/flagsmith/engine/core.rb +++ b/lib/flagsmith/engine/core.rb @@ -12,6 +12,7 @@ require_relative 'segments/models' require_relative 'utils/hash_func' require_relative 'evaluation/mappers' +require_relative 'evaluation/core' module Flagsmith module Engine diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index ff30a3a..1f8a898 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -1,10 +1,18 @@ # frozen_string_literal: true +require_relative '../utils/hash_func' +require_relative '../features/constants' +require_relative '../segments/evaluator' + module Flagsmith module Engine module Evaluation # Core evaluation logic module module Core + extend self + include Flagsmith::Engine::Utils::HashFunc + include Flagsmith::Engine::Features::TargetingReasons + include Flagsmith::Engine::Segments::Evaluator # Get evaluation result from evaluation context # # @param evaluation_context [Hash] The evaluation context @@ -25,7 +33,7 @@ def evaluate_segments(evaluation_context) return [], {} end - identity_segments = [] # To be getIdentitySegments when implemented + identity_segments = get_identity_segments_from_context(evaluation_context) segments = identity_segments.map do |segment| result = { @@ -68,18 +76,68 @@ def process_segment_overrides(identity_segments) end # returns EvaluationResultFlags - def evaluate_features(evaluation_context, _segment_overrides) - raise NotImplementedError + def evaluate_features(evaluation_context, segment_overrides) + flags = {} + + (evaluation_context[:features] || {}).each_value do |feature| + segment_override = segment_overrides[feature[:name]] + final_feature = segment_override ? segment_override[:feature] : feature + has_override = !segment_override.nil? + + # Evaluate feature value + evaluated = if has_override + { value: final_feature[:value], reason: nil } + else + evaluate_feature_value(final_feature, get_identity_key(evaluation_context)) + end + + # Build flag result + flag_result = { + name: final_feature[:name], + enabled: final_feature[:enabled], + value: evaluated[:value] + } + + # Add metadata if present + flag_result[:metadata] = final_feature[:metadata] if final_feature[:metadata] + + # Set reason + flag_result[:reason] = evaluated[:reason] || + get_targeting_match_reason({ type: 'SEGMENT', override: segment_override }) + + flags[final_feature[:name]] = flag_result + end + + flags end # Returns {value: any; reason?: string} - def evaluate_feature_value(_feature, _identity_key) - raise NotImplementedError + def evaluate_feature_value(feature, identity_key = nil) + if feature[:variants]&.any? && identity_key + return get_multivariate_feature_value(feature, identity_key) + end + + { value: feature[:value], reason: nil } end # Returns {value: any; reason?: string} - def get_multivariate_feature_value(_feature, _identity_key) - raise NotImplementedError + def get_multivariate_feature_value(feature, identity_key) + percentage_value = hashed_percentage_for_object_ids([feature[:key], identity_key]) + sorted_variants = (feature[:variants] || []).sort_by { |v| v[:priority] || Float::INFINITY } + + start_percentage = 0 + sorted_variants.each do |variant| + limit = start_percentage + variant[:weight] + if start_percentage <= percentage_value && percentage_value < limit + return { + value: variant[:value], + reason: get_targeting_match_reason({ type: 'SPLIT', weight: variant[:weight] }) + } + end + start_percentage = limit + end + + { value: feature[:value], reason: nil } end # returns boolean @@ -90,21 +148,29 @@ def should_apply_override(override, existing_overrides) private + # Extract identity key from evaluation context + # + # @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) + end + # returns boolean def higher_priority?(priority_a, priority_b) (priority_a || Float::INFINITY) < (priority_b || Float::INFINITY) end def get_targeting_match_reason(match_object) - type = match_object.type + type = match_object[:type] if type == 'SEGMENT' - return match_object.override ? "TARGETING_MATCH; segment=#{match_object.override.segment_name}" : 'DEFAULT' + return match_object[:override] ? "#{TARGETING_REASON_TARGETING_MATCH}; segment=#{match_object[:override][:segment_name]}" : TARGETING_REASON_DEFAULT end - return "SPLIT; weight=#{match_object.weight}" if type == 'SPLIT' + return "#{TARGETING_REASON_SPLIT}; weight=#{match_object[:weight]}" if type == 'SPLIT' - 'DEFAULT' + TARGETING_REASON_DEFAULT end end end diff --git a/lib/flagsmith/engine/features/constants.rb b/lib/flagsmith/engine/features/constants.rb new file mode 100644 index 0000000..b3baa08 --- /dev/null +++ b/lib/flagsmith/engine/features/constants.rb @@ -0,0 +1,14 @@ +# frozen_string_literal: true + +module Flagsmith + module Engine + module Features + # Targeting reason constants for evaluation results + module TargetingReasons + TARGETING_REASON_DEFAULT = 'DEFAULT' + TARGETING_REASON_TARGETING_MATCH = 'TARGETING_MATCH' + TARGETING_REASON_SPLIT = 'SPLIT' + end + end + end +end diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index cc4a2f0..019da54 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -1,6 +1,7 @@ # frozen_string_literal: true require_relative 'constants' +require_relative 'models' require_relative '../utils/hash_func' module Flagsmith @@ -8,9 +9,26 @@ module Engine module Segments # Evaluator methods module Evaluator + extend self include Flagsmith::Engine::Segments::Constants include Flagsmith::Engine::Utils::HashFunc + # 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] Array of segments that the identity matches + def get_identity_segments_from_context(context) + return [] unless context[:identity] && context[: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) } + end + 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) @@ -70,6 +88,163 @@ def traits_match_segment_condition(identity_traits, condition, segment_id, ident false end + # Context-based helper functions (new approach) + + # Evaluates whether a segment rule matches using context + # + # @param rule [Hash] The rule to evaluate + # @param segment_key [String] The segment key (used for percentage split) + # @param context [Hash] The evaluation context + # @return [Boolean] True if the rule matches + def traits_match_segment_rule_from_context(rule, segment_key, context) + matches_conditions = evaluate_conditions_from_context(rule, segment_key, context) + matches_sub_rules = evaluate_sub_rules_from_context(rule, segment_key, context) + + matches_conditions && matches_sub_rules + end + + # Evaluates rule conditions based on rule type (ALL/ANY/NONE) + # + # @param rule [Hash] The rule containing conditions and type + # @param segment_key [String] The segment key + # @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? + + condition_results = rule[:conditions].map do |condition| + traits_match_segment_condition_from_context(condition, segment_key, context) + end + + evaluate_rule_conditions(rule[:type], condition_results) + end + + # Evaluates nested sub-rules + # + # @param rule [Hash] The rule containing nested rules + # @param segment_key [String] The segment key + # @param context [Hash] The evaluation context + # @return [Boolean] True if all sub-rules match + def evaluate_sub_rules_from_context(rule, segment_key, context) + return true if rule[:rules].nil? || rule[:rules].empty? + + rule[:rules].all? do |sub_rule| + traits_match_segment_rule_from_context(sub_rule, segment_key, context) + end + end + + # Evaluates a single segment condition using context + # + # @param condition [Hash] The condition to evaluate + # @param segment_key [String] The segment key (used for percentage split hashing) + # @param context [Hash] The evaluation context + # @return [Boolean] True if the condition matches + def traits_match_segment_condition_from_context(condition, segment_key, context) + if condition[:operator] == PERCENTAGE_SPLIT + context_value_key = get_context_value(condition[:property], context) || get_identity_key_from_context(context) + hashed_percentage = hashed_percentage_for_object_ids([segment_key, context_value_key]) + return hashed_percentage <= condition[:value].to_f + end + + 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_NOT_SET + + if !trait_value.nil? + # Reuse existing Condition class logic + condition_obj = Flagsmith::Engine::Segments::Condition.new( + operator: condition[:operator], + value: condition[:value], + property: condition[:property] + ) + return condition_obj.match_trait_value?(trait_value) + end + + false + end + + # Evaluate rule conditions based on type (ALL/ANY/NONE) + # + # @param rule_type [String] The rule type + # @param condition_results [Array] Array of condition evaluation results + # @return [Boolean] True if conditions match according to rule type + def evaluate_rule_conditions(rule_type, condition_results) + case rule_type + when 'ALL' + condition_results.empty? || condition_results.all? + when 'ANY' + !condition_results.empty? && condition_results.any? + when 'NONE' + condition_results.empty? || condition_results.none? + else + false + end + end + + # Get trait value from context, supporting JSONPath expressions + # + # @param property [String] The property name or JSONPath + # @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) + end + + # Otherwise look in traits + traits = context.dig(:identity, :traits) || {} + traits[property] + end + + # Get value from context using JSONPath-like syntax + # + # @param json_path [String] JSONPath expression (e.g., '$.identity.identifier') + # @param context [Hash] The evaluation context + # @return [Object, nil] The value at the path or nil + def get_context_value(json_path, context) + return nil unless context && json_path&.start_with?('$.') + + # Simple JSONPath implementation - handle basic cases + path_parts = json_path.sub('$.', '').split('.') + current = context + + path_parts.each do |part| + return nil unless current.is_a?(Hash) + + current = current[part.to_sym] + end + + current + rescue StandardError + nil + end + + # Get identity key from context + # + # @param context [Hash] The evaluation context + # @return [String, nil] The identity key or generated composite key + def get_identity_key_from_context(context) + return nil unless context[:identity] + + context[:identity][:key] || + "#{context[:environment][:key]}_#{context[:identity][:identifier]}" + end + + # Check if value is non-primitive (object or array) + # + # @param value [Object] The value to check + # @return [Boolean] True if value is an object or array + def non_primitive?(value) + return false if value.nil? + + value.is_a?(Hash) || value.is_a?(Array) + end + private def handle_trait_existence_conditions(matching_trait, operator) diff --git a/spec/engine/e2e/engine_spec.rb b/spec/engine/e2e/engine_spec.rb index 77c9f92..0f227a1 100644 --- a/spec/engine/e2e/engine_spec.rb +++ b/spec/engine/e2e/engine_spec.rb @@ -35,11 +35,11 @@ def load_test_file(filepath) test_expected_result = test_case[:result] # TODO: Implement evaluation logic - evaluation_result = {} + evaluation_result = Flagsmith::Engine::Evaluation::Core.get_evaluation_result(test_evaluation_context) # TODO: Uncomment when evaluation is implemented - # expect(evaluation_result).to eq(test_expected_result) + expect(evaluation_result[:flags]).to eq(test_expected_result[:flags]) end end end From af51bf794ae8ab8b40d6ecd442a1bf40389b5111 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 27 Oct 2025 15:33:17 +0100 Subject: [PATCH 07/28] feat: implemented-new-in-and-fixed-remaining-tests --- .gitmodules | 2 +- lib/flagsmith/engine/evaluation/core.rb | 10 +++-- lib/flagsmith/engine/segments/evaluator.rb | 15 +++++--- lib/flagsmith/engine/segments/models.rb | 43 ++++++++++++++++++---- spec/engine-test-data | 2 +- spec/engine/e2e/engine_spec.rb | 1 + 6 files changed, 53 insertions(+), 20 deletions(-) diff --git a/.gitmodules b/.gitmodules index 1fca970..da6957d 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,4 +1,4 @@ [submodule "spec/engine-test-data"] path = spec/engine-test-data url = git@github.com:Flagsmith/engine-test-data.git - branch = v3.1.0 + branch = main diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 1f8a898..90154f2 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/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 diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index 019da54..d1031f6 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/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 diff --git a/lib/flagsmith/engine/segments/models.rb b/lib/flagsmith/engine/segments/models.rb index f339112..a95d547 100644 --- a/lib/flagsmith/engine/segments/models.rb +++ b/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 diff --git a/spec/engine-test-data b/spec/engine-test-data index 41c2021..6ab57ec 160000 --- a/spec/engine-test-data +++ b/spec/engine-test-data @@ -1 +1 @@ -Subproject commit 41c202145e375c712600e318c439456de5b221d7 +Subproject commit 6ab57ec67bc84659e8b5aa41534b04fe45cc4cbe diff --git a/spec/engine/e2e/engine_spec.rb b/spec/engine/e2e/engine_spec.rb index 0f227a1..0a40dbe 100644 --- a/spec/engine/e2e/engine_spec.rb +++ b/spec/engine/e2e/engine_spec.rb @@ -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 From 0fb7587b92c809e4146e788601b3ff5893a755b1 Mon Sep 17 00:00:00 2001 From: wadii Date: Tue, 28 Oct 2025 17:15:38 +0100 Subject: [PATCH 08/28] feat: run-lint --- lib/flagsmith/engine/evaluation/core.rb | 30 +++++++++------------- lib/flagsmith/engine/segments/evaluator.rb | 12 +++------ lib/flagsmith/engine/segments/models.rb | 16 +++++------- 3 files changed, 22 insertions(+), 36 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 90154f2..10fc8d3 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/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; } 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_from_context(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 @@ -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 diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index d1031f6..547804c 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -21,14 +21,12 @@ module Evaluator def get_identity_segments_from_context(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 # Model-based segment evaluation (existing approach) @@ -153,10 +151,10 @@ def traits_match_segment_condition_from_context(condition, segment_key, context) 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], @@ -195,9 +193,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) || {} diff --git a/lib/flagsmith/engine/segments/models.rb b/lib/flagsmith/engine/segments/models.rb index a95d547..94cf4a6 100644 --- a/lib/flagsmith/engine/segments/models.rb +++ b/lib/flagsmith/engine/segments/models.rb @@ -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,16 +103,12 @@ 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) - 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) 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 From 6a6a129d14a0f15bbf3252a2c6b539681dfa7e85 Mon Sep 17 00:00:00 2001 From: wadii Date: Tue, 28 Oct 2025 17:44:35 +0100 Subject: [PATCH 09/28] feat: misc --- lib/flagsmith/engine/segments/evaluator.rb | 4 ++-- lib/flagsmith/engine/segments/models.rb | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index 547804c..8b8a4b1 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -9,10 +9,10 @@ module Engine module Segments # Evaluator methods module Evaluator - extend self include Flagsmith::Engine::Segments::Constants include Flagsmith::Engine::Utils::HashFunc + module_function # Context-based segment evaluation (new approach) # Returns all segments that the identity belongs to based on segment rules evaluation # @@ -111,7 +111,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) diff --git a/lib/flagsmith/engine/segments/models.rb b/lib/flagsmith/engine/segments/models.rb index 94cf4a6..756c905 100644 --- a/lib/flagsmith/engine/segments/models.rb +++ b/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 From f0a53b77166adfbf533d43640a6ca650cbf6dcbc Mon Sep 17 00:00:00 2001 From: wadii Date: Thu, 30 Oct 2025 20:41:40 +0100 Subject: [PATCH 10/28] feat: json-path-lib-implementation --- Gemfile.lock | 4 ++++ flagsmith.gemspec | 1 + lib/flagsmith/engine/segments/evaluator.rb | 18 +++++------------- spec/engine-test-data | 2 +- 4 files changed, 11 insertions(+), 14 deletions(-) diff --git a/Gemfile.lock b/Gemfile.lock index bed803f..249a91e 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -4,6 +4,7 @@ PATH flagsmith (4.3.0) faraday (>= 2.0.1) faraday-retry + jsonpath (~> 1.1) semantic GEM @@ -21,8 +22,11 @@ GEM faraday (~> 2.0) gem-release (2.2.2) json (2.7.1) + jsonpath (1.1.5) + multi_json language_server-protocol (3.17.0.3) method_source (1.0.0) + multi_json (1.17.0) net-http (0.4.1) uri parallel (1.24.0) diff --git a/flagsmith.gemspec b/flagsmith.gemspec index a4b950d..a1e9459 100644 --- a/flagsmith.gemspec +++ b/flagsmith.gemspec @@ -34,6 +34,7 @@ Gem::Specification.new do |spec| spec.add_dependency 'faraday', '>= 2.0.1' spec.add_dependency 'faraday-retry' + spec.add_dependency 'jsonpath', '~> 1.1' spec.add_dependency 'semantic' spec.metadata['rubygems_mfa_required'] = 'true' end diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index 8b8a4b1..d4342f8 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -1,5 +1,7 @@ # frozen_string_literal: true +require 'json' +require 'jsonpath' require_relative 'constants' require_relative 'models' require_relative '../utils/hash_func' @@ -200,25 +202,15 @@ def get_trait_value(property, context) traits[property] || traits[property.to_sym] end - # Get value from context using JSONPath-like syntax + # Get value from context using JSONPath syntax # # @param json_path [String] JSONPath expression (e.g., '$.identity.identifier') # @param context [Hash] The evaluation context # @return [Object, nil] The value at the path or nil def get_context_value(json_path, context) return nil unless context && json_path&.start_with?('$.') - - # Simple JSONPath implementation - handle basic cases - path_parts = json_path.sub('$.', '').split('.') - current = context - - path_parts.each do |part| - return nil unless current.is_a?(Hash) - - current = current[part.to_sym] - end - - current + results = JsonPath.new(json_path, use_symbols: true).on(context) + results.first rescue StandardError nil end diff --git a/spec/engine-test-data b/spec/engine-test-data index 6ab57ec..218757f 160000 --- a/spec/engine-test-data +++ b/spec/engine-test-data @@ -1 +1 @@ -Subproject commit 6ab57ec67bc84659e8b5aa41534b04fe45cc4cbe +Subproject commit 218757fd23f932760be681a09c686c9d6ef55fad From ef1274a63848569c9533eb0e1cc558755d40b00e Mon Sep 17 00:00:00 2001 From: Gagan Trivedi Date: Wed, 5 Nov 2025 15:52:08 +0530 Subject: [PATCH 11/28] remove dup --- lib/flagsmith/engine/evaluation/core.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 10fc8d3..e0d4eb1 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -38,7 +38,7 @@ def evaluate_segments(evaluation_context) name: segment[:name] } - result[:metadata] = segment[:metadata].dup if segment[:metadata] + result[:metadata] = segment[:metadata] if segment[:metadata] result end From 962c01c3985f927e96085df2c17cc107d0d3b1d1 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:12:10 +0100 Subject: [PATCH 12/28] feat: made-legacy-functions-public --- lib/flagsmith/engine/segments/evaluator.rb | 48 +++++++++++----------- 1 file changed, 25 insertions(+), 23 deletions(-) diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index d4342f8..374a592 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -13,6 +13,31 @@ module Segments module Evaluator include Flagsmith::Engine::Segments::Constants include Flagsmith::Engine::Utils::HashFunc + + # 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 + + + def traits_match_segment_condition(identity_traits, condition, segment_id, identity_id) + if condition.operator == PERCENTAGE_SPLIT + return hashed_percentage_for_object_ids([segment_id, + identity_id]) <= condition.value.to_f + end + + trait = identity_traits.find { |t| t.key.to_s == condition.property } + + return handle_trait_existence_conditions(trait, condition.operator) if [IS_SET, + IS_NOT_SET].include?(condition.operator) + + return condition.match_trait_value?(trait.trait_value) if trait + + false + end + module_function # Context-based segment evaluation (new approach) @@ -31,13 +56,6 @@ def get_identity_segments_from_context(context) end 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 @@ -75,22 +93,6 @@ def traits_match_segment_rule(identity_traits, rule, segment_id, identity_id) end # rubocop:enable Metrics/MethodLength - def traits_match_segment_condition(identity_traits, condition, segment_id, identity_id) - if condition.operator == PERCENTAGE_SPLIT - return hashed_percentage_for_object_ids([segment_id, - identity_id]) <= condition.value.to_f - end - - trait = identity_traits.find { |t| t.key.to_s == condition.property } - - return handle_trait_existence_conditions(trait, condition.operator) if [IS_SET, - IS_NOT_SET].include?(condition.operator) - - return condition.match_trait_value?(trait.trait_value) if trait - - false - end - # Context-based helper functions (new approach) # Evaluates whether a segment rule matches using context From 771a1a15eb58e2ec4cce83aaf81e5715a6da593e Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:12:40 +0100 Subject: [PATCH 13/28] feat: updated-tests-to-match-engine-in-operator-accepting-numbers --- lib/flagsmith/engine/segments/models.rb | 6 +++++- spec/engine/unit/segments/models_spec.rb | 4 +--- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/lib/flagsmith/engine/segments/models.rb b/lib/flagsmith/engine/segments/models.rb index 756c905..0bfeb6e 100644 --- a/lib/flagsmith/engine/segments/models.rb +++ b/lib/flagsmith/engine/segments/models.rb @@ -102,8 +102,12 @@ 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) + + return false unless ![true, false].include? trait_value - return @value.include?(trait_value.to_s) if @value.is_a?(Array) + if @value.is_a?(Array) + return @value.include?(trait_value.to_s) + end if @value.is_a?(String) begin diff --git a/spec/engine/unit/segments/models_spec.rb b/spec/engine/unit/segments/models_spec.rb index 517657a..1c50637 100644 --- a/spec/engine/unit/segments/models_spec.rb +++ b/spec/engine/unit/segments/models_spec.rb @@ -94,9 +94,7 @@ ['IN', 1, '1,2,3,4', true], ['IN', 1, '', false], ['IN', 1, '1', true], - # Flagsmith's engine does not evaluate `IN` condition for floats/doubles and booleans - # due to ambiguous serialization across supported platforms. - ['IN', 1.5, '1.5', false], + ['IN', 1.5, '1.5', true], ['IN', false, 'false', false], ].freeze From 21d7e74e61feaf4b44cc9e259cd03804f87a9ea2 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:18:26 +0100 Subject: [PATCH 14/28] feat: engine-agnostic-to-empty-identity-in-segment-evaluation --- lib/flagsmith/engine/evaluation/core.rb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 25596c3..15160ef 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -29,7 +29,7 @@ def get_evaluation_result(evaluation_context) # Returns { segments: EvaluationResultSegments; segmentOverrides: Record; } def evaluate_segments(evaluation_context) - return [], {} if evaluation_context[:identity].nil? || evaluation_context[:segments].nil? + return [], {} if evaluation_context[:segments].nil? identity_segments = get_identity_segments_from_context(evaluation_context) From 0baa0b4b938fc3b0467464f696a9fc32757ef047 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:19:21 +0100 Subject: [PATCH 15/28] feat: renamed-to-is-higher-priority --- lib/flagsmith/engine/evaluation/core.rb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 15160ef..844bffa 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -136,7 +136,7 @@ def get_multivariate_feature_value(feature, identity_key) # returns boolean def should_apply_override(override, existing_overrides) current_override = existing_overrides[override[:name]] - !current_override || higher_priority?(override[:priority], current_override[:feature][:priority]) + !current_override || is_stronger_priority?(override[:priority], current_override[:feature][:priority]) end private @@ -153,7 +153,7 @@ def get_identity_key(evaluation_context) end # returns boolean - def higher_priority?(priority_a, priority_b) + def is_stronger_priority?(priority_a, priority_b) (priority_a || Float::INFINITY) < (priority_b || Float::INFINITY) end From 97cfdfbc4c0a0a52890bdf7ffc92fe8f1668eb30 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:19:57 +0100 Subject: [PATCH 16/28] feat: renamed-get-identity-segments-func --- lib/flagsmith/engine/evaluation/core.rb | 2 +- lib/flagsmith/engine/segments/evaluator.rb | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 844bffa..12f4bce 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -31,7 +31,7 @@ def get_evaluation_result(evaluation_context) def evaluate_segments(evaluation_context) return [], {} if evaluation_context[:segments].nil? - identity_segments = get_identity_segments_from_context(evaluation_context) + identity_segments = get_segments_from_context(evaluation_context) segments = identity_segments.map do |segment| result = { diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index 374a592..768994e 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -45,7 +45,7 @@ def traits_match_segment_condition(identity_traits, condition, segment_id, ident # # @param context [Hash] Evaluation context containing identity and segment definitions # @return [Array] Array of segments that the identity matches - def get_identity_segments_from_context(context) + def get_segments_from_context(context) return [] unless context[:identity] && context[:segments] context[:segments].values.select do |segment| From 7188b952badde99e215b7e403df4df073969ae84 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:21:44 +0100 Subject: [PATCH 17/28] feat: reverted-to-is-primitive --- lib/flagsmith/engine/segments/evaluator.rb | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index 768994e..54f0554 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -197,7 +197,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) - return context_value if !context_value.nil? && !non_primitive?(context_value) + return context_value if !context_value.nil? && is_primitive?(context_value) end traits = context.dig(:identity, :traits) || {} @@ -228,14 +228,14 @@ def get_identity_key_from_context(context) "#{context[:environment][:key]}_#{context[:identity][:identifier]}" end - # Check if value is non-primitive (object or array) + # Check if value is primitive (not an object or array) # # @param value [Object] The value to check - # @return [Boolean] True if value is an object or array - def non_primitive?(value) - return false if value.nil? + # @return [Boolean] True if value is primitive (not an object or array) + def is_primitive?(value) + return true if value.nil? - value.is_a?(Hash) || value.is_a?(Array) + !(value.is_a?(Hash) || value.is_a?(Array)) end private From 418ae3345791c3b953e4597b30705ab1cb15e4f1 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:24:04 +0100 Subject: [PATCH 18/28] feat: use-weakest-priority-constant --- lib/flagsmith/engine/evaluation/core.rb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 12f4bce..215078e 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -116,7 +116,7 @@ def evaluate_feature_value(feature, identity_key = nil) # Returns {value: any; reason?: string} def get_multivariate_feature_value(feature, identity_key) percentage_value = hashed_percentage_for_object_ids([feature[:key], identity_key]) - sorted_variants = (feature[:variants] || []).sort_by { |v| v[:priority] || Float::INFINITY } + sorted_variants = (feature[:variants] || []).sort_by { |v| v[:priority] || WEAKEST_PRIORITY } start_percentage = 0 sorted_variants.each do |variant| @@ -154,7 +154,7 @@ def get_identity_key(evaluation_context) # returns boolean def is_stronger_priority?(priority_a, priority_b) - (priority_a || Float::INFINITY) < (priority_b || Float::INFINITY) + (priority_a || WEAKEST_PRIORITY) < (priority_b || WEAKEST_PRIORITY) end def get_targeting_match_reason(match_object) From 12144a31cda639b6e6ed5a75970c3157574b9478 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:31:29 +0100 Subject: [PATCH 19/28] feat: upgraded-engine-test-data-and-fixed-mv-evaluation-bug --- lib/flagsmith/engine/evaluation/core.rb | 6 +----- spec/engine-test-data | 2 +- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 215078e..79c8709 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -80,11 +80,7 @@ def evaluate_features(evaluation_context, segment_overrides) has_override = !segment_override.nil? # Evaluate feature value - evaluated = if has_override - { value: final_feature[:value], reason: nil } - else - evaluate_feature_value(final_feature, get_identity_key(evaluation_context)) - end + evaluated = evaluate_feature_value(final_feature, get_identity_key(evaluation_context)) # Build flag result flag_result = { diff --git a/spec/engine-test-data b/spec/engine-test-data index 218757f..839e8d5 160000 --- a/spec/engine-test-data +++ b/spec/engine-test-data @@ -1 +1 @@ -Subproject commit 218757fd23f932760be681a09c686c9d6ef55fad +Subproject commit 839e8d5e5f2e9af6392062cf5e575d43c03770d4 From fe63b4583aa445dbcf5757d74c0e6c5ab329061a Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:37:08 +0100 Subject: [PATCH 20/28] feat: removed-targeting-reason-func --- lib/flagsmith/engine/evaluation/core.rb | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 79c8709..d288e6a 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -94,8 +94,7 @@ def evaluate_features(evaluation_context, segment_overrides) # Set reason flag_result[:reason] = evaluated[:reason] || - get_targeting_match_reason({ type: 'SEGMENT', override: segment_override }) - + (has_override ? "#{TARGETING_REASON_TARGETING_MATCH}; segment=#{segment_override[:segment_name]}" : TARGETING_REASON_DEFAULT) flags[final_feature[:name].to_sym] = flag_result end @@ -120,7 +119,7 @@ def get_multivariate_feature_value(feature, identity_key) if start_percentage <= percentage_value && percentage_value < limit return { value: variant[:value], - reason: get_targeting_match_reason({ type: 'SPLIT', weight: variant[:weight] }) + reason: "#{TARGETING_REASON_SPLIT}; weight=#{variant[:weight]}" } end start_percentage = limit @@ -152,18 +151,6 @@ def get_identity_key(evaluation_context) def is_stronger_priority?(priority_a, priority_b) (priority_a || WEAKEST_PRIORITY) < (priority_b || WEAKEST_PRIORITY) end - - def get_targeting_match_reason(match_object) - type = match_object[:type] - - if type == 'SEGMENT' - return match_object[:override] ? "#{TARGETING_REASON_TARGETING_MATCH}; segment=#{match_object[:override][:segment_name]}" : TARGETING_REASON_DEFAULT - end - - return "#{TARGETING_REASON_SPLIT}; weight=#{match_object[:weight]}" if type == 'SPLIT' - - TARGETING_REASON_DEFAULT - end end end end From 6420d15425458cd3574cdadca1fb90e5bbe27557 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:50:31 +0100 Subject: [PATCH 21/28] feat: linter-rubocop-autocorrect --- lib/flagsmith/engine/evaluation/core.rb | 2 +- lib/flagsmith/engine/segments/evaluator.rb | 6 +++--- lib/flagsmith/engine/segments/models.rb | 8 +++----- 3 files changed, 7 insertions(+), 9 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index d288e6a..4967695 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -94,7 +94,7 @@ def evaluate_features(evaluation_context, segment_overrides) # Set reason flag_result[:reason] = evaluated[:reason] || - (has_override ? "#{TARGETING_REASON_TARGETING_MATCH}; segment=#{segment_override[:segment_name]}" : TARGETING_REASON_DEFAULT) + (has_override ? "#{TARGETING_REASON_TARGETING_MATCH}; segment=#{segment_override[:segment_name]}" : TARGETING_REASON_DEFAULT) flags[final_feature[:name].to_sym] = flag_result end diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index 54f0554..ce56f95 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -13,7 +13,7 @@ module Segments module Evaluator include Flagsmith::Engine::Segments::Constants include Flagsmith::Engine::Utils::HashFunc - + # Model-based segment evaluation (existing approach) def get_identity_segments(environment, identity, override_traits = nil) environment.project.segments.select do |s| @@ -21,7 +21,6 @@ def get_identity_segments(environment, identity, override_traits = nil) end end - def traits_match_segment_condition(identity_traits, condition, segment_id, identity_id) if condition.operator == PERCENTAGE_SPLIT return hashed_percentage_for_object_ids([segment_id, @@ -38,8 +37,8 @@ def traits_match_segment_condition(identity_traits, condition, segment_id, ident false end - module_function + # Context-based segment evaluation (new approach) # Returns all segments that the identity belongs to based on segment rules evaluation # @@ -211,6 +210,7 @@ def get_trait_value(property, context) # @return [Object, nil] The value at the path or nil def get_context_value(json_path, context) return nil unless context && json_path&.start_with?('$.') + results = JsonPath.new(json_path, use_symbols: true).on(context) results.first rescue StandardError diff --git a/lib/flagsmith/engine/segments/models.rb b/lib/flagsmith/engine/segments/models.rb index 0bfeb6e..26c9522 100644 --- a/lib/flagsmith/engine/segments/models.rb +++ b/lib/flagsmith/engine/segments/models.rb @@ -102,12 +102,10 @@ 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) - - return false unless ![true, false].include? trait_value - if @value.is_a?(Array) - return @value.include?(trait_value.to_s) - end + return false if [true, false].include? trait_value + + return @value.include?(trait_value.to_s) if @value.is_a?(Array) if @value.is_a?(String) begin From cbbd3c27d2b9ef8677d9a9d2fa5c645fbbfc7327 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 17:57:08 +0100 Subject: [PATCH 22/28] feat: linter --- lib/flagsmith/engine/evaluation/core.rb | 12 +++--------- lib/flagsmith/engine/segments/evaluator.rb | 4 ++-- lib/flagsmith/engine/segments/models.rb | 13 ++++--------- 3 files changed, 9 insertions(+), 20 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 4967695..088502c 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -34,13 +34,7 @@ def evaluate_segments(evaluation_context) identity_segments = get_segments_from_context(evaluation_context) segments = identity_segments.map do |segment| - result = { - name: segment[:name] - } - - result[:metadata] = segment[:metadata] if segment[:metadata] - - result + { name: segment[:name], metadata: segment[:metadata] }.compact end segment_overrides = process_segment_overrides(identity_segments) @@ -131,7 +125,7 @@ def get_multivariate_feature_value(feature, identity_key) # returns boolean def should_apply_override(override, existing_overrides) current_override = existing_overrides[override[:name]] - !current_override || is_stronger_priority?(override[:priority], current_override[:feature][:priority]) + !current_override || stronger_priority?(override[:priority], current_override[:feature][:priority]) end private @@ -148,7 +142,7 @@ def get_identity_key(evaluation_context) end # returns boolean - def is_stronger_priority?(priority_a, priority_b) + def stronger_priority?(priority_a, priority_b) (priority_a || WEAKEST_PRIORITY) < (priority_b || WEAKEST_PRIORITY) end end diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index ce56f95..66797a7 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -196,7 +196,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) - return context_value if !context_value.nil? && is_primitive?(context_value) + return context_value if !context_value.nil? && primitive?(context_value) end traits = context.dig(:identity, :traits) || {} @@ -232,7 +232,7 @@ def get_identity_key_from_context(context) # # @param value [Object] The value to check # @return [Boolean] True if value is primitive (not an object or array) - def is_primitive?(value) + def primitive?(value) return true if value.nil? !(value.is_a?(Hash) || value.is_a?(Array)) diff --git a/lib/flagsmith/engine/segments/models.rb b/lib/flagsmith/engine/segments/models.rb index 26c9522..d547580 100644 --- a/lib/flagsmith/engine/segments/models.rb +++ b/lib/flagsmith/engine/segments/models.rb @@ -54,7 +54,7 @@ def initialize(operator:, value:, property: nil) @property = property end - def match_trait_value?(trait_value) + def match_trait_value?(trait_value) # rubocop:disable Metrics/MethodLength if @value.is_a?(String) && @value.match?(/:semver$/) begin trait_value = Semantic::Version.new(trait_value.to_s.gsub(/:semver$/, '')) @@ -73,8 +73,7 @@ def match_trait_value?(trait_value) MATCHING_FUNCTIONS[operator]&.call(trait_value, formatted_value) end - # rubocop:disable Metrics/AbcSize - def format_to_type_of(input) + def format_to_type_of(input) # rubocop:disable Metrics/AbcSize { 'String' => ->(v) { v.to_s }, 'Semantic::Version' => ->(v) { Semantic::Version.new(v.to_s.gsub(/:semver$/, '')) }, @@ -91,7 +90,6 @@ def format_to_type_of(input) } }[input.class.to_s] end - # rubocop:enable Metrics/AbcSize def match_modulo_value(trait_value) divisor, remainder = @value.split('|') @@ -100,10 +98,8 @@ def match_modulo_value(trait_value) false end - def match_in_value(trait_value) - return false if trait_value.nil? || trait_value.is_a?(TrueClass) || trait_value.is_a?(FalseClass) - - return false if [true, false].include? trait_value + def match_in_value(trait_value) # rubocop:disable Metrics/AbcSize + return false if trait_value.nil? || trait_value.is_a?(TrueClass) || trait_value.is_a?(FalseClass) || ([true, false].include? trait_value) return @value.include?(trait_value.to_s) if @value.is_a?(Array) @@ -114,7 +110,6 @@ def match_in_value(trait_value) rescue JSON::ParserError end end - @value.to_s.split(',').include?(trait_value.to_s) end From 3b729fc47d477bbbb56188592ca43d4581cb0a09 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 20:30:58 +0100 Subject: [PATCH 23/28] feat: linter --- lib/flagsmith/engine/evaluation/core.rb | 62 +++++++--------- lib/flagsmith/engine/segments/evaluator.rb | 38 +++++----- lib/flagsmith/engine/segments/models.rb | 84 +++++++++++++--------- 3 files changed, 95 insertions(+), 89 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 088502c..3eac01d 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -43,15 +43,11 @@ def evaluate_segments(evaluation_context) end # Returns Record - def process_segment_overrides(identity_segments) + def process_segment_overrides(identity_segments) # rubocop:disable Metrics/MethodLength segment_overrides = {} identity_segments.each do |segment| - next unless segment[:overrides] - - overrides_list = segment[:overrides].is_a?(Array) ? segment[:overrides] : [] - - overrides_list.each do |override| + Array(segment[:overrides]).each do |override| next unless should_apply_override(override, segment_overrides) segment_overrides[override[:name]] = { @@ -66,33 +62,15 @@ def process_segment_overrides(identity_segments) # returns EvaluationResultFlags def evaluate_features(evaluation_context, segment_overrides) - flags = {} + identity_key = get_identity_key(evaluation_context) - (evaluation_context[:features] || {}).each_value do |feature| + (evaluation_context[:features] || {}).each_with_object({}) do |(_, feature), flags| segment_override = segment_overrides[feature[:name]] final_feature = segment_override ? segment_override[:feature] : feature - has_override = !segment_override.nil? - - # Evaluate feature value - evaluated = evaluate_feature_value(final_feature, get_identity_key(evaluation_context)) - - # Build flag result - flag_result = { - name: final_feature[:name], - enabled: final_feature[:enabled], - value: evaluated[:value] - } - - # Add metadata if present - flag_result[:metadata] = final_feature[:metadata] if final_feature[:metadata] - # Set reason - flag_result[:reason] = evaluated[:reason] || - (has_override ? "#{TARGETING_REASON_TARGETING_MATCH}; segment=#{segment_override[:segment_name]}" : TARGETING_REASON_DEFAULT) + flag_result = build_flag_result(final_feature, identity_key, segment_override) flags[final_feature[:name].to_sym] = flag_result end - - flags end # Returns {value: any; reason?: string} @@ -107,19 +85,19 @@ def get_multivariate_feature_value(feature, identity_key) percentage_value = hashed_percentage_for_object_ids([feature[:key], identity_key]) sorted_variants = (feature[:variants] || []).sort_by { |v| v[:priority] || WEAKEST_PRIORITY } + variant = find_matching_variant(sorted_variants, percentage_value) + variant || { value: feature[:value], reason: nil } + end + + def find_matching_variant(sorted_variants, percentage_value) start_percentage = 0 sorted_variants.each do |variant| limit = start_percentage + variant[:weight] - if start_percentage <= percentage_value && percentage_value < limit - return { - value: variant[:value], - reason: "#{TARGETING_REASON_SPLIT}; weight=#{variant[:weight]}" - } - end + return { value: variant[:value], reason: "#{TARGETING_REASON_SPLIT}; weight=#{variant[:weight]}" } if start_percentage <= percentage_value && percentage_value < limit + start_percentage = limit end - - { value: feature[:value], reason: nil } + nil end # returns boolean @@ -130,6 +108,20 @@ def should_apply_override(override, existing_overrides) private + def build_flag_result(feature, identity_key, segment_override) + evaluated = evaluate_feature_value(feature, identity_key) + + flag_result = { + name: feature[:name], + enabled: feature[:enabled], + value: evaluated[:value], + reason: evaluated[:reason] || (segment_override ? "#{TARGETING_REASON_TARGETING_MATCH}; segment=#{segment_override[:segment_name]}" : TARGETING_REASON_DEFAULT) + } + + flag_result[:metadata] = feature[:metadata] if feature[:metadata] + flag_result + end + # Extract identity key from evaluation context # # @param evaluation_context [Hash] The evaluation context diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index 66797a7..31a892b 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -10,7 +10,7 @@ module Flagsmith module Engine module Segments # Evaluator methods - module Evaluator + module Evaluator # rubocop:disable Metrics/ModuleLength include Flagsmith::Engine::Segments::Constants include Flagsmith::Engine::Utils::HashFunc @@ -144,30 +144,30 @@ def evaluate_sub_rules_from_context(rule, segment_key, context) # @param context [Hash] The evaluation context # @return [Boolean] True if the condition matches def traits_match_segment_condition_from_context(condition, segment_key, context) - if condition[:operator] == PERCENTAGE_SPLIT - context_value_key = get_context_value(condition[:property], context) || get_identity_key_from_context(context) - hashed_percentage = hashed_percentage_for_object_ids([segment_key, context_value_key]) - return hashed_percentage <= condition[:value].to_f - end - + return handle_percentage_split(condition, segment_key, context) if condition[:operator] == PERCENTAGE_SPLIT return false if condition[:property].nil? trait_value = get_trait_value(condition[:property], context) + evaluate_trait_condition(condition, trait_value) + end + + def handle_percentage_split(condition, segment_key, context) + context_value_key = get_context_value(condition[:property], context) || get_identity_key_from_context(context) + hashed_percentage = hashed_percentage_for_object_ids([segment_key, context_value_key]) + hashed_percentage <= condition[:value].to_f + end + def evaluate_trait_condition(condition, trait_value) return !trait_value.nil? if condition[:operator] == IS_SET return trait_value.nil? if condition[:operator] == IS_NOT_SET - - unless trait_value.nil? - # Reuse existing Condition class logic - condition_obj = Flagsmith::Engine::Segments::Condition.new( - operator: condition[:operator], - value: condition[:value], - property: condition[:property] - ) - return condition_obj.match_trait_value?(trait_value) - end - - false + return false if trait_value.nil? + + condition_obj = Flagsmith::Engine::Segments::Condition.new( + operator: condition[:operator], + value: condition[:value], + property: condition[:property] + ) + condition_obj.match_trait_value?(trait_value) end # Evaluate rule conditions based on type (ALL/ANY/NONE) diff --git a/lib/flagsmith/engine/segments/models.rb b/lib/flagsmith/engine/segments/models.rb index d547580..70a6d03 100644 --- a/lib/flagsmith/engine/segments/models.rb +++ b/lib/flagsmith/engine/segments/models.rb @@ -54,41 +54,48 @@ def initialize(operator:, value:, property: nil) @property = property end - def match_trait_value?(trait_value) # rubocop:disable Metrics/MethodLength - if @value.is_a?(String) && @value.match?(/:semver$/) - begin - trait_value = Semantic::Version.new(trait_value.to_s.gsub(/:semver$/, '')) - rescue ArgumentError, Semantic::Version::ValidationFailed => _e - return false - end - end + def match_trait_value?(trait_value) + trait_value = parse_semver_trait_value(trait_value) + return false if trait_value.nil? 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 + match_with_type_conversion(trait_value) + end + + def parse_semver_trait_value(trait_value) + return trait_value unless @value.is_a?(String) && @value.match?(/:semver$/) + + Semantic::Version.new(trait_value.to_s.gsub(/:semver$/, '')) + rescue ArgumentError, Semantic::Version::ValidationFailed + nil + end + + def match_with_type_conversion(trait_value) type_as_trait_value = format_to_type_of(trait_value) formatted_value = type_as_trait_value ? type_as_trait_value.call(@value) : @value - MATCHING_FUNCTIONS[operator]&.call(trait_value, formatted_value) end - def format_to_type_of(input) # rubocop:disable Metrics/AbcSize - { - '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].include?(v) }, - 'Integer' => lambda { |v| - i = v.to_i - i.to_s == v.to_s ? i : v - }, - 'Float' => lambda { |v| - f = v.to_f - f.to_s == v.to_s ? f : v - } - }[input.class.to_s] + TYPE_CONVERTERS = { + 'String' => ->(v) { v.to_s }, + 'Semantic::Version' => ->(v) { Semantic::Version.new(v.to_s.gsub(/:semver$/, '')) }, + 'TrueClass' => ->(v) { ['True', 'true', 'TRUE', true, 1, '1'].include?(v) }, + 'FalseClass' => ->(v) { !['False', 'false', 'FALSE', false].include?(v) }, + 'Integer' => lambda { |v| + i = v.to_i + i.to_s == v.to_s ? i : v + }, + 'Float' => lambda { |v| + f = v.to_f + f.to_s == v.to_s ? f : v + } + }.freeze + + def format_to_type_of(input) + TYPE_CONVERTERS[input.class.to_s] end def match_modulo_value(trait_value) @@ -98,18 +105,25 @@ def match_modulo_value(trait_value) false end - def match_in_value(trait_value) # rubocop:disable Metrics/AbcSize - return false if trait_value.nil? || trait_value.is_a?(TrueClass) || trait_value.is_a?(FalseClass) || ([true, false].include? trait_value) - + def match_in_value(trait_value) + return false if invalid_in_value?(trait_value) return @value.include?(trait_value.to_s) if @value.is_a?(Array) - if @value.is_a?(String) - begin - parsed = JSON.parse(@value) - return parsed.include?(trait_value.to_s) if parsed.is_a?(Array) - rescue JSON::ParserError - end - end + parse_and_match_string_value(trait_value) + end + + def invalid_in_value?(trait_value) + trait_value.nil? || [TrueClass, FalseClass].any? { |klass| trait_value.is_a?(klass) } + end + + def parse_and_match_string_value(trait_value) # rubocop:disable Metrics/AbcSize + return @value.to_s.split(',').include?(trait_value.to_s) unless @value.is_a?(String) + + parsed = JSON.parse(@value) + return parsed.include?(trait_value.to_s) if parsed.is_a?(Array) + + @value.to_s.split(',').include?(trait_value.to_s) + rescue JSON::ParserError @value.to_s.split(',').include?(trait_value.to_s) end From 13057f97d7d0e1ac1a01fc5cb5ce3f4a281ee995 Mon Sep 17 00:00:00 2001 From: wadii Date: Mon, 10 Nov 2025 20:47:57 +0100 Subject: [PATCH 24/28] feat: moved-mappers-to-engine-namespace --- lib/flagsmith/engine/core.rb | 2 +- lib/flagsmith/engine/environments/models.rb | 4 +- lib/flagsmith/engine/evaluation/mappers.rb | 68 ------------ .../engine/evaluation/mappers/environment.rb | 62 ----------- .../engine/evaluation/mappers/identity.rb | 100 ------------------ .../engine/evaluation/mappers/segments.rb | 68 ------------ lib/flagsmith/engine/mappers.rb | 66 ++++++++++++ lib/flagsmith/engine/mappers/environment.rb | 60 +++++++++++ lib/flagsmith/engine/mappers/identity.rb | 98 +++++++++++++++++ lib/flagsmith/engine/mappers/segments.rb | 66 ++++++++++++ .../unit/evaluation_context_mappers_spec.rb | 4 +- 11 files changed, 296 insertions(+), 302 deletions(-) delete mode 100644 lib/flagsmith/engine/evaluation/mappers.rb delete mode 100644 lib/flagsmith/engine/evaluation/mappers/environment.rb delete mode 100644 lib/flagsmith/engine/evaluation/mappers/identity.rb delete mode 100644 lib/flagsmith/engine/evaluation/mappers/segments.rb create mode 100644 lib/flagsmith/engine/mappers.rb create mode 100644 lib/flagsmith/engine/mappers/environment.rb create mode 100644 lib/flagsmith/engine/mappers/identity.rb create mode 100644 lib/flagsmith/engine/mappers/segments.rb diff --git a/lib/flagsmith/engine/core.rb b/lib/flagsmith/engine/core.rb index cb872b0..3e64f1c 100644 --- a/lib/flagsmith/engine/core.rb +++ b/lib/flagsmith/engine/core.rb @@ -11,7 +11,7 @@ require_relative 'segments/evaluator' require_relative 'segments/models' require_relative 'utils/hash_func' -require_relative 'evaluation/mappers' +require_relative 'mappers' require_relative 'evaluation/core' module Flagsmith diff --git a/lib/flagsmith/engine/environments/models.rb b/lib/flagsmith/engine/environments/models.rb index 41f7da4..174d1fe 100644 --- a/lib/flagsmith/engine/environments/models.rb +++ b/lib/flagsmith/engine/environments/models.rb @@ -8,7 +8,8 @@ class Environment attr_accessor :project, :feature_states, :amplitude_config, :segment_config, :mixpanel_config, :heap_config, :identity_overrides - def initialize(id:, api_key:, name: nil, project:, feature_states: [], identity_overrides: []) + # rubocop:disable Metrics/ParameterLists + def initialize(id:, api_key:, project:, name: nil, feature_states: [], identity_overrides: []) @id = id @api_key = api_key @name = name @@ -16,6 +17,7 @@ def initialize(id:, api_key:, name: nil, project:, feature_states: [], identity_ @feature_states = feature_states @identity_overrides = identity_overrides end + # rubocop:enable Metrics/ParameterLists class << self # rubocop:disable Metrics/MethodLength diff --git a/lib/flagsmith/engine/evaluation/mappers.rb b/lib/flagsmith/engine/evaluation/mappers.rb deleted file mode 100644 index 39a2aab..0000000 --- a/lib/flagsmith/engine/evaluation/mappers.rb +++ /dev/null @@ -1,68 +0,0 @@ -# frozen_string_literal: true - -require_relative 'mappers/environment' -require_relative 'mappers/identity' -require_relative 'mappers/segments' - -module Flagsmith - module Engine - module Evaluation - # Mappers for converting between models and evaluation contexts - module Mappers - STRONGEST_PRIORITY = Float::INFINITY - WEAKEST_PRIORITY = -Float::INFINITY - - # @param environment [Flagsmith::Engine::Environment] The environment model - # @param identity [Flagsmith::Engine::Identity, nil] Optional identity model - # @param override_traits [Array, nil] Optional override traits - # @return [Hash] Evaluation context with environment, features, segments, and optionally identity - def self.get_evaluation_context(environment, identity = nil, override_traits = nil) - context = map_environment_model_to_evaluation_context(environment) - context[:identity] = map_identity_model_to_identity_context(identity, override_traits) if identity - context - end - - # Maps environment model to evaluation context - # - # @param environment [Flagsmith::Engine::Environment] The environment model - # @return [Hash] Context with :environment, :features, and :segments keys - def self.map_environment_model_to_evaluation_context(environment) - context = { - environment: Environment.build_environment_context(environment), - features: Environment.build_features_context(environment.feature_states), - segments: Segments.build_segments_context(environment.project.segments) - } - - context[:segments].merge!(Identity.map_overrides_to_segments(environment.identity_overrides)) if environment.identity_overrides&.any? - - context - end - - # Maps identity model to identity context - # - # @param identity [Flagsmith::Engine::Identity] The identity model - # @param override_traits [Array, nil] Optional override traits - # @return [Hash] Identity context with :identifier, :key, and :traits - def self.map_identity_model_to_identity_context(identity, override_traits = nil) - Identity.build_environment_context(identity, override_traits) - end - - # Maps segment rule model to rule hash - # - # @param rule [Flagsmith::Engine::Segments::Rule] The segment rule model - # @return [Hash] Mapped rule with :type, :conditions, and :rules - def self.map_segment_rule_model_to_rule(rule) - Segments.map_rule(rule) - end - - # Maps identity overrides to segments - # - # @param identity_overrides [Array] Array of identity override models - # @return [Hash] Segments hash for identity overrides - def self.map_identity_overrides_to_segments(identity_overrides) - Identity.map_overrides_to_segments(identity_overrides) - end - end - end - end -end diff --git a/lib/flagsmith/engine/evaluation/mappers/environment.rb b/lib/flagsmith/engine/evaluation/mappers/environment.rb deleted file mode 100644 index 92b669b..0000000 --- a/lib/flagsmith/engine/evaluation/mappers/environment.rb +++ /dev/null @@ -1,62 +0,0 @@ -# frozen_string_literal: true - -module Flagsmith - module Engine - module Evaluation - module Mappers - # Handles environment and feature mapping - module Environment - def self.build_environment_context(environment) - { - key: environment.api_key, - name: environment.name - } - end - - def self.build_features_context(feature_states) - features = {} - feature_states.each do |feature_state| - features[feature_state.feature.name] = build_feature_hash(feature_state) - end - features - end - - def self.build_feature_hash(feature_state) # rubocop:disable Metrics/MethodLength - feature_hash = { - key: feature_state.django_id&.to_s || feature_state.uuid, - feature_key: feature_state.feature.id.to_s, - name: feature_state.feature.name, - enabled: feature_state.enabled, - value: feature_state.get_value, - metadata: { flagsmith_id: feature_state.feature.id } - } - add_variants_to_feature(feature_hash, feature_state) - add_priority_to_feature(feature_hash, feature_state) - feature_hash - end - - def self.add_variants_to_feature(feature_hash, feature_state) - return unless feature_state.multivariate_feature_state_values&.any? - - feature_hash[:variants] = feature_state.multivariate_feature_state_values.map do |mv| - { - value: mv.multivariate_feature_option.value, - weight: mv.percentage_allocation, - priority: mv.id || uuid_to_big_int(mv.mv_fs_value_uuid) - } - end - end - - def self.uuid_to_big_int(uuid) - uuid.gsub('-', '').to_i(16) - end - - def self.add_priority_to_feature(feature_hash, feature_state) - priority = feature_state.feature_segment&.priority - feature_hash[:priority] = priority unless priority.nil? - end - end - end - end - end -end diff --git a/lib/flagsmith/engine/evaluation/mappers/identity.rb b/lib/flagsmith/engine/evaluation/mappers/identity.rb deleted file mode 100644 index 8c8c266..0000000 --- a/lib/flagsmith/engine/evaluation/mappers/identity.rb +++ /dev/null @@ -1,100 +0,0 @@ -# frozen_string_literal: true - -module Flagsmith - module Engine - module Evaluation - module Mappers - # Handles identity and override mapping - module Identity - def self.build_environment_context(identity, override_traits = nil) - traits = override_traits || identity.identity_traits - - { - identifier: identity.identifier, - key: identity.django_id&.to_s || identity.composite_key, - traits: build_traits_hash(traits) - } - end - - def self.build_traits_hash(traits) - traits_hash = {} - traits.each do |trait| - traits_hash[trait.trait_key] = trait.trait_value - end - traits_hash - end - - def self.map_overrides_to_segments(identity_overrides) - features_to_identifiers = group_by_overrides(identity_overrides) - build_identity_override_segments(features_to_identifiers) - end - - def self.group_by_overrides(identity_overrides) - features_to_identifiers = {} - - identity_overrides.each do |identity| - next if identity.identity_features.nil? || identity.identity_features.none? - - overrides_key = build_overrides_key(identity.identity_features) - overrides_hash = overrides_key.hash - - features_to_identifiers[overrides_hash] ||= { identifiers: [], overrides: overrides_key } - features_to_identifiers[overrides_hash][:identifiers] << identity.identifier - end - - features_to_identifiers - end - - def self.build_overrides_key(identity_features) # rubocop:disable Metrics/MethodLength - sorted_features = identity_features.to_a.sort_by { |fs| fs.feature.name } - sorted_features.map do |feature_state| - { - feature_key: feature_state.feature.id.to_s, - name: feature_state.feature.name, - enabled: feature_state.enabled, - value: feature_state.get_value, - priority: Mappers::STRONGEST_PRIORITY, - metadata: { flagsmith_id: feature_state.feature.id } - } - end - end - - def self.build_identity_override_segments(features_to_identifiers) - segments = {} - - features_to_identifiers.each do |overrides_hash, data| - segment_key = "identity_override_#{overrides_hash}" - segments[segment_key] = build_identity_override_segment(segment_key, data) - end - - segments - end - - def self.build_identity_override_segment(segment_key, data) - { - key: segment_key, - name: 'identity_override', - rules: [build_identity_override_rule(data[:identifiers])], - metadata: { source: 'identity_override' }, - overrides: data[:overrides] - } - end - - def self.build_identity_override_rule(identifiers) # rubocop:disable Metrics/MethodLength - { - type: 'ALL', - conditions: [ - { - property: '$.identity.identifier', - operator: 'IN', - value: identifiers - } - ], - rules: [] - } - end - end - end - end - end -end diff --git a/lib/flagsmith/engine/evaluation/mappers/segments.rb b/lib/flagsmith/engine/evaluation/mappers/segments.rb deleted file mode 100644 index b281c14..0000000 --- a/lib/flagsmith/engine/evaluation/mappers/segments.rb +++ /dev/null @@ -1,68 +0,0 @@ -# frozen_string_literal: true - -module Flagsmith - module Engine - module Evaluation - module Mappers - # Handles segment and rule mapping - module Segments - def self.build_segments_context(project_segments) - segments = {} - project_segments.each do |segment| - segments[segment.id.to_s] = build_segment_hash(segment) - end - segments - end - - def self.build_segment_hash(segment) - { - key: segment.id.to_s, - name: segment.name, - rules: segment.rules.map { |rule| map_rule(rule) }, - overrides: build_overrides(segment.feature_states), - metadata: { - source: 'API', - flagsmith_id: segment.id - } - } - end - - def self.build_overrides(feature_states) # rubocop:disable Metrics/MethodLength - feature_states.map do |feature_state| - override_hash = { - key: feature_state.django_id&.to_s || feature_state.uuid, - feature_key: feature_state.feature.id.to_s, - name: feature_state.feature.name, - enabled: feature_state.enabled, - value: feature_state.get_value, - metadata: { flagsmith_id: feature_state.feature.id } - } - add_priority_to_override(override_hash, feature_state) - override_hash - end - end - - def self.add_priority_to_override(override_hash, feature_state) - return unless feature_state.feature_segment&.priority - - override_hash[:priority] = feature_state.feature_segment.priority - end - - def self.map_rule(rule) - { - type: rule.type, - conditions: map_conditions(rule.conditions), - rules: (rule.rules || []).map { |nested_rule| map_rule(nested_rule) } - } - end - - def self.map_conditions(conditions) - (conditions || []).map do |condition| - { property: condition.property, operator: condition.operator, value: condition.value } - end - end - end - end - end - end -end diff --git a/lib/flagsmith/engine/mappers.rb b/lib/flagsmith/engine/mappers.rb new file mode 100644 index 0000000..d9baa8a --- /dev/null +++ b/lib/flagsmith/engine/mappers.rb @@ -0,0 +1,66 @@ +# frozen_string_literal: true + +require_relative 'mappers/environment' +require_relative 'mappers/identity' +require_relative 'mappers/segments' + +module Flagsmith + module Engine + # Mappers for converting between models and evaluation contexts + module Mappers + STRONGEST_PRIORITY = Float::INFINITY + WEAKEST_PRIORITY = -Float::INFINITY + + # @param environment [Flagsmith::Engine::Environment] The environment model + # @param identity [Flagsmith::Engine::Identity, nil] Optional identity model + # @param override_traits [Array, nil] Optional override traits + # @return [Hash] Evaluation context with environment, features, segments, and optionally identity + def self.get_evaluation_context(environment, identity = nil, override_traits = nil) + context = map_environment_model_to_evaluation_context(environment) + context[:identity] = map_identity_model_to_identity_context(identity, override_traits) if identity + context + end + + # Maps environment model to evaluation context + # + # @param environment [Flagsmith::Engine::Environment] The environment model + # @return [Hash] Context with :environment, :features, and :segments keys + def self.map_environment_model_to_evaluation_context(environment) + context = { + environment: Environment.build_environment_context(environment), + features: Environment.build_features_context(environment.feature_states), + segments: Segments.build_segments_context(environment.project.segments) + } + + context[:segments].merge!(Identity.map_overrides_to_segments(environment.identity_overrides)) if environment.identity_overrides&.any? + + context + end + + # Maps identity model to identity context + # + # @param identity [Flagsmith::Engine::Identity] The identity model + # @param override_traits [Array, nil] Optional override traits + # @return [Hash] Identity context with :identifier, :key, and :traits + def self.map_identity_model_to_identity_context(identity, override_traits = nil) + Identity.build_environment_context(identity, override_traits) + end + + # Maps segment rule model to rule hash + # + # @param rule [Flagsmith::Engine::Segments::Rule] The segment rule model + # @return [Hash] Mapped rule with :type, :conditions, and :rules + def self.map_segment_rule_model_to_rule(rule) + Segments.map_rule(rule) + end + + # Maps identity overrides to segments + # + # @param identity_overrides [Array] Array of identity override models + # @return [Hash] Segments hash for identity overrides + def self.map_identity_overrides_to_segments(identity_overrides) + Identity.map_overrides_to_segments(identity_overrides) + end + end + end +end diff --git a/lib/flagsmith/engine/mappers/environment.rb b/lib/flagsmith/engine/mappers/environment.rb new file mode 100644 index 0000000..399d2d3 --- /dev/null +++ b/lib/flagsmith/engine/mappers/environment.rb @@ -0,0 +1,60 @@ +# frozen_string_literal: true + +module Flagsmith + module Engine + module Mappers + # Handles environment and feature mapping + module Environment + def self.build_environment_context(environment) + { + key: environment.api_key, + name: environment.name + } + end + + def self.build_features_context(feature_states) + features = {} + feature_states.each do |feature_state| + features[feature_state.feature.name] = build_feature_hash(feature_state) + end + features + end + + def self.build_feature_hash(feature_state) # rubocop:disable Metrics/MethodLength + feature_hash = { + key: feature_state.django_id&.to_s || feature_state.uuid, + feature_key: feature_state.feature.id.to_s, + name: feature_state.feature.name, + enabled: feature_state.enabled, + value: feature_state.get_value, + metadata: { flagsmith_id: feature_state.feature.id } + } + add_variants_to_feature(feature_hash, feature_state) + add_priority_to_feature(feature_hash, feature_state) + feature_hash + end + + def self.add_variants_to_feature(feature_hash, feature_state) + return unless feature_state.multivariate_feature_state_values&.any? + + feature_hash[:variants] = feature_state.multivariate_feature_state_values.map do |mv| + { + value: mv.multivariate_feature_option.value, + weight: mv.percentage_allocation, + priority: mv.id || uuid_to_big_int(mv.mv_fs_value_uuid) + } + end + end + + def self.uuid_to_big_int(uuid) + uuid.gsub('-', '').to_i(16) + end + + def self.add_priority_to_feature(feature_hash, feature_state) + priority = feature_state.feature_segment&.priority + feature_hash[:priority] = priority unless priority.nil? + end + end + end + end +end diff --git a/lib/flagsmith/engine/mappers/identity.rb b/lib/flagsmith/engine/mappers/identity.rb new file mode 100644 index 0000000..a0c1c22 --- /dev/null +++ b/lib/flagsmith/engine/mappers/identity.rb @@ -0,0 +1,98 @@ +# frozen_string_literal: true + +module Flagsmith + module Engine + module Mappers + # Handles identity and override mapping + module Identity + def self.build_environment_context(identity, override_traits = nil) + traits = override_traits || identity.identity_traits + + { + identifier: identity.identifier, + key: identity.django_id&.to_s || identity.composite_key, + traits: build_traits_hash(traits) + } + end + + def self.build_traits_hash(traits) + traits_hash = {} + traits.each do |trait| + traits_hash[trait.trait_key] = trait.trait_value + end + traits_hash + end + + def self.map_overrides_to_segments(identity_overrides) + features_to_identifiers = group_by_overrides(identity_overrides) + build_identity_override_segments(features_to_identifiers) + end + + def self.group_by_overrides(identity_overrides) + features_to_identifiers = {} + + identity_overrides.each do |identity| + next if identity.identity_features.nil? || identity.identity_features.none? + + overrides_key = build_overrides_key(identity.identity_features) + overrides_hash = overrides_key.hash + + features_to_identifiers[overrides_hash] ||= { identifiers: [], overrides: overrides_key } + features_to_identifiers[overrides_hash][:identifiers] << identity.identifier + end + + features_to_identifiers + end + + def self.build_overrides_key(identity_features) # rubocop:disable Metrics/MethodLength + sorted_features = identity_features.to_a.sort_by { |fs| fs.feature.name } + sorted_features.map do |feature_state| + { + feature_key: feature_state.feature.id.to_s, + name: feature_state.feature.name, + enabled: feature_state.enabled, + value: feature_state.get_value, + priority: Mappers::STRONGEST_PRIORITY, + metadata: { flagsmith_id: feature_state.feature.id } + } + end + end + + def self.build_identity_override_segments(features_to_identifiers) + segments = {} + + features_to_identifiers.each do |overrides_hash, data| + segment_key = "identity_override_#{overrides_hash}" + segments[segment_key] = build_identity_override_segment(segment_key, data) + end + + segments + end + + def self.build_identity_override_segment(segment_key, data) + { + key: segment_key, + name: 'identity_override', + rules: [build_identity_override_rule(data[:identifiers])], + metadata: { source: 'identity_override' }, + overrides: data[:overrides] + } + end + + def self.build_identity_override_rule(identifiers) # rubocop:disable Metrics/MethodLength + { + type: 'ALL', + conditions: [ + { + property: '$.identity.identifier', + operator: 'IN', + value: identifiers + } + ], + rules: [] + } + end + end + end + end +end diff --git a/lib/flagsmith/engine/mappers/segments.rb b/lib/flagsmith/engine/mappers/segments.rb new file mode 100644 index 0000000..09858f1 --- /dev/null +++ b/lib/flagsmith/engine/mappers/segments.rb @@ -0,0 +1,66 @@ +# frozen_string_literal: true + +module Flagsmith + module Engine + module Mappers + # Handles segment and rule mapping + module Segments + def self.build_segments_context(project_segments) + segments = {} + project_segments.each do |segment| + segments[segment.id.to_s] = build_segment_hash(segment) + end + segments + end + + def self.build_segment_hash(segment) + { + key: segment.id.to_s, + name: segment.name, + rules: segment.rules.map { |rule| map_rule(rule) }, + overrides: build_overrides(segment.feature_states), + metadata: { + source: 'API', + flagsmith_id: segment.id + } + } + end + + def self.build_overrides(feature_states) # rubocop:disable Metrics/MethodLength + feature_states.map do |feature_state| + override_hash = { + key: feature_state.django_id&.to_s || feature_state.uuid, + feature_key: feature_state.feature.id.to_s, + name: feature_state.feature.name, + enabled: feature_state.enabled, + value: feature_state.get_value, + metadata: { flagsmith_id: feature_state.feature.id } + } + add_priority_to_override(override_hash, feature_state) + override_hash + end + end + + def self.add_priority_to_override(override_hash, feature_state) + return unless feature_state.feature_segment&.priority + + override_hash[:priority] = feature_state.feature_segment.priority + end + + def self.map_rule(rule) + { + type: rule.type, + conditions: map_conditions(rule.conditions), + rules: (rule.rules || []).map { |nested_rule| map_rule(nested_rule) } + } + end + + def self.map_conditions(conditions) + (conditions || []).map do |condition| + { property: condition.property, operator: condition.operator, value: condition.value } + end + end + end + end + end +end diff --git a/spec/engine/unit/evaluation_context_mappers_spec.rb b/spec/engine/unit/evaluation_context_mappers_spec.rb index dbaa4fe..2cb0301 100644 --- a/spec/engine/unit/evaluation_context_mappers_spec.rb +++ b/spec/engine/unit/evaluation_context_mappers_spec.rb @@ -2,7 +2,7 @@ require 'spec_helper' -RSpec.describe Flagsmith::Engine::Evaluation::Mappers do +RSpec.describe Flagsmith::Engine::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::Evaluation::Mappers::STRONGEST_PRIORITY) + expect(override[:priority]).to eq(Flagsmith::Engine::Mappers::STRONGEST_PRIORITY) expect(override[:metadata][:flagsmith_id]).to eq(1) # Verify features From 37c424f9ba734fde42ed70ead6cb4eeb1743b31b Mon Sep 17 00:00:00 2001 From: wadii Date: Tue, 11 Nov 2025 12:26:07 +0100 Subject: [PATCH 25/28] feat: enrich-context-with-identity-key --- lib/flagsmith/engine/evaluation/core.rb | 1 + lib/flagsmith/engine/segments/evaluator.rb | 21 ++++++++++++++++----- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 3eac01d..409aa93 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -19,6 +19,7 @@ module Core # @return [Hash] Evaluation result with flags and segments # returns EvaluationResultWithMetadata def get_evaluation_result(evaluation_context) + evaluation_context = get_enriched_context(evaluation_context) segments, segment_overrides = evaluate_segments(evaluation_context) flags = evaluate_features(evaluation_context, segment_overrides) { diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index 31a892b..79a9cf3 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -14,7 +14,7 @@ module Evaluator # rubocop:disable Metrics/ModuleLength include Flagsmith::Engine::Segments::Constants include Flagsmith::Engine::Utils::HashFunc - # Model-based segment evaluation (existing approach) + # Model-based segment evaluation def get_identity_segments(environment, identity, override_traits = nil) environment.project.segments.select do |s| evaluate_identity_in_segment(identity, s, override_traits) @@ -39,7 +39,19 @@ def traits_match_segment_condition(identity_traits, condition, segment_id, ident module_function - # Context-based segment evaluation (new approach) + def get_enriched_context(context) + identity_context = context[:identity] + return context unless identity_context + return context if identity_context[:key] + + enriched_context = context.dup + enriched_context[:identity] = identity_context.merge( + key: "#{context[:environment][:key]}_#{identity_context[:identifier]}" + ) + enriched_context + end + + # 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 @@ -92,7 +104,7 @@ def traits_match_segment_rule(identity_traits, rule, segment_id, identity_id) end # rubocop:enable Metrics/MethodLength - # Context-based helper functions (new approach) + # Context-based helper functions # Evaluates whether a segment rule matches using context # @@ -224,8 +236,7 @@ def get_context_value(json_path, context) def get_identity_key_from_context(context) return nil unless context[:identity] - context[:identity][:key] || - "#{context[:environment][:key]}_#{context[:identity][:identifier]}" + context[:identity][:key] end # Check if value is primitive (not an object or array) From 29e6bf69ea92edc405eef69a3cf2706522bb6fb3 Mon Sep 17 00:00:00 2001 From: wadii Date: Tue, 11 Nov 2025 14:55:03 +0100 Subject: [PATCH 26/28] feat: run-ci-on-all-branches --- .github/workflows/pull_request.yaml | 3 --- 1 file changed, 3 deletions(-) diff --git a/.github/workflows/pull_request.yaml b/.github/workflows/pull_request.yaml index ed95b9d..9880607 100644 --- a/.github/workflows/pull_request.yaml +++ b/.github/workflows/pull_request.yaml @@ -14,9 +14,6 @@ on: - synchronize - reopened - ready_for_review - branches: - - main - - release/** push: branches: From 080f191e32814766de3c93591c078cc918eadf98 Mon Sep 17 00:00:00 2001 From: wadii Date: Tue, 11 Nov 2025 14:58:16 +0100 Subject: [PATCH 27/28] feat: removed-comments --- lib/flagsmith/engine/evaluation/core.rb | 2 -- 1 file changed, 2 deletions(-) diff --git a/lib/flagsmith/engine/evaluation/core.rb b/lib/flagsmith/engine/evaluation/core.rb index 409aa93..5a7fe58 100644 --- a/lib/flagsmith/engine/evaluation/core.rb +++ b/lib/flagsmith/engine/evaluation/core.rb @@ -17,7 +17,6 @@ module Core # # @param evaluation_context [Hash] The evaluation context # @return [Hash] Evaluation result with flags and segments - # returns EvaluationResultWithMetadata def get_evaluation_result(evaluation_context) evaluation_context = get_enriched_context(evaluation_context) segments, segment_overrides = evaluate_segments(evaluation_context) @@ -61,7 +60,6 @@ def process_segment_overrides(identity_segments) # rubocop:disable Metrics/Metho segment_overrides end - # returns EvaluationResultFlags def evaluate_features(evaluation_context, segment_overrides) identity_key = get_identity_key(evaluation_context) From fc1369ae08e9b889da822272c3c4435677a580f6 Mon Sep 17 00:00:00 2001 From: Zaimwa9 Date: Wed, 12 Nov 2025 10:18:21 +0100 Subject: [PATCH 28/28] feat!: sdk consumes context engine (#89) * fix: sdk-uses-new-engine-methods * feat: introduced-jsonpath-library * feat: fixed-conflict * Update lib/flagsmith/engine/segments/models.rb Co-authored-by: Kim Gustyr * Update lib/flagsmith/engine/segments/models.rb * feat: removed-normalize * feat: linter * feat: replaced-flagsmith-id-with-id * feat: removed-comments --------- Co-authored-by: Kim Gustyr --- lib/flagsmith.rb | 46 +++--- lib/flagsmith/engine/core.rb | 155 ++++++++++++------ lib/flagsmith/engine/features/models.rb | 2 +- lib/flagsmith/engine/mappers/environment.rb | 2 +- lib/flagsmith/engine/mappers/identity.rb | 2 +- lib/flagsmith/engine/mappers/segments.rb | 4 +- lib/flagsmith/engine/segments/evaluator.rb | 47 ++---- lib/flagsmith/sdk/models/flags.rb | 34 ++-- spec/engine/e2e/engine_spec.rb | 7 +- spec/engine/unit/core_spec.rb | 114 ------------- .../unit/evaluation_context_mappers_spec.rb | 6 +- spec/engine/unit/segments/evaluator_spec.rb | 29 ---- 12 files changed, 182 insertions(+), 266 deletions(-) delete mode 100644 spec/engine/unit/core_spec.rb delete mode 100644 spec/engine/unit/segments/evaluator_spec.rb diff --git a/lib/flagsmith.rb b/lib/flagsmith.rb index 6e0464e..51ae62a 100644 --- a/lib/flagsmith.rb +++ b/lib/flagsmith.rb @@ -69,7 +69,6 @@ def initialize(config) api_client analytics_processor environment_data_polling_manager - engine load_offline_handler end @@ -99,10 +98,6 @@ def realtime_client @realtime_client ||= Flagsmith::RealtimeClient.new(@config) end - def engine - @engine ||= Flagsmith::Engine::Engine.new - end - def analytics_processor return nil unless @config.enable_analytics? @@ -211,21 +206,33 @@ def get_value_for_identity(feature_name, user_id = nil, default: nil) end def get_identity_segments(identifier, traits = {}) - unless environment - raise Flagsmith::ClientError, - 'Local evaluation or offline handler is required to obtain identity segments.' - end + raise Flagsmith::ClientError, 'Local evaluation or offline handler is required to obtain identity segments.' unless environment 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::Mappers.get_evaluation_context(environment, identity_model) + raise Flagsmith::ClientError, 'Local evaluation required to obtain identity segments' unless context + + evaluation_result = Flagsmith::Engine.get_evaluation_result(context) + evaluation_result[:segments].filter_map do |segment_result| + id = segment_result.dig(:metadata, :id) + Flagsmith::Segments::Segment.new(id: id, name: segment_result[:name]) if id + end end private - def environment_flags_from_document - Flagsmith::Flags::Collection.from_feature_state_models( - engine.get_environment_feature_states(environment), + def environment_flags_from_document # rubocop:disable Metrics/MethodLength + context = Flagsmith::Engine::Mappers.get_evaluation_context(environment) + + unless context + raise Flagsmith::ClientError, + 'Unable to get flags. No environment present.' + end + + evaluation_result = Flagsmith::Engine.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 @@ -234,12 +241,13 @@ def environment_flags_from_document def get_identity_flags_from_document(identifier, traits = {}) identity_model = get_identity_model(identifier, traits) + context = Flagsmith::Engine::Mappers.get_evaluation_context(environment, identity_model) + raise Flagsmith::ClientError, 'Unable to get flags. No environment present.' unless context - Flagsmith::Flags::Collection.from_feature_state_models( - engine.get_identity_feature_states(environment, identity_model), - identity_id: identity_model.composite_key, - analytics_processor: analytics_processor, - default_flag_handler: default_flag_handler, + evaluation_result = Flagsmith::Engine.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 ) end diff --git a/lib/flagsmith/engine/core.rb b/lib/flagsmith/engine/core.rb index 3e64f1c..dded5a5 100644 --- a/lib/flagsmith/engine/core.rb +++ b/lib/flagsmith/engine/core.rb @@ -5,6 +5,7 @@ require_relative 'environments/models' require_relative 'features/models' +require_relative 'features/constants' require_relative 'identities/models' require_relative 'organisations/models' require_relative 'projects/models' @@ -12,79 +13,135 @@ require_relative 'segments/models' require_relative 'utils/hash_func' require_relative 'mappers' -require_relative 'evaluation/core' module Flagsmith + # Core evaluation logic for feature flags module Engine - # Flags engine methods - 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 + extend self + include Flagsmith::Engine::Utils::HashFunc + include Flagsmith::Engine::Features::TargetingReasons + include Flagsmith::Engine::Segments::Evaluator + + # Get evaluation result from evaluation context + # + # @param evaluation_context [Hash] The evaluation context + # @return [Hash] Evaluation result with flags and segments + def get_evaluation_result(evaluation_context) + evaluation_context = get_enriched_context(evaluation_context) + segments, segment_overrides = evaluate_segments(evaluation_context) + flags = evaluate_features(evaluation_context, segment_overrides) + { + flags: flags, + segments: segments + } + end - feature_state = feature_states.find { |f| f.feature.name == feature_name } + # Returns { segments: EvaluationResultSegments; segmentOverrides: Record; } + def evaluate_segments(evaluation_context) + return [], {} if evaluation_context[:segments].nil? - raise Flagsmith::FeatureStateNotFound, 'Feature State Not Found' if feature_state.nil? + identity_segments = get_segments_from_context(evaluation_context) - feature_state + segments = identity_segments.map do |segment| + { name: segment[:name], metadata: segment[:metadata] }.compact end - def get_identity_feature_states(environment, identity, override_traits = nil) - feature_states = get_identity_feature_states_dict(environment, identity, override_traits).values + segment_overrides = process_segment_overrides(identity_segments) + + [segments, segment_overrides] + end - return feature_states.select(&:enabled?) if environment.project.hide_disabled_flags + # Returns Record + def process_segment_overrides(identity_segments) # rubocop:disable Metrics/MethodLength + segment_overrides = {} - feature_states + identity_segments.each do |segment| + Array(segment[:overrides]).each do |override| + next unless should_apply_override(override, segment_overrides) + + segment_overrides[override[:name]] = { + feature: override, + segment_name: segment[:name] + } + end end - def get_environment_feature_state(environment, feature_name) - features_state = environment.feature_states.find { |f| f.feature.name == feature_name } + segment_overrides + end - raise Flagsmith::FeatureStateNotFound, 'Feature State Not Found' if features_state.nil? + def evaluate_features(evaluation_context, segment_overrides) + identity_key = get_identity_key(evaluation_context) - features_state + (evaluation_context[:features] || {}).each_with_object({}) do |(_, feature), flags| + segment_override = segment_overrides[feature[:name]] + final_feature = segment_override ? segment_override[:feature] : feature + + flag_result = build_flag_result(final_feature, identity_key, segment_override) + flags[final_feature[:name].to_sym] = flag_result end + end - def get_environment_feature_states(environment) - return environment.feature_states.select(&:enabled?) if environment.project.hide_disabled_flags + # Returns {value: any; reason?: string} + def evaluate_feature_value(feature, identity_key = nil) + return get_multivariate_feature_value(feature, identity_key) if feature[:variants]&.any? && identity_key - environment.feature_states - end + { value: feature[:value], reason: nil } + end - private + # Returns {value: any; reason?: string} + def get_multivariate_feature_value(feature, identity_key) + percentage_value = hashed_percentage_for_object_ids([feature[:key], identity_key]) + sorted_variants = (feature[:variants] || []).sort_by { |v| v[:priority] || WEAKEST_PRIORITY } - 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) + variant = find_matching_variant(sorted_variants, percentage_value) + variant || { value: feature[:value], reason: nil } + end - override_by_matching_segments(environment, identity, override_traits) do |fs| - override.call(fs) unless higher_segment_priority?(feature_states, fs) - end + def find_matching_variant(sorted_variants, percentage_value) + start_percentage = 0 + sorted_variants.each do |variant| + limit = start_percentage + variant[:weight] + return { value: variant[:value], reason: "#{TARGETING_REASON_SPLIT}; weight=#{variant[:weight]}" } if start_percentage <= percentage_value && percentage_value < limit - # Override with any feature states defined directly the identity - identity.identity_features.each(&override) - feature_states + start_percentage = limit end + nil + 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 + # returns boolean + def should_apply_override(override, existing_overrides) + current_override = existing_overrides[override[:name]] + !current_override || stronger_priority?(override[:priority], current_override[:feature][:priority]) + 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 + private + + def build_flag_result(feature, identity_key, segment_override) + evaluated = evaluate_feature_value(feature, identity_key) + + flag_result = { + name: feature[:name], + enabled: feature[:enabled], + value: evaluated[:value], + reason: evaluated[:reason] || (segment_override ? "#{TARGETING_REASON_TARGETING_MATCH}; segment=#{segment_override[:segment_name]}" : TARGETING_REASON_DEFAULT) + } + + flag_result[:metadata] = feature[:metadata] if feature[:metadata] + flag_result + end + + # Extract identity key from evaluation context + # + # @param evaluation_context [Hash] The evaluation context + # @return [String, nil] The identity key or nil if no identity + def get_identity_key(evaluation_context) + return nil unless evaluation_context[:identity] + + evaluation_context[:identity][:key] + end + + def stronger_priority?(priority_a, priority_b) + (priority_a || WEAKEST_PRIORITY) < (priority_b || WEAKEST_PRIORITY) end end end diff --git a/lib/flagsmith/engine/features/models.rb b/lib/flagsmith/engine/features/models.rb index d6d0ff2..de7ae0f 100644 --- a/lib/flagsmith/engine/features/models.rb +++ b/lib/flagsmith/engine/features/models.rb @@ -58,7 +58,7 @@ def multivariate_value(identity_id) # but `self` does. # 2. `other` have a feature segment with high priority def higher_segment_priority?(other) - feature_segment.priority.to_i < (other&.feature_segment&.priority || Float::INFINITY) + feature_segment.priority.to_i < (other&.feature_segment&.priority || WEAKEST_PRIORITY) rescue TypeError, NoMethodError false end diff --git a/lib/flagsmith/engine/mappers/environment.rb b/lib/flagsmith/engine/mappers/environment.rb index 75539f6..4931ace 100644 --- a/lib/flagsmith/engine/mappers/environment.rb +++ b/lib/flagsmith/engine/mappers/environment.rb @@ -26,7 +26,7 @@ def self.build_feature_hash(feature_state) name: feature_state.feature.name, enabled: feature_state.enabled, value: feature_state.get_value, - metadata: { flagsmith_id: feature_state.feature.id } + metadata: { id: feature_state.feature.id } } add_variants_to_feature(feature_hash, feature_state) add_priority_to_feature(feature_hash, feature_state) diff --git a/lib/flagsmith/engine/mappers/identity.rb b/lib/flagsmith/engine/mappers/identity.rb index 84c278c..45dc374 100644 --- a/lib/flagsmith/engine/mappers/identity.rb +++ b/lib/flagsmith/engine/mappers/identity.rb @@ -52,7 +52,7 @@ def self.build_overrides_key(identity_features) enabled: feature_state.enabled, value: feature_state.get_value, priority: Mappers::STRONGEST_PRIORITY, - metadata: { flagsmith_id: feature_state.feature.id } + metadata: { id: feature_state.feature.id } } end end diff --git a/lib/flagsmith/engine/mappers/segments.rb b/lib/flagsmith/engine/mappers/segments.rb index 7020be1..f842e6f 100644 --- a/lib/flagsmith/engine/mappers/segments.rb +++ b/lib/flagsmith/engine/mappers/segments.rb @@ -21,7 +21,7 @@ def self.build_segment_hash(segment) overrides: build_overrides(segment.feature_states), metadata: { source: 'API', - flagsmith_id: segment.id + id: segment.id } } end @@ -33,7 +33,7 @@ def self.build_overrides(feature_states) # rubocop:disable Metrics/MethodLength name: feature_state.feature.name, enabled: feature_state.enabled, value: feature_state.get_value, - metadata: { flagsmith_id: feature_state.feature.id } + metadata: { id: feature_state.feature.id } } add_priority_to_override(override_hash, feature_state) override_hash diff --git a/lib/flagsmith/engine/segments/evaluator.rb b/lib/flagsmith/engine/segments/evaluator.rb index 79a9cf3..c5d55cb 100644 --- a/lib/flagsmith/engine/segments/evaluator.rb +++ b/lib/flagsmith/engine/segments/evaluator.rb @@ -14,29 +14,6 @@ module Evaluator # rubocop:disable Metrics/ModuleLength include Flagsmith::Engine::Segments::Constants include Flagsmith::Engine::Utils::HashFunc - # Model-based segment evaluation - 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 - - def traits_match_segment_condition(identity_traits, condition, segment_id, identity_id) - if condition.operator == PERCENTAGE_SPLIT - return hashed_percentage_for_object_ids([segment_id, - identity_id]) <= condition.value.to_f - end - - trait = identity_traits.find { |t| t.key.to_s == condition.property } - - return handle_trait_existence_conditions(trait, condition.operator) if [IS_SET, - IS_NOT_SET].include?(condition.operator) - - return condition.match_trait_value?(trait.trait_value) if trait - - false - end - module_function def get_enriched_context(context) @@ -67,6 +44,22 @@ def get_segments_from_context(context) end end + def traits_match_segment_condition(identity_traits, condition, segment_id, identity_id) + if condition.operator == PERCENTAGE_SPLIT + return hashed_percentage_for_object_ids([segment_id, + identity_id]) <= condition.value.to_f + end + + trait = identity_traits.find { |t| t.key.to_s == condition.property } + + return handle_trait_existence_conditions(trait, condition.operator) if [IS_SET, + IS_NOT_SET].include?(condition.operator) + + return condition.match_trait_value?(trait.trait_value) if trait + + false + end + # Evaluates whether a given identity is in the provided segment. # # :param identity: identity model object to evaluate @@ -248,14 +241,6 @@ def primitive?(value) !(value.is_a?(Hash) || value.is_a?(Array)) end - - private - - def handle_trait_existence_conditions(matching_trait, operator) - return operator == IS_NOT_SET if matching_trait.nil? - - operator == IS_SET - end end end end diff --git a/lib/flagsmith/sdk/models/flags.rb b/lib/flagsmith/sdk/models/flags.rb index d851c98..59cea07 100644 --- a/lib/flagsmith/sdk/models/flags.rb +++ b/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 @@ -172,15 +174,27 @@ def from_api(json_data, **args) ) end - def from_feature_state_models(feature_states, identity_id: nil, **args) - to_flag_object = lambda { |feature_state, acc| - acc[normalize_key(feature_state.feature.name)] = - Flagsmith::Flags::Flag.from_feature_state_model(feature_state, identity_id) + def from_evaluation_result(evaluation_result, **args) + to_flag_object = lambda { |flag_result, acc| + id = flag_result.dig(:metadata, :id) + if id.nil? + raise Flagsmith::ClientError, + "FlagResult metadata.id is missing for feature \"#{flag_result[:name]}\". This indicates a bug in the SDK, please report it." + end + + acc[flag_result[:name]] = Collection.map_evaluated_flag_to_flag_result(flag_result, id) } - new( - feature_states.each_with_object({}, &to_flag_object), - **args + new(evaluation_result[:flags].each_value.each_with_object({}, &to_flag_object), **args) + end + + def map_evaluated_flag_to_flag_result(flag_result, id) + Flagsmith::Flags::Flag.new( + feature_name: flag_result[:name], + enabled: flag_result[:enabled], + value: flag_result[:value], + feature_id: id, + reason: flag_result[:reason] ) end diff --git a/spec/engine/e2e/engine_spec.rb b/spec/engine/e2e/engine_spec.rb index 0a40dbe..8fe8703 100644 --- a/spec/engine/e2e/engine_spec.rb +++ b/spec/engine/e2e/engine_spec.rb @@ -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) + evaluation_result = Flagsmith::Engine.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 diff --git a/spec/engine/unit/core_spec.rb b/spec/engine/unit/core_spec.rb deleted file mode 100644 index ad94a63..0000000 --- a/spec/engine/unit/core_spec.rb +++ /dev/null @@ -1,114 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -RSpec.describe Flagsmith::Engine, type: :model do - subject { Flagsmith::Engine::Engine.new } - - it 'test_identity_get_feature_state_without_any_override' do - feature_state = subject.get_identity_feature_state( - environment, identity, feature1.name - ) - - expect(feature_state.feature).to eq(feature1) - end - - it 'test_identity_get_feature_state_without_any_override_no_fs' do - expect { - subject.get_identity_feature_state(environment, identity, 'nonExistentName') - }.to raise_error(Flagsmith::FeatureStateNotFound) - end - - it 'test_identity_get_all_feature_states_no_segments' do - env = environment - ident = identity - overridden_feature = Flagsmith::Engine::Feature.new( - id: 3, name: 'overridden_feature', type: 'STANDARD' - ) - - env.feature_states << Flagsmith::Engine::FeatureState.new( - feature: overridden_feature, enabled: false, django_id: 3 - ) - - ident.identity_features << Flagsmith::Engine::FeatureState.new( - feature: overridden_feature, enabled: true, id: 4 - ) - - feature_states = subject.get_identity_feature_states(env, ident) - - expect(feature_states.length).to eq(3) - - feature_states.each do |feature_state| - environment_feature_state = get_environment_feature_state_for_feature( - env, feature_state.feature - ) - expected = - if environment_feature_state&.feature == overridden_feature then true - else environment_feature_state&.enabled - end - expect(feature_state.enabled?).to eq(expected) - end - end - - it 'test_identity_get_all_feature_states_with_traits' do - trait_models = [Flagsmith::Engine::Identities::Trait.new( - trait_key: Engine::Builders::SEGMENT_CONDITION_PROPERTY, - trait_value: Engine::Builders::SEGMENT_CONDITION_STRING_VALUE - )] - - feature_states = subject.get_identity_feature_states( - environment_with_segment_override, identity_in_segment, trait_models - ) - - expect(feature_states.first.get_value).to eq(Engine::Builders::SEGMENT_OVERRIDE_FEATURE_STATE_VALUE) - end - - it 'test_identity_get_all_feature_states_with_traits_hideDisabledFlags' do - trait_models = [Flagsmith::Engine::Identities::Trait.new( - trait_key: Engine::Builders::SEGMENT_CONDITION_PROPERTY, - trait_value: Engine::Builders::SEGMENT_CONDITION_STRING_VALUE - )] - - env = environment_with_segment_override - env.project.hide_disabled_flags = true - - feature_states = subject.get_identity_feature_states( - env, identity_in_segment, trait_models - ) - expect(feature_states.length).to eq(0) - end - - it 'test_environment_get_all_feature_states' do - env = environment - feature_states = subject.get_environment_feature_states(env) - - expect(feature_states).to eq(env.feature_states) - end - - it 'test_environment_get_feature_states_hides_disabled_flags_if_enabled' do - env = environment - - env.project.hide_disabled_flags = true - - feature_states = subject.get_environment_feature_states(env) - - expect(feature_states).to_not eq(env.feature_states) - feature_states.each do |fs| - expect(fs.enabled).to be_truthy - end - end - - it 'test_environment_get_feature_state' do - env = environment - feature = feature1 - feature_state = subject.get_environment_feature_state(env, feature.name) - - expect(feature_state.feature).to eq(feature) - end - - it 'test_environment_get_feature_state_raises_feature_state_not_found' do - expect { - subject.get_environment_feature_state(environment, 'not_a_feature_name') - }.to raise_error(Flagsmith::FeatureStateNotFound) - end -end diff --git a/spec/engine/unit/evaluation_context_mappers_spec.rb b/spec/engine/unit/evaluation_context_mappers_spec.rb index 0af9686..ce422b7 100644 --- a/spec/engine/unit/evaluation_context_mappers_spec.rb +++ b/spec/engine/unit/evaluation_context_mappers_spec.rb @@ -33,7 +33,7 @@ expect(segment[:rules].length).to eq(1) expect(segment[:overrides]).to be_empty.or be_an(Array) expect(segment[:metadata][:source]).to eq('API') - expect(segment[:metadata][:flagsmith_id]).to eq(1) + expect(segment[:metadata][:id]).to eq(1) # Verify segment rules expect(segment[:rules][0][:type]).to eq('ALL') @@ -72,7 +72,7 @@ expect(override[:enabled]).to be false expect(override[:value]).to eq('some-overridden-value') expect(override[:priority]).to eq(Flagsmith::Engine::Mappers::STRONGEST_PRIORITY) - expect(override[:metadata][:flagsmith_id]).to eq(1) + expect(override[:metadata][:id]).to eq(1) # Verify features expect(context[:features]).to be_a(Hash) @@ -83,7 +83,7 @@ expect(some_feature[:enabled]).to be true expect(some_feature[:value]).to eq('some-value') expect(some_feature[:priority]).to be_nil - expect(some_feature[:metadata][:flagsmith_id]).to eq(1) + expect(some_feature[:metadata][:id]).to eq(1) # Verify multivariate feature expect(context[:features]).to have_key('test_mv') diff --git a/spec/engine/unit/segments/evaluator_spec.rb b/spec/engine/unit/segments/evaluator_spec.rb deleted file mode 100644 index d89106b..0000000 --- a/spec/engine/unit/segments/evaluator_spec.rb +++ /dev/null @@ -1,29 +0,0 @@ -# frozen_string_literal: true - -require 'spec_helper' - -# list of test cases containing: operator, property, value, traits (list of dicts), expected_result -TEST_CASES = [ - ['IS_SET', 'foo', nil, {}, false], - ['IS_SET', 'foo', nil, {'foo': 'bar'}, true], - ['IS_NOT_SET', 'foo', nil, {}, true], - ['IS_NOT_SET', 'foo', nil, {'foo': 'bar'}, false], -] - -RSpec.describe Flagsmith::Engine::Segments::Evaluator do - subject { Class.new { extend Flagsmith::Engine::Segments::Evaluator } } - - TEST_CASES.each do |(operator, property, value, traits, expected_result)| - it "traits: #{traits} #traits_match_segment_condition(#{operator}, #{property}, #{value || 'No value'}) should be #{expected_result}" do - condition = Flagsmith::Engine::Segments::Condition.new( - operator: operator, property: property, value: value - ) - trait_models = traits.map { - |k,v| Flagsmith::Engine::Identities::Trait.new(trait_key: k, trait_value: v) - } - - expect(subject.traits_match_segment_condition( - trait_models, condition, 1, 1)).to eq(expected_result) - end - end -end