featurevisor 3.0.0 → 4.0.0

data/lib/featurevisor/mutations.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Featurevisor
+  module Mutations
+    DANGEROUS_KEYS = %w[__proto__ prototype constructor].freeze
+    OPERATIONS = %w[set append prepend appendUnique removeValue before after remove].freeze
+    MAX_SAFE_INTEGER = 9_007_199_254_740_991
+    private_constant :DANGEROUS_KEYS, :OPERATIONS, :MAX_SAFE_INTEGER
+
+    def self.apply(value, operations)
+      raise ArgumentError, "Invalid variable mutation operations" unless operations.is_a?(Array)
+
+      operations.reduce(value) do |current, operation|
+        validate(operation)
+        update_at_path(current, operation, 0)
+      end
+    end
+
+    def self.validate(operation)
+      unless operation.is_a?(Hash) && operation.key?(:op) && operation.key?(:path)
+        raise ArgumentError, "Invalid variable mutation operation"
+      end
+      op = operation[:op]
+      raise ArgumentError, "Invalid variable mutation operation" unless OPERATIONS.include?(op)
+      if op != "remove" && !operation.key?(:value)
+        raise ArgumentError, "Variable mutation operation requires a value"
+      end
+      if %w[appendUnique removeValue].include?(op)
+        value = operation[:value]
+        unless primitive?(value) && (!value.is_a?(Numeric) || !value.respond_to?(:finite?) || value.finite?)
+          raise ArgumentError, "Variable mutation operation requires a primitive value"
+        end
+      end
+      raise ArgumentError, "Invalid variable mutation path" unless operation[:path].is_a?(Array)
+
+      operation[:path].each do |part|
+        key = if part.is_a?(String)
+                part
+              elsif !array_index(part).nil?
+                nil
+              else
+                select = selector(part)
+                raise ArgumentError, "Invalid variable mutation path" unless select
+                select[:property]
+              end
+        raise ArgumentError, "Unsafe variable mutation key" if key && DANGEROUS_KEYS.include?(key)
+      end
+    end
+    private_class_method :validate
+
+    def self.primitive?(value)
+      value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
+    end
+    private_class_method :primitive?
+
+    def self.same?(left, right)
+      return true if left.nil? && right.nil?
+      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 [true, false].include?(left) && [true, false].include?(right)
+
+      left.equal?(right)
+    end
+    private_class_method :same?
+
+    def self.array_index(value)
+      return nil unless value.is_a?(Numeric)
+      return nil if value.respond_to?(:finite?) && !value.finite?
+      return nil unless value >= 0 && value <= MAX_SAFE_INTEGER && value.to_i == value
+
+      value.to_i
+    end
+    private_class_method :array_index
+
+    def self.selector(part)
+      return nil unless part.is_a?(Hash)
+      select = part[:select] || part["select"]
+      return nil unless select.is_a?(Hash)
+      property = select[:property] || select["property"]
+      values = select[:values] || select["values"]
+      return nil unless property.is_a?(String) && values.is_a?(Array) && values.all? { |value| primitive?(value) }
+
+      { property: property, values: values }
+    end
+    private_class_method :selector
+
+    def self.hash_key(hash, key)
+      return key if hash.key?(key)
+      symbol = key.to_sym
+      hash.key?(symbol) ? symbol : symbol
+    end
+    private_class_method :hash_key
+
+    def self.selected_index(array, select)
+      array.each_with_index do |candidate, index|
+        next unless candidate.is_a?(Hash)
+        key = hash_key(candidate, select[:property])
+        next unless candidate.key?(key)
+        value = candidate[key]
+        return index if primitive?(value) && select[:values].any? { |expected| same?(value, expected) }
+      end
+      -1
+    end
+    private_class_method :selected_index
+
+    def self.path_key(container, part)
+      if part.is_a?(String)
+        raise ArgumentError, "Variable mutation expected an object" unless container.is_a?(Hash)
+        return hash_key(container, part)
+      end
+      raise ArgumentError, "Variable mutation expected an array" unless container.is_a?(Array)
+
+      index = array_index(part)
+      return index unless index.nil?
+
+      select = selector(part)
+      raise ArgumentError, "Invalid variable mutation path" unless select
+
+      selected_index(container, select)
+    end
+    private_class_method :path_key
+
+    def self.exists?(container, key)
+      container.is_a?(Hash) ? container.key?(key) : key >= 0 && key < container.length
+    end
+    private_class_method :exists?
+
+    def self.replace(container, key, value)
+      result = container.dup
+      if result.is_a?(Array) && key == result.length
+        result << value
+      else
+        result[key] = value
+      end
+      result
+    end
+    private_class_method :replace
+
+    def self.update_array(array, op, item)
+      if op == "removeValue"
+        return array unless array.any? { |value| same?(value, item) }
+        return array.reject { |value| same?(value, item) }
+      end
+      return array if op == "appendUnique" && array.any? { |value| same?(value, item) }
+
+      op == "prepend" ? [item, *array] : [*array, item]
+    end
+    private_class_method :update_array
+
+    def self.update_final(container, part, operation)
+      return container if container.nil?
+      op = operation[:op]
+      if %w[before after].include?(op) && part.is_a?(String)
+        raise ArgumentError, "Variable mutation before/after requires an array element path"
+      end
+      key = path_key(container, part)
+      found = exists?(container, key)
+
+      if op == "remove"
+        return container unless found
+        result = container.dup
+        result.is_a?(Array) ? result.delete_at(key) : result.delete(key)
+        return result
+      end
+
+      item = operation[:value]
+      if op == "set"
+        return container if key.is_a?(Integer) && (key.negative? || key > container.length)
+        return container if found && same?(container[key], item)
+        return replace(container, key, item)
+      end
+      if %w[before after].include?(op)
+        return container unless found
+        result = container.dup
+        result.insert(key + (op == "after" ? 1 : 0), item)
+        return result
+      end
+
+      current = found ? container[key] : nil
+      return container if current.nil? && key.is_a?(Integer)
+      return container if current.nil? && op == "removeValue"
+      raise ArgumentError, "Variable mutation expected an array" if !current.nil? && !current.is_a?(Array)
+      array = current || []
+      result = update_array(array, op, item)
+      result.equal?(current) ? container : replace(container, key, result)
+    end
+    private_class_method :update_final
+
+    def self.update_at_path(value, operation, offset)
+      path = operation[:path]
+      if offset == path.length
+        return same?(value, operation[:value]) ? value : operation[:value] if operation[:op] == "set"
+        raise ArgumentError, "Cannot remove the root variable value" if operation[:op] == "remove"
+        if %w[before after].include?(operation[:op])
+          raise ArgumentError, "Variable mutation before/after requires an array element path"
+        end
+        return value if value.nil?
+        raise ArgumentError, "Variable mutation expected an array" unless value.is_a?(Array)
+        return update_array(value, operation[:op], operation[:value])
+      end
+
+      return update_final(value, path[offset], operation) if offset == path.length - 1
+      return value if value.nil?
+      key = path_key(value, path[offset])
+      return value unless exists?(value, key)
+      current = value[key]
+      return value if current.nil?
+      result = update_at_path(current, operation, offset + 1)
+      result.equal?(current) ? value : replace(value, key, result)
+    end
+    private_class_method :update_at_path
+  end
+end

data/lib/featurevisor/normalize.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Featurevisor
+  module Normalize
+    class InvalidConditions < Hash
+      def initialize
+        super
+        self[:or] = []
+      end
+    end
+
+    class ParseFailure < StandardError; end
+
+    def self.legacy(value, features = false)
+      return value if value.is_a?(InvalidConditions)
+      case value
+      when String
+        features ? { feature: value } : value
+      when Array
+        value.empty? ? "*" : value.map { |entry| legacy(entry, features) }
+      when Hash
+        group = %i[and or not].find { |name| value[name].is_a?(Array) }
+        return value unless group
+        return "*" if group == :and && value[group].empty?
+        { group => value[group].map { |entry| legacy(entry, features) } }
+      else
+        value
+      end
+    end
+
+    def self.entity(kind, key, source, legacy = false)
+      errors = []
+      parse = lambda do |value|
+        next value unless value.is_a?(String) && value.lstrip.match?(/\A[\{\[\"]/)
+        begin
+          JSON.parse(value, symbolize_names: true)
+        rescue JSON::ParserError => error
+          errors << { level: "error", code: "conditions_parse_error", message: "Error parsing conditions",
+                      original_error: error,
+                      details: { conditions: value, entityType: kind.to_s, entityKey: key.to_s } }
+          InvalidConditions.new
+        end
+      end
+      select = lambda do |entry, old = false|
+        result = entry.reject { |name, _| %i[segments requiredFeatures requiredVariables required].include?(name) }
+        parts = []
+        if entry.key?(:conditions)
+          value = parse.call(entry[:conditions])
+          parts << (old ? self.legacy(value) : value)
+        end
+        parts << self.legacy(parse.call(entry[:segments])) if entry.key?(:segments)
+        if entry.key?(:requiredFeatures)
+          features = entry[:requiredFeatures]
+          features = [features] unless features.is_a?(Array)
+          parts << features.map { |value| self.legacy(value, true) } unless features.empty?
+        end
+        if parts.any? { |part| part.is_a?(InvalidConditions) }
+          result[:conditions] = InvalidConditions.new
+        elsif parts.length == 1
+          result[:conditions] = parts.first
+        elsif !parts.empty?
+          result[:conditions] = parts.flat_map { |part| part.is_a?(Array) ? (part.empty? ? [{ and: [] }] : part) : [part] }
+        end
+        result
+      end
+      with_overrides = lambda do |entry|
+        next entry unless entry[:variableOverrides]
+        entry.merge(variableOverrides: entry[:variableOverrides].transform_values do |values|
+          values.map { |override| select.call(override, legacy) }
+        end)
+      end
+      if kind.to_s == "segment"
+        value = parse.call(source[:conditions])
+        result = source.merge(conditions: legacy ? self.legacy(value) : value)
+      else
+        result = select.call(source)
+        if kind.to_s == "feature"
+          result[:traffic] = (source[:traffic] || []).map { |entry| with_overrides.call(select.call(entry)) }
+          result[:force] = source[:force].map { |entry| select.call(entry, legacy) } if source[:force]
+          result[:variations] = source[:variations].map { |entry| with_overrides.call(entry) } if source[:variations]
+        else
+          %i[overrides overrideProgram].each do |name|
+            result[name] = source[name].map { |entry| select.call(entry, legacy && name == :overrides) } if source[name]
+          end
+        end
+      end
+      [result, errors]
+    end
+
+    def self.datafile(source)
+      errors = []
+      result = source.dup
+      { features: :feature, segments: :segment, variables: :variable }.each do |name, kind|
+        next unless source[name]
+        result[name] = source[name].each_with_object({}) do |(key, entry), values|
+          values[key], diagnostics = entity(kind, key, entry, true)
+          errors.concat(diagnostics)
+        end
+      end
+      [result, errors]
+    end
+  end
+end

data/lib/featurevisor/unified_conditions.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Featurevisor
+  module UnifiedConditions
+    def self.matches?(conditions, options)
+      match(conditions, options)
+    rescue Normalize::ParseFailure
+      false
+    end
+
+    def self.match(conditions, options)
+      raise Normalize::ParseFailure if conditions.is_a?(Normalize::InvalidConditions)
+      return true if conditions == "*"
+      if conditions.is_a?(String)
+        datafile = options[:__featurevisor_datafile_source]&.call || options[:datafile]
+        segment = datafile.get_segment(conditions)
+        return false unless segment
+        raise Normalize::ParseFailure if segment[:conditions].is_a?(Normalize::InvalidConditions)
+        if datafile.attribute_only_conditions?(segment[:conditions])
+          return datafile.all_conditions_are_matched(segment[:conditions], options[:context])
+        end
+        session = options[:__featurevisor_session] ||= EvaluationSession.new
+        return session.segment(conditions) { match(segment[:conditions], options) }
+      end
+      if conditions.is_a?(Array)
+        return !conditions.empty? && conditions.all? { |child| match(child, options) }
+      end
+      return false unless conditions.is_a?(Hash)
+      if conditions.key?(:variable)
+        begin
+          return options[:__featurevisor_instance].send(:variable_condition_matches?, conditions, options)
+        rescue RequirementError
+          raise
+        rescue => error
+          raise RequirementError, error.message
+        end
+      end
+      if conditions.key?(:feature)
+        clean = options.reject { |key, _| %i[feature_key variable_key default_variable_value default_variation_value].include?(key) }
+        clean = clean.merge(__featurevisor_prerequisite: true, dependency_purpose: "condition")
+        flag = Evaluate.evaluate_with_modules(clean.merge(type: "flag", feature_key: conditions[:feature]))
+        enabled = conditions[:enabled].nil? ? true : conditions[:enabled]
+        return false unless (flag[:enabled] == true) == enabled
+        return true unless conditions.key?(:variation)
+        variation = Evaluate.evaluate_with_modules(clean.merge(type: "variation", feature_key: conditions[:feature]))
+        value = variation.key?(:variation_value) ? variation[:variation_value] : variation.dig(:variation, :value)
+        return value == conditions[:variation]
+      end
+      if conditions.key?(:attribute)
+        return options[:datafile].all_conditions_are_matched(conditions, options[:context])
+      end
+      %i[and or not].each do |group|
+        next unless conditions[group].is_a?(Array)
+        children = conditions[group]
+        return false if children.empty?
+        return children.any? { |child| match(child, options) } if group == :or
+        result = children.all? { |child| match(child, options) }
+        return group == :not ? !result : result
+      end
+      false
+    end
+    private_class_method :match
+
+    def self.attribute_only?(conditions)
+      case conditions
+      when Array
+        conditions.all? { |child| attribute_only?(child) }
+      when Hash
+        return false if conditions.is_a?(Normalize::InvalidConditions) || conditions.key?(:feature) || conditions.key?(:variable)
+        return true if conditions.key?(:attribute)
+        group = %i[and or not].find { |name| conditions.key?(name) }
+        group.nil? || attribute_only?(conditions[group])
+      else
+        false
+      end
+    end
+    private_class_method :attribute_only?
+  end
+end

data/lib/featurevisor/version.rb

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

data/lib/featurevisor.rb

@@ -4,9 +4,14 @@ require_relative "featurevisor/compare_versions"
 require_relative "featurevisor/diagnostics"
 require_relative "featurevisor/emitter"
 require_relative "featurevisor/conditions"
+require_relative "featurevisor/normalize"
+require_relative "featurevisor/mutations"
+require_relative "featurevisor/dependencies"
 require_relative "featurevisor/evaluation_data_provider"
 require_relative "featurevisor/bucketer"
 require_relative "featurevisor/modules"
+require_relative "featurevisor/evaluation_session"
+require_relative "featurevisor/unified_conditions"
 require_relative "featurevisor/evaluate"
 require_relative "featurevisor/instance"
 require_relative "featurevisor/child_instance"
@@ -17,4 +22,6 @@ module Featurevisor
 
   private_constant :InstanceEvaluationDataProvider
   private_constant :DiagnosticReporter
+  private_constant :Mutations
+  private_constant :Dependencies
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: featurevisor
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 4.0.0
 platform: ruby
 authors:
 - Fahad Heylaal
@@ -69,21 +69,30 @@ files:
 - bin/commands.rb
 - bin/commands/assess_distribution.rb
 - bin/commands/benchmark.rb
+- bin/commands/node_cli.rb
+- bin/commands/runtime_project.rb
 - bin/commands/test.rb
 - bin/featurevisor
+- bin/segment_tests.rb
+- bin/test_checks.rb
 - lib/featurevisor.rb
 - lib/featurevisor/bucketer.rb
 - lib/featurevisor/child_instance.rb
 - lib/featurevisor/compare_versions.rb
 - lib/featurevisor/conditions.rb
+- lib/featurevisor/dependencies.rb
 - lib/featurevisor/diagnostics.rb
 - lib/featurevisor/emitter.rb
 - lib/featurevisor/evaluate.rb
 - lib/featurevisor/evaluation_data_provider.rb
+- lib/featurevisor/evaluation_session.rb
 - lib/featurevisor/events.rb
 - lib/featurevisor/instance.rb
 - lib/featurevisor/modules.rb
 - lib/featurevisor/murmurhash.rb
+- lib/featurevisor/mutations.rb
+- lib/featurevisor/normalize.rb
+- lib/featurevisor/unified_conditions.rb
 - lib/featurevisor/version.rb
 homepage: https://featurevisor.com
 licenses: