split 4.0.1 → 4.0.2

data/lib/split.rb

@@ -1,29 +1,30 @@
 # frozen_string_literal: true
 
-require 'redis'
+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'
-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 "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)
 
 module Split
   extend self
@@ -75,8 +76,8 @@ end
 # 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 {} }
+    config.before_initialize { Split.configure { } }
   end
 else
-  Split.configure {}
+  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)

data/spec/cache_spec.rb

@@ -1,19 +1,18 @@
 # frozen_string_literal: true
-require 'spec_helper'
 
-describe Split::Cache do
+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
-
+  describe "clear" do
     before { Split.configuration.cache = true }
 
-    it 'clears the cache' do
+    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
@@ -21,10 +20,10 @@ describe Split::Cache do
     end
   end
 
-  describe 'clear_key' do
+  describe "clear_key" do
     before { Split.configuration.cache = true }
 
-    it 'clears the cache' do
+    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 }
@@ -35,40 +34,37 @@ describe Split::Cache do
     end
   end
 
-  describe 'fetch' do
-
+  describe "fetch" do
     subject { Split::Cache.fetch(namespace, key) { Time.now } }
 
-    context 'when cache disabled' do
-
+    context "when cache disabled" do
       before { Split.configuration.cache = false }
 
-      it 'returns the yield' do
+      it "returns the yield" do
         expect(subject).to eql(now)
       end
 
-      it 'yields every time' do
+      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
-
+    context "when cache enabled" do
       before { Split.configuration.cache = true }
 
-      it 'returns the yield' do
+      it "returns the yield" do
         expect(subject).to eql(now)
       end
 
-      it 'yields once' do
+      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
+      it "honors namespace" do
         expect(Split::Cache.fetch(:a, key) { :a }).to eql(:a)
         expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
 
@@ -76,7 +72,7 @@ describe Split::Cache do
         expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
       end
 
-      it 'honors key' do
+      it "honors key" do
         expect(Split::Cache.fetch(namespace, :a) { :a }).to eql(:a)
         expect(Split::Cache.fetch(namespace, :b) { :b }).to eql(:b)
 

data/spec/combined_experiments_helper_spec.rb

@@ -1,57 +1,58 @@
 # frozen_string_literal: true
-require 'spec_helper'
-require 'split/combined_experiments_helper'
+
+require "spec_helper"
+require "split/combined_experiments_helper"
 
 describe Split::CombinedExperimentsHelper do
   include Split::CombinedExperimentsHelper
 
-  describe 'ab_combined_test' do
+  describe "ab_combined_test" do
     let!(:config_enabled) { true }
-    let!(:combined_experiments) { [:exp_1_click, :exp_1_scroll ]}
+    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
+        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
+    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 )
+        expect { ab_combined_test :combined_exp_1 }.to raise_error(Split::InvalidExperimentsFormatError)
       end
     end
 
-    context 'multiple experiments disabled' do
+    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)
+        expect { ab_combined_test :combined_exp_1 }.to raise_error(Split::InvalidExperimentsFormatError)
       end
     end
 
-    context 'without combined experiments' do
+    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 )
+        expect { 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(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')
+      expect(ab_combined_test("combined_exp_1")).to eq("test-alt")
     end
   end
 end