split 0.5.0 → 0.6.0

data/lib/split/helper.rb

@@ -1,14 +1,20 @@
 module Split
   module Helper
 
-    def ab_test(experiment_name, control=nil, *alternatives)
+    def ab_test(metric_descriptor, control=nil, *alternatives)
       if RUBY_VERSION.match(/1\.8/) && alternatives.length.zero? && ! control.nil?
         puts 'WARNING: You should always pass the control alternative through as the second argument with any other alternatives as the third because the order of the hash is not preserved in ruby 1.8'
       end
 
       begin
+      experiment_name_with_version, goals = normalize_experiment(metric_descriptor)
+      experiment_name = experiment_name_with_version.to_s.split(':')[0]
+      experiment = Split::Experiment.new(experiment_name, :alternatives => [control].compact + alternatives, :goals => goals)
+      control ||= experiment.control && experiment.control.name
+
         ret = if Split.configuration.enabled
-          load_and_start_trial(experiment_name, control, alternatives)
+          experiment.save
+          start_trial( Trial.new(:experiment => experiment) )
         else
           control_variable(control)
         end
@@ -21,7 +27,7 @@ module Split
           ret = override_alternative(experiment_name)
         end
       ensure
-        if ret.nil?
+        unless ret
           ret = control_variable(control)
         end
       end
@@ -44,12 +50,13 @@ module Split
     end
 
     def finish_experiment(experiment, options = {:reset => true})
+      return true unless experiment.winner.nil?
       should_reset = experiment.resettable? && options[:reset]
       if ab_user[experiment.finished_key] && !should_reset
         return true
       else
         alternative_name = ab_user[experiment.key]
-        trial = Trial.new(:experiment => experiment, :alternative_name => alternative_name)
+        trial = Trial.new(:experiment => experiment, :alternative => alternative_name, :goals => options[:goals])
         trial.complete!
         if should_reset
           reset!(experiment)
@@ -60,13 +67,14 @@ module Split
     end
 
 
-    def finished(metric_name, options = {:reset => true})
+    def finished(metric_descriptor, options = {:reset => true})
       return if exclude_visitor? || Split.configuration.disabled?
-      experiments = Metric.possible_experiments(metric_name)
+      metric_descriptor, goals = normalize_experiment(metric_descriptor)
+      experiments = Metric.possible_experiments(metric_descriptor)
 
       if experiments.any?
         experiments.each do |experiment|
-          finish_experiment(experiment, options)
+          finish_experiment(experiment, options.merge(:goals => goals))
         end
       end
     rescue => e
@@ -93,7 +101,7 @@ module Split
     end
 
     def exclude_visitor?
-      is_robot? || is_ignored_ip_address?
+      instance_eval(&Split.configuration.ignore_filter)
     end
 
     def not_allowed_to_test?(experiment_key)
@@ -124,35 +132,37 @@ module Split
     end
 
     def is_ignored_ip_address?
-      if Split.configuration.ignore_ip_addresses.any?
-        Split.configuration.ignore_ip_addresses.include?(request.ip)
-      else
-        false
+      return false if Split.configuration.ignore_ip_addresses.empty?
+
+      Split.configuration.ignore_ip_addresses.each do |ip|
+        return true if request.ip == ip || (ip.class == Regexp && request.ip =~ ip)
       end
+      false
     end
 
     protected
 
-    def control_variable(control)
-      Hash === control ? control.keys.first : control
-    end
-
-    def load_and_start_trial(experiment_name, control, alternatives)
-      if control.nil? && alternatives.length.zero?
-        experiment = Experiment.find(experiment_name)
-
-        raise ExperimentNotFound.new("#{experiment_name} not found") if experiment.nil?
+    def normalize_experiment(metric_descriptor)
+      if Hash === metric_descriptor
+        experiment_name = metric_descriptor.keys.first
+        goals = Array(metric_descriptor.values.first)
       else
-        experiment = Split::Experiment.find_or_create(experiment_name, *([control] + alternatives))
+        experiment_name = metric_descriptor
+        goals = []
       end
+      return experiment_name, goals
+    end
 
-      start_trial( Trial.new(:experiment => experiment) )
+    def control_variable(control)
+      Hash === control ? control.keys.first : control
     end
 
     def start_trial(trial)
       experiment = trial.experiment
       if override_present?(experiment.name)
         ret = override_alternative(experiment.name)
+      elsif ! experiment.winner.nil?
+        ret = experiment.winner.name
       else
         clean_old_versions(experiment)
         if exclude_visitor? || not_allowed_to_test?(experiment.key)

data/lib/split/metric.rb

@@ -64,5 +64,18 @@ module Split
         experiment.complete!
       end
     end
+
+    private
+
+    def self.normalize_metric(label)
+      if Hash === label
+        metric_name = label.keys.first
+        goals = label.values.first
+      else
+        metric_name = label
+        goals = []
+      end
+      return metric_name, goals
+    end
   end
 end

data/lib/split/persistence/cookie_adapter.rb

@@ -36,9 +36,17 @@ module Split
       end
 
       def hash
-        @cookies[:split] ? JSON.parse(@cookies[:split]) : {}
+        if @cookies[:split]
+          begin
+            JSON.parse(@cookies[:split])
+          rescue JSON::ParserError
+            {}
+          end
+        else
+          {}
+        end
       end
 
     end
   end
-end
+end

data/lib/split/trial.rb

@@ -1,12 +1,12 @@
 module Split
   class Trial
     attr_accessor :experiment
-    attr_writer :alternative
+    attr_accessor :goals
 
     def initialize(attrs = {})
       self.experiment = attrs[:experiment]  if !attrs[:experiment].nil?
       self.alternative = attrs[:alternative] if !attrs[:alternative].nil?
-      self.alternative_name = attrs[:alternative_name] if !attrs[:alternative_name].nil?
+      self.goals = attrs[:goals] if !attrs[:goals].nil?
     end
 
     def alternative
@@ -16,28 +16,34 @@ module Split
     end
 
     def complete!
-      alternative.increment_completion if alternative
+      if alternative
+        if self.goals.empty?
+          alternative.increment_completion
+        else
+          self.goals.each {|g| alternative.increment_completion(g)}
+        end
+      end
     end
 
     def choose!
       choose
       record!
     end
-    
+
     def record!
       alternative.increment_participation
     end
 
     def choose
-      if experiment.winner
-        self.alternative = experiment.winner
+      self.alternative = experiment.next_alternative
+    end
+
+    def alternative=(alternative)
+      @alternative = if alternative.kind_of?(Split::Alternative)
+        alternative
       else
-        self.alternative = experiment.next_alternative
+        self.experiment.alternatives.find{|a| a.name == alternative }
       end
     end
-    
-    def alternative_name=(name)
-      self.alternative= self.experiment.alternatives.find{|a| a.name == name }
-    end
   end
-end
+end

data/lib/split/version.rb

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

data/spec/alternative_spec.rb

@@ -3,31 +3,51 @@ require 'split/alternative'
 
 describe Split::Alternative do
 
+  let(:alternative) {
+    Split::Alternative.new('Basket', 'basket_text')
+  }
+
+  let(:alternative2) {
+    Split::Alternative.new('Cart', 'basket_text')
+  }
+
+  let(:experiment) {
+    Split::Experiment.find_or_create({"basket_text" => ["purchase", "refund"]}, "Basket", "Cart")
+  }
+
+  let(:goal1) { "purchase" }
+  let(:goal2) { "refund" }
+
+  # setup experiment
+  before do
+    experiment
+  end
+
+  it "should have goals" do
+    alternative.goals.should eql(["purchase", "refund"])
+  end
+
   it "should have a name" do
-    experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"])
-    alternative = Split::Alternative.new('Basket', 'basket_text')
     alternative.name.should eql('Basket')
   end
 
   it "return only the name" do
-    experiment = Split::Experiment.new('basket_text', :alternative_names => [{'Basket' => 0.6}, {"Cart" => 0.4}])
-    alternative = Split::Alternative.new('Basket', 'basket_text')
     alternative.name.should eql('Basket')
   end
-  
+
   describe 'weights' do
-  
+
     it "should set the weights" do
-      experiment = Split::Experiment.new('basket_text', :alternative_names => [{'Basket' => 0.6}, {"Cart" => 0.4}])
+      experiment = Split::Experiment.new('basket_text', :alternatives => [{'Basket' => 0.6}, {"Cart" => 0.4}])
       first = experiment.alternatives[0]
       first.name.should == 'Basket'
       first.weight.should == 0.6
-    
+
       second = experiment.alternatives[1]
       second.name.should == 'Cart'
-      second.weight.should == 0.4  
+      second.weight.should == 0.4
     end
-    
+
     it "accepts probability on alternatives" do
       Split.configuration.experiments = {
         :my_experiment => {
@@ -35,150 +55,173 @@ describe Split::Alternative do
             { :name => "control_opt", :percent => 67 },
             { :name => "second_opt", :percent => 10 },
             { :name => "third_opt", :percent => 23 },
-          ],
+          ]
         }
       }
-      experiment = Split::Experiment.find(:my_experiment)
+      experiment = Split::Experiment.new(:my_experiment)
       first = experiment.alternatives[0]
       first.name.should == 'control_opt'
       first.weight.should == 0.67
-    
+
       second = experiment.alternatives[1]
       second.name.should == 'second_opt'
       second.weight.should == 0.1
     end
-  
-    # it "accepts probability on some alternatives" do
-    #   Split.configuration.experiments[:my_experiment] = {
-    #     :alternatives => [
-    #       { :name => "control_opt", :percent => 34 },
-    #       "second_opt",
-    #       { :name => "third_opt", :percent => 23 },
-    #       "fourth_opt",
-    #     ],
-    #   }
-    #   should start_experiment(:my_experiment).with({"control_opt" => 0.34}, {"second_opt" => 0.215}, {"third_opt" => 0.23}, {"fourth_opt" => 0.215})
-    #   ab_test :my_experiment
-    # end
-    #   
-    # it "allows name param without probability" do
-    #   Split.configuration.experiments[:my_experiment] = {
-    #     :alternatives => [
-    #       { :name => "control_opt" },
-    #       "second_opt",
-    #       { :name => "third_opt", :percent => 64 },
-    #     ],
-    #   }
-    #   should start_experiment(:my_experiment).with({"control_opt" => 0.18}, {"second_opt" => 0.18}, {"third_opt" => 0.64})
-    #   ab_test :my_experiment
-    # end
-  
-    it "should set the weights from a configuration file" do
-    
+
+    it "accepts probability on some alternatives" do
+      Split.configuration.experiments = {
+        :my_experiment => {
+          :alternatives => [
+            { :name => "control_opt", :percent => 34 },
+            "second_opt",
+            { :name => "third_opt", :percent => 23 },
+            "fourth_opt",
+          ],
+        }
+      }
+      experiment = Split::Experiment.new(:my_experiment)
+      alts = experiment.alternatives
+      [
+        ["control_opt", 0.34],
+        ["second_opt", 0.215],
+        ["third_opt", 0.23],
+        ["fourth_opt", 0.215]
+      ].each do |h|
+        name, weight = h
+        alt = alts.shift
+        alt.name.should == name
+        alt.weight.should == weight
+      end
+    end
+    #
+    it "allows name param without probability" do
+      Split.configuration.experiments = {
+        :my_experiment => {
+          :alternatives => [
+            { :name => "control_opt" },
+            "second_opt",
+            { :name => "third_opt", :percent => 64 },
+          ],
+        }
+      }
+      experiment = Split::Experiment.new(:my_experiment)
+      alts = experiment.alternatives
+      [
+        ["control_opt", 0.18],
+        ["second_opt", 0.18],
+        ["third_opt", 0.64],
+      ].each do |h|
+        name, weight = h
+        alt = alts.shift
+        alt.name.should == name
+        alt.weight.should == weight
+      end
     end
   end
 
   it "should have a default participation count of 0" do
-    alternative = Split::Alternative.new('Basket', 'basket_text')
     alternative.participant_count.should eql(0)
   end
 
-  it "should have a default completed count of 0" do
-    alternative = Split::Alternative.new('Basket', 'basket_text')
+  it "should have a default completed count of 0 for each goal" do
     alternative.completed_count.should eql(0)
+    alternative.completed_count(goal1).should eql(0)
+    alternative.completed_count(goal2).should eql(0)
   end
 
   it "should belong to an experiment" do
-    experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"])
-    experiment.save
-    alternative = Split::Alternative.new('Basket', 'basket_text')
     alternative.experiment.name.should eql(experiment.name)
   end
 
   it "should save to redis" do
-    alternative = Split::Alternative.new('Basket', 'basket_text')
     alternative.save
     Split.redis.exists('basket_text:Basket').should be true
   end
 
   it "should increment participation count" do
-    experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"])
-    experiment.save
-    alternative = Split::Alternative.new('Basket', 'basket_text')
     old_participant_count = alternative.participant_count
     alternative.increment_participation
     alternative.participant_count.should eql(old_participant_count+1)
-
-    Split::Alternative.new('Basket', 'basket_text').participant_count.should eql(old_participant_count+1)
   end
 
-  it "should increment completed count" do
-    experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"])
-    experiment.save
-    alternative = Split::Alternative.new('Basket', 'basket_text')
-    old_completed_count = alternative.participant_count
+  it "should increment completed count for each goal" do
+    old_default_completed_count = alternative.completed_count
+    old_completed_count_for_goal1 = alternative.completed_count(goal1)
+    old_completed_count_for_goal2 = alternative.completed_count(goal2)
+
     alternative.increment_completion
-    alternative.completed_count.should eql(old_completed_count+1)
+    alternative.increment_completion(goal1)
+    alternative.increment_completion(goal2)
 
-    Split::Alternative.new('Basket', 'basket_text').completed_count.should eql(old_completed_count+1)
+    alternative.completed_count.should eql(old_default_completed_count+1)
+    alternative.completed_count(goal1).should eql(old_completed_count_for_goal1+1)
+    alternative.completed_count(goal2).should eql(old_completed_count_for_goal2+1)
   end
 
   it "can be reset" do
-    alternative = Split::Alternative.new('Basket', 'basket_text')
     alternative.participant_count = 10
-    alternative.completed_count = 4
+    alternative.set_completed_count(4, goal1)
+    alternative.set_completed_count(5, goal2)
+    alternative.set_completed_count(6)
     alternative.reset
     alternative.participant_count.should eql(0)
+    alternative.completed_count(goal1).should eql(0)
+    alternative.completed_count(goal2).should eql(0)
     alternative.completed_count.should eql(0)
   end
 
   it "should know if it is the control of an experiment" do
-    experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"])
-    experiment.save
-    alternative = Split::Alternative.new('Basket', 'basket_text')
     alternative.control?.should be_true
-    alternative = Split::Alternative.new('Cart', 'basket_text')
-    alternative.control?.should be_false
+    alternative2.control?.should be_false
   end
 
   describe 'unfinished_count' do
     it "should be difference between participant and completed counts" do
-      experiment = Split::Experiment.new('basket_text', :alternative_names => ['Basket', "Cart"])
-      experiment.save
-      alternative = Split::Alternative.new('Basket', 'basket_text')
       alternative.increment_participation
       alternative.unfinished_count.should eql(alternative.participant_count)
     end
+
+    it "should return the correct unfinished_count" do
+      alternative.participant_count = 10
+      alternative.set_completed_count(4, goal1)
+      alternative.set_completed_count(3, goal2)
+      alternative.set_completed_count(2)
+
+      alternative.unfinished_count.should eql(1)
+    end
   end
 
   describe 'conversion rate' do
     it "should be 0 if there are no conversions" do
-      alternative = Split::Alternative.new('Basket', 'basket_text')
       alternative.completed_count.should eql(0)
       alternative.conversion_rate.should eql(0)
     end
 
     it "calculate conversion rate" do
-      alternative = Split::Alternative.new('Basket', 'basket_text')
       alternative.stub(:participant_count).and_return(10)
       alternative.stub(:completed_count).and_return(4)
       alternative.conversion_rate.should eql(0.4)
+
+      alternative.stub(:completed_count).with(goal1).and_return(5)
+      alternative.conversion_rate(goal1).should eql(0.5)
+
+      alternative.stub(:completed_count).with(goal2).and_return(6)
+      alternative.conversion_rate(goal2).should eql(0.6)
     end
   end
 
   describe 'z score' do
     it 'should be zero when the control has no conversions' do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
-
-      alternative = Split::Alternative.new('red', 'link_color')
-      alternative.z_score.should eql(0)
+      alternative2.z_score.should eql(0)
+      alternative2.z_score(goal1).should eql(0)
+      alternative2.z_score(goal2).should eql(0)
     end
 
     it "should be N/A for the control" do
-      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
-
       control = experiment.control
       control.z_score.should eql('N/A')
+      control.z_score(goal1).should eql('N/A')
+      control.z_score(goal2).should eql('N/A')
     end
   end
 end