featurevisor 3.1.0 → 4.0.0

data/lib/featurevisor/child_instance.rb

@@ -10,9 +10,13 @@ module Featurevisor
       @sticky_variables = options[:sticky_variables] || {}
       @emitter = Featurevisor::Emitter.new
       @parent_unsubscribers = []
+      @closed = false
+      @evaluation_generation = 0
     end
 
     def on(event_name, callback = nil, &block)
+      return -> {} if @closed
+
       callback = block if block_given?
       if %w[context_set sticky_features_set sticky_variables_set].include?(event_name)
         return @emitter.on(event_name, callback)
@@ -33,6 +37,9 @@ module Featurevisor
     end
 
     def close
+      return if @closed
+
+      @closed = true
       @parent_unsubscribers.dup.each(&:call)
       @parent_unsubscribers.clear
       @emitter.clear_all
@@ -40,6 +47,7 @@ module Featurevisor
 
     def set_context(context, replace = false)
       @context = replace ? context : { **@context, **context }
+      @evaluation_generation += 1
       @emitter.trigger("context_set", context: @context, replaced: replace)
     end
 
@@ -50,6 +58,7 @@ module Featurevisor
     def set_sticky_features(sticky, replace = false)
       previous = @sticky_features
       @sticky_features = replace ? sticky : { **@sticky_features, **sticky }
+      @evaluation_generation += 1
       params = Featurevisor::Events.get_params_for_sticky_features_set_event(previous, @sticky_features, replace)
       @emitter.trigger("sticky_features_set", params)
     end
@@ -57,6 +66,7 @@ module Featurevisor
     def set_sticky_variables(sticky, replace = false)
       previous = @sticky_variables
       @sticky_variables = replace ? sticky : { **@sticky_variables, **sticky }
+      @evaluation_generation += 1
       @emitter.trigger(
         "sticky_variables_set",
         Featurevisor::Events.get_params_for_sticky_variables_set_event(previous, @sticky_variables, replace)
@@ -87,7 +97,7 @@ module Featurevisor
       delegate_variable(:evaluate_variable, feature_or_variable_key, variable_key_or_context, context_or_options, options)
     end
 
-    %i[boolean string integer double array object json].each do |type|
+    %i[boolean string integer number array object json].each do |type|
       define_method("get_variable_#{type}") do |feature_or_variable_key, variable_key_or_context = nil, context_or_options = {}, options = {}|
         delegate_variable("get_variable_#{type}".to_sym, feature_or_variable_key, variable_key_or_context, context_or_options, options)
       end
@@ -111,7 +121,10 @@ module Featurevisor
       {
         **options,
         __featurevisor_child_sticky_features: @sticky_features,
-        __featurevisor_child_sticky_variables: @sticky_variables
+        __featurevisor_child_sticky_variables: @sticky_variables,
+        __featurevisor_sticky_features_source: -> { @sticky_features },
+        __featurevisor_sticky_variables_source: -> { @sticky_variables },
+        __featurevisor_child_generation: -> { @evaluation_generation }
       }
     end
 

data/lib/featurevisor/compare_versions.rb

@@ -19,7 +19,7 @@ module Featurevisor
     end
 
     match = version.match(SEMVER_REGEX)
-    unless match
+    unless match && version.ascii_only? && match[0] == version
       raise ArgumentError, "Invalid argument not valid semver ('#{version}' received)"
     end
 
@@ -34,50 +34,29 @@ module Featurevisor
     s == "*" || s.downcase == "x"
   end
 
-  # Forces types to be the same for comparison
-  # @param a [String, Integer] First value
-  # @param b [String, Integer] Second value
-  # @return [Array] Array with both values converted to same type
-  def self.force_type(a, b)
-    if a.is_a?(Integer) != b.is_a?(Integer)
-      [a.to_s, b.to_s]
-    else
-      [a, b]
-    end
-  end
-
-  # Tries to parse a string as an integer
-  # @param v [String] String to parse
-  # @return [Integer, String] Parsed integer or original string
-  def self.try_parse(v)
-    Integer(v, 10)
-  rescue ArgumentError
-    v
-  end
-
   # Compares two strings for version comparison
   # @param a [String] First string
   # @param b [String] Second string
   # @return [Integer] -1 if a < b, 0 if equal, 1 if a > b
-  def self.compare_strings(a, b)
-    return 0 if wildcard?(a) || wildcard?(b)
-
-    ap, bp = force_type(try_parse(a), try_parse(b))
-
-    if ap > bp
-      1
-    elsif ap < bp
-      -1
-    else
-      0
+  def self.compare_strings(a, b, prerelease = false)
+    return 0 if !prerelease && (wildcard?(a) || wildcard?(b))
+    an = /\A[0-9]+\z/.match?(a)
+    bn = /\A[0-9]+\z/.match?(b)
+    if an && bn
+      a = a.sub(/\A0+/, "")
+      b = b.sub(/\A0+/, "")
+      return a.length <=> b.length if a.length != b.length
+    elsif prerelease && an != bn
+      return an ? -1 : 1
     end
+    a <=> b
   end
 
   # Compares version segments
   # @param a [Array<String>, MatchData] First version segments
   # @param b [Array<String>, MatchData] Second version segments
   # @return [Integer] -1 if a < b, 0 if equal, 1 if a > b
-  def self.compare_segments(a, b)
+  def self.compare_segments(a, b, prerelease = false)
     # Convert to arrays if needed
     a_array = a.is_a?(MatchData) ? a.to_a[1..-1] : a.to_a
     b_array = b.is_a?(MatchData) ? b.to_a[1..-1] : b.to_a
@@ -85,10 +64,13 @@ module Featurevisor
     max_length = [a_array.length, b_array.length].max
 
     (0...max_length).each do |i|
+      if prerelease && (i == a_array.length || i == b_array.length)
+        return a_array.length <=> b_array.length
+      end
       a_val = a_array[i] || "0"
       b_val = b_array[i] || "0"
 
-      result = compare_strings(a_val, b_val)
+      result = compare_strings(a_val, b_val, prerelease)
       return result unless result == 0
     end
 
@@ -116,7 +98,7 @@ module Featurevisor
 
     # Validate pre-release
     if p1 && p2
-      compare_segments(p1.split("."), p2.split("."))
+      compare_segments(p1.split("."), p2.split("."), true)
     elsif p1 || p2
       p1 ? -1 : 1
     else

data/lib/featurevisor/conditions.rb

@@ -23,6 +23,16 @@ module Featurevisor
     def self.get_value_with_presence(obj, path)
       return MISSING unless obj.is_a?(Hash) && path.is_a?(String)
 
+      # Most attributes are direct keys. Avoid allocating a path array for
+      # every condition while retaining the existing nested path behaviour.
+      unless path.empty? || path.include?(".")
+        symbol = path.to_sym
+        return obj[symbol] if obj.key?(symbol)
+        return obj[path] if obj.key?(path)
+
+        return MISSING
+      end
+
       path.split(".").reduce(obj) do |current, key|
         break MISSING unless current.is_a?(Hash)
 
@@ -39,7 +49,7 @@ module Featurevisor
 
     def self.strict_equal?(left, right)
       return true if left.nil? && right.nil?
-      return left.to_f == right.to_f if left.is_a?(Numeric) && right.is_a?(Numeric)
+      return left == right if left.is_a?(Numeric) && right.is_a?(Numeric)
       return left == right if left.is_a?(String) && right.is_a?(String)
       return left == right if (left == true || left == false) && (right == true || right == false)
 
@@ -47,6 +57,15 @@ module Featurevisor
     end
     private_class_method :strict_equal?
 
+    def self.missing_value
+      MISSING
+    end
+
+    def self.value_is_matched(raw_value, condition, get_regex)
+      context = raw_value.equal?(MISSING) ? {} : { value: raw_value }
+      condition_is_matched(condition.merge(attribute: "value"), context, get_regex)
+    end
+
     # Check if a condition is matched against context
     # @param condition [Hash] Condition to evaluate
     # @param context [Hash] Context to evaluate against
@@ -55,7 +74,11 @@ module Featurevisor
     def self.condition_is_matched(condition, context, get_regex)
       attribute = condition["attribute"] || condition[:attribute]
       operator = condition["operator"] || condition[:operator]
-      value = condition["value"] || condition[:value]
+      value = if condition.key?(:value)
+                condition[:value]
+              elsif condition.key?("value")
+                condition["value"]
+              end
       regex_flags = condition["regexFlags"] || condition[:regexFlags]
 
       raw_context_value = get_value_with_presence(context, attribute)
@@ -63,6 +86,18 @@ module Featurevisor
       attribute_exists = !raw_context_value.equal?(MISSING)
 
       case operator
+      when "empty", "notEmpty"
+        return false unless attribute_exists && !context_value_from_path.nil?
+
+        size = if context_value_from_path.is_a?(String) || context_value_from_path.is_a?(Array) ||
+                  context_value_from_path.is_a?(Hash)
+                 context_value_from_path.size
+               end
+        !size.nil? && (operator == "empty" ? size.zero? : size.positive?)
+      when "isNull"
+        attribute_exists && context_value_from_path.nil?
+      when "notNull"
+        attribute_exists && !context_value_from_path.nil?
       when "equals"
         attribute_exists && strict_equal?(context_value_from_path, value)
       when "notEquals"
@@ -148,6 +183,12 @@ module Featurevisor
         attribute_exists
       when "notExists"
         !attribute_exists
+      when "includesAny", "notIncludesAny"
+        return false unless context_value_from_path.is_a?(Array) && value.is_a?(Array)
+        return false unless value.all? { |candidate| candidate.nil? || candidate.is_a?(String) || candidate.is_a?(Integer) || candidate.is_a?(Float) || candidate == true || candidate == false }
+
+        matched = value.any? { |candidate| context_value_from_path.any? { |actual| strict_equal?(actual, candidate) } }
+        operator == "includesAny" ? matched : !matched
       when "includes", "notIncludes"
         # includes / notIncludes (where context value is an array)
         if context_value_from_path.is_a?(Array) &&
@@ -167,15 +208,56 @@ module Featurevisor
     end
 
     def self.portable_date(value)
-      return value if value.is_a?(Time) || value.is_a?(DateTime)
-      return value.to_time if value.is_a?(Date)
-      return nil unless value.is_a?(String)
-      return nil unless value.match?(/T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+\-]\d{2}:\d{2})\z/)
-
-      Time.iso8601(value)
-    rescue ArgumentError
+      if value.is_a?(String)
+        match = /\A[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]{1,9})?(?:Z|([+\-])([0-9]{2}):([0-9]{2}))\z/.match(value)
+        return nil unless match
+        return nil if value.start_with?("0000-")
+        if match[2] && (match[2].to_i > 14 || match[3].to_i > 59 || (match[2] == "14" && match[3] != "00"))
+          return nil
+        end
+        parsed = Time.iso8601(value)
+        # Time.iso8601 must not normalize an invalid calendar date or clock time.
+        return nil unless parsed.getlocal(match[1] ? "#{match[1]}#{match[2]}:#{match[3]}" : "+00:00").strftime("%Y-%m-%dT%H:%M:%S") == value[0, 19]
+      elsif value.is_a?(Time) || value.is_a?(DateTime)
+        return nil unless (1..9999).cover?(value.year)
+        offset_seconds = value.is_a?(DateTime) ? value.offset * 86400 : value.utc_offset
+        return nil if offset_seconds.abs > 14 * 3600
+        parsed = value.to_time
+      else
+        return nil
+      end
+      milliseconds = (parsed.to_r * 1000).floor
+      result = Time.at(Rational(milliseconds, 1000)).utc
+      return nil if result.year < 1 || result.year > 9999
+      result
+    rescue ArgumentError, RangeError
       nil
     end
     private_class_method :portable_date
+
+    def self.normalize_portable_regex(pattern)
+      inside = {
+        'd' => '0-9', 'D' => '\\u{0}-\\u{2F}\\u{3A}-\\u{10FFFF}',
+        'w' => 'A-Za-z0-9_', 'W' => '\\u{0}-\\u{2F}\\u{3A}-\\u{40}\\u{5B}-\\u{5E}\\u{60}\\u{7B}-\\u{10FFFF}'
+      }
+      outside = { 'd' => '[0-9]', 'D' => '[^0-9]', 'w' => '(?-i:[A-Za-z0-9_])', 'W' => '(?-i:[^A-Za-z0-9_])' }
+      output = +''
+      in_class = false
+      index = 0
+      while index < pattern.length
+        char = pattern[index]
+        if char == '\\' && index + 1 < pattern.length
+          code = pattern[index + 1]
+          output << (in_class ? inside : outside).fetch(code, pattern[index, 2])
+          index += 2
+          next
+        end
+        in_class = true if char == '[' && !in_class
+        in_class = false if char == ']' && in_class
+        output << char
+        index += 1
+      end
+      output
+    end
   end
 end

data/lib/featurevisor/dependencies.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Featurevisor
+  module Dependencies
+    def self.extract_entity_dependencies(entry)
+      sources = {}
+      add = lambda do |kind, key, dependent|
+        source = [kind, key.to_sym]
+        sources[source] = true
+      end
+      conditions = nil
+      conditions = lambda do |value, dependent|
+        case value
+        when String
+          next if value == "*"
+          if value.lstrip.match?(/\A[\{\[\"]/)
+            begin
+              conditions.call(JSON.parse(value, symbolize_names: true), dependent)
+            rescue JSON::ParserError
+              nil
+            end
+          else
+            add.call(:segment, value, dependent)
+          end
+        when Array
+          value.each { |child| conditions.call(child, dependent) }
+        when Hash
+          if value.key?(:variable)
+            add.call(value[:feature] ? :feature : :variable, value[:feature] || value[:variable], dependent)
+          elsif value.key?(:feature)
+            add.call(:feature, value[:feature], dependent)
+          elsif !value.key?(:attribute)
+            %i[and or not].each { |group| conditions.call(value[group], dependent) if value.key?(group) }
+          end
+        end
+      end
+      visit = nil
+      visit = lambda do |entry, dependent|
+        conditions.call(entry[:conditions], dependent) if entry.key?(:conditions)
+        %i[force traffic variations overrides overrideProgram].each do |name|
+          (entry[name] || []).each { |child| visit.call(child, dependent) }
+        end
+        (entry[:variableOverrides] || {}).each_value do |overrides|
+          overrides.each { |child| visit.call(child, dependent) }
+        end
+      end
+      visit.call(entry, nil)
+      compose = entry[:compose]
+      if compose.is_a?(String)
+        add.call(:variable, compose, nil)
+      elsif compose.is_a?(Array)
+        compose.each do |reference|
+          add.call(reference[:feature] ? :feature : :variable, reference[:feature] || reference[:variable], nil)
+        end
+      end
+      sources.keys
+    end
+
+    COLLECTIONS = { segments: :segment, features: :feature, variables: :variable }.freeze
+
+    # Edge identities do not retain old providers, definitions or caller values.
+    class Index
+      EMPTY = [].freeze
+
+      def initialize
+        @reverse = {}
+        @owners = {}
+        @order = {}
+        @next_order = 0
+      end
+
+      def update(datafile, incoming, previous = nil)
+        updates = []
+        COLLECTIONS.each do |name, kind|
+          definitions = datafile[name] || {}
+          (incoming[name] || {}).each_key do |key|
+            owner = [kind, key.to_sym]
+            entry = definitions[key.to_sym]
+            # Hashes do not identify edges. Reuse only an identical definition.
+            next if previous && @owners.key?(owner) && entry && entry == (previous[name] || {})[key.to_sym]
+            updates << [owner, entry && Dependencies.extract_entity_dependencies(entry)]
+          end
+        end
+        updates.each do |owner, sources|
+          (@owners.delete(owner) || []).each do |source|
+            dependents = @reverse[source]
+            dependents.delete(owner)
+            @reverse.delete(source) if dependents.empty?
+          end
+          unless sources
+            @order.delete(owner)
+            next
+          end
+          unless @order.key?(owner)
+            @order[owner] = @next_order
+            @next_order += 1
+          end
+          @owners[owner] = sources
+          sources.each { |source| (@reverse[source] ||= {})[owner] = true }
+        end
+      end
+
+      def reorder(datafile)
+        @order = {}
+        COLLECTIONS.each do |name, kind|
+          (datafile[name] || {}).each_key.with_index { |key, rank| @order[[kind, key.to_sym]] = rank }
+        end
+        @next_order = (@order.values.max || -1) + 1
+      end
+
+      def dependents(identity)
+        dependents = @reverse[identity]
+        dependents ? dependents.keys.sort_by { |owner| @order.fetch(owner) } : EMPTY
+      end
+    end
+
+    def self.create_index(datafile)
+      index = Index.new
+      index.update(datafile, datafile)
+      index
+    end
+
+    def self.add_changes(features, variables, changed_segments, index)
+      kinds = %i[feature variable segment]
+      affected = [features, variables, changed_segments].map { |keys| keys.to_h { |key| [key.to_sym, true] } }
+      queues = affected.map(&:keys)
+      cursors = [0, 0, 0]
+      loop do
+        advanced = false
+        kinds.each_with_index do |kind, source|
+          next if cursors[source] >= queues[source].length
+          advanced = true
+          key = queues[source][cursors[source]]
+          cursors[source] += 1
+          index.dependents([kind, key]).each do |target_kind, target_key|
+            target = kinds.index(target_kind)
+            next if affected[target].key?(target_key)
+            affected[target][target_key] = true
+            queues[target] << target_key
+          end
+        end
+        break unless advanced
+      end
+      features.replace(affected[0].keys)
+      variables.replace(affected[1].keys)
+    end
+  end
+end

data/lib/featurevisor/emitter.rb

@@ -31,6 +31,7 @@ module Featurevisor
         is_active = false
         index = listeners.index(callback)
         listeners.delete_at(index) if index && index >= 0
+        callback = nil
       end
     end
 
@@ -54,6 +55,9 @@ module Featurevisor
 
     # Clear all event listeners
     def clear_all
+      # Cleanup functions may still reference the previous listener arrays.
+      # Empty those arrays too, rather than retaining unrelated callbacks.
+      @listeners.each_value(&:clear)
       @listeners = {}
     end
   end