split 3.3.0 → 4.0.0.pre

data/lib/split/metric.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+
 module Split
   class Metric
     attr_accessor :name
     attr_accessor :experiments
 
     def initialize(attrs = {})
-      attrs.each do |key,value|
+      attrs.each do |key, value|
         if self.respond_to?("#{key}=")
           self.send("#{key}=", value)
         end

data/lib/split/persistence.rb

@@ -8,8 +8,10 @@ module Split
     require 'split/persistence/session_adapter'
 
     ADAPTERS = {
-      :cookie => Split::Persistence::CookieAdapter,
-      :session => Split::Persistence::SessionAdapter
+      cookie: Split::Persistence::CookieAdapter,
+      session: Split::Persistence::SessionAdapter,
+      redis: Split::Persistence::RedisAdapter,
+      dual_adapter: Split::Persistence::DualAdapter
     }.freeze
 
     def self.adapter

data/lib/split/persistence/cookie_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "json"
 
 module Split

data/lib/split/persistence/dual_adapter.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 module Split
   module Persistence
     class DualAdapter
-      extend Forwardable
-      def_delegators :@adapter, :keys, :[], :[]=, :delete
+      def self.with_config(options={})
+        self.config.merge!(options)
+        self
+      end
+
+      def self.config
+        @config ||= {}
+      end
 
       def initialize(context)
         if logged_in = self.class.config[:logged_in]
@@ -22,22 +26,60 @@ module Split
           raise "Please configure :logged_out_adapter"
         end
 
-        if logged_in.call(context)
-          @adapter = logged_in_adapter.new(context)
+        @fallback_to_logged_out_adapter =
+          self.class.config[:fallback_to_logged_out_adapter] || false
+        @logged_in = logged_in.call(context)
+        @logged_in_adapter = logged_in_adapter.new(context)
+        @logged_out_adapter = logged_out_adapter.new(context)
+        @active_adapter = @logged_in ? @logged_in_adapter : @logged_out_adapter
+      end
+
+      def keys
+        if @fallback_to_logged_out_adapter
+          (@logged_in_adapter.keys + @logged_out_adapter.keys).uniq
         else
-          @adapter = logged_out_adapter.new(context)
+          @active_adapter.keys
         end
       end
 
-      def self.with_config(options={})
-        self.config.merge!(options)
-        self
+      def [](key)
+        if @fallback_to_logged_out_adapter
+          @logged_in && @logged_in_adapter[key] || @logged_out_adapter[key]
+        else
+          @active_adapter[key]
+        end
       end
 
-      def self.config
-        @config ||= {}
+      def []=(key, value)
+        if @fallback_to_logged_out_adapter
+          @logged_in_adapter[key] = value if @logged_in
+          old_value = @logged_out_adapter[key]
+          @logged_out_adapter[key] = value
+
+          decrement_participation(key, old_value) if decrement_participation?(old_value, value)
+        else
+          @active_adapter[key] = value
+        end
+      end
+
+      def delete(key)
+        if @fallback_to_logged_out_adapter
+          @logged_in_adapter.delete(key)
+          @logged_out_adapter.delete(key)
+        else
+          @active_adapter.delete(key)
+        end
       end
 
+      private
+
+      def decrement_participation?(old_value, value)
+        !old_value.nil? && !value.nil? && old_value != value
+      end
+
+      def decrement_participation(key, value)
+        Split.redis.hincrby("#{key}:#{value}", 'participant_count', -1)
+      end
     end
   end
 end

data/lib/split/persistence/redis_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class RedisAdapter
@@ -39,6 +40,10 @@ module Split
         Split.redis.hkeys(redis_key)
       end
 
+      def self.find(user_id)
+        new(nil, user_id)
+      end
+
       def self.with_config(options={})
         self.config.merge!(options)
         self

data/lib/split/persistence/session_adapter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   module Persistence
     class SessionAdapter

data/lib/split/redis_interface.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Split
   # Simplifies the interface to Redis.
   class RedisInterface
@@ -6,40 +8,19 @@ module Split
     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)
+      if list_values.length > 0
+        redis.multi do |multi|
+          tmp_list = "#{list_name}_tmp"
+          multi.rpush(tmp_list, list_values)
+          multi.rename(tmp_list, list_name)
         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)
-      redis.ltrim(list_name, 0, new_length - 1)
+      list_values
     end
 
     def add_to_set(set_name, value)
-      redis.sadd(set_name, value) unless redis.sismember(set_name, value)
+      redis.sadd(set_name, value)
     end
 
     private

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
@@ -33,7 +36,7 @@ module Split
       end
     end
 
-    def complete!(goals=[], context = nil)
+    def complete!(context = nil)
       if alternative
         if Array(goals).empty?
           alternative.increment_completion
@@ -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,23 +72,27 @@ 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
 

data/lib/split/user.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 module Split
@@ -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'
         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 &&
@@ -38,7 +44,7 @@ module Split
 
     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,6 +54,16 @@ module Split
       experiment_pairs
     end
 
+    def self.find(user_id, adapter)
+      adapter = adapter.is_a?(Symbol) ? Split::Persistence::ADAPTERS[adapter] : adapter
+
+      if adapter.respond_to?(:find)
+        User.new(nil, adapter.find(user_id))
+      else
+        nil
+      end
+    end
+
     private
 
     def keys_without_experiment(keys, experiment_key)

data/lib/split/version.rb

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

data/lib/split/zscore.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Split
   class Zscore
 

data/spec/alternative_spec.rb

@@ -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

data/spec/cache_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+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
+
+    before { Split.configuration.cache = true }
+
+    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
+      Split::Cache.fetch(namespace, key) { Time.now }
+    end
+  end
+
+  describe 'clear_key' do
+    before { Split.configuration.cache = true }
+
+    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 }
+      Split::Cache.clear_key(:key1)
+
+      Split::Cache.fetch(namespace, :key1) { Time.now }
+      Split::Cache.fetch(namespace, :key2) { Time.now }
+    end
+  end
+
+  describe 'fetch' do
+
+    subject { Split::Cache.fetch(namespace, key) { Time.now } }
+
+    context 'when cache disabled' do
+
+      before { Split.configuration.cache = false }
+
+      it 'returns the yield' do
+        expect(subject).to eql(now)
+      end
+
+      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
+
+      before { Split.configuration.cache = true }
+
+      it 'returns the yield' do
+        expect(subject).to eql(now)
+      end
+
+      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
+        expect(Split::Cache.fetch(:a, key) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
+
+        expect(Split::Cache.fetch(:a, key) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(:b, key) { :b }).to eql(:b)
+      end
+
+      it 'honors key' do
+        expect(Split::Cache.fetch(namespace, :a) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(namespace, :b) { :b }).to eql(:b)
+
+        expect(Split::Cache.fetch(namespace, :a) { :a }).to eql(:a)
+        expect(Split::Cache.fetch(namespace, :b) { :b }).to eql(:b)
+      end
+    end
+  end
+end