split 3.4.1 → 4.0.4

data/lib/split/helper.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   module Helper
     OVERRIDE_PARAM_NAME = "ab_test"
@@ -11,9 +12,9 @@ module Split
         alternative = if Split.configuration.enabled && !exclude_visitor?
           experiment.save
           raise(Split::InvalidExperimentsFormatError) unless (Split.configuration.experiments || {}).fetch(experiment.name.to_sym, {})[:combined_experiments].nil?
-          trial = Trial.new(:user => ab_user, :experiment => experiment,
-              :override => override_alternative(experiment.name), :exclude => exclude_visitor?,
-              :disabled => split_generically_disabled?)
+          trial = Trial.new(user: ab_user, experiment: experiment,
+              override: override_alternative(experiment.name), exclude: exclude_visitor?,
+              disabled: split_generically_disabled?)
           alt = trial.choose!(self)
           alt ? alt.name : nil
         else
@@ -32,8 +33,8 @@ module Split
       end
 
       if block_given?
-        metadata = trial ? trial.metadata : {}
-        yield(alternative, metadata)
+        metadata = experiment.metadata[alternative] if experiment.metadata
+        yield(alternative, metadata || {})
       else
         alternative
       end
@@ -43,17 +44,22 @@ module Split
       ab_user.delete(experiment.key)
     end
 
-    def finish_experiment(experiment, options = {:reset => true})
+    def finish_experiment(experiment, options = { reset: true })
       return false if active_experiments[experiment.name].nil?
       return true if experiment.has_winner?
       should_reset = experiment.resettable? && options[:reset]
       if ab_user[experiment.finished_key] && !should_reset
-        return true
+        true
       else
         alternative_name = ab_user[experiment.key]
-        trial = Trial.new(:user => ab_user, :experiment => experiment,
-              :alternative => alternative_name)
-        trial.complete!(options[:goals], self)
+        trial = Trial.new(
+          user: ab_user,
+          experiment: experiment,
+          alternative: alternative_name,
+          goals: options[:goals],
+        )
+
+        trial.complete!(self)
 
         if should_reset
           reset!(experiment)
@@ -63,14 +69,15 @@ module Split
       end
     end
 
-    def ab_finished(metric_descriptor, options = {:reset => true})
+    def ab_finished(metric_descriptor, options = { reset: true })
       return if exclude_visitor? || Split.configuration.disabled?
       metric_descriptor, goals = normalize_metric(metric_descriptor)
       experiments = Metric.possible_experiments(metric_descriptor)
 
       if experiments.any?
         experiments.each do |experiment|
-          finish_experiment(experiment, options.merge(:goals => goals))
+          next if override_present?(experiment.key)
+          finish_experiment(experiment, options.merge(goals: goals))
         end
       end
     rescue => e
@@ -79,7 +86,7 @@ module Split
     end
 
     def ab_record_extra_info(metric_descriptor, key, value = 1)
-      return if exclude_visitor? || Split.configuration.disabled?
+      return if exclude_visitor? || Split.configuration.disabled? || value.nil?
       metric_descriptor, _ = normalize_metric(metric_descriptor)
       experiments = Metric.possible_experiments(metric_descriptor)
 
@@ -88,7 +95,7 @@ module Split
           alternative_name = ab_user[experiment.key]
 
           if alternative_name
-            alternative = experiment.alternatives.find{|alt| alt.name == alternative_name}
+            alternative = experiment.alternatives.find { |alt| alt.name == alternative_name }
             alternative.record_extra_info(key, value) if alternative
           end
         end
@@ -98,24 +105,36 @@ module Split
       Split.configuration.db_failover_on_db_error.call(e)
     end
 
-    def ab_active_experiments()
+    def ab_active_experiments
       ab_user.active_experiments
     rescue => e
       raise unless Split.configuration.db_failover
       Split.configuration.db_failover_on_db_error.call(e)
     end
 
-
     def override_present?(experiment_name)
-      override_alternative(experiment_name)
+      override_alternative_by_params(experiment_name) || override_alternative_by_cookies(experiment_name)
     end
 
     def override_alternative(experiment_name)
-      defined?(params) && params[OVERRIDE_PARAM_NAME] && params[OVERRIDE_PARAM_NAME][experiment_name]
+      override_alternative_by_params(experiment_name) || override_alternative_by_cookies(experiment_name)
+    end
+
+    def override_alternative_by_params(experiment_name)
+      params_present? && params[OVERRIDE_PARAM_NAME] && params[OVERRIDE_PARAM_NAME][experiment_name]
+    end
+
+    def override_alternative_by_cookies(experiment_name)
+      return unless request_present?
+
+      if request.cookies && request.cookies.key?("split_override")
+        experiments = JSON.parse(request.cookies["split_override"]) rescue {}
+        experiments[experiment_name]
+      end
     end
 
     def split_generically_disabled?
-      defined?(params) && params['SPLIT_DISABLE']
+      params_present? && params["SPLIT_DISABLE"]
     end
 
     def ab_user
@@ -123,26 +142,34 @@ module Split
     end
 
     def exclude_visitor?
-      defined?(request) && (instance_exec(request, &Split.configuration.ignore_filter) || is_ignored_ip_address? || is_robot? || is_preview?)
+      request_present? && (instance_exec(request, &Split.configuration.ignore_filter) || is_ignored_ip_address? || is_robot? || is_preview?)
     end
 
     def is_robot?
-      defined?(request) && request.user_agent =~ Split.configuration.robot_regex
+      request_present? && request.user_agent =~ Split.configuration.robot_regex
     end
 
     def is_preview?
-      defined?(request) && defined?(request.headers) && request.headers['x-purpose'] == 'preview'
+      request_present? && defined?(request.headers) && request.headers["x-purpose"] == "preview"
     end
 
     def is_ignored_ip_address?
       return false if Split.configuration.ignore_ip_addresses.empty?
 
       Split.configuration.ignore_ip_addresses.each do |ip|
-        return true if defined?(request) && (request.ip == ip || (ip.class == Regexp && request.ip =~ ip))
+        return true if request_present? && (request.ip == ip || (ip.class == Regexp && request.ip =~ ip))
       end
       false
     end
 
+    def params_present?
+      defined?(params) && params
+    end
+
+    def request_present?
+      defined?(request) && request
+    end
+
     def active_experiments
       ab_user.active_experiments
     end

data/lib/split/metric.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 module Split
   class Metric
     attr_accessor :name
     attr_accessor :experiments
 
     def initialize(attrs = {})
-      attrs.each do |key,value|
+      attrs.each do |key, value|
         if self.respond_to?("#{key}=")
           self.send("#{key}=", value)
         end
@@ -15,13 +16,13 @@ module Split
     def self.load_from_redis(name)
       metric = Split.redis.hget(:metrics, name)
       if metric
-        experiment_names = metric.split(',')
+        experiment_names = metric.split(",")
 
         experiments = experiment_names.collect do |experiment_name|
           Split::ExperimentCatalog.find(experiment_name)
         end
 
-        Split::Metric.new(:name => name, :experiments => experiments)
+        Split::Metric.new(name: name, experiments: experiments)
       else
         nil
       end
@@ -30,7 +31,7 @@ module Split
     def self.load_from_configuration(name)
       metrics = Split.configuration.metrics
       if metrics && metrics[name]
-        Split::Metric.new(:experiments => metrics[name], :name => name)
+        Split::Metric.new(experiments: metrics[name], name: name)
       else
         nil
       end
@@ -76,7 +77,7 @@ module Split
     end
 
     def save
-      Split.redis.hset(:metrics, name, experiments.map(&:name).join(','))
+      Split.redis.hset(:metrics, name, experiments.map(&:name).join(","))
     end
 
     def complete!
@@ -96,6 +97,5 @@ module Split
       return metric_name, goals
     end
     private_class_method :normalize_metric
-
   end
 end

data/lib/split/persistence/cookie_adapter.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require "json"
 
 module Split
   module Persistence
     class CookieAdapter
-
       def initialize(context)
         @context = context
         @request, @response = context.request, context.response
@@ -29,50 +29,49 @@ module Split
       end
 
       private
+        def set_cookie(value = {})
+          cookie_key = :split.to_s
+          cookie_value = default_options.merge(value: JSON.generate(value))
+          if action_dispatch?
+            # The "send" is necessary when we call ab_test from the controller
+            # and thus @context is a rails controller, because then "cookies" is
+            # a private method.
+            @context.send(:cookies)[cookie_key] = cookie_value
+          else
+            set_cookie_via_rack(cookie_key, cookie_value)
+          end
+        end
 
-      def set_cookie(value = {})
-        cookie_key = :split.to_s
-        cookie_value = default_options.merge(value: JSON.generate(value))
-        if action_dispatch?
-          # The "send" is necessary when we call ab_test from the controller
-          # and thus @context is a rails controller, because then "cookies" is
-          # a private method.
-          @context.send(:cookies)[cookie_key] = cookie_value
-        else
-          set_cookie_via_rack(cookie_key, cookie_value)
+        def default_options
+          { expires: @expires, path: "/", domain: cookie_domain_config }.compact
         end
-      end
 
-      def default_options
-        { expires: @expires, path: '/' }
-      end
+        def set_cookie_via_rack(key, value)
+          delete_cookie_header!(@response.header, key, value)
+          Rack::Utils.set_cookie_header!(@response.header, key, value)
+        end
 
-      def set_cookie_via_rack(key, value)
-        delete_cookie_header!(@response.header, key, value)
-        Rack::Utils.set_cookie_header!(@response.header, key, value)
-      end
+        # Use Rack::Utils#make_delete_cookie_header after Rack 2.0.0
+        def delete_cookie_header!(header, key, value)
+          cookie_header = header["Set-Cookie"]
+          case cookie_header
+          when nil, ""
+            cookies = []
+          when String
+            cookies = cookie_header.split("\n")
+          when Array
+            cookies = cookie_header
+          end
 
-      # Use Rack::Utils#make_delete_cookie_header after Rack 2.0.0
-      def delete_cookie_header!(header, key, value)
-        cookie_header = header['Set-Cookie']
-        case cookie_header
-        when nil, ''
-          cookies = []
-        when String
-          cookies = cookie_header.split("\n")
-        when Array
-          cookies = cookie_header
+          cookies.reject! { |cookie| cookie =~ /\A#{Rack::Utils.escape(key)}=/ }
+          header["Set-Cookie"] = cookies.join("\n")
         end
 
-        cookies.reject! { |cookie| cookie =~ /\A#{Rack::Utils.escape(key)}=/ }
-        header['Set-Cookie'] = cookies.join("\n")
-      end
-
-      def hash
-        @hash ||= begin
-          if cookies = @cookies[:split.to_s]
+        def hash
+          @hash ||= if cookies = @cookies[:split.to_s]
             begin
-              JSON.parse(cookies)
+              parsed = JSON.parse(cookies)
+              parsed.is_a?(Hash) ? parsed : {}
             rescue JSON::ParserError
               {}
             end
@@ -80,15 +79,18 @@ module Split
             {}
           end
         end
-      end
 
-      def cookie_length_config
-        Split.configuration.persistence_cookie_length
-      end
+        def cookie_length_config
+          Split.configuration.persistence_cookie_length
+        end
 
-      def action_dispatch?
-        defined?(Rails) && @response.is_a?(ActionDispatch::Response)
-      end
+        def cookie_domain_config
+          Split.configuration.persistence_cookie_domain
+        end
+
+        def action_dispatch?
+          defined?(Rails) && @response.is_a?(ActionDispatch::Response)
+        end
     end
   end
 end

data/lib/split/persistence/dual_adapter.rb

@@ -3,7 +3,7 @@
 module Split
   module Persistence
     class DualAdapter
-      def self.with_config(options={})
+      def self.with_config(options = {})
         self.config.merge!(options)
         self
       end
@@ -72,14 +72,13 @@ module Split
       end
 
       private
+        def decrement_participation?(old_value, value)
+          !old_value.nil? && !value.nil? && old_value != value
+        end
 
-      def decrement_participation?(old_value, value)
-        !old_value.nil? && !value.nil? && old_value != value
-      end
-
-      def decrement_participation(key, value)
-        Split.redis.hincrby("#{key}:#{value}", 'participant_count', -1)
-      end
+        def decrement_participation(key, value)
+          Split.redis.hincrby("#{key}:#{value}", "participant_count", -1)
+        end
     end
   end
 end

data/lib/split/persistence/redis_adapter.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class RedisAdapter
-      DEFAULT_CONFIG = {:namespace => 'persistence'}.freeze
+      DEFAULT_CONFIG = { namespace: "persistence" }.freeze
 
       attr_reader :redis_key
 
@@ -26,7 +27,7 @@ module Split
       end
 
       def []=(field, value)
-        Split.redis.hset(redis_key, field, value)
+        Split.redis.hset(redis_key, field, value.to_s)
         expire_seconds = self.class.config[:expire_seconds]
         Split.redis.expire(redis_key, expire_seconds) if expire_seconds
       end
@@ -39,7 +40,11 @@ module Split
         Split.redis.hkeys(redis_key)
       end
 
-      def self.with_config(options={})
+      def self.find(user_id)
+        new(nil, user_id)
+      end
+
+      def self.with_config(options = {})
         self.config.merge!(options)
         self
       end
@@ -51,7 +56,6 @@ module Split
       def self.reset_config!
         @config = DEFAULT_CONFIG.dup
       end
-
     end
   end
 end

data/lib/split/persistence/session_adapter.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class SessionAdapter
-
       def initialize(context)
         @session = context.session
         @session[:split] ||= {}
@@ -23,7 +23,6 @@ module Split
       def keys
         @session[:split].keys
       end
-
     end
   end
 end

data/lib/split/persistence.rb

@@ -2,14 +2,16 @@
 
 module Split
   module Persistence
-    require 'split/persistence/cookie_adapter'
-    require 'split/persistence/dual_adapter'
-    require 'split/persistence/redis_adapter'
-    require 'split/persistence/session_adapter'
+    require "split/persistence/cookie_adapter"
+    require "split/persistence/dual_adapter"
+    require "split/persistence/redis_adapter"
+    require "split/persistence/session_adapter"
 
     ADAPTERS = {
-      :cookie => Split::Persistence::CookieAdapter,
-      :session => Split::Persistence::SessionAdapter
+      cookie: Split::Persistence::CookieAdapter,
+      session: Split::Persistence::SessionAdapter,
+      redis: Split::Persistence::RedisAdapter,
+      dual_adapter: Split::Persistence::DualAdapter
     }.freeze
 
     def self.adapter

data/lib/split/redis_interface.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   # Simplifies the interface to Redis.
   class RedisInterface
@@ -7,44 +8,29 @@ module Split
     end
 
     def persist_list(list_name, list_values)
-      max_index = list_length(list_name) - 1
-      list_values.each_with_index do |value, index|
-        if index > max_index
-          add_to_list(list_name, value)
-        else
-          set_list_index(list_name, index, value)
+      if list_values.length > 0
+        redis.multi do |multi|
+          tmp_list = "#{list_name}_tmp"
+          tmp_list += redis_namespace_used? ? "{#{Split.redis.namespace}:#{list_name}}" : "{#{list_name}}"
+          multi.rpush(tmp_list, list_values)
+          multi.rename(tmp_list, list_name)
         end
       end
-      make_list_length(list_name, list_values.length)
-      list_values
-    end
-
-    def add_to_list(list_name, value)
-      redis.rpush(list_name, value)
-    end
-
-    def set_list_index(list_name, index, value)
-      redis.lset(list_name, index, value)
-    end
 
-    def list_length(list_name)
-      redis.llen(list_name)
-    end
-
-    def remove_last_item_from_list(list_name)
-      redis.rpop(list_name)
-    end
-
-    def make_list_length(list_name, new_length)
-      redis.ltrim(list_name, 0, new_length - 1)
+      list_values
     end
 
     def add_to_set(set_name, value)
-      redis.sadd(set_name, value) unless redis.sismember(set_name, value)
+      return redis.sadd?(set_name, value) if redis.respond_to?(:sadd?)
+
+      redis.sadd(set_name, value)
     end
 
     private
+      attr_accessor :redis
 
-    attr_accessor :redis
+      def redis_namespace_used?
+        Redis.const_defined?("Namespace") && Split.redis.is_a?(Redis::Namespace)
+      end
   end
 end

data/lib/split/trial.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+
 module Split
   class Trial
+    attr_accessor :goals
     attr_accessor :experiment
     attr_writer :metadata
 
@@ -8,11 +10,12 @@ module Split
       self.experiment   = attrs.delete(:experiment)
       self.alternative  = attrs.delete(:alternative)
       self.metadata  = attrs.delete(:metadata)
+      self.goals = attrs.delete(:goals) || []
 
       @user             = attrs.delete(:user)
       @options          = attrs
 
-      @alternative_choosen = false
+      @alternative_chosen = false
     end
 
     def metadata
@@ -21,24 +24,24 @@ module Split
 
     def alternative
       @alternative ||=  if @experiment.has_winner?
-                          @experiment.winner
-                        end
+        @experiment.winner
+      end
     end
 
     def alternative=(alternative)
       @alternative = if alternative.kind_of?(Split::Alternative)
         alternative
       else
-        @experiment.alternatives.find{|a| a.name == alternative }
+        @experiment.alternatives.find { |a| a.name == alternative }
       end
     end
 
-    def complete!(goals=[], context = nil)
+    def complete!(context = nil)
       if alternative
         if Array(goals).empty?
           alternative.increment_completion
         else
-          Array(goals).each {|g| alternative.increment_completion(g) }
+          Array(goals).each { |g| alternative.increment_completion(g) }
         end
 
         run_callback context, Split.configuration.on_trial_complete
@@ -51,8 +54,9 @@ module Split
     def choose!(context = nil)
       @user.cleanup_old_experiments!
       # Only run the process once
-      return alternative if @alternative_choosen
+      return alternative if @alternative_chosen
 
+      new_participant = @user[@experiment.key].nil?
       if override_is_alternative?
         self.alternative = @options[:override]
         if should_store_alternative? && !@user[@experiment.key]
@@ -70,48 +74,53 @@ module Split
         else
           self.alternative = @user[@experiment.key]
           if alternative.nil?
-            self.alternative = @experiment.next_alternative
+            if @experiment.cohorting_disabled?
+              self.alternative = @experiment.control
+            else
+              self.alternative = @experiment.next_alternative
 
-            # Increment the number of participants since we are actually choosing a new alternative
-            self.alternative.increment_participation
+              # Increment the number of participants since we are actually choosing a new alternative
+              self.alternative.increment_participation
 
-            run_callback context, Split.configuration.on_trial_choose
+              run_callback context, Split.configuration.on_trial_choose
+            end
           end
         end
       end
 
-      @user[@experiment.key] = alternative.name if !@experiment.has_winner? && should_store_alternative?
-      @alternative_choosen = true
-      run_callback context, Split.configuration.on_trial unless @options[:disabled] || Split.configuration.disabled?
+      new_participant_and_cohorting_disabled = new_participant && @experiment.cohorting_disabled?
+
+      @user[@experiment.key] = alternative.name unless @experiment.has_winner? || !should_store_alternative? || new_participant_and_cohorting_disabled
+      @alternative_chosen = true
+      run_callback context, Split.configuration.on_trial unless @options[:disabled] || Split.configuration.disabled? || new_participant_and_cohorting_disabled
       alternative
     end
 
     private
+      def run_callback(context, callback_name)
+        context.send(callback_name, self) if callback_name && context.respond_to?(callback_name, true)
+      end
 
-    def run_callback(context, callback_name)
-      context.send(callback_name, self) if callback_name && context.respond_to?(callback_name, true)
-    end
-
-    def override_is_alternative?
-      @experiment.alternatives.map(&:name).include?(@options[:override])
-    end
+      def override_is_alternative?
+        @experiment.alternatives.map(&:name).include?(@options[:override])
+      end
 
-    def should_store_alternative?
-      if @options[:override] || @options[:disabled]
-        Split.configuration.store_override
-      else
-        !exclude_user?
+      def should_store_alternative?
+        if @options[:override] || @options[:disabled]
+          Split.configuration.store_override
+        else
+          !exclude_user?
+        end
       end
-    end
 
-    def cleanup_old_versions
-      if @experiment.version > 0
-        @user.cleanup_old_versions!(@experiment)
+      def cleanup_old_versions
+        if @experiment.version > 0
+          @user.cleanup_old_versions!(@experiment)
+        end
       end
-    end
 
-    def exclude_user?
-      @options[:exclude] || @experiment.start_time.nil? || @user.max_experiments_reached?(@experiment.key)
-    end
+      def exclude_user?
+        @options[:exclude] || @experiment.start_time.nil? || @user.max_experiments_reached?(@experiment.key)
+      end
   end
 end