featureflip 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b4009e153b6dc621cee9ed4d8f1aaa7f199396e5d8a8266d949b3367b0f06b8
-  data.tar.gz: 1f45c271ce3d180c362cfa095d6027f0d5d48f51cc259fd31215baa8959732d6
+  metadata.gz: 74310b5e1a7545b5d289a4f09d32c7e396f3f03bcb5af9265fe970667f2aedfd
+  data.tar.gz: 6f0fd700429f63dbba04b3311c88700e9281113f0b114a6c635797745ca1cddc
 SHA512:
-  metadata.gz: debfee24678c85c688e94935396ef142f3b1f31aaec0b7788c6fc09e51e03e805104f273e53bda66686d4eded49baff6e33f58bb7e0b2543cbdf5cfac1cf9289
-  data.tar.gz: ff2cc0874823a1dcd23c3fc29dd70deffb46b0a08fc6c9efce620299bb3200b6edbf78d5352579e2b476725e5870d9bcde1f2a48faafc8e5ccca11e113e750ba
+  metadata.gz: 6eb646f7ba550b44639e2d294ad8b171d2a9931f5004afcdb7621db46abc18dfa047732da544e74a9167a509da1fd5018e71e49f7126e0753ee87f8ac9e2bccf
+  data.tar.gz: ca59f44a28682ac0fcc5924d4a19e3bb9df8ae76809dfa133f34a57d4bf24243e3cf4b2b7a7f82a54efc0249653a6d54a1fd6ca4c5d0b685fbe2438282e27776

data/lib/featureflip/evaluation/evaluator.rb

@@ -4,20 +4,37 @@ require_relative "bucketing"
 module Featureflip
   module Evaluation
     class Evaluator
+      # Mirrors packages/js-sdk/src/core/evaluator.ts. The guard uses `>` (not `>=`)
+      # so a chain of MAX_PREREQUISITE_DEPTH + 1 nested flags trips the cap — matches
+      # the JS reference implementation; see prerequisite_spec.rb depth test.
+      MAX_PREREQUISITE_DEPTH = 10
+
       def initialize
         @condition_evaluator = ConditionEvaluator.new
       end
 
-      def evaluate(flag, context, get_segment: nil)
+      def evaluate(flag, context, get_segment: nil, all_flags: {})
+        evaluate_with_shared_memo(flag, context, get_segment: get_segment, all_flags: all_flags, memo: {})
+      end
+
+      def evaluate_with_shared_memo(flag, context, all_flags:, memo:, get_segment: nil)
+        evaluate_internal(flag, context, get_segment, all_flags, 0, memo)
+      end
+
+      private
+
+      def evaluate_internal(flag, context, get_segment, all_flags, depth, memo)
+        if depth > MAX_PREREQUISITE_DEPTH
+          return off_result(flag, reason: "Error")
+        end
+
         unless flag.enabled
-          variation = flag.get_variation(flag.off_variation)
-          return Models::EvaluationDetail.new(
-            value: variation&.value,
-            reason: "FlagDisabled",
-            variation_key: flag.off_variation
-          )
+          return off_result(flag, reason: "FlagDisabled")
         end
 
+        prereq_failure = resolve_prerequisites(flag, context, get_segment, all_flags, depth, memo)
+        return prereq_failure if prereq_failure
+
         sorted_rules = flag.rules.sort_by(&:priority)
         sorted_rules.each do |rule|
           conditions_match = if rule.segment_key && get_segment
@@ -38,25 +55,72 @@ module Featureflip
           if conditions_match
             variation_key = resolve_serve(rule.serve, context)
             variation = flag.get_variation(variation_key)
-            return Models::EvaluationDetail.new(
+            result = Models::EvaluationDetail.new(
               value: variation&.value,
               reason: "RuleMatch",
               rule_id: rule.id,
               variation_key: variation_key
             )
+            memo[flag.key] = result
+            return result
           end
         end
 
         variation_key = resolve_serve(flag.fallthrough, context)
         variation = flag.get_variation(variation_key)
-        Models::EvaluationDetail.new(
+        result = Models::EvaluationDetail.new(
           value: variation&.value,
           reason: "Fallthrough",
           variation_key: variation_key
         )
+        memo[flag.key] = result
+        result
       end
 
-      private
+      # Returns nil when all prerequisites pass; otherwise returns the off-variation
+      # result for the flag and memoises it under flag.key. Mirrors the per-branch
+      # memo writes in the JS SDK evaluator.
+      def resolve_prerequisites(flag, context, get_segment, all_flags, depth, memo)
+        prerequisites = flag.prerequisites || []
+        prerequisites.each do |prereq|
+          key = prereq.prerequisite_flag_key
+          prereq_result = memo[key]
+
+          unless prereq_result
+            prereq_flag = all_flags[key]
+            unless prereq_flag
+              return memoise(memo, flag.key, off_result(flag, reason: "PrerequisiteFailed", prerequisite_key: key))
+            end
+
+            prereq_result = evaluate_internal(prereq_flag, context, get_segment, all_flags, depth + 1, memo)
+            memo[key] = prereq_result
+          end
+
+          if prereq_result.reason == "Error"
+            return memoise(memo, flag.key, off_result(flag, reason: "Error"))
+          end
+
+          if prereq_result.variation_key != prereq.expected_variation_key
+            return memoise(memo, flag.key, off_result(flag, reason: "PrerequisiteFailed", prerequisite_key: key))
+          end
+        end
+        nil
+      end
+
+      def memoise(memo, key, result)
+        memo[key] = result
+        result
+      end
+
+      def off_result(flag, reason:, prerequisite_key: nil)
+        variation = flag.get_variation(flag.off_variation)
+        Models::EvaluationDetail.new(
+          value: variation&.value,
+          reason: reason,
+          variation_key: flag.off_variation,
+          prerequisite_key: prerequisite_key
+        )
+      end
 
       def resolve_serve(serve, context)
         if serve.type == "Fixed"

data/lib/featureflip/http/client.rb

@@ -82,7 +82,15 @@ module Featureflip
           variations: (data["variations"] || []).map { |v| Models::Variation.new(key: v["key"], value: v["value"]) },
           rules: (data["rules"] || []).map { |r| parse_rule(r) },
           fallthrough: parse_serve(data["fallthrough"]),
-          off_variation: data["offVariation"]
+          off_variation: data["offVariation"],
+          prerequisites: (data["prerequisites"] || []).map { |p| parse_prerequisite(p) }
+        )
+      end
+
+      def parse_prerequisite(data)
+        Models::Prerequisite.new(
+          prerequisite_flag_key: data["prerequisiteFlagKey"],
+          expected_variation_key: data["expectedVariationKey"]
         )
       end
 

data/lib/featureflip/models/evaluation_detail.rb

@@ -1,7 +1,7 @@
 module Featureflip
   module Models
-    EvaluationDetail = Struct.new(:value, :reason, :rule_id, :variation_key, keyword_init: true) do
-      def initialize(value:, reason:, rule_id: nil, variation_key: nil)
+    EvaluationDetail = Struct.new(:value, :reason, :rule_id, :variation_key, :prerequisite_key, keyword_init: true) do
+      def initialize(value:, reason:, rule_id: nil, variation_key: nil, prerequisite_key: nil)
         super
       end
     end

data/lib/featureflip/models/flag.rb

@@ -28,7 +28,16 @@ module Featureflip
       end
     end
 
-    FlagConfiguration = Struct.new(:key, :version, :type, :enabled, :variations, :rules, :fallthrough, :off_variation, keyword_init: true) do
+    Prerequisite = Struct.new(:prerequisite_flag_key, :expected_variation_key, keyword_init: true)
+
+    FlagConfiguration = Struct.new(
+      :key, :version, :type, :enabled, :variations, :rules, :fallthrough, :off_variation, :prerequisites,
+      keyword_init: true
+    ) do
+      def initialize(key:, version:, type:, enabled:, variations:, rules:, fallthrough:, off_variation:, prerequisites: [])
+        super
+      end
+
       def get_variation(key)
         @variations_by_key ||= variations.each_with_object({}) { |v, h| h[v.key] = v }
         @variations_by_key[key]

data/lib/featureflip/shared_core.rb

@@ -135,7 +135,12 @@ module Featureflip
         return Models::EvaluationDetail.new(value: default_value, reason: "FlagNotFound")
       end
 
-      result = @evaluator.evaluate(flag, context, get_segment: method(:get_segment))
+      result = @evaluator.evaluate(
+        flag,
+        context,
+        get_segment: method(:get_segment),
+        all_flags: @store.all_flags_map
+      )
       value = result.value.nil? ? default_value : result.value
       record_evaluation(key, context, result.variation_key)
 
@@ -143,10 +148,14 @@ module Featureflip
         value: value,
         reason: result.reason,
         rule_id: result.rule_id,
-        variation_key: result.variation_key
+        variation_key: result.variation_key,
+        prerequisite_key: result.prerequisite_key
       )
     rescue StandardError
-      Models::EvaluationDetail.new(value: default_value, reason: "Error")
+      # Prerequisite-resolution failures return PrerequisiteFailed cleanly through
+      # the evaluator; this rescue only fires on unexpected exceptions (malformed
+      # config, programming errors), so prerequisite_key has no defined value.
+      Models::EvaluationDetail.new(value: default_value, reason: "Error", prerequisite_key: nil)
     end
 
     # --- Event methods ---

data/lib/featureflip/store/flag_store.rb

@@ -28,6 +28,10 @@ module Featureflip
         @mutex.synchronize { @flags.values }
       end
 
+      def all_flags_map
+        @mutex.synchronize { @flags.dup }
+      end
+
       def upsert(flag)
         @mutex.synchronize do
           existing = @flags[flag.key]

data/lib/featureflip/version.rb

@@ -1,3 +1,3 @@
 module Featureflip
-  VERSION = "2.0.0"
+  VERSION = "2.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: featureflip
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Featureflip
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-11 00:00:00.000000000 Z
+date: 2026-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec