split 3.2.0 → 4.0.5

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
@@ -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]
@@ -68,52 +72,55 @@ 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
 
     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

data/lib/split/user.rb

@@ -1,4 +1,6 @@
-require 'forwardable'
+# frozen_string_literal: true
+
+require "forwardable"
 
 module Split
   class User
@@ -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'
+      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,18 +54,27 @@ module Split
       experiment_pairs
     end
 
-    private
+    def self.find(user_id, adapter)
+      adapter = adapter.is_a?(Symbol) ? Split::Persistence::ADAPTERS[adapter] : adapter
 
-    def keys_without_experiment(keys, experiment_key)
-      keys.reject { |k| k.match(Regexp.new("^#{experiment_key}(:finished)?$")) }
+      if adapter.respond_to?(:find)
+        User.new(nil, adapter.find(user_id))
+      else
+        nil
+      end
     end
 
-    def keys_without_finished(keys)
-      keys.reject { |k| k.include?(":finished") }
-    end
+    private
+      def keys_without_experiment(keys, experiment_key)
+        keys.reject { |k| k.match(Regexp.new("^#{experiment_key}(:finished)?$")) }
+      end
 
-    def key_without_version(key)
-      key.split(/\:\d(?!\:)/)[0]
-    end
+      def keys_without_finished(keys)
+        keys.reject { |k| k.include?(":finished") }
+      end
+
+      def key_without_version(key)
+        key.split(/\:\d(?!\:)/)[0]
+      end
   end
 end

data/lib/split/version.rb

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

data/lib/split/zscore.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Split
   class Zscore
-
     include Math
 
     def self.calculate(p1, n1, p2, n2)
@@ -50,8 +50,7 @@ module Split
       # Calculate z-score
       z_score = (p_1 - p_2)/(se)
 
-      return z_score
-
+      z_score
     end
   end
 end

data/lib/split.rb

@@ -1,27 +1,30 @@
 # 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/configuration'
-require 'split/encapsulated_helper'
-require 'split/exceptions'
-require 'split/experiment'
-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'
-require 'split/trial'
-require 'split/user'
-require 'split/version'
-require 'split/zscore'
-require 'split/engine' if defined?(Rails)
+require "redis"
+
+require "split/algorithms"
+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"
+require "split/experiment"
+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"
+require "split/trial"
+require "split/user"
+require "split/version"
+require "split/zscore"
+require "split/engine" if defined?(::Rails::Engine)
 
 module Split
   extend self
@@ -35,9 +38,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
@@ -64,6 +67,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::Railtie)
+  class Split::Railtie < Rails::Railtie
+    config.before_initialize { Split.configure { } }
+  end
+else
+  Split.configure { }
+end

data/spec/algorithms/block_randomization_spec.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Algorithms::BlockRandomization do
-
-  let(:experiment) { Split::Experiment.new 'experiment' }
-  let(:alternative_A) { Split::Alternative.new 'A', 'experiment' }
-  let(:alternative_B) { Split::Alternative.new 'B', 'experiment' }
-  let(:alternative_C) { Split::Alternative.new 'C', 'experiment' }
+  let(:experiment) { Split::Experiment.new "experiment" }
+  let(:alternative_A) { Split::Alternative.new "A", "experiment" }
+  let(:alternative_B) { Split::Alternative.new "B", "experiment" }
+  let(:alternative_C) { Split::Alternative.new "C", "experiment" }
 
   before :each do
     allow(experiment).to receive(:alternatives) { [alternative_A, alternative_B, alternative_C] }

data/spec/algorithms/weighted_sample_spec.rb

@@ -1,19 +1,20 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Algorithms::WeightedSample do
   it "should return an alternative" do
-    experiment = Split::ExperimentCatalog.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::ExperimentCatalog.find_or_create('link_color', {'blue' => 100}, {'red' => 0 })
-    expect(Split::Algorithms::WeightedSample.choose_alternative(experiment).name).to eq('blue')
+    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::ExperimentCatalog.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
-    expect(['red', 'blue']).to include Split::Algorithms::WeightedSample.choose_alternative(experiment).name
+    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

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
+
 require "spec_helper"
 
 describe Split::Algorithms::Whiplash do
-
   it "should return an algorithm" do
-    experiment = Split::ExperimentCatalog.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::ExperimentCatalog.find_or_create('link_color', {'blue' => 1}, {'red' => 1 })
-    expect(['red', 'blue']).to include Split::Algorithms::Whiplash.choose_alternative(experiment).name
+    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
 
   it "should guess floats" do
@@ -20,5 +20,4 @@ describe Split::Algorithms::Whiplash do
     expect(Split::Algorithms::Whiplash.send(:arm_guess, 1000, 5).class).to eq(Float)
     expect(Split::Algorithms::Whiplash.send(:arm_guess, 10, -2).class).to eq(Float)
   end
-
 end

data/spec/alternative_spec.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'split/alternative'
 
-describe Split::Alternative do
+require "spec_helper"
+require "split/alternative"
 
+describe Split::Alternative do
   let(:alternative) {
-    Split::Alternative.new('Basket', 'basket_text')
+    Split::Alternative.new("Basket", "basket_text")
   }
 
   let(:alternative2) {
-    Split::Alternative.new('Cart', 'basket_text')
+    Split::Alternative.new("Cart", "basket_text")
   }
 
   let!(:experiment) {
-    Split::ExperimentCatalog.find_or_create({"basket_text" => ["purchase", "refund"]}, "Basket", "Cart")
+    Split::ExperimentCatalog.find_or_create({ "basket_text" => ["purchase", "refund"] }, "Basket", "Cart")
   }
 
   let(:goal1) { "purchase" }
@@ -24,48 +24,48 @@ describe Split::Alternative do
   end
 
   it "should have and only return the name" do
-    expect(alternative.name).to eq('Basket')
+    expect(alternative.name).to eq("Basket")
   end
 
-  describe 'weights' do
+  describe "weights" do
     it "should set the weights" do
-      experiment = Split::Experiment.new('basket_text', :alternatives => [{'Basket' => 0.6}, {"Cart" => 0.4}])
+      experiment = Split::Experiment.new("basket_text", alternatives: [{ "Basket" => 0.6 }, { "Cart" => 0.4 }])
       first = experiment.alternatives[0]
-      expect(first.name).to eq('Basket')
+      expect(first.name).to eq("Basket")
       expect(first.weight).to eq(0.6)
 
       second = experiment.alternatives[1]
-      expect(second.name).to eq('Cart')
+      expect(second.name).to eq("Cart")
       expect(second.weight).to eq(0.4)
     end
 
     it "accepts probability on alternatives" do
       Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => [
-            { :name => "control_opt", :percent => 67 },
-            { :name => "second_opt", :percent => 10 },
-            { :name => "third_opt", :percent => 23 },
+        my_experiment: {
+          alternatives: [
+            { name: "control_opt", percent: 67 },
+            { name: "second_opt", percent: 10 },
+            { name: "third_opt", percent: 23 },
           ]
         }
       }
       experiment = Split::Experiment.new(:my_experiment)
       first = experiment.alternatives[0]
-      expect(first.name).to eq('control_opt')
+      expect(first.name).to eq("control_opt")
       expect(first.weight).to eq(0.67)
 
       second = experiment.alternatives[1]
-      expect(second.name).to eq('second_opt')
+      expect(second.name).to eq("second_opt")
       expect(second.weight).to eq(0.1)
     end
 
     it "accepts probability on some alternatives" do
       Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => [
-            { :name => "control_opt", :percent => 34 },
+        my_experiment: {
+          alternatives: [
+            { name: "control_opt", percent: 34 },
             "second_opt",
-            { :name => "third_opt", :percent => 23 },
+            { name: "third_opt", percent: 23 },
             "fourth_opt",
           ],
         }
@@ -87,11 +87,11 @@ describe Split::Alternative do
     #
     it "allows name param without probability" do
       Split.configuration.experiments = {
-        :my_experiment => {
-          :alternatives => [
-            { :name => "control_opt" },
+        my_experiment: {
+          alternatives: [
+            { name: "control_opt" },
             "second_opt",
-            { :name => "third_opt", :percent => 64 },
+            { name: "third_opt", percent: 64 },
           ],
         }
       }
@@ -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
@@ -166,7 +166,7 @@ describe Split::Alternative do
     expect(alternative2.control?).to be_falsey
   end
 
-  describe 'unfinished_count' do
+  describe "unfinished_count" do
     it "should be difference between participant and completed counts" do
       alternative.increment_participation
       expect(alternative.unfinished_count).to eq(alternative.participant_count)
@@ -182,7 +182,7 @@ describe Split::Alternative do
     end
   end
 
-  describe 'conversion rate' do
+  describe "conversion rate" do
     it "should be 0 if there are no conversions" do
       expect(alternative.completed_count).to eq(0)
       expect(alternative.conversion_rate).to eq(0)
@@ -225,8 +225,7 @@ describe Split::Alternative do
     end
   end
 
-  describe 'z score' do
-
+  describe "z score" do
     it "should return an error string when the control has 0 people" do
       expect(alternative2.z_score).to eq("Needs 30+ participants.")
       expect(alternative2.z_score(goal1)).to eq("Needs 30+ participants.")
@@ -269,9 +268,9 @@ describe Split::Alternative do
 
     it "should be N/A for the control" do
       control = experiment.control
-      expect(control.z_score).to eq('N/A')
-      expect(control.z_score(goal1)).to eq('N/A')
-      expect(control.z_score(goal2)).to eq('N/A')
+      expect(control.z_score).to eq("N/A")
+      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
@@ -289,8 +288,8 @@ describe Split::Alternative do
 
   describe "extra_info" do
     it "reads saved value of recorded_info in redis" do
-      saved_recorded_info = {"key_1" => 1, "key_2" => "2"}
-      Split.redis.hset "#{alternative.experiment_name}:#{alternative.name}", 'recorded_info', saved_recorded_info.to_json
+      saved_recorded_info = { "key_1" => 1, "key_2" => "2" }
+      Split.redis.hset "#{alternative.experiment_name}:#{alternative.name}", "recorded_info", saved_recorded_info.to_json
       extra_info = alternative.extra_info
 
       expect(extra_info).to eql(saved_recorded_info)