feat: linter

Zaimwa9 · Zaimwa9 · commit 1bdaad6cd8d3 · 2025-11-11T12:47:32.000+01:00
diff --git a/lib/flagsmith.rb b/lib/flagsmith.rb
@@ -206,35 +206,22 @@ 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)
-
-      context = Flagsmith::Engine::Mappers.get_evaluation_context(
-        environment, identity_model
-      )
-
-      unless context
-        raise Flagsmith::ClientError,
-              'Local evaluation required to obtain identity segments'
-      end
+      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].map do |segment_result|
+      evaluation_result[:segments].filter_map do |segment_result|
         flagsmith_id = segment_result.dig(:metadata, :flagsmith_id)
-        next unless flagsmith_id
-
-        Flagsmith::Segments::Segment.new(id: flagsmith_id, name: segment_result[:name])
-      end.compact
+        Flagsmith::Segments::Segment.new(id: flagsmith_id, name: segment_result[:name]) if flagsmith_id
+      end
     end
 
     private
 
-    def environment_flags_from_document
+    def environment_flags_from_document # rubocop:disable Metrics/MethodLength
       context = Flagsmith::Engine::Mappers.get_evaluation_context(environment)
 
       unless context
@@ -254,22 +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
-      )
-
-      unless context
-        raise Flagsmith::ClientError,
-              'Unable to get flags. No environment present.'
-      end
+      context = Flagsmith::Engine::Mappers.get_evaluation_context(environment, identity_model)
+      raise Flagsmith::ClientError, 'Unable to get flags. No environment present.' unless context
 
       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,
+        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
@@ -44,13 +44,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)
@@ -59,15 +53,11 @@ def evaluate_segments(evaluation_context)
     end
 
     # Returns Record<string: override.name, SegmentOverride>
-    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]] = {
@@ -82,33 +72,15 @@ def process_segment_overrides(identity_segments)
 
     # returns EvaluationResultFlags<Metadata>
     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}
@@ -123,19 +95,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
@@ -144,12 +116,22 @@ def should_apply_override(override, existing_overrides)
       !current_override || stronger_priority?(override[:priority], current_override[:feature][:priority])
     end
 
-    def stronger_priority?(priority_a, priority_b)
-      (priority_a || WEAKEST_PRIORITY) < (priority_b || WEAKEST_PRIORITY)
-    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
@@ -159,5 +141,9 @@ def get_identity_key(evaluation_context)
 
       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/sdk/models/flags.rb b/lib/flagsmith/sdk/models/flags.rb
@@ -177,25 +177,24 @@ def from_api(json_data, **args)
         def from_evaluation_result(evaluation_result, **args)
           to_flag_object = lambda { |flag_result, acc|
             flagsmith_id = flag_result.dig(:metadata, :flagsmith_id)
-
             if flagsmith_id.nil?
               raise Flagsmith::ClientError,
-                    "FlagResult metadata.flagsmith_id is missing for feature \"#{flag_result[:name]}\". " \
-                    'This indicates a bug in the SDK, please report it.'
+                    "FlagResult metadata.flagsmith_id is missing for feature \"#{flag_result[:name]}\". This indicates a bug in the SDK, please report it."
             end
 
-            acc[flag_result[:name]] = Flagsmith::Flags::Flag.new(
-              feature_name: flag_result[:name],
-              enabled: flag_result[:enabled],
-              value: flag_result[:value],
-              feature_id: flagsmith_id,
-              reason: flag_result[:reason]
-            )
+            acc[flag_result[:name]] = Collection.map_evaluated_flag_to_flag_result(flag_result, flagsmith_id)
           }
 
-          new(
-            evaluation_result[:flags].each_value.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, flagsmith_id)
+          Flagsmith::Flags::Flag.new(
+            feature_name: flag_result[:name],
+            enabled: flag_result[:enabled],
+            value: flag_result[:value],
+            feature_id: flagsmith_id,
+            reason: flag_result[:reason]
           )
         end
 
