split 1.0.0 → 1.1.0

data/lib/split/metric.rb

@@ -17,7 +17,7 @@ module Split
         experiment_names = metric.split(',')
 
         experiments = experiment_names.collect do |experiment_name|
-          Split::Experiment.find(experiment_name)
+          Split::ExperimentCatalog.find(experiment_name)
         end
 
         Split::Metric.new(:name => name, :experiments => experiments)
@@ -67,7 +67,7 @@ module Split
       if metric
         experiments << metric.experiments
       end
-      experiment = Split::Experiment.find(metric_name)
+      experiment = Split::ExperimentCatalog.find(metric_name)
       if experiment
         experiments << experiment
       end

data/lib/split/persistence/redis_adapter.rb

@@ -5,8 +5,10 @@ module Split
 
       attr_reader :redis_key
 
-      def initialize(context)
-        if lookup_by = self.class.config[:lookup_by]
+      def initialize(context, key = nil)
+        if key
+          @redis_key = "#{self.class.config[:namespace]}:#{key}"
+        elsif lookup_by = self.class.config[:lookup_by]
           if lookup_by.respond_to?(:call)
             key_frag = lookup_by.call(context)
           else

data/lib/split/trial.rb

@@ -1,49 +1,111 @@
 module Split
   class Trial
     attr_accessor :experiment
-    attr_accessor :goals
 
     def initialize(attrs = {})
-      self.experiment = attrs[:experiment]  if !attrs[:experiment].nil?
-      self.alternative = attrs[:alternative] if !attrs[:alternative].nil?
-      self.goals = attrs[:goals].nil? ? [] : attrs[:goals]
+      self.experiment   = attrs.delete(:experiment)
+      self.alternative  = attrs.delete(:alternative)
+
+      @user             = attrs.delete(:user)
+      @options          = attrs
+
+      @alternative_choosen = false
     end
 
     def alternative
-      @alternative ||=  if experiment.has_winner?
-                          experiment.winner
+      @alternative ||=  if @experiment.has_winner?
+                          @experiment.winner
                         end
     end
 
-    def complete!
+    def alternative=(alternative)
+      @alternative = if alternative.kind_of?(Split::Alternative)
+        alternative
+      else
+        @experiment.alternatives.find{|a| a.name == alternative }
+      end
+    end
+
+    def complete!(goals, context = nil)
+      goals = goals || []
+
       if alternative
-        if self.goals.empty?
+        if goals.empty?
           alternative.increment_completion
         else
-          self.goals.each {|g| alternative.increment_completion(g)}
+          goals.each {|g| alternative.increment_completion(g) }
         end
+
+        context.send(Split.configuration.on_trial_complete, self) \
+            if Split.configuration.on_trial_complete && context
       end
     end
 
-    def choose!
-      choose
-      record!
-    end
+    # Choose an alternative, add a participant, and save the alternative choice on the user. This
+    # method is guaranteed to only run once, and will skip the alternative choosing process if run
+    # a second time.
+    def choose!(context = nil)
+      # Only run the process once
+      return alternative if @alternative_choosen
 
-    def record!
-      alternative.increment_participation
-    end
+      if @options[:override]
+        self.alternative = @options[:override]
+      elsif @options[:disabled] || !Split.configuration.enabled
+        self.alternative = @experiment.control
+      elsif @experiment.has_winner?
+        self.alternative = @experiment.winner
+      else
+        cleanup_old_versions
+
+        if exclude_user?
+          self.alternative = @experiment.control
+        elsif @user[@experiment.key]
+          self.alternative = @user[@experiment.key]
+        else
+          self.alternative = @experiment.next_alternative
+
+          # Increment the number of participants since we are actually choosing a new alternative
+          self.alternative.increment_participation
 
-    def choose
-      self.alternative = experiment.next_alternative
+          # Run the post-choosing hook on the context
+          context.send(Split.configuration.on_trial_choose, self) \
+              if Split.configuration.on_trial_choose && context
+        end
+      end
+
+      @user[@experiment.key] = alternative.name if should_store_alternative?
+      @alternative_choosen = true
+      alternative
     end
 
-    def alternative=(alternative)
-      @alternative = if alternative.kind_of?(Split::Alternative)
-        alternative
+    private
+
+    def should_store_alternative?
+      if @options[:override] || @options[:disabled]
+        Split.configuration.store_override
       else
-        self.experiment.alternatives.find{|a| a.name == alternative }
+        !exclude_user?
+      end
+    end
+
+    def cleanup_old_versions
+      if @experiment.version > 0
+        keys = @user.keys.select { |k| k.match(Regexp.new(@experiment.name)) }
+        keys_without_experiment(keys).each { |key| @user.delete(key) }
       end
     end
+
+    def exclude_user?
+      @options[:exclude] || @experiment.start_time.nil? || max_experiments_reached?
+    end
+
+    def max_experiments_reached?
+      !Split.configuration.allow_multiple_experiments &&
+          keys_without_experiment(@user.keys).length > 0
+    end
+
+    def keys_without_experiment(keys)
+      keys.reject { |k| k.match(Regexp.new("^#{@experiment.key}(:finished)?$")) }
+    end
   end
 end

data/lib/split/version.rb

@@ -1,6 +1,6 @@
 module Split
   MAJOR   = 1
-  MINOR   = 0
+  MINOR   = 1
   PATCH   = 0
   VERSION = [MAJOR, MINOR, PATCH].join('.')
 end

data/spec/algorithms/weighted_sample_spec.rb

@@ -2,17 +2,17 @@ require "spec_helper"
 
 describe Split::Algorithms::WeightedSample do
   it "should return an alternative" do
-    experiment = Split::Experiment.find_or_create('link_color', {'blue' => 100}, {'red' => 0 })
+    experiment = Split::ExperimentCatalog.find_or_create('link_color', {'blue' => 100}, {'red' => 0 })
     expect(Split::Algorithms::WeightedSample.choose_alternative(experiment).class).to eq(Split::Alternative)
   end
 
   it "should always return a heavily weighted option" do
-    experiment = Split::Experiment.find_or_create('link_color', {'blue' => 100}, {'red' => 0 })
+    experiment = Split::ExperimentCatalog.find_or_create('link_color', {'blue' => 100}, {'red' => 0 })
     expect(Split::Algorithms::WeightedSample.choose_alternative(experiment).name).to eq('blue')
   end
 
   it "should return one of the results" do
-    experiment = Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
+    experiment = Split::ExperimentCatalog.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
     expect(['red', 'blue']).to include Split::Algorithms::WeightedSample.choose_alternative(experiment).name
   end
 end

data/spec/algorithms/whiplash_spec.rb

@@ -3,12 +3,12 @@ require "spec_helper"
 describe Split::Algorithms::Whiplash do
 
   it "should return an algorithm" do
-    experiment = Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
+    experiment = Split::ExperimentCatalog.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
     expect(Split::Algorithms::Whiplash.choose_alternative(experiment).class).to eq(Split::Alternative)
   end
 
   it "should return one of the results" do
-    experiment = Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
+    experiment = Split::ExperimentCatalog.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
     expect(['red', 'blue']).to include Split::Algorithms::Whiplash.choose_alternative(experiment).name
   end
 

data/spec/alternative_spec.rb

@@ -12,7 +12,7 @@ describe Split::Alternative do
   }
 
   let!(:experiment) {
-    Split::Experiment.find_or_create({"basket_text" => ["purchase", "refund"]}, "Basket", "Cart")
+    Split::ExperimentCatalog.find_or_create({"basket_text" => ["purchase", "refund"]}, "Basket", "Cart")
   }
 
   let(:goal1) { "purchase" }

data/spec/dashboard_spec.rb

@@ -14,11 +14,11 @@ describe Split::Dashboard do
   end
 
   let(:experiment) {
-    Split::Experiment.find_or_create("link_color", "blue", "red")
+    Split::ExperimentCatalog.find_or_create("link_color", "blue", "red")
   }
 
   let(:experiment_with_goals) {
-    Split::Experiment.find_or_create({"link_color" => ["goal_1", "goal_2"]}, "blue", "red")
+    Split::ExperimentCatalog.find_or_create({"link_color" => ["goal_1", "goal_2"]}, "blue", "red")
   }
 
   let(:metric) {
@@ -139,7 +139,7 @@ describe Split::Dashboard do
   it "should delete an experiment" do
     delete "/#{experiment.name}"
     expect(last_response).to be_redirect
-    expect(Split::Experiment.find(experiment.name)).to be_nil
+    expect(Split::ExperimentCatalog.find(experiment.name)).to be_nil
   end
 
   it "should mark an alternative as the winner" do

data/spec/encapsulated_helper_spec.rb

@@ -4,12 +4,8 @@ describe Split::EncapsulatedHelper do
   include Split::EncapsulatedHelper
 
   before do
-    @persistence_adapter = Split.configuration.persistence
-    Split.configuration.persistence = Hash
-  end
-
-  after do
-    Split.configuration.persistence = @persistence_adapter
+    allow_any_instance_of(Split::EncapsulatedHelper::ContextShim).to receive(:ab_user)
+        .and_return({})
   end
 
   def params

data/spec/experiment_catalog_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Split::ExperimentCatalog do
+  subject { Split::ExperimentCatalog }
+
+  describe ".find_or_create" do
+    it "should not raise an error when passed strings for alternatives" do
+      expect { subject.find_or_create('xyz', '1', '2', '3') }.not_to raise_error
+    end
+
+    it "should not raise an error when passed an array for alternatives" do
+      expect { subject.find_or_create('xyz', ['1', '2', '3']) }.not_to raise_error
+    end
+
+    it "should raise the appropriate error when passed integers for alternatives" do
+      expect { subject.find_or_create('xyz', 1, 2, 3) }.to raise_error
+    end
+
+    it "should raise the appropriate error when passed symbols for alternatives" do
+      expect { subject.find_or_create('xyz', :a, :b, :c) }.to raise_error
+    end
+
+    it "should not raise error when passed an array for goals" do
+      expect { subject.find_or_create({'link_color' => ["purchase", "refund"]}, 'blue', 'red') }
+          .not_to raise_error
+    end
+
+    it "should not raise error when passed just one goal" do
+      expect { subject.find_or_create({'link_color' => "purchase"}, 'blue', 'red') }
+          .not_to raise_error
+    end
+
+    it "constructs a new experiment" do
+      expect(subject.find_or_create('my_exp', 'control me').control.to_s).to eq('control me')
+    end
+  end
+end

data/spec/experiment_spec.rb

@@ -48,14 +48,14 @@ describe Split::Experiment do
       expect(Time).to receive(:now).and_return(experiment_start_time)
       experiment.save
 
-      expect(Split::Experiment.find('basket_text').start_time).to eq(experiment_start_time)
+      expect(Split::ExperimentCatalog.find('basket_text').start_time).to eq(experiment_start_time)
     end
 
     it "should not save the start time to redis when start_manually is enabled" do
       expect(Split.configuration).to receive(:start_manually).and_return(true)
       experiment.save
 
-      expect(Split::Experiment.find('basket_text').start_time).to be_nil
+      expect(Split::ExperimentCatalog.find('basket_text').start_time).to be_nil
     end
 
     it "should save the selected algorithm to redis" do
@@ -63,7 +63,7 @@ describe Split::Experiment do
       experiment.algorithm = experiment_algorithm
       experiment.save
 
-      expect(Split::Experiment.find('basket_text').algorithm).to eq(experiment_algorithm)
+      expect(Split::ExperimentCatalog.find('basket_text').algorithm).to eq(experiment_algorithm)
     end
 
     it "should handle having a start time stored as a string" do
@@ -72,7 +72,7 @@ describe Split::Experiment do
       experiment.save
       Split.redis.hset(:experiment_start_times, experiment.name, experiment_start_time)
 
-      expect(Split::Experiment.find('basket_text').start_time).to eq(experiment_start_time)
+      expect(Split::ExperimentCatalog.find('basket_text').start_time).to eq(experiment_start_time)
     end
 
     it "should handle not having a start time" do
@@ -82,7 +82,7 @@ describe Split::Experiment do
 
       Split.redis.hdel(:experiment_start_times, experiment.name)
 
-      expect(Split::Experiment.find('basket_text').start_time).to be_nil
+      expect(Split::ExperimentCatalog.find('basket_text').start_time).to be_nil
     end
 
     it "should not create duplicates when saving multiple times" do
@@ -106,12 +106,12 @@ describe Split::Experiment do
     describe 'find' do
       it "should return an existing experiment" do
         experiment.save
-        experiment = Split::Experiment.find('basket_text')
+        experiment = Split::ExperimentCatalog.find('basket_text')
         expect(experiment.name).to eq('basket_text')
       end
 
       it "should return an existing experiment" do
-        expect(Split::Experiment.find('non_existent_experiment')).to be_nil
+        expect(Split::ExperimentCatalog.find('non_existent_experiment')).to be_nil
       end
     end
 
@@ -141,7 +141,7 @@ describe Split::Experiment do
       experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :resettable => false)
       experiment.save
 
-      e = Split::Experiment.find('basket_text')
+      e = Split::ExperimentCatalog.find('basket_text')
       expect(e).to eq(experiment)
       expect(e.resettable).to be_falsey
 
@@ -151,7 +151,7 @@ describe Split::Experiment do
       experiment = Split::Experiment.new('basket_text', :alternatives => ['Basket', "Cart"], :algorithm => Split::Algorithms::Whiplash)
       experiment.save
 
-      e = Split::Experiment.find('basket_text')
+      e = Split::ExperimentCatalog.find('basket_text')
       expect(e).to eq(experiment)
       expect(e.algorithm).to eq(Split::Algorithms::Whiplash)
     end
@@ -160,7 +160,7 @@ describe Split::Experiment do
       experiment = Split::Experiment.new('foobar', :alternatives => ['tra', 'la'], :algorithm => Split::Algorithms::Whiplash)
       experiment.save
 
-      e = Split::Experiment.find('foobar')
+      e = Split::ExperimentCatalog.find('foobar')
       expect(e).to eq(experiment)
       expect(e.alternatives.collect{|a| a.name}).to eq(['tra', 'la'])
     end
@@ -173,7 +173,7 @@ describe Split::Experiment do
 
       experiment.delete
       expect(Split.redis.exists('link_color')).to be false
-      expect(Split::Experiment.find('link_color')).to be_nil
+      expect(Split::ExperimentCatalog.find('link_color')).to be_nil
     end
 
     it "should increment the version" do
@@ -255,7 +255,7 @@ describe Split::Experiment do
   end
 
   describe 'algorithm' do
-    let(:experiment) { Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green') }
+    let(:experiment) { Split::ExperimentCatalog.find_or_create('link_color', 'blue', 'red', 'green') }
 
     it 'should use the default algorithm if none is specified' do
       expect(experiment.algorithm).to eq(Split.configuration.algorithm)
@@ -268,7 +268,7 @@ describe Split::Experiment do
   end
 
   describe 'next_alternative' do
-    let(:experiment) { Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green') }
+    let(:experiment) { Split::ExperimentCatalog.find_or_create('link_color', 'blue', 'red', 'green') }
 
     it "should always return the winner if one exists" do
       green = Split::Alternative.new('green', 'link_color')
@@ -288,7 +288,7 @@ describe Split::Experiment do
   end
 
   describe 'single alternative' do
-    let(:experiment) { Split::Experiment.find_or_create('link_color', 'blue') }
+    let(:experiment) { Split::ExperimentCatalog.find_or_create('link_color', 'blue') }
 
     it "should always return the color blue" do
       expect(experiment.next_alternative.name).to eq('blue')
@@ -297,7 +297,7 @@ describe Split::Experiment do
 
   describe 'changing an existing experiment' do
     def same_but_different_alternative
-      Split::Experiment.find_or_create('link_color', 'blue', 'yellow', 'orange')
+      Split::ExperimentCatalog.find_or_create('link_color', 'blue', 'yellow', 'orange')
     end
 
     it "should reset an experiment if it is loaded with different alternatives" do
@@ -320,14 +320,14 @@ describe Split::Experiment do
 
   describe 'alternatives passed as non-strings' do
     it "should throw an exception if an alternative is passed that is not a string" do
-      expect(lambda { Split::Experiment.find_or_create('link_color', :blue, :red) }).to raise_error
-      expect(lambda { Split::Experiment.find_or_create('link_enabled', true, false) }).to raise_error
+      expect(lambda { Split::ExperimentCatalog.find_or_create('link_color', :blue, :red) }).to raise_error
+      expect(lambda { Split::ExperimentCatalog.find_or_create('link_enabled', true, false) }).to raise_error
     end
   end
 
   describe 'specifying weights' do
     let(:experiment_with_weight) {
-      Split::Experiment.find_or_create('link_color', {'blue' => 1}, {'red' => 2 })
+      Split::ExperimentCatalog.find_or_create('link_color', {'blue' => 1}, {'red' => 2 })
     }
 
     it "should work for a new experiment" do
@@ -347,18 +347,18 @@ describe Split::Experiment do
 
     context "saving experiment" do
       def same_but_different_goals
-        Split::Experiment.find_or_create({'link_color' => ["purchase", "refund"]}, 'blue', 'red', 'green')
+        Split::ExperimentCatalog.find_or_create({'link_color' => ["purchase", "refund"]}, 'blue', 'red', 'green')
       end
 
       before { experiment.save }
 
       it "can find existing experiment" do
-        expect(Split::Experiment.find("link_color").name).to eq("link_color")
+        expect(Split::ExperimentCatalog.find("link_color").name).to eq("link_color")
       end
 
       it "should reset an experiment if it is loaded with different goals" do
         same_experiment = same_but_different_goals
-        expect(Split::Experiment.find("link_color").goals).to eq(["purchase", "refund"])
+        expect(Split::ExperimentCatalog.find("link_color").goals).to eq(["purchase", "refund"])
       end
 
     end
@@ -369,9 +369,9 @@ describe Split::Experiment do
 
     context "find or create experiment" do
       it "should have correct goals"  do
-        experiment = Split::Experiment.find_or_create({'link_color3' => ["purchase", "refund"]}, 'blue', 'red', 'green')
+        experiment = Split::ExperimentCatalog.find_or_create({'link_color3' => ["purchase", "refund"]}, 'blue', 'red', 'green')
         expect(experiment.goals).to eq(["purchase", "refund"])
-        experiment = Split::Experiment.find_or_create('link_color3', 'blue', 'red', 'green')
+        experiment = Split::ExperimentCatalog.find_or_create('link_color3', 'blue', 'red', 'green')
         expect(experiment.goals).to eq([])
       end
     end
@@ -379,19 +379,19 @@ describe Split::Experiment do
 
   describe "beta probability calculation" do
     it "should return a hash with the probability of each alternative being the best" do
-      experiment = Split::Experiment.find_or_create('mathematicians', 'bernoulli', 'poisson', 'lagrange')
+      experiment = Split::ExperimentCatalog.find_or_create('mathematicians', 'bernoulli', 'poisson', 'lagrange')
       experiment.calc_winning_alternatives
       expect(experiment.alternative_probabilities).not_to be_nil
     end
 
     it "should return between 46% and 54% probability for an experiment with 2 alternatives and no data" do
-      experiment = Split::Experiment.find_or_create('scientists', 'einstein', 'bohr')
+      experiment = Split::ExperimentCatalog.find_or_create('scientists', 'einstein', 'bohr')
       experiment.calc_winning_alternatives
       expect(experiment.alternatives[0].p_winner).to be_within(0.04).of(0.50)
     end
 
     it "should calculate the probability of being the winning alternative separately for each goal" do
-      experiment = Split::Experiment.find_or_create({'link_color3' => ["purchase", "refund"]}, 'blue', 'red', 'green')
+      experiment = Split::ExperimentCatalog.find_or_create({'link_color3' => ["purchase", "refund"]}, 'blue', 'red', 'green')
       goal1 = experiment.goals[0]
       goal2 = experiment.goals[1]
       experiment.alternatives.each do |alternative|