split 3.0.0 → 4.0.1

data/lib/split/persistence/dual_adapter.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 module Split
   module Persistence
     class DualAdapter
-      extend Forwardable
-      def_delegators :@adapter, :keys, :[], :[]=, :delete
+      def self.with_config(options={})
+        self.config.merge!(options)
+        self
+      end
+
+      def self.config
+        @config ||= {}
+      end
 
       def initialize(context)
         if logged_in = self.class.config[:logged_in]
@@ -22,22 +26,60 @@ module Split
           raise "Please configure :logged_out_adapter"
         end
 
-        if logged_in.call(context)
-          @adapter = logged_in_adapter.new(context)
+        @fallback_to_logged_out_adapter =
+          self.class.config[:fallback_to_logged_out_adapter] || false
+        @logged_in = logged_in.call(context)
+        @logged_in_adapter = logged_in_adapter.new(context)
+        @logged_out_adapter = logged_out_adapter.new(context)
+        @active_adapter = @logged_in ? @logged_in_adapter : @logged_out_adapter
+      end
+
+      def keys
+        if @fallback_to_logged_out_adapter
+          (@logged_in_adapter.keys + @logged_out_adapter.keys).uniq
         else
-          @adapter = logged_out_adapter.new(context)
+          @active_adapter.keys
         end
       end
 
-      def self.with_config(options={})
-        self.config.merge!(options)
-        self
+      def [](key)
+        if @fallback_to_logged_out_adapter
+          @logged_in && @logged_in_adapter[key] || @logged_out_adapter[key]
+        else
+          @active_adapter[key]
+        end
       end
 
-      def self.config
-        @config ||= {}
+      def []=(key, value)
+        if @fallback_to_logged_out_adapter
+          @logged_in_adapter[key] = value if @logged_in
+          old_value = @logged_out_adapter[key]
+          @logged_out_adapter[key] = value
+
+          decrement_participation(key, old_value) if decrement_participation?(old_value, value)
+        else
+          @active_adapter[key] = value
+        end
+      end
+
+      def delete(key)
+        if @fallback_to_logged_out_adapter
+          @logged_in_adapter.delete(key)
+          @logged_out_adapter.delete(key)
+        else
+          @active_adapter.delete(key)
+        end
       end
 
+      private
+
+      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
     end
   end
 end

data/lib/split/persistence/redis_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class RedisAdapter
@@ -39,6 +40,10 @@ module Split
         Split.redis.hkeys(redis_key)
       end
 
+      def self.find(user_id)
+        new(nil, user_id)
+      end
+
       def self.with_config(options={})
         self.config.merge!(options)
         self

data/lib/split/persistence/session_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class SessionAdapter

data/lib/split/persistence.rb

@@ -8,8 +8,10 @@ module Split
     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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Split
   # Simplifies the interface to Redis.
   class RedisInterface
@@ -6,42 +8,19 @@ 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"
+          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)
-      while list_length(list_name) > new_length
-        remove_last_item_from_list(list_name)
-      end
+      list_values
     end
 
     def add_to_set(set_name, value)
-      redis.sadd(set_name, value) unless redis.sismember(set_name, value)
+      redis.sadd(set_name, value)
     end
 
     private

data/lib/split/trial.rb

@@ -1,18 +1,21 @@
 # frozen_string_literal: true
+
 module Split
   class Trial
+    attr_accessor :goals
     attr_accessor :experiment
-    attr_accessor :metadata
+    attr_writer :metadata
 
     def initialize(attrs = {})
       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
@@ -33,7 +36,7 @@ module Split
       end
     end
 
-    def complete!(goals=[], context = nil)
+    def complete!(context = nil)
       if alternative
         if Array(goals).empty?
           alternative.increment_completion
@@ -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]
@@ -68,23 +72,27 @@ module Split
         if exclude_user?
           self.alternative = @experiment.control
         else
-          value = @user[@experiment.key]
-          if value
-            self.alternative = value
-          else
-            self.alternative = @experiment.next_alternative
-
-            # 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
+          self.alternative = @user[@experiment.key]
+          if alternative.nil?
+            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
+
+              run_callback context, Split.configuration.on_trial_choose
+            end
           end
         end
       end
 
-      @user[@experiment.key] = alternative.name if 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
 

data/lib/split/user.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 module Split
@@ -6,11 +8,13 @@ module Split
     def_delegators :@user, :keys, :[], :[]=, :delete
     attr_reader :user
 
-    def initialize(context, adapter=nil)
+    def initialize(context, adapter = nil)
       @user = adapter || Split::Persistence.adapter.new(context)
+      @cleaned_up = false
     end
 
     def cleanup_old_experiments!
+      return if @cleaned_up
       keys_without_finished(user.keys).each do |key|
         experiment = ExperimentCatalog.find key_without_version(key)
         if experiment.nil? || experiment.has_winner? || experiment.start_time.nil?
@@ -18,12 +22,14 @@ module Split
           user.delete Experiment.finished_key(key)
         end
       end
+      @cleaned_up = true
     end
 
     def max_experiments_reached?(experiment_key)
       if Split.configuration.allow_multiple_experiments == 'control'
         experiments = active_experiments
-        count_control = experiments.count {|k,v| k == experiment_key || v == 'control'}
+        experiment_key_without_version = key_without_version(experiment_key)
+        count_control = experiments.count {|k, v| k == experiment_key_without_version || v == 'control'}
         experiments.size > count_control
       else
         !Split.configuration.allow_multiple_experiments &&
@@ -32,13 +38,13 @@ module Split
     end
 
     def cleanup_old_versions!(experiment)
-      keys = user.keys.select { |k| k.match(Regexp.new(experiment.name)) }
+      keys = user.keys.select { |k| key_without_version(k) == experiment.name }
       keys_without_experiment(keys, experiment.key).each { |key| user.delete(key) }
     end
 
     def active_experiments
       experiment_pairs = {}
-      user.keys.each do |key|
+      keys_without_finished(user.keys).each do |key|
         Metric.possible_experiments(key_without_version(key)).each do |experiment|
           if !experiment.has_winner?
             experiment_pairs[key_without_version(key)] = user[key]
@@ -48,6 +54,16 @@ module Split
       experiment_pairs
     end
 
+    def self.find(user_id, adapter)
+      adapter = adapter.is_a?(Symbol) ? Split::Persistence::ADAPTERS[adapter] : adapter
+
+      if adapter.respond_to?(:find)
+        User.new(nil, adapter.find(user_id))
+      else
+        nil
+      end
+    end
+
     private
 
     def keys_without_experiment(keys, experiment_key)

data/lib/split/version.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
+
 module Split
-  MAJOR   = 3
-  MINOR   = 0
-  PATCH   = 0
-  VERSION = [MAJOR, MINOR, PATCH].join('.')
+  VERSION = "4.0.1"
 end

data/lib/split/zscore.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   class Zscore
 

data/lib/split.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
+
 require 'redis'
 
 require 'split/algorithms/block_randomization'
 require 'split/algorithms/weighted_sample'
 require 'split/algorithms/whiplash'
 require 'split/alternative'
+require 'split/cache'
 require 'split/configuration'
 require 'split/encapsulated_helper'
 require 'split/exceptions'
@@ -13,6 +15,7 @@ require 'split/experiment_catalog'
 require 'split/extensions/string'
 require 'split/goals_collection'
 require 'split/helper'
+require 'split/combined_experiments_helper'
 require 'split/metric'
 require 'split/persistence'
 require 'split/redis_interface'
@@ -34,9 +37,9 @@ module Split
   #      `Redis::DistRedis`, or `Redis::Namespace`.
   def redis=(server)
     @redis = if server.is_a?(String)
-      Redis.new(:url => server, :thread_safe => true)
+      Redis.new(url: server)
     elsif server.is_a?(Hash)
-      Redis.new(server.merge(:thread_safe => true))
+      Redis.new(server)
     elsif server.respond_to?(:smembers)
       server
     else
@@ -63,6 +66,17 @@ module Split
     self.configuration ||= Configuration.new
     yield(configuration)
   end
+
+  def cache(namespace, key, &block)
+    Split::Cache.fetch(namespace, key, &block)
+  end
 end
 
-Split.configure {}
+# Check to see if being run in a Rails application.  If so, wait until before_initialize to run configuration so Gems that create ENV variables have the chance to initialize first.
+if defined?(::Rails)
+  class Split::Railtie < Rails::Railtie
+    config.before_initialize { Split.configure {} }
+  end
+else
+  Split.configure {}
+end

data/spec/alternative_spec.rb

@@ -126,7 +126,7 @@ describe Split::Alternative do
 
   it "should save to redis" do
     alternative.save
-    expect(Split.redis.exists('basket_text:Basket')).to be true
+    expect(Split.redis.exists?('basket_text:Basket')).to be true
   end
 
   it "should increment participation count" do
@@ -273,6 +273,18 @@ describe Split::Alternative do
       expect(control.z_score(goal1)).to eq('N/A')
       expect(control.z_score(goal2)).to eq('N/A')
     end
+
+    it "should not blow up for Conversion Rates > 1" do
+      control = experiment.control
+      control.participant_count = 3474
+      control.set_completed_count(4244)
+
+      alternative2.participant_count = 3434
+      alternative2.set_completed_count(4358)
+
+      expect { control.z_score }.not_to raise_error
+      expect { alternative2.z_score }.not_to raise_error
+    end
   end
 
   describe "extra_info" do

data/spec/cache_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+require 'spec_helper'
+
+describe Split::Cache do
+
+  let(:namespace) { :test_namespace }
+  let(:key) { :test_key }
+  let(:now) { 1606189017 }
+
+  before { allow(Time).to receive(:now).and_return(now) }
+
+  describe 'clear' do
+
+    before { Split.configuration.cache = true }
+
+    it 'clears the cache' do
+      expect(Time).to receive(:now).and_return(now).exactly(2).times
+      Split::Cache.fetch(namespace, key) { Time.now }
+      Split::Cache.clear
+      Split::Cache.fetch(namespace, key) { Time.now }
+    end
+  end
+
+  describe 'clear_key' do
+    before { Split.configuration.cache = true }
+
+    it 'clears the cache' do
+      expect(Time).to receive(:now).and_return(now).exactly(3).times
+      Split::Cache.fetch(namespace, :key1) { Time.now }
+      Split::Cache.fetch(namespace, :key2) { Time.now }
+      Split::Cache.clear_key(:key1)
+
+      Split::Cache.fetch(namespace, :key1) { Time.now }
+      Split::Cache.fetch(namespace, :key2) { Time.now }
+    end
+  end
+
+  describe 'fetch' do
+
+    subject { Split::Cache.fetch(namespace, key) { Time.now } }
+
+    context 'when cache disabled' do
+
+      before { Split.configuration.cache = false }
+
+      it 'returns the yield' do
+        expect(subject).to eql(now)
+      end
+
+      it 'yields every time' do
+        expect(Time).to receive(:now).and_return(now).exactly(2).times
+        Split::Cache.fetch(namespace, key) { Time.now }
+        Split::Cache.fetch(namespace, key) { Time.now }
+      end
+    end
+
+    context 'when cache enabled' do
+
+      before { Split.configuration.cache = true }
+
+      it 'returns the yield' do
+        expect(subject).to eql(now)
+      end
+
+      it 'yields once' do
+        expect(Time).to receive(:now).and_return(now).once
+        Split::Cache.fetch(namespace, key) { Time.now }
+        Split::Cache.fetch(namespace, key) { Time.now }
+      end
+
+      it 'honors namespace' do
+        expect(Split::Cache.fetch(:a, key) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
+
+        expect(Split::Cache.fetch(:a, key) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
+      end
+
+      it 'honors key' do
+        expect(Split::Cache.fetch(namespace, :a) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(namespace, :b) { :b }).to eql(:b)
+
+        expect(Split::Cache.fetch(namespace, :a) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(namespace, :b) { :b }).to eql(:b)
+      end
+    end
+  end
+end

data/spec/combined_experiments_helper_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require 'split/combined_experiments_helper'
+
+describe Split::CombinedExperimentsHelper do
+  include Split::CombinedExperimentsHelper
+
+  describe 'ab_combined_test' do
+    let!(:config_enabled) { true }
+    let!(:combined_experiments) { [:exp_1_click, :exp_1_scroll ]}
+    let!(:allow_multiple_experiments) { true }
+
+    before do
+      Split.configuration.experiments = {
+        :combined_exp_1 => {
+          :alternatives => [ {"control"=> 0.5}, {"test-alt"=> 0.5} ],
+          :metric => :my_metric,
+          :combined_experiments => combined_experiments
+        }
+      }
+      Split.configuration.enabled = config_enabled
+      Split.configuration.allow_multiple_experiments = allow_multiple_experiments
+    end
+
+    context 'without config enabled' do
+      let!(:config_enabled) { false }
+
+      it "raises an error" do
+        expect(lambda { ab_combined_test :combined_exp_1 }).to raise_error(Split::InvalidExperimentsFormatError )
+      end
+    end
+
+    context 'multiple experiments disabled' do
+      let!(:allow_multiple_experiments) { false }
+
+      it "raises an error if multiple experiments is disabled" do
+        expect(lambda { ab_combined_test :combined_exp_1 }).to raise_error(Split::InvalidExperimentsFormatError)
+      end
+    end
+
+    context 'without combined experiments' do
+      let!(:combined_experiments) { nil }
+
+      it "raises an error" do
+        expect(lambda { ab_combined_test :combined_exp_1 }).to raise_error(Split::InvalidExperimentsFormatError )
+      end
+    end
+
+    it "uses same alternative for all sub experiments and returns the alternative" do
+      allow(self).to receive(:get_alternative) { "test-alt" }
+      expect(self).to receive(:ab_test).with(:exp_1_click, {"control"=>0.5}, {"test-alt"=>0.5}) { "test-alt" }
+      expect(self).to receive(:ab_test).with(:exp_1_scroll, [{"control" => 0, "test-alt" => 1}])
+
+      expect(ab_combined_test('combined_exp_1')).to eq('test-alt')
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -212,23 +212,12 @@ describe Split::Configuration do
     expect(@config.normalized_experiments).to eq({:my_experiment=>{:alternatives=>[{"control_opt"=>0.67}, [{"second_opt"=>0.1}, {"third_opt"=>0.23}]]}})
   end
 
-  context 'redis_url configuration [DEPRECATED]' do
-    it 'should warn on set and assign to #redis' do
-      expect(@config).to receive(:warn).with(/\[DEPRECATED\]/) { nil }
-      @config.redis_url = 'example_url'
-      expect(@config.redis).to eq('example_url')
-    end
-
-    it 'should warn on get and return #redis' do
-      expect(@config).to receive(:warn).with(/\[DEPRECATED\]/) { nil }
-      @config.redis = 'example_url'
-      expect(@config.redis_url).to eq('example_url')
-    end
-  end
-
   context "redis configuration" do
     it "should default to local redis server" do
-      expect(@config.redis).to eq("redis://localhost:6379")
+      old_redis_url = ENV['REDIS_URL']
+      ENV.delete('REDIS_URL')
+      expect(Split::Configuration.new.redis).to eq("redis://localhost:6379")
+      ENV['REDIS_URL'] = old_redis_url
     end
 
     it "should allow for redis url to be configured" do
@@ -238,8 +227,10 @@ describe Split::Configuration do
 
     context "provided REDIS_URL environment variable" do
       it "should use the ENV variable" do
+        old_redis_url = ENV['REDIS_URL']
         ENV['REDIS_URL'] = "env_redis_url"
         expect(Split::Configuration.new.redis).to eq("env_redis_url")
+        ENV['REDIS_URL'] = old_redis_url
       end
     end
   end
@@ -255,4 +246,15 @@ describe Split::Configuration do
     end
   end
 
+  context "persistence cookie domain" do
+    it "should default to nil" do
+      expect(@config.persistence_cookie_domain).to eq(nil)
+    end
+
+    it "should allow the persistence cookie domain to be configured" do
+      @config.persistence_cookie_domain = '.acme.com'
+      expect(@config.persistence_cookie_domain).to eq('.acme.com')
+    end
+  end
+
 end