feat: run-lint

Author: Zaimwa9

lib/flagsmith/engine/evaluation/core.rb

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

lib/flagsmith/engine/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) || {}

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