split 2.0.0 → 3.0.0

data/lib/split/experiment.rb

@@ -80,29 +80,15 @@ module Split
       validate!
 
       if new_record?
-        Split.redis.sadd(:experiments, name)
         start unless Split.configuration.start_manually
-        @alternatives.reverse.each {|a| Split.redis.lpush(name, a.name)}
-        goals_collection.save
-        save_metadata
-      else
-        existing_alternatives = load_alternatives_from_redis
-        existing_goals = Split::GoalsCollection.new(@name).load_from_redis
-        existing_metadata = load_metadata_from_redis
-        unless existing_alternatives == @alternatives.map(&:name) && existing_goals == @goals && existing_metadata == @metadata
-          reset
-          @alternatives.each(&:delete)
-          goals_collection.delete
-          delete_metadata
-          Split.redis.del(@name)
-          @alternatives.reverse.each {|a| Split.redis.lpush(name, a.name)}
-          goals_collection.save
-          save_metadata
-        end
+      elsif experiment_configuration_has_changed?
+        reset unless Split.configuration.reset_manually
       end
 
-      Split.redis.hset(experiment_config_key, :resettable, resettable)
-      Split.redis.hset(experiment_config_key, :algorithm, algorithm.to_s)
+      persist_experiment_configuration if new_record? || experiment_configuration_has_changed?
+
+      redis.hset(experiment_config_key, :resettable, resettable)
+      redis.hset(experiment_config_key, :algorithm, algorithm.to_s)
       self
     end
 
@@ -115,7 +101,7 @@ module Split
     end
 
     def new_record?
-      !Split.redis.exists(name)
+      !redis.exists(name)
     end
 
     def ==(obj)
@@ -149,8 +135,9 @@ module Split
     end
 
     def winner
-      if w = Split.redis.hget(:experiment_winner, name)
-        Split::Alternative.new(w, name)
+      experiment_winner = redis.hget(:experiment_winner, name)
+      if experiment_winner
+        Split::Alternative.new(experiment_winner, name)
       else
         nil
       end
@@ -161,7 +148,7 @@ module Split
     end
 
     def winner=(winner_name)
-      Split.redis.hset(:experiment_winner, name, winner_name.to_s)
+      redis.hset(:experiment_winner, name, winner_name.to_s)
     end
 
     def participant_count
@@ -173,21 +160,21 @@ module Split
     end
 
     def reset_winner
-      Split.redis.hdel(:experiment_winner, name)
+      redis.hdel(:experiment_winner, name)
     end
 
     def start
-      Split.redis.hset(:experiment_start_times, @name, Time.now.to_i)
+      redis.hset(:experiment_start_times, @name, Time.now.to_i)
     end
 
     def start_time
-      t = Split.redis.hget(:experiment_start_times, @name)
+      t = redis.hget(:experiment_start_times, @name)
       if t
         # Check if stored time is an integer
         if t =~ /^[-+]?[0-9]+$/
-          t = Time.at(t.to_i)
+          Time.at(t.to_i)
         else
-          t = Time.parse(t)
+          Time.parse(t)
         end
       end
     end
@@ -205,11 +192,11 @@ module Split
     end
 
     def version
-      @version ||= (Split.redis.get("#{name.to_s}:version").to_i || 0)
+      @version ||= (redis.get("#{name}:version").to_i || 0)
     end
 
     def increment_version
-      @version = Split.redis.incr("#{name}:version")
+      @version = redis.incr("#{name}:version")
     end
 
     def key
@@ -247,24 +234,21 @@ module Split
     def delete
       Split.configuration.on_before_experiment_delete.call(self)
       if Split.configuration.start_manually
-        Split.redis.hdel(:experiment_start_times, @name)
+        redis.hdel(:experiment_start_times, @name)
       end
-      alternatives.each(&:delete)
       reset_winner
-      Split.redis.srem(:experiments, name)
-      Split.redis.del(name)
-      goals_collection.delete
-      delete_metadata
+      redis.srem(:experiments, name)
+      remove_experiment_configuration
       Split.configuration.on_experiment_delete.call(self)
       increment_version
     end
 
     def delete_metadata
-      Split.redis.del(metadata_key)
+      redis.del(metadata_key)
     end
 
     def load_from_redis
-      exp_config = Split.redis.hgetall(experiment_config_key)
+      exp_config = redis.hgetall(experiment_config_key)
 
       options = {
         resettable: exp_config['resettable'],
@@ -297,8 +281,6 @@ module Split
     end
 
     def estimate_winning_alternative(goal = nil)
-      # TODO - refactor out functionality to work with and without goals
-
       # initialize a hash of beta distributions based on the alternatives' conversion rates
       beta_params = calc_beta_params(goal)
 
@@ -395,11 +377,11 @@ module Split
     end
 
     def calc_time=(time)
-      Split.redis.hset(experiment_config_key, :calc_time, time)
+      redis.hset(experiment_config_key, :calc_time, time)
     end
 
     def calc_time
-      Split.redis.hget(experiment_config_key, :calc_time).to_i
+      redis.hget(experiment_config_key, :calc_time).to_i
     end
 
     def jstring(goal = nil)
@@ -418,11 +400,11 @@ module Split
     end
 
     def load_metadata_from_configuration
-      metadata = Split.configuration.experiment_for(@name)[:metadata]
+      Split.configuration.experiment_for(@name)[:metadata]
     end
 
     def load_metadata_from_redis
-      meta = Split.redis.get(metadata_key)
+      meta = redis.get(metadata_key)
       JSON.parse(meta) unless meta.nil?
     end
 
@@ -437,22 +419,49 @@ module Split
     end
 
     def load_alternatives_from_redis
-      case Split.redis.type(@name)
+      case redis.type(@name)
       when 'set' # convert legacy sets to lists
-        alts = Split.redis.smembers(@name)
-        Split.redis.del(@name)
-        alts.reverse.each {|a| Split.redis.lpush(@name, a) }
-        Split.redis.lrange(@name, 0, -1)
+        alts = redis.smembers(@name)
+        redis.del(@name)
+        alts.reverse.each {|a| redis.lpush(@name, a) }
+        redis.lrange(@name, 0, -1)
       else
-        Split.redis.lrange(@name, 0, -1)
+        redis.lrange(@name, 0, -1)
       end
     end
 
-    def save_metadata
-      Split.redis.set(metadata_key, @metadata.to_json) unless @metadata.nil?
+    private
+
+    def redis
+      Split.redis
     end
 
-    private
+    def redis_interface
+      RedisInterface.new
+    end
+
+    def persist_experiment_configuration
+      redis_interface.add_to_set(:experiments, name)
+      redis_interface.persist_list(name, @alternatives.map(&:name))
+      goals_collection.save
+      redis.set(metadata_key, @metadata.to_json) unless @metadata.nil?
+    end
+
+    def remove_experiment_configuration
+      @alternatives.each(&:delete)
+      goals_collection.delete
+      delete_metadata
+      redis.del(@name)
+    end
+
+    def experiment_configuration_has_changed?
+      existing_alternatives = load_alternatives_from_redis
+      existing_goals = Split::GoalsCollection.new(@name).load_from_redis
+      existing_metadata = load_metadata_from_redis
+      existing_alternatives != @alternatives.map(&:name) ||
+        existing_goals != @goals ||
+        existing_metadata != @metadata
+    end
 
     def goals_collection
       Split::GoalsCollection.new(@name, @goals)

data/lib/split/goals_collection.rb

@@ -22,7 +22,7 @@ module Split
 
     def save
       return false if @goals.nil?
-      @goals.reverse.each { |goal| Split.redis.lpush(goals_key, goal) }
+      RedisInterface.new.persist_list(goals_key, @goals)
     end
 
     def validate!

data/lib/split/helper.rb

@@ -76,6 +76,26 @@ module Split
       Split.configuration.db_failover_on_db_error.call(e)
     end
 
+    def ab_record_extra_info(metric_descriptor, key, value = 1)
+      return if exclude_visitor? || Split.configuration.disabled?
+      metric_descriptor, goals = normalize_metric(metric_descriptor)
+      experiments = Metric.possible_experiments(metric_descriptor)
+
+      if experiments.any?
+        experiments.each do |experiment|
+          alternative_name = ab_user[experiment.key]
+
+          if alternative_name
+            alternative = experiment.alternatives.find{|alt| alt.name == alternative_name}
+            alternative.record_extra_info(key, value) if alternative
+          end
+        end
+      end
+    rescue => e
+      raise unless Split.configuration.db_failover
+      Split.configuration.db_failover_on_db_error.call(e)
+    end
+
     def override_present?(experiment_name)
       override_alternative(experiment_name)
     end

data/lib/split/persistence/dual_adapter.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require 'forwardable'
+
 module Split
   module Persistence
     class DualAdapter

data/lib/split/persistence.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
-%w[session_adapter cookie_adapter redis_adapter dual_adapter].each do |f|
-  require "split/persistence/#{f}"
-end
 
 module Split
   module Persistence
+    require 'split/persistence/cookie_adapter'
+    require 'split/persistence/dual_adapter'
+    require 'split/persistence/redis_adapter'
+    require 'split/persistence/session_adapter'
+
     ADAPTERS = {
       :cookie => Split::Persistence::CookieAdapter,
       :session => Split::Persistence::SessionAdapter

data/lib/split/redis_interface.rb

@@ -0,0 +1,51 @@
+module Split
+  # Simplifies the interface to Redis.
+  class RedisInterface
+    def initialize
+      self.redis = Split.redis
+    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)
+        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
+    end
+
+    def add_to_set(set_name, value)
+      redis.sadd(set_name, value) unless redis.sismember(set_name, value)
+    end
+
+    private
+
+    attr_accessor :redis
+  end
+end

data/lib/split/user.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Split
   class User
     extend Forwardable
@@ -21,7 +23,7 @@ module Split
     def max_experiments_reached?(experiment_key)
       if Split.configuration.allow_multiple_experiments == 'control'
         experiments = active_experiments
-        count_control = experiments.values.count {|v| v == 'control'}
+        count_control = experiments.count {|k,v| k == experiment_key || v == 'control'}
         experiments.size > count_control
       else
         !Split.configuration.allow_multiple_experiments &&

data/lib/split/version.rb

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

data/lib/split/zscore.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Split
-  module Zscore
+  class Zscore
 
     include Math
 

data/lib/split.rb

@@ -1,54 +1,47 @@
 # frozen_string_literal: true
-%w[algorithms
-   alternative
-   configuration
-   exceptions
-   experiment
-   experiment_catalog
-   extensions
-   goals_collection
-   helper
-   metric
-   persistence
-   encapsulated_helper
-   trial
-   user
-   version
-   zscore].each do |f|
-  require "split/#{f}"
-end
+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/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/namespace'
 
 module Split
   extend self
   attr_accessor :configuration
 
   # Accepts:
-  #   1. A 'hostname:port' string
-  #   2. A 'hostname:port:db' string (to select the Redis db)
-  #   3. A 'hostname:port/namespace' string (to set the Redis namespace)
-  #   4. A redis URL string 'redis://host:port'
-  #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
-  #      or `Redis::Namespace`.
+  #   1. A redis URL (valid for `Redis.new(url: url)`)
+  #   2. an options hash compatible with `Redis.new`
+  #   3. or a valid Redis instance (one that responds to `#smembers`). Likely,
+  #      this will be an instance of either `Redis`, `Redis::Client`,
+  #      `Redis::DistRedis`, or `Redis::Namespace`.
   def redis=(server)
-    if server.respond_to? :split
-      if server["redis://"]
-        redis = Redis.connect(:url => server, :thread_safe => true)
-      else
-        server, namespace = server.split('/', 2)
-        host, port, db = server.split(':')
-        redis = Redis.new(:host => host, :port => port,
-          :thread_safe => true, :db => db)
-      end
-      namespace ||= :split
-
-      @redis = Redis::Namespace.new(namespace, :redis => redis)
-    elsif server.respond_to? :namespace=
-      @redis = server
+    @redis = if server.is_a?(String)
+      Redis.new(:url => server, :thread_safe => true)
+    elsif server.is_a?(Hash)
+      Redis.new(server.merge(:thread_safe => true))
+    elsif server.respond_to?(:smembers)
+      server
     else
-      @redis = Redis::Namespace.new(:split, :redis => server)
+      raise ArgumentError,
+        "You must supply a url, options hash or valid Redis connection instance"
     end
   end
 
@@ -56,7 +49,7 @@ module Split
   # create a new one.
   def redis
     return @redis if @redis
-    self.redis = self.configuration.redis_url
+    self.redis = self.configuration.redis
     self.redis
   end
 

data/spec/algorithms/block_randomization_spec.rb

@@ -0,0 +1,32 @@
+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' }
+
+  before :each do
+    allow(experiment).to receive(:alternatives) { [alternative_A, alternative_B, alternative_C] }
+  end
+
+  it "should return an alternative" do
+    expect(Split::Algorithms::BlockRandomization.choose_alternative(experiment).class).to eq(Split::Alternative)
+  end
+
+  it "should always return the minimum participation option" do
+    allow(alternative_A).to receive(:participant_count) { 1 }
+    allow(alternative_B).to receive(:participant_count) { 1 }
+    allow(alternative_C).to receive(:participant_count) { 0 }
+    expect(Split::Algorithms::BlockRandomization.choose_alternative(experiment)).to eq(alternative_C)
+  end
+
+  it "should return one of the minimum participation options when multiple" do
+    allow(alternative_A).to receive(:participant_count) { 0 }
+    allow(alternative_B).to receive(:participant_count) { 0 }
+    allow(alternative_C).to receive(:participant_count) { 0 }
+    alternative = Split::Algorithms::BlockRandomization.choose_alternative(experiment)
+    expect([alternative_A, alternative_B, alternative_C].include?(alternative)).to be(true)
+  end
+end

data/spec/alternative_spec.rb

@@ -274,4 +274,35 @@ describe Split::Alternative do
       expect(control.z_score(goal2)).to eq('N/A')
     end
   end
+
+  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
+      extra_info = alternative.extra_info
+
+      expect(extra_info).to eql(saved_recorded_info)
+    end
+  end
+
+  describe "record_extra_info" do
+    it "saves key" do
+      alternative.record_extra_info("signup", 1)
+      expect(alternative.extra_info["signup"]).to eql(1)
+    end
+
+    it "adds value to saved key's value second argument is number" do
+      alternative.record_extra_info("signup", 1)
+      alternative.record_extra_info("signup", 2)
+      expect(alternative.extra_info["signup"]).to eql(3)
+    end
+
+    it "sets saved's key value to the second argument if it's a string" do
+      alternative.record_extra_info("signup", "Value 1")
+      expect(alternative.extra_info["signup"]).to eql("Value 1")
+
+      alternative.record_extra_info("signup", "Value 2")
+      expect(alternative.extra_info["signup"]).to eql("Value 2")
+    end
+  end
 end

data/spec/configuration_spec.rb

@@ -212,20 +212,34 @@ 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 "configuration URL" do
+  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_url).to eq("localhost:6379")
+      expect(@config.redis).to eq("redis://localhost:6379")
     end
 
     it "should allow for redis url to be configured" do
-      @config.redis_url = "custom_redis_url"
-      expect(@config.redis_url).to eq("custom_redis_url")
+      @config.redis = "custom_redis_url"
+      expect(@config.redis).to eq("custom_redis_url")
     end
 
     context "provided REDIS_URL environment variable" do
       it "should use the ENV variable" do
         ENV['REDIS_URL'] = "env_redis_url"
-        expect(Split::Configuration.new.redis_url).to eq("env_redis_url")
+        expect(Split::Configuration.new.redis).to eq("env_redis_url")
       end
     end
   end

data/spec/dashboard_helpers_spec.rb

@@ -24,5 +24,19 @@ describe Split::DashboardHelpers do
       expect(confidence_level(2.58)).to eq('99% confidence')
       expect(confidence_level(3.00)).to eq('99% confidence')
     end
+
+    describe '#round' do
+      it 'can round number strings' do
+        expect(round('3.1415')).to eq BigDecimal.new('3.14')
+      end
+
+      it 'can round number strings for precsion' do
+        expect(round('3.1415', 1)).to eq BigDecimal.new('3.1')
+      end
+
+      it 'can handle invalid number strings' do
+        expect(round('N/A')).to be_zero
+      end
+    end
   end
 end

data/spec/dashboard_spec.rb

@@ -73,6 +73,21 @@ describe Split::Dashboard do
     end
   end
 
+  describe "force alternative" do
+    let!(:user) do
+      Split::User.new(@app, { experiment.name => 'a' })
+    end
+
+    before do
+      allow(Split::User).to receive(:new).and_return(user)
+    end
+
+    it "should set current user's alternative" do
+      post "/force_alternative?experiment=#{experiment.name}", alternative: "b"
+      expect(user[experiment.name]).to eq("b")
+    end
+  end
+
   describe "index page" do
     context "with winner" do
       before { experiment.winner = 'red' }

data/spec/encapsulated_helper_spec.rb

@@ -4,18 +4,49 @@ require 'spec_helper'
 describe Split::EncapsulatedHelper do
   include Split::EncapsulatedHelper
 
-  before do
-    allow_any_instance_of(Split::EncapsulatedHelper::ContextShim).to receive(:ab_user)
-        .and_return(mock_user)
-  end
 
   def params
     raise NoMethodError, 'This method is not really defined'
   end
 
   describe "ab_test" do
+    before do
+      allow_any_instance_of(Split::EncapsulatedHelper::ContextShim).to receive(:ab_user)
+      .and_return(mock_user)
+    end
+
     it "should not raise an error when params raises an error" do
+      expect{ params }.to raise_error(NoMethodError)
       expect(lambda { ab_test('link_color', 'blue', 'red') }).not_to raise_error
     end
+
+    it "calls the block with selected alternative" do
+      expect{|block| ab_test('link_color', 'red', 'red', &block) }.to yield_with_args('red', nil)
+    end
+
+    context "inside a view" do
+
+      it "works inside ERB" do
+        require 'erb'
+        template = ERB.new(<<-ERB.split(/\s+/s).map(&:strip).join(' '), nil, "%")
+          foo <% ab_test(:foo, '1', '2') do |alt, meta| %>
+            static <%= alt %>
+          <% end %>
+        ERB
+        expect(template.result(binding)).to match /foo  static \d/
+      end
+
+    end
+  end
+
+  describe "context" do
+    it 'is passed in shim' do
+      ctx = Class.new{
+        include Split::EncapsulatedHelper
+        public :session
+      }.new
+      expect(ctx).to receive(:session){{}}
+      expect{ ctx.ab_test('link_color', 'blue', 'red') }.not_to raise_error
+    end
   end
 end