growthbook 0.0.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91514b6437d92dc4d5ff6464f6ae4088dd2f57974fe60ac24d001eeca58ca498
-  data.tar.gz: 5ecb57a051072fd053838e8dfb0733bf879a44eddb68687583f1c7245496aae6
+  metadata.gz: 9f6c9a059b34fad58095b5e0ea6b3710d7b427617a4cd4f9c7ddc8fdebd2a1da
+  data.tar.gz: c93b9e289a8c950dc3cfa5974062634e7c11f6123e7fd5e94f6ff8c88d262566
 SHA512:
-  metadata.gz: 77a2244bec748a0d55666716b0e532430fc84c3f0d268bf44a54e60fd19ea92329af4cb2cdd19e9af90606845ae8d6a7db6d7ca066d1e1ee2af8a2b126593280
-  data.tar.gz: af03f9ed8278aaf28705b3eed68e81e9fe0f58e482e476ecfc8bc00c073663db68dcd7f70e2902be56a2debf2eb0e465ac29c6730d2b6377f71c862ee924b8b7
+  metadata.gz: 0f1c46dac7d0e9dccc8641f67d7dbbe8d2af91ec18a4cf0fdcb13701042e0fad55bbcf35b91c330506816fa59cbb0129a8ae5a7f3fb103b308735268f3638937
+  data.tar.gz: c38fe86529984df54ee57560b01591c99a20b616f02d8296e9e81a7c1fc56d6755096c675e96e94a52c57c5e9e77435b497aed2d4a3ebb4c0cdcbd78f7d8085b

data/lib/growthbook/conditions.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Growthbook
+  class Conditions
+    # Evaluate a targeting conditions hash against an attributes hash
+    # Both attributes and conditions only have string keys (no symbols)
+    def self.eval_condition(attributes, condition)
+      return eval_or(attributes, condition['$or']) if condition.key?('$or')
+      return !eval_or(attributes, condition['$nor']) if condition.key?('$nor')
+      return eval_and(attributes, condition['$and']) if condition.key?('$and')
+      return !eval_condition(attributes, condition['$not']) if condition.key?('$not')
+
+      condition.each do |key, value|
+        return false unless eval_condition_value(value, get_path(attributes, key))
+      end
+
+      true
+    end
+
+    # Helper function to ensure conditions only have string keys (no symbols)
+    def self.parse_condition(condition)
+      case condition
+      when Array
+        return condition.map { |v| parse_condition(v) }
+      when Hash
+        return condition.map { |k, v| [k.to_s, parse_condition(v)] }.to_h
+      end
+
+      condition
+    end
+
+    def self.eval_or(attributes, conditions)
+      return true if conditions.length <= 0
+
+      conditions.each do |condition|
+        return true if eval_condition(attributes, condition)
+      end
+      false
+    end
+
+    def self.eval_and(attributes, conditions)
+      conditions.each do |condition|
+        return false unless eval_condition(attributes, condition)
+      end
+      true
+    end
+
+    def self.is_operator_object(obj)
+      obj.each do |key, _value|
+        return false if key[0] != '$'
+      end
+      true
+    end
+
+    def self.get_type(attribute_value)
+      return 'string' if attribute_value.is_a? String
+      return 'number' if attribute_value.is_a? Integer
+      return 'number' if attribute_value.is_a? Float
+      return 'boolean' if attribute_value == true || attribute_value == false
+      return 'array' if attribute_value.is_a? Array
+      return 'null' if attribute_value.nil?
+
+      'object'
+    end
+
+    def self.get_path(attributes, path)
+      parts = path.split('.')
+      current = attributes
+
+      parts.each do |value|
+        if current && current.is_a?(Hash) && current.key?(value)
+          current = current[value]
+        else
+          return nil
+        end
+      end
+
+      current
+    end
+
+    def self.eval_condition_value(condition_value, attribute_value)
+      if condition_value.is_a?(Hash) && is_operator_object(condition_value)
+        condition_value.each do |key, value|
+          return false unless eval_operator_condition(key, attribute_value, value)
+        end
+        return true
+      end
+      condition_value.to_json == attribute_value.to_json
+    end
+
+    def self.elem_match(condition, attribute_value)
+      return false unless attribute_value.is_a? Array
+
+      attribute_value.each do |item|
+        if is_operator_object(condition)
+          return true if eval_condition_value(condition, item)
+        elsif eval_condition(item, condition)
+          return true
+        end
+      end
+      false
+    end
+
+    def self.eval_operator_condition(operator, attribute_value, condition_value)
+      case operator
+      when '$eq'
+        attribute_value == condition_value
+      when '$ne'
+        attribute_value != condition_value
+      when '$lt'
+        attribute_value < condition_value
+      when '$lte'
+        attribute_value <= condition_value
+      when '$gt'
+        attribute_value > condition_value
+      when '$gte'
+        attribute_value >= condition_value
+      when '$regex'
+        silence_warnings do
+          re = Regexp.new(condition_value)
+          !!attribute_value.match(re)
+        rescue StandardError
+          false
+        end
+      when '$in'
+        condition_value.include? attribute_value
+      when '$nin'
+        !(condition_value.include? attribute_value)
+      when '$elemMatch'
+        elem_match(condition_value, attribute_value)
+      when '$size'
+        return false unless attribute_value.is_a? Array
+
+        eval_condition_value(condition_value, attribute_value.length)
+      when '$all'
+        return false unless attribute_value.is_a? Array
+
+        condition_value.each do |condition|
+          passed = false
+          attribute_value.each do |attr|
+            passed = true if eval_condition_value(condition, attr)
+          end
+          return false unless passed
+        end
+        true
+      when '$exists'
+        exists = !attribute_value.nil?
+        if !condition_value
+          !exists
+        else
+          exists
+        end
+      when '$type'
+        condition_value == get_type(attribute_value)
+      when '$not'
+        !eval_condition_value(condition_value, attribute_value)
+      else
+        false
+      end
+    end
+
+    # Sets $VERBOSE for the duration of the block and back to its original
+    # value afterwards. Used for testing invalid regexes.
+    def self.silence_warnings
+      old_verbose = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = old_verbose
+    end
+  end
+end

data/lib/growthbook/context.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Growthbook
+  class Context
+    attr_accessor :enabled, :url, :qa_mode, :listener
+    attr_reader :attributes, :features, :impressions, :forced_variations, :forced_features
+
+    def initialize(options = {})
+      @features = {}
+      @forced_variations = {}
+      @forced_features = {}
+      @attributes = {}
+      @enabled = true
+      @impressions = {}
+
+      options.each do |key, value|
+        case key.to_sym
+        when :enabled
+          @enabled = value
+        when :attributes
+          self.attributes = value
+        when :url
+          @url = value
+        when :features
+          self.features = value
+        when :forced_variations, :forcedVariations
+          self.forced_variations = value
+        when :forced_features
+          self.forced_features = value
+        when :qa_mode, :qaMode
+          @qa_mode = value
+        when :listener
+          @listener = value
+        else
+          warn("Unknown context option: #{key}")
+        end
+      end
+    end
+
+    def features=(features)
+      @features = {}
+
+      features.each do |k, v|
+        # Convert to a Feature object if it's not already
+        v = Growthbook::Feature.new(v) unless v.is_a? Growthbook::Feature
+
+        @features[k.to_s] = v
+      end
+    end
+
+    def attributes=(attrs)
+      @attributes = stringify_keys(attrs || {})
+    end
+
+    def forced_variations=(forced_variations)
+      @forced_variations = stringify_keys(forced_variations || {})
+    end
+
+    def forced_features=(forced_features)
+      @forced_features = stringify_keys(forced_features || {})
+    end
+
+    def eval_feature(key)
+      # Forced in the context
+      if @forced_features.key?(key.to_s)
+        return get_feature_result(@forced_features[key.to_s], 'override') 
+      end
+
+      # Return if we can't find the feature definition
+      feature = get_feature(key)
+      return get_feature_result(nil, 'unknownFeature') unless feature
+
+      feature.rules.each do |rule|
+        # Targeting condition
+        next if rule.condition && !condition_passes(rule.condition)
+
+        # Rollout or forced value rule
+        if rule.is_force?
+          unless rule.coverage.nil?
+            hash_value = get_attribute(rule.hash_attribute || 'id').to_s
+            next if hash_value.length.zero?
+
+            n = Growthbook::Util.hash(hash_value + key)
+            next if n > rule.coverage
+          end
+          return get_feature_result(rule.force, 'force')
+        end
+        # Experiment rule
+        next unless rule.is_experiment?
+
+        exp = rule.to_experiment(key)
+        result = _run(exp, key)
+
+        next unless result.in_experiment
+
+        return get_feature_result(result.value, 'experiment', exp, result)
+      end
+
+      # Fallback
+      get_feature_result(feature.default_value || nil, 'defaultValue')
+    end
+
+    def run(exp)
+      _run(exp)
+    end
+
+    def on?(key)
+      eval_feature(key).on
+    end
+
+    def off?(key)
+      eval_feature(key).off
+    end
+
+    def feature_value(key, fallback = nil)
+      value = eval_feature(key).value
+      value.nil? ? fallback : value
+    end
+
+    private
+
+    def _run(exp, feature_id="")
+      key = exp.key
+
+      # 1. If experiment doesn't have enough variations, return immediately
+      return get_experiment_result(exp, -1, false, feature_id) if exp.variations.length < 2
+
+      # 2. If context is disabled, return immediately
+      return get_experiment_result(exp, -1, false, feature_id) unless @enabled
+
+      # 3. If forced via URL querystring
+      if @url
+        qsOverride = Util.get_query_string_override(key, @url, exp.variations.length)
+        return get_experiment_result(exp, qsOverride, false, feature_id) unless qsOverride.nil?
+      end
+
+      # 4. If variation is forced in the context, return the forced value
+      return get_experiment_result(exp, @forced_variations[key.to_s], false, feature_id) if @forced_variations.key?(key.to_s)
+
+      # 5. Exclude if not active
+      return get_experiment_result(exp, -1, false, feature_id) unless exp.active
+
+      # 6. Get hash_attribute/value and return if empty
+      hash_attribute = exp.hash_attribute || 'id'
+      hash_value = get_attribute(hash_attribute).to_s
+      return get_experiment_result(exp, -1, false, feature_id) if hash_value.length.zero?
+
+      # 7. Exclude if user not in namespace
+      return get_experiment_result(exp, -1, false, feature_id) if exp.namespace && !Growthbook::Util.in_namespace(hash_value, exp.namespace)
+
+      # 8. Exclude if condition is false
+      return get_experiment_result(exp, -1, false, feature_id) if exp.condition && !condition_passes(exp.condition)
+
+      # 9. Calculate bucket ranges and choose one
+      ranges = Growthbook::Util.get_bucket_ranges(
+        exp.variations.length,
+        exp.coverage,
+        exp.weights
+      )
+      n = Growthbook::Util.hash(hash_value + key)
+      assigned = Growthbook::Util.choose_variation(n, ranges)
+
+      # 10. Return if not in experiment
+      return get_experiment_result(exp, -1, false, feature_id) if assigned.negative?
+
+      # 11. Experiment has a forced variation
+      return get_experiment_result(exp, exp.force, false, feature_id) unless exp.force.nil?
+
+      # 12. Exclude if in QA mode
+      return get_experiment_result(exp, -1, false, feature_id) if @qa_mode
+
+      # 13. Build the result object
+      result = get_experiment_result(exp, assigned, true, feature_id)
+
+      # 14. Fire tracking callback
+      track_experiment(exp, result)
+
+      # 15. Return the result
+      result
+    end
+
+    def stringify_keys(hash)
+      new_hash = {}
+      hash.each do |key, value|
+        new_hash[key.to_s] = value
+      end
+      new_hash
+    end
+
+    def condition_passes(condition)
+      Growthbook::Conditions.eval_condition(@attributes, condition)
+    end
+
+    def get_experiment_result(experiment, variation_index = -1, hash_used = false, feature_id = "")
+      in_experiment = true
+      if variation_index.negative? || variation_index >= experiment.variations.length
+        variation_index = 0
+        in_experiment = false
+      end
+
+      hash_attribute = experiment.hash_attribute || 'id'
+      hash_value = get_attribute(hash_attribute)
+
+      Growthbook::InlineExperimentResult.new(hash_used, in_experiment, variation_index,
+                                             experiment.variations[variation_index], hash_attribute, hash_value, feature_id)
+    end
+
+    def get_feature_result(value, source, experiment = nil, experiment_result = nil)
+      Growthbook::FeatureResult.new(value, source, experiment, experiment_result)
+    end
+
+    def get_feature(key)
+      return @features[key.to_sym] if @features.key?(key.to_sym)
+      return @features[key.to_s] if @features.key?(key.to_s)
+
+      nil
+    end
+
+    def get_attribute(key)
+      return @attributes[key.to_sym] if @attributes.key?(key.to_sym)
+      return @attributes[key.to_s] if @attributes.key?(key.to_s)
+
+      ''
+    end
+
+    def track_experiment(experiment, result)
+      if @listener && @listener.respond_to?(:on_experiment_viewed)
+        @listener.on_experiment_viewed(experiment, result)
+      end
+      @impressions[experiment.key] = result
+    end
+  end
+end

data/lib/growthbook/feature.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Growthbook
+  class Feature
+    # @return [Any , nil]
+    attr_reader :default_value
+
+    # @return [Array<Growthbook::FeatureRule>]
+    attr_reader :rules
+
+    def initialize(feature)
+      @default_value = getOption(feature, :defaultValue)
+
+      rules = getOption(feature, :rules)
+
+      @rules = []
+      rules&.each do |rule|
+        @rules << Growthbook::FeatureRule.new(rule)
+      end
+    end
+
+    def to_json(*_args)
+      res = {}
+      res['defaultValue'] = @default_value unless @default_value.nil?
+      res['rules'] = []
+      @rules.each do |rule|
+        res['rules'] << rule.to_json
+      end
+      res
+    end
+
+    private
+
+    def getOption(hash, key)
+      return hash[key.to_sym] if hash.key?(key.to_sym)
+      return hash[key.to_s] if hash.key?(key.to_s)
+
+      nil
+    end
+  end
+end

data/lib/growthbook/feature_result.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Growthbook
+  class FeatureResult
+    # The assigned value of the feature
+    # @return [Any, nil]
+    attr_reader :value
+
+    # Whether or not the feature is ON
+    # @return [Bool]
+    attr_reader :on
+
+    # Whether or not the feature is OFF
+    # @return [Bool]
+    attr_reader :off
+
+    # The reason the feature was assigned this value
+    # @return [String]
+    attr_reader :source
+
+    # The experiment used to decide the feature value
+    # @return [Growthbook.Experiment, nil]
+    attr_reader :experiment
+
+    # The result of the experiment
+    # @return [Growthbook.ExperimentResult, nil]
+    attr_reader :experiment_result
+
+    def initialize(
+      value,
+      source,
+      experiment,
+      experiment_result
+    )
+
+      on = !value.nil? && value != 0 && value != '' && value != false
+
+      @value = value
+      @on = on
+      @off = !on
+      @source = source
+      @experiment = experiment
+      @experiment_result = experiment_result
+    end
+
+    def to_json(*_args)
+      json = {}
+      json['on'] = @on
+      json['off'] = @off
+      json['value'] = @value
+      json['source'] = @source
+
+      if @experiment
+        json['experiment'] = @experiment.to_json
+        json['experimentResult'] = @experiment_result.to_json
+      end
+
+      json
+    end
+  end
+end

data/lib/growthbook/feature_rule.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Growthbook
+  class FeatureRule
+    # @return [Hash , nil]
+    attr_reader :condition
+    # @return [Float , nil]
+    attr_reader :coverage
+    # @return [T , nil]
+    attr_reader :force
+    # @return [T[] , nil]
+    attr_reader :variations
+    # @return [String , nil]
+    attr_reader :key
+    # @return [Float[] , nil]
+    attr_reader :weights
+    # @return [Array , nil]
+    attr_reader :namespace
+    # @return [String , nil]
+    attr_reader :hash_attribute
+
+    def initialize(rule)
+      @coverage = getOption(rule, :coverage)
+      @force = getOption(rule, :force)
+      @variations = getOption(rule, :variations)
+      @key = getOption(rule, :key)
+      @weights = getOption(rule, :weights)
+      @namespace = getOption(rule, :namespace)
+      @hash_attribute = getOption(rule, :hash_attribute) || getOption(rule, :hashAttribute)
+
+      cond = getOption(rule, :condition)
+      @condition = Growthbook::Conditions.parse_condition(cond) unless cond.nil?
+    end
+
+    def to_experiment(feature_key)
+      return nil unless @variations
+
+      Growthbook::InlineExperiment.new(
+        key: @key || feature_key,
+        variations: @variations,
+        coverage: @coverage,
+        weights: @weights,
+        hash_attribute: @hash_attribute,
+        namespace: @namespace
+      )
+    end
+
+    def is_experiment?
+      !!@variations
+    end
+
+    def is_force?
+      !is_experiment? && !@force.nil?
+    end
+
+    def to_json(*_args)
+      res = {}
+      res['condition'] = @condition unless @condition.nil?
+      res['coverage'] = @coverage unless @coverage.nil?
+      res['force'] = @force unless @force.nil?
+      res['variations'] = @variations unless @variations.nil?
+      res['key'] = @key unless @key.nil?
+      res['weights'] = @weights unless @weights.nil?
+      res['namespace'] = @namespace unless @namespace.nil?
+      res['hashAttribute'] = @hash_attribute unless @hash_attribute.nil?
+      res
+    end
+
+    private
+
+    def getOption(hash, key)
+      return hash[key.to_sym] if hash.key?(key.to_sym)
+      return hash[key.to_s] if hash.key?(key.to_s)
+
+      nil
+    end
+  end
+end

data/lib/growthbook/inline_experiment.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Growthbook
+  class InlineExperiment
+    # @returns [String]
+    attr_accessor :key
+
+    # @returns [Any]
+    attr_accessor :variations
+
+    # @returns [Bool]
+    attr_accessor :active
+
+    # @returns [Integer, nil]
+    attr_accessor :force
+
+    # @returns [Array<Float>, nil]
+    attr_accessor :weights
+
+    # @returns [Float]
+    attr_accessor :coverage
+
+    # @returns [Hash, nil]
+    attr_accessor :condition
+
+    # @returns [Array]
+    attr_accessor :namespace
+
+    # @returns [String]
+    attr_accessor :hash_attribute
+
+    # Constructor for an Experiment
+    #
+    # @param options [Hash]
+    # @option options [Array<Any>] :variations The variations to pick between
+    # @option options [String] :key The unique identifier for this experiment
+    # @option options [Float] :coverage (1.0) The percent of elegible traffic to include in the experiment
+    # @option options [Array<Float>] :weights The relative weights of the variations.
+    #    Length must be the same as the number of variations. Total should add to 1.0.
+    #    Default is an even split between variations
+    # @option options [Boolean] :anon (false) If false, the experiment uses the logged-in user id for bucketing
+    #    If true, the experiment uses the anonymous id for bucketing
+    # @option options [Array<String>] :targeting Array of targeting rules in the format "key op value"
+    #    where op is one of: =, !=, <, >, ~, !~
+    # @option options [Integer, nil] :force If an integer, force all users to get this variation
+    # @option options [Hash] :data Data to attach to the variations
+    def initialize(options = {})
+      @key = getOption(options, :key, '').to_s
+      @variations = getOption(options, :variations, [])
+      @active = getOption(options, :active, true)
+      @force = getOption(options, :force)
+      @weights = getOption(options, :weights)
+      @coverage = getOption(options, :coverage, 1)
+      @condition = getOption(options, :condition)
+      @namespace = getOption(options, :namespace)
+      @hash_attribute = getOption(options, :hash_attribute) || getOption(options, :hashAttribute) || 'id'
+    end
+
+    def getOption(hash, key, default = nil)
+      return hash[key.to_sym] if hash.key?(key.to_sym)
+      return hash[key.to_s] if hash.key?(key.to_s)
+
+      default
+    end
+
+    def to_json(*_args)
+      res = {}
+      res['key'] = @key
+      res['variations'] = @variations
+      res['active'] = @active if @active != true && !@active.nil?
+      res['force'] = @force unless @force.nil?
+      res['weights'] = @weights unless @weights.nil?
+      res['coverage'] = @coverage if @coverage != 1 && !@coverage.nil?
+      res['condition'] = @condition unless @condition.nil?
+      res['namespace'] = @namespace unless @namespace.nil?
+      res['hashAttribute'] = @hash_attribute if @hash_attribute != 'id' && !@hash_attribute.nil?
+      res
+    end
+  end
+end