featurevisor 3.0.0 → 4.0.0

data/lib/featurevisor/evaluation_session.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Featurevisor
+  class RequirementError < StandardError; end
+  class RequirementCycleError < RequirementError; end
+
+  # One evaluation owns its prerequisite stack and completed prerequisite values.
+  class EvaluationSession
+    def initialize
+      @root = nil
+      @root_current = nil
+      @active = nil
+      @memo = nil
+      @sticky_inputs = nil
+      @segments = nil
+    end
+
+    def dependency_of
+      @active ? @active.last&.dig(:current) : @root_current
+    end
+
+    def update_current(options)
+      current = dependency_of
+      return if current && current[:type] == options[:type] &&
+                current[:feature_key] == options[:feature_key] && current[:variable_key] == options[:variable_key]
+
+      identity = identity_of(options)
+      if @active
+        @active.last[:current] = identity
+      else
+        @root_current = identity
+      end
+    end
+
+    def run(options, prerequisite: false)
+      # A root needs its original and redirected identities, but no dependency
+      # stack, memo or retained sticky maps until a handoff is actually reached.
+      if !@root && !@active && !prerequisite
+        @root = @root_current = identity_of(options)
+        begin
+          return yield
+        ensure
+          clear
+        end
+      end
+
+      @active ||= @root ? [{ identity: @root, current: @root_current }] : []
+      identity = identity_of(options)
+      raise RequirementCycleError, "Circular evaluation requirement" if @active.any? { |frame| frame[:identity] == identity || frame[:current] == identity }
+      raise RequirementError, "Evaluation dependency depth exceeded" if @active.length + (@segments&.length || 0) > 256
+
+      requester = dependency_of
+      key = prerequisite ? fingerprint(identity, requester, options) : nil
+      borrowed = options[:dependency_purpose] == "composition"
+      return @memo[key] if key && @memo&.key?(key)
+
+      @active << { identity: identity, current: identity }
+      begin
+        result = yield
+        if prerequisite && options[:__featurevisor_project_variable]
+          result = options[:__featurevisor_project_variable].call(result)
+        end
+        if key && key == fingerprint(identity, requester, options)
+          minimal = minimal_result(result, borrowed)
+          (@memo ||= {})[key] = borrowed ? minimal : duplicate(minimal) if minimal
+        end
+        result
+      rescue => e
+        @pending_error = { identity: identity, requester: requester, key: key }
+        raise
+      ensure
+        @active.pop
+        clear if @active.empty?
+      end
+    end
+
+    def segment(key)
+      @segments ||= []
+      raise RequirementCycleError, "Circular dependency" if @segments.include?(key)
+      active_length = @active ? @active.length : (@root ? 1 : 0)
+      raise RequirementError, "Evaluation dependency depth exceeded" if @segments.length + [active_length - 1, 0].max >= 256
+      @segments << key
+      begin
+        yield
+      ensure
+        @segments.pop
+      end
+    end
+
+    def remember(options, result)
+      return unless options[:__featurevisor_prerequisite]
+
+      identity = identity_of(options)
+      pending = @pending_error
+      @pending_error = nil
+      return unless pending && pending[:identity] == identity && pending[:requester] == dependency_of
+
+      key = fingerprint(identity, dependency_of, options)
+      return unless key && key == pending[:key]
+      borrowed = options[:dependency_purpose] == "composition"
+      minimal = minimal_result(result, borrowed)
+      (@memo ||= {})[key] = borrowed ? minimal : duplicate(minimal) if minimal
+    end
+
+    private
+
+    def clear
+      @root = @root_current = nil
+      @active&.clear
+      @memo&.clear
+      @sticky_inputs&.clear
+      @segments&.clear
+      @active = nil
+      @pending_error = nil
+    end
+
+    def identity_of(options)
+      identity = {}
+      identity[:type] = options[:type] unless options[:type].nil?
+      identity[:feature_key] = options[:feature_key] unless options[:feature_key].nil?
+      identity[:variable_key] = options[:variable_key] unless options[:variable_key].nil?
+      identity
+    end
+
+    def fingerprint(identity, requester, options)
+      @sticky_inputs ||= {}
+      # Keep referenced maps alive until the root ends so object_id cannot be reused.
+      [options[:sticky], options[:sticky_variables]].each do |input|
+        @sticky_inputs[input.object_id] = input if input
+      end
+      JSON.generate(canonical([
+        identity, requester, options[:dependency_purpose], options[:context], options[:sticky]&.object_id, options[:sticky_variables]&.object_id,
+        options[:__featurevisor_generation]&.call,
+        options[:__featurevisor_child_generation]&.call,
+        options[:datafile]&.object_id
+      ]))
+    rescue ArgumentError, TypeError, JSON::GeneratorError
+      nil
+    end
+
+    def canonical(value, ancestors = [])
+      raise ArgumentError, "Too deep" if ancestors.length > 64
+
+      case value
+      when NilClass, TrueClass, FalseClass, String, Integer
+        value
+      when Float
+        raise ArgumentError, "Nonfinite number" unless value.finite?
+        value
+      when Array
+        raise ArgumentError, "Circular value" if ancestors.include?(value.object_id)
+        ["array", value.map { |entry| canonical(entry, ancestors + [value.object_id]) }]
+      when Hash
+        raise ArgumentError, "Circular value" if ancestors.include?(value.object_id)
+        keys = value.keys
+        raise ArgumentError, "Unsupported key" unless keys.all? { |key| key.is_a?(String) || key.is_a?(Symbol) }
+        pairs = keys.sort_by { |key| [key.to_s, key.is_a?(String) ? 0 : 1] }.map do |key|
+          [key.is_a?(String) ? "string" : "symbol", key.to_s,
+           canonical(value[key], ancestors + [value.object_id])]
+        end
+        ["object", pairs]
+      else
+        raise ArgumentError, "Unsupported value"
+      end
+    end
+
+    def minimal_result(result, borrowed = false)
+      return nil unless result.is_a?(Hash)
+
+      keys = %i[type feature_key variable_key reason enabled variation_value variable_value __featurevisor_decoded_json]
+      value = result.select { |key, _| keys.include?(key) }
+      value[:variation] = { value: result[:variation][:value] } if result[:variation].is_a?(Hash)
+      value[:variable_schema] = { type: result[:variable_schema][:type] } if result[:variable_schema].is_a?(Hash)
+      if result[:variable].is_a?(Hash)
+        value[:variable] = { type: result[:variable][:type] }
+        value[:variable][:compose] = true if result[:variable][:compose]
+      end
+      return value if borrowed
+      canonical(value)
+      duplicate(value)
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def duplicate(value)
+      Marshal.load(Marshal.dump(value))
+    end
+  end
+end

data/lib/featurevisor/events.rb

@@ -33,7 +33,7 @@ module Featurevisor
     # @param previous_reader [InstanceEvaluationDataProvider] Previous datafile
     # @param new_reader [InstanceEvaluationDataProvider] New datafile
     # @return [Hash] Event parameters
-    def self.get_params_for_datafile_set_event(previous_reader, new_reader, replace = false)
+    def self.get_params_for_datafile_set_event(previous_reader, new_reader, replace = false, incoming = nil)
       previous_revision = previous_reader.get_revision
       previous_feature_keys = previous_reader.get_feature_keys
 
@@ -42,6 +42,17 @@ module Featurevisor
       previous_variable_keys = previous_reader.get_variable_keys
       new_variable_keys = new_reader.get_variable_keys
 
+      if previous_feature_keys.empty? && previous_variable_keys.empty? && previous_reader.get_segment_keys.empty?
+        return {
+          revision: new_revision,
+          previousRevision: previous_revision,
+          revisionChanged: previous_revision != new_revision,
+          features: new_feature_keys,
+          variables: new_variable_keys,
+          replaced: replace
+        }
+      end
+
       # results
       removed_features = []
       changed_features = []
@@ -49,18 +60,20 @@ module Featurevisor
 
       # checking against existing datafile
       previous_feature_keys.each do |previous_feature_key|
-        if !new_feature_keys.include?(previous_feature_key)
+        if !new_reader.features.key?(previous_feature_key)
           # feature was removed in new datafile
           removed_features << previous_feature_key
           next
         end
 
         # feature exists in both datafiles, check if it was changed
-        previous_feature = previous_reader.get_feature(previous_feature_key)
-        new_feature = new_reader.get_feature(previous_feature_key)
+        previous_feature = previous_reader.features[previous_feature_key]
+        new_feature = new_reader.features[previous_feature_key]
 
         if previous_feature && new_feature &&
-           (previous_feature[:hash].nil? || new_feature[:hash].nil? || previous_feature[:hash] != new_feature[:hash])
+           (previous_feature[:hash].nil? || previous_feature[:hash].empty? ||
+             new_feature[:hash].nil? || new_feature[:hash].empty? ||
+             previous_feature[:hash] != new_feature[:hash])
           # feature was changed in new datafile
           changed_features << previous_feature_key
         end
@@ -68,7 +81,7 @@ module Featurevisor
 
       # checking against new datafile
       new_feature_keys.each do |new_feature_key|
-        if !previous_feature_keys.include?(new_feature_key)
+        if !previous_reader.features.key?(new_feature_key)
           # feature was added in new datafile
           added_features << new_feature_key
         end
@@ -77,41 +90,33 @@ 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]
+        previous = previous_reader.variables[key]
+        current = new_reader.variables[key]
+        previous.nil? || current.nil? ||
+          previous[:hash].nil? || previous[:hash].empty? || current[:hash].nil? || current[:hash].empty? ||
+          previous[:hash] != current[:hash]
       end
 
 
+      new_datafile = new_reader.get_datafile
       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
+        previous = previous_reader.segments[key]
+        current = new_reader.segments[key]
+        !previous.equal?(current) && previous != current
       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?
+      index = previous_reader.dependency_index || Dependencies.create_index(previous_reader.get_datafile)
+      if replace || incoming.nil?
+        incoming = Dependencies::COLLECTIONS.to_h do |name, _|
+          [name, (previous_reader.public_send(name).keys + new_datafile[name].keys).uniq.to_h { |key| [key, true] }]
         end
       end
+      Dependencies.add_changes(all_affected_features, all_affected_variables, changed_segments,
+                               index)
+      index.update(new_datafile, incoming, previous_reader.get_datafile)
+      index.reorder(new_datafile) if replace
+      Dependencies.add_changes(all_affected_features, all_affected_variables, changed_segments,
+                               index)
+      new_reader.dependency_index = index
 
       {
         revision: new_revision,
@@ -123,71 +128,5 @@ module Featurevisor
       }
     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