featurevisor 2.0.0 → 3.0.0

data/lib/featurevisor/events.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Featurevisor
   # Events module for generating event parameters
   module Events
@@ -8,7 +10,7 @@ module Featurevisor
     # @param new_sticky [Hash] New sticky features
     # @param replace [Boolean] Whether features were replaced
     # @return [Hash] Event parameters
-    def self.get_params_for_sticky_set_event(previous_sticky = {}, new_sticky = {}, replace = false)
+    def self.get_params_for_sticky_features_set_event(previous_sticky = {}, new_sticky = {}, replace = false)
       keys_before = previous_sticky.keys
       keys_after = new_sticky.keys
 
@@ -20,6 +22,13 @@ module Featurevisor
       }
     end
 
+    def self.get_params_for_sticky_variables_set_event(previous_sticky = {}, new_sticky = {}, replace = false)
+      {
+        variables: (previous_sticky.keys + new_sticky.keys).uniq,
+        replaced: replace
+      }
+    end
+
     # Get parameters for datafile set event
     # @param previous_reader [InstanceEvaluationDataProvider] Previous datafile
     # @param new_reader [InstanceEvaluationDataProvider] New datafile
@@ -30,6 +39,8 @@ module Featurevisor
 
       new_revision = new_reader.get_revision
       new_feature_keys = new_reader.get_feature_keys
+      previous_variable_keys = previous_reader.get_variable_keys
+      new_variable_keys = new_reader.get_variable_keys
 
       # results
       removed_features = []
@@ -48,7 +59,8 @@ module Featurevisor
         previous_feature = previous_reader.get_feature(previous_feature_key)
         new_feature = new_reader.get_feature(previous_feature_key)
 
-        if previous_feature && new_feature && previous_feature[:hash] != new_feature[:hash]
+        if previous_feature && new_feature &&
+           (previous_feature[:hash].nil? || new_feature[:hash].nil? || previous_feature[:hash] != new_feature[:hash])
           # feature was changed in new datafile
           changed_features << previous_feature_key
         end
@@ -64,14 +76,118 @@ module Featurevisor
 
       # combine all affected feature keys
       all_affected_features = (removed_features + changed_features + added_features).uniq
+      all_affected_variables = (previous_variable_keys + new_variable_keys).uniq.select do |key|
+        previous = previous_reader.get_global_variable(key)
+        current = new_reader.get_global_variable(key)
+        previous.nil? || current.nil? || previous[:hash].nil? || current[:hash].nil? || previous[:hash] != current[:hash]
+      end
+
+
+      changed_segments = (previous_reader.get_segment_keys + new_reader.get_segment_keys).uniq.select do |key|
+        previous_reader.get_segment(key) != new_reader.get_segment(key)
+      end.map(&:to_s)
+      feature_keys = (previous_feature_keys + new_feature_keys).uniq
+      loop do
+        before = all_affected_features.length
+        feature_keys.each do |key|
+          next if all_affected_features.include?(key)
+
+          candidates = [previous_reader.get_feature(key), new_reader.get_feature(key)].compact
+          all_affected_features << key if candidates.any? do |feature|
+            dependency = feature_dependencies(feature)
+            !(dependency[:segments].map(&:to_s) & changed_segments).empty? ||
+              !(dependency[:features].map(&:to_s) & all_affected_features.map(&:to_s)).empty?
+          end
+        end
+        break if before == all_affected_features.length
+      end
+
+      (previous_variable_keys + new_variable_keys).uniq.each do |key|
+        next if all_affected_variables.include?(key)
+
+        candidates = [previous_reader.get_global_variable(key), new_reader.get_global_variable(key)].compact
+        all_affected_variables << key if candidates.any? do |variable|
+          dependency = global_variable_dependencies(variable)
+          !(dependency[:segments].map(&:to_s) & changed_segments).empty? ||
+            !(dependency[:features].map(&:to_s) & all_affected_features.map(&:to_s)).empty?
+        end
+      end
 
       {
         revision: new_revision,
         previousRevision: previous_revision,
         revisionChanged: previous_revision != new_revision,
         features: all_affected_features,
+        variables: all_affected_variables,
         replaced: replace
       }
     end
+
+    def self.required_feature_keys(values)
+      items = values.is_a?(Array) ? values : [values].compact
+      items.filter_map do |required|
+        required.is_a?(String) ? required : (required[:feature] || required[:key])
+      end
+    end
+    private_class_method :required_feature_keys
+
+    def self.segment_keys(value)
+      return [] if value.nil? || value == "*"
+      if value.is_a?(String)
+        if value.start_with?("{", "[")
+          begin
+            return segment_keys(JSON.parse(value, symbolize_names: true))
+          rescue JSON::ParserError
+            return []
+          end
+        end
+        return [value]
+      end
+      return value.flat_map { |item| segment_keys(item) }.uniq if value.is_a?(Array)
+      return [] unless value.is_a?(Hash)
+
+      %i[and or not].flat_map { |key| segment_keys(value[key] || value[key.to_s]) }.uniq
+    end
+    private_class_method :segment_keys
+
+    def self.override_dependencies(groups)
+      overrides = groups.is_a?(Hash) ? groups.values.flatten : []
+      {
+        segments: overrides.flat_map { |override| segment_keys(override[:segments]) }.uniq,
+        features: overrides.flat_map { |override| required_feature_keys(override[:requiredFeatures]) }.uniq
+      }
+    end
+    private_class_method :override_dependencies
+
+    def self.feature_dependencies(feature)
+      requirements = feature.key?(:requiredFeatures) ? feature[:requiredFeatures] : feature[:required]
+      segments = []
+      features = required_feature_keys(requirements)
+      Array(feature[:traffic]).each do |traffic|
+        segments.concat(segment_keys(traffic[:segments]))
+        nested = override_dependencies(traffic[:variableOverrides])
+        segments.concat(nested[:segments])
+        features.concat(nested[:features])
+      end
+      Array(feature[:force]).each { |force| segments.concat(segment_keys(force[:segments])) }
+      Array(feature[:variations]).each do |variation|
+        nested = override_dependencies(variation[:variableOverrides])
+        segments.concat(nested[:segments])
+        features.concat(nested[:features])
+      end
+      { segments: segments.uniq, features: features.uniq }
+    end
+    private_class_method :feature_dependencies
+
+    def self.global_variable_dependencies(variable)
+      segments = []
+      features = required_feature_keys(variable[:requiredFeatures])
+      Array(variable[:overrides]).each do |override|
+        segments.concat(segment_keys(override[:segments]))
+        features.concat(required_feature_keys(override[:requiredFeatures]))
+      end
+      { segments: segments.uniq, features: features.uniq }
+    end
+    private_class_method :global_variable_dependencies
   end
 end

data/lib/featurevisor/instance.rb

@@ -11,7 +11,8 @@ module Featurevisor
       schemaVersion: "2",
       revision: "unknown",
       segments: {},
-      features: {}
+      features: {},
+      variables: {}
     }.freeze
 
     # Initialize a new Featurevisor instance
@@ -19,7 +20,7 @@ module Featurevisor
     # @option options [Hash, String] :datafile Datafile content or JSON string
     # @option options [Hash] :context Initial context
     # @option options [String] :log_level Log level
-    # @option options [Hash] :sticky Sticky features
+    # @option options [Hash] :sticky_features Sticky features
     # @option options [Array<Hash, FeaturevisorModule>] :modules Array of modules
     # @option options [Proc] :on_diagnostic Diagnostic handler
     def initialize(options = {})
@@ -31,7 +32,8 @@ module Featurevisor
       )
       @on_diagnostic = options[:on_diagnostic] || options[:onDiagnostic]
       @emitter = Featurevisor::Emitter.new
-      @sticky = options[:sticky] || {}
+      @sticky_features = options[:sticky_features] || options[:stickyFeatures] || {}
+      @sticky_variables = options[:sticky_variables] || options[:stickyVariables] || {}
       @closed = false
       @module_diagnostic_subscriptions = []
 
@@ -108,7 +110,8 @@ module Featurevisor
                           end
         unless parsed_datafile.is_a?(Hash) && parsed_datafile[:schemaVersion].is_a?(String) &&
                parsed_datafile[:revision].is_a?(String) && parsed_datafile[:segments].is_a?(Hash) &&
-               parsed_datafile[:features].is_a?(Hash)
+               parsed_datafile[:features].is_a?(Hash) &&
+               (!parsed_datafile.key?(:variables) || parsed_datafile[:variables].is_a?(Hash))
           raise ArgumentError, "Invalid datafile"
         end
         next_datafile = replace ? parsed_datafile : merge_datafiles(@datafile.get_datafile, parsed_datafile)
@@ -140,27 +143,35 @@ module Featurevisor
     # Set sticky features
     # @param sticky [Hash] Sticky features
     # @param replace [Boolean] Whether to replace existing sticky features
-    def set_sticky(sticky, replace = false)
-      previous_sticky_features = @sticky || {}
+    def set_sticky_features(sticky, replace = false)
+      previous_sticky_features = @sticky_features || {}
 
       if replace
-        @sticky = sticky
+        @sticky_features = sticky
       else
-        @sticky = {
-          **@sticky,
+        @sticky_features = {
+          **@sticky_features,
           **sticky
         }
       end
 
-      params = Featurevisor::Events.get_params_for_sticky_set_event(previous_sticky_features, @sticky, replace)
+      params = Featurevisor::Events.get_params_for_sticky_features_set_event(previous_sticky_features, @sticky_features, replace)
 
       report_diagnostic(
         level: "info",
-        code: "sticky_set",
+        code: "sticky_features_set",
         message: "Sticky features set",
         details: params
       )
-      @emitter.trigger("sticky_set", params)
+      @emitter.trigger("sticky_features_set", params)
+    end
+
+    def set_sticky_variables(sticky, replace = false)
+      previous = @sticky_variables || {}
+      @sticky_variables = replace ? sticky : { **@sticky_variables, **sticky }
+      params = Featurevisor::Events.get_params_for_sticky_variables_set_event(previous, @sticky_variables, replace)
+      report_diagnostic(level: "info", code: "sticky_variables_set", message: "Sticky variables set", details: params)
+      @emitter.trigger("sticky_variables_set", params)
     end
 
     # Get the revision
@@ -181,7 +192,7 @@ module Featurevisor
       @datafile.get_feature_keys
     end
 
-    def get_variable_keys(feature_key)
+    def get_variable_keys(feature_key = nil)
       @datafile.get_variable_keys(feature_key)
     end
 
@@ -275,7 +286,8 @@ module Featurevisor
       Featurevisor::ChildInstance.new(
         parent: self,
         context: get_context(context),
-        sticky: options[:sticky]
+        sticky_features: options[:sticky_features] || options[:stickyFeatures],
+        sticky_variables: options[:sticky_variables] || options[:stickyVariables]
       )
     end
 
@@ -350,12 +362,17 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Hash] Evaluation result
-    def evaluate_variable(feature_key, variable_key, context = {}, options = {})
+    def evaluate_variable(feature_or_variable_key, variable_key_or_context = nil, context_or_options = {}, options = {})
+      if variable_key_or_context.nil? || variable_key_or_context.is_a?(Hash)
+        context = variable_key_or_context || {}
+        return evaluate_variable_without_feature(feature_or_variable_key, context, context_or_options)
+      end
+
       Featurevisor::Evaluate.evaluate_with_modules(
-        get_evaluation_dependencies(context, options).merge(
+        get_evaluation_dependencies(context_or_options, options).merge(
           type: "variable",
-          feature_key: feature_key,
-          variable_key: variable_key
+          feature_key: feature_or_variable_key,
+          variable_key: variable_key_or_context
         )
       )
     end
@@ -366,13 +383,13 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Object, nil] Variable value or nil
-    def get_variable(feature_key, variable_key, context = {}, options = {})
+    def get_variable(feature_or_variable_key, variable_key_or_context = nil, context_or_options = {}, options = {})
       begin
-        evaluation = evaluate_variable(feature_key, variable_key, context, options)
+        evaluation = evaluate_variable(feature_or_variable_key, variable_key_or_context, context_or_options, options)
 
         if evaluation.key?(:variable_value)
-          if evaluation[:variable_schema] &&
-             evaluation[:variable_schema][:type] == "json" &&
+          variable_type = evaluation.dig(:variable_schema, :type) || evaluation.dig(:variable, :type)
+          if variable_type == "json" &&
              evaluation[:variable_value].is_a?(String)
             JSON.parse(evaluation[:variable_value], symbolize_names: true)
           else
@@ -382,7 +399,7 @@ module Featurevisor
           nil
         end
       rescue => e
-        report_diagnostic(level: "error", code: "evaluation_error", message: "getVariable failed", originalError: e, details: { featureKey: feature_key, variableKey: variable_key })
+        report_diagnostic(level: "error", code: "evaluation_error", message: "getVariable failed", originalError: e, details: { variableKey: variable_key_or_context || feature_or_variable_key })
         nil
       end
     end
@@ -393,8 +410,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Boolean, nil] Boolean value or nil
-    def get_variable_boolean(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_boolean(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "boolean")
     end
 
@@ -404,8 +421,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [String, nil] String value or nil
-    def get_variable_string(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_string(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "string")
     end
 
@@ -415,8 +432,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Integer, nil] Integer value or nil
-    def get_variable_integer(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_integer(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "integer")
     end
 
@@ -426,8 +443,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Float, nil] Float value or nil
-    def get_variable_double(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_double(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "double")
     end
 
@@ -437,8 +454,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Array, nil] Array value or nil
-    def get_variable_array(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_array(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "array")
     end
 
@@ -448,8 +465,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Hash, nil] Object value or nil
-    def get_variable_object(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_object(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "object")
     end
 
@@ -459,8 +476,8 @@ module Featurevisor
     # @param context [Hash] Context
     # @param options [Hash] Override options
     # @return [Object, nil] JSON value or nil
-    def get_variable_json(feature_key, variable_key, context = {}, options = {})
-      variable_value = get_variable(feature_key, variable_key, context, options)
+    def get_variable_json(*args)
+      variable_value = get_variable(*args)
       get_value_by_type(variable_value, "json")
     end
 
@@ -469,7 +486,7 @@ module Featurevisor
     # @param feature_keys [Array<String>] Feature keys to evaluate
     # @param options [Hash] Override options
     # @return [Hash] All evaluations
-    def get_all_evaluations(context = {}, feature_keys = [], options = {})
+    def get_feature_evaluations(context = {}, feature_keys = [], options = {})
       result = {}
 
       keys = feature_keys.size > 0 ? feature_keys : @datafile.get_feature_keys
@@ -510,8 +527,100 @@ module Featurevisor
       result
     end
 
+    def get_variable_evaluations(context = {}, variable_keys = [], options = {})
+      keys = variable_keys.empty? ? @datafile.get_variable_keys : variable_keys
+      keys.to_h { |key| [key, get_variable(key.to_s, context, options)] }
+    end
+
     private
 
+    def evaluate_variable_without_feature(variable_key, context = {}, options = {})
+      evaluation_options = {
+        type: "variable",
+        variable_key: variable_key.to_s,
+        context: get_context(context)
+      }
+      evaluation_options[:default_variable_value] = options[:default_variable_value] if options.key?(:default_variable_value)
+      begin
+        evaluation_options = @modules_manager.run_before_evaluation_modules(evaluation_options)
+        resolved_key = evaluation_options[:variable_key]
+        variable = @datafile.get_global_variable(resolved_key)
+        sticky = options[:__featurevisor_child_sticky_variables] || @sticky_variables
+        evaluation = { type: "variable", variable_key: resolved_key, reason: Featurevisor::EvaluationReason::VARIABLE_NOT_FOUND }
+
+        if sticky.key?(resolved_key) || sticky.key?(resolved_key.to_sym)
+          sticky_value = sticky.key?(resolved_key) ? sticky[resolved_key] : sticky[resolved_key.to_sym]
+          evaluation.merge!(reason: Featurevisor::EvaluationReason::STICKY, variable: variable,
+                            variable_value: sticky_value)
+        elsif variable
+          unless required_features_are_matched(variable[:requiredFeatures], evaluation_options[:context], options)
+            value_key = variable[:useDefaultWhenDisabled] ? :defaultValue : :disabledValue
+            evaluation.merge!(reason: Featurevisor::EvaluationReason::REQUIRED_FEATURES_UNMET,
+                              variable: variable)
+            evaluation[:variable_value] = variable[value_key] if variable.key?(value_key)
+          else
+            (variable[:overrides] || []).each_with_index do |override, index|
+              next unless required_features_are_matched(override[:requiredFeatures], evaluation_options[:context], options)
+              conditions_match = !override[:conditions] || @datafile.all_conditions_are_matched(
+                @datafile.parse_conditions_if_stringified(override[:conditions]), evaluation_options[:context]
+              )
+              segments_match = !override[:segments] || @datafile.all_segments_are_matched(
+                @datafile.parse_segments_if_stringified(override[:segments]), evaluation_options[:context]
+              )
+              next unless conditions_match && segments_match
+
+              evaluation.merge!(reason: Featurevisor::EvaluationReason::VARIABLE_OVERRIDE_RULE,
+                                variable: variable,
+                                variable_override_index: index, variable_override_key: override[:key],
+                                variable_override_path: override[:keyPath])
+              evaluation[:variable_value] = override[:value] if override.key?(:value)
+              break
+            end
+            if evaluation[:reason] == Featurevisor::EvaluationReason::VARIABLE_NOT_FOUND
+              evaluation.merge!(reason: Featurevisor::EvaluationReason::VARIABLE_DEFAULT,
+                                variable: variable)
+              evaluation[:variable_value] = variable[:defaultValue] if variable.key?(:defaultValue)
+            end
+          end
+          report_diagnostic(level: "warn", code: "variable_deprecated", message: "Variable \"#{resolved_key}\" is deprecated",
+                            details: { variableKey: resolved_key, evaluation: evaluation }) if variable[:deprecated]
+        end
+
+        if !evaluation.key?(:variable_value) && evaluation_options.key?(:default_variable_value)
+          evaluation[:variable_value] = evaluation_options[:default_variable_value]
+        end
+        evaluation = @modules_manager.run_global_after_modules(evaluation, evaluation_options)
+        report_diagnostic(level: "debug", code: evaluation[:reason], message: "Global variable evaluated", details: evaluation)
+        evaluation
+      rescue => e
+        evaluation = { type: "variable", variable_key: evaluation_options[:variable_key],
+                       reason: Featurevisor::EvaluationReason::ERROR, error: e }
+        report_diagnostic(level: "error", code: "evaluation_error", message: "Global variable evaluation failed",
+                          originalError: e, details: evaluation)
+        evaluation
+      end
+    end
+
+    def required_features_are_matched(requirements, context, options)
+      return true if requirements.nil?
+
+      items = requirements.is_a?(Array) ? requirements : [requirements]
+      clean_options = options.reject { |key, _| %i[default_variation_value default_variable_value].include?(key) }
+      items.all? do |required|
+        if required.is_a?(String)
+          key = required
+          expected_enabled = true
+          expected_variation = nil
+        else
+          key = required[:feature]
+          expected_enabled = required.key?(:enabled) ? required[:enabled] : true
+          expected_variation = required[:variation]
+        end
+        next false unless is_enabled(key, context, clean_options) == expected_enabled
+        expected_variation.nil? || get_variation(key, context, clean_options) == expected_variation
+      end
+    end
+
     # Get evaluation dependencies
     # @param context [Hash] Context
     # @param options [Hash] Override options
@@ -522,7 +631,8 @@ module Featurevisor
         diagnostics: @diagnostics,
         modules_manager: @modules_manager,
         datafile: @datafile,
-        sticky: options[:__featurevisor_child_sticky] || @sticky,
+        sticky: options[:__featurevisor_child_sticky_features] || @sticky_features,
+        sticky_variables: options[:__featurevisor_child_sticky_variables] || @sticky_variables,
       }.tap do |dependencies|
         dependencies[:default_variation_value] = options[:default_variation_value] if options.key?(:default_variation_value)
         dependencies[:default_variable_value] = options[:default_variable_value] if options.key?(:default_variable_value)
@@ -573,6 +683,10 @@ module Featurevisor
         features: {
           **(previous[:features] || {}),
           **(incoming[:features] || {})
+        },
+        variables: {
+          **(previous[:variables] || {}),
+          **(incoming[:variables] || {})
         }
       }.compact
     end

data/lib/featurevisor/modules.rb

@@ -13,9 +13,11 @@ module Featurevisor
         @name = options[:name]
         @setup = options[:setup]
         @before = options[:before]
+        @before_evaluation = options[:before_evaluation] || options[:beforeEvaluation]
         @bucket_key = options[:bucket_key]
         @bucket_value = options[:bucket_value]
         @after = options[:after]
+        @after_evaluation = options[:after_evaluation] || options[:afterEvaluation]
         @close = options[:close]
       end
 
@@ -29,6 +31,12 @@ module Featurevisor
         @before.call(options)
       end
 
+      def call_before_evaluation(options)
+        return options unless @before_evaluation
+
+        @before_evaluation.call(options)
+      end
+
       def call_bucket_key(options)
         return options[:bucket_key] unless @bucket_key
 
@@ -47,6 +55,12 @@ module Featurevisor
         @after.call(evaluation, options)
       end
 
+      def call_after_evaluation(evaluation, options)
+        return evaluation unless @after_evaluation
+
+        @after_evaluation.call(evaluation, options)
+      end
+
       def call_close
         @close.call if @close
       end
@@ -124,6 +138,43 @@ module Featurevisor
       end
 
       def run_before_modules(options)
+        result = @modules.reduce(options) do |current, mod|
+          mod.call_before(current)
+        end
+        @modules.reduce(result) do |current, mod|
+          mod.call_before_evaluation(current)
+        end
+      end
+
+      def run_before_evaluation_modules(options)
+        @modules.reduce(options) do |result, mod|
+          mod.call_before_evaluation(result)
+        end
+      end
+
+      def run_after_evaluation_modules(evaluation, options)
+        @modules.reduce(evaluation) do |result, mod|
+          mod.call_after_evaluation(result, options)
+        end
+      end
+
+      def run_after_modules(evaluation, options)
+        result = @modules.reduce(evaluation) do |current, mod|
+          mod.call_after_evaluation(current, options)
+        end
+        @modules.reduce(result) do |current, mod|
+          mod.call_after(current, options)
+        end
+      end
+
+      # Deprecated feature-only callbacks are intentionally excluded here.
+      def run_global_after_modules(evaluation, options)
+        @modules.reduce(evaluation) do |result, mod|
+          mod.call_after_evaluation(result, options)
+        end
+      end
+
+      def run_legacy_before_modules(options)
         @modules.reduce(options) do |result, mod|
           mod.call_before(result)
         end
@@ -145,12 +196,6 @@ module Featurevisor
         bucket_value
       end
 
-      def run_after_modules(evaluation, options)
-        @modules.reduce(evaluation) do |result, mod|
-          mod.call_after(result, options)
-        end
-      end
-
       def close_all
         @modules.each do |mod|
           @clear_module_diagnostic_subscriptions.call(mod) if @clear_module_diagnostic_subscriptions

data/lib/featurevisor/version.rb

@@ -1,3 +1,3 @@
 module Featurevisor
-  VERSION = "2.0.0"
+  VERSION = "3.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: featurevisor
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Fahad Heylaal