split 0.4.6 → 0.5.0

data/lib/split/extensions.rb

@@ -0,0 +1,3 @@
+%w[array string].each do |f|
+  require "split/extensions/#{f}"
+end

data/lib/split/extensions/array.rb

@@ -0,0 +1,4 @@
+class Array
+  # maintain backwards compatibility with 1.8.7
+  alias_method :sample, :choice unless method_defined?(:sample)
+end

data/lib/split/extensions/string.rb

@@ -0,0 +1,15 @@
+class String
+  # Constatntize is often provided by ActiveSupport, but ActiveSupport is not a dependency of Split. 
+  unless method_defined?(:constantize)
+    def constantize
+      names = self.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
+    end
+  end
+end

data/lib/split/helper.rb

@@ -1,16 +1,30 @@
 module Split
   module Helper
-    def ab_test(experiment_name, control, *alternatives)
-      
-      if RUBY_VERSION.match(/1\.8/) && alternatives.length.zero?
+
+    def ab_test(experiment_name, 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
-      
-      ret = if Split.configuration.enabled
-              experiment_variable(alternatives, control, experiment_name)
-            else
-              control_variable(control)
-            end
+
+      begin
+        ret = if Split.configuration.enabled
+          load_and_start_trial(experiment_name, control, alternatives)
+        else
+          control_variable(control)
+        end
+
+      rescue => e
+        raise(e) unless Split.configuration.db_failover
+        Split.configuration.db_failover_on_db_error.call(e)
+
+        if Split.configuration.db_failover_allow_parameter_override && override_present?(experiment_name)
+          ret = override_alternative(experiment_name)
+        end
+      ensure
+        if ret.nil?
+          ret = control_variable(control)
+        end
+      end
 
       if block_given?
         if defined?(capture) # a block in a rails view
@@ -25,41 +39,61 @@ module Split
       end
     end
 
-    def finished(experiment_name, options = {:reset => true})
-      return if exclude_visitor? or !Split.configuration.enabled
-      return unless (experiment = Split::Experiment.find(experiment_name))
-      return if !options[:reset] && ab_user[experiment.finished_key]
-
-      if alternative_name = ab_user[experiment.key]
-        alternative = Split::Alternative.new(alternative_name, experiment_name)
-        alternative.increment_completion
+    def reset!(experiment)
+      ab_user.delete(experiment.key)
+    end
 
-        if options[:reset]
-          ab_user.delete(experiment.key)
+    def finish_experiment(experiment, options = {:reset => true})
+      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.complete!
+        if should_reset
+          reset!(experiment)
         else
           ab_user[experiment.finished_key] = true
         end
       end
+    end
+
+
+    def finished(metric_name, options = {:reset => true})
+      return if exclude_visitor? || Split.configuration.disabled?
+      experiments = Metric.possible_experiments(metric_name)
+
+      if experiments.any?
+        experiments.each do |experiment|
+          finish_experiment(experiment, options)
+        end
+      end
     rescue => e
       raise unless Split.configuration.db_failover
       Split.configuration.db_failover_on_db_error.call(e)
     end
 
-    def override(experiment_name, alternatives)
-      params[experiment_name] if defined?(params) && alternatives.include?(params[experiment_name])
+    def override_present?(experiment_name)
+      defined?(params) && params[experiment_name]
+    end
+
+    def override_alternative(experiment_name)
+      params[experiment_name] if override_present?(experiment_name)
     end
 
     def begin_experiment(experiment, alternative_name = nil)
       alternative_name ||= experiment.control.name
       ab_user[experiment.key] = alternative_name
+      alternative_name
     end
 
     def ab_user
-      session[:split] ||= {}
+      @ab_user ||= Split::Persistence.adapter.new(self)
     end
 
     def exclude_visitor?
-      is_robot? or is_ignored_ip_address?
+      is_robot? || is_ignored_ip_address?
     end
 
     def not_allowed_to_test?(experiment_key)
@@ -67,7 +101,7 @@ module Split
     end
 
     def doing_other_tests?(experiment_key)
-      ab_user.keys.reject { |k| k == experiment_key }.length > 0
+      keys_without_experiment(ab_user.keys, experiment_key).length > 0
     end
 
     def clean_old_versions(experiment)
@@ -78,7 +112,8 @@ module Split
 
     def old_versions(experiment)
       if experiment.version > 0
-        ab_user.keys.select { |k| k.match(Regexp.new(experiment.name)) }.reject { |k| k == experiment.key }
+        keys = ab_user.keys.select { |k| k.match(Regexp.new(experiment.name)) }
+        keys_without_experiment(keys, experiment.key)
       else
         []
       end
@@ -96,50 +131,47 @@ module Split
       end
     end
 
-
     protected
 
     def control_variable(control)
       Hash === control ? control.keys.first : control
     end
 
-    def experiment_variable(alternatives, control, experiment_name)
-      begin
+    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?
+      else
         experiment = Split::Experiment.find_or_create(experiment_name, *([control] + alternatives))
-        if experiment.winner
-          ret = experiment.winner.name
+      end
+
+      start_trial( Trial.new(:experiment => experiment) )
+    end
+
+    def start_trial(trial)
+      experiment = trial.experiment
+      if override_present?(experiment.name)
+        ret = override_alternative(experiment.name)
+      else
+        clean_old_versions(experiment)
+        if exclude_visitor? || not_allowed_to_test?(experiment.key)
+          ret = experiment.control.name
         else
-          if forced_alternative = override(experiment.name, experiment.alternative_names)
-            ret = forced_alternative
+          if ab_user[experiment.key]
+            ret = ab_user[experiment.key]
           else
-            clean_old_versions(experiment)
-            begin_experiment(experiment) if exclude_visitor? or not_allowed_to_test?(experiment.key)
-
-            if ab_user[experiment.key]
-              ret = ab_user[experiment.key]
-            else
-              alternative = experiment.next_alternative
-              alternative.increment_participation
-              begin_experiment(experiment, alternative.name)
-              ret = alternative.name
-            end
+            trial.choose!
+            ret = begin_experiment(experiment, trial.alternative.name)
           end
         end
-      rescue => e
-        raise unless Split.configuration.db_failover
-        Split.configuration.db_failover_on_db_error.call(e)
-        if Split.configuration.db_failover_allow_parameter_override
-          all_alternatives = *([control] + alternatives)
-          alternative_names = all_alternatives.map{|a| a.is_a?(Hash) ? a.keys : a}.flatten
-          ret = override(experiment_name, alternative_names)
-        end
-        unless ret
-          ret = control_variable(control)
-        end
       end
+
       ret
     end
 
+    def keys_without_experiment(keys, experiment_key)
+      keys.reject { |k| k.match(Regexp.new("^#{experiment_key}(:finished)?$")) }
+    end
   end
-
 end

data/lib/split/metric.rb

@@ -0,0 +1,68 @@
+module Split
+  class Metric
+    attr_accessor :name
+    attr_accessor :experiments
+
+    def initialize(attrs = {})
+      attrs.each do |key,value|
+        if self.respond_to?("#{key}=")
+          self.send("#{key}=", value)
+        end
+      end
+    end
+
+    def self.load_from_redis(name)
+      metric = Split.redis.hget(:metrics, name)
+      if metric
+        experiment_names = metric.split(',')
+
+        experiments = experiment_names.collect do |experiment_name|
+          Split::Experiment.find(experiment_name)
+        end
+
+        Split::Metric.new(:name => name, :experiments => experiments)
+      else
+        nil
+      end
+    end
+
+    def self.load_from_configuration(name)
+      metrics = Split.configuration.metrics
+      if metrics && metrics[name]
+        Split::Metric.new(:experiments => metrics[name], :name => name)
+      else
+        nil
+      end
+    end
+
+    def self.find(name)
+      name = name.intern if name.is_a?(String)
+      metric = load_from_configuration(name)
+      metric = load_from_redis(name) if metric.nil?
+      metric
+    end
+
+    def self.possible_experiments(metric_name)
+      experiments = []
+      metric  = Split::Metric.find(metric_name)
+      if metric
+        experiments << metric.experiments
+      end
+      experiment = Split::Experiment.find(metric_name)
+      if experiment
+        experiments << experiment
+      end
+      experiments.flatten
+    end
+
+    def save
+      Split.redis.hset(:metrics, name, experiments.map(&:name).join(','))
+    end
+
+    def complete!
+      experiments.each do |experiment|
+        experiment.complete!
+      end
+    end
+  end
+end

data/lib/split/persistence.rb

@@ -0,0 +1,28 @@
+%w[session_adapter cookie_adapter].each do |f|
+  require "split/persistence/#{f}"
+end
+
+module Split
+  module Persistence
+    ADAPTERS = {
+      :cookie => Split::Persistence::CookieAdapter,
+      :session => Split::Persistence::SessionAdapter
+    }
+
+    def self.adapter
+      if persistence_config.is_a?(Symbol)
+        adapter_class = ADAPTERS[persistence_config]
+        raise Split::InvalidPersistenceAdapterError unless adapter_class
+      else
+        adapter_class = persistence_config
+      end
+      adapter_class
+    end
+
+    private
+
+    def self.persistence_config
+      Split.configuration.persistence
+    end
+  end
+end

data/lib/split/persistence/cookie_adapter.rb

@@ -0,0 +1,44 @@
+require "json"
+
+module Split
+  module Persistence
+    class CookieAdapter
+
+      EXPIRES = Time.now + 31536000 # One year from now
+
+      def initialize(context)
+        @cookies = context.send(:cookies)
+      end
+
+      def [](key)
+        hash[key]
+      end
+
+      def []=(key, value)
+        set_cookie(hash.merge(key => value))
+      end
+
+      def delete(key)
+        set_cookie(hash.tap { |h| h.delete(key) })
+      end
+
+      def keys
+        hash.keys
+      end
+
+      private
+
+      def set_cookie(value)
+        @cookies[:split] = {
+          :value => JSON.generate(value),
+          :expires => EXPIRES
+        }
+      end
+
+      def hash
+        @cookies[:split] ? JSON.parse(@cookies[:split]) : {}
+      end
+
+    end
+  end
+end

data/lib/split/persistence/session_adapter.rb

@@ -0,0 +1,28 @@
+module Split
+  module Persistence
+    class SessionAdapter
+
+      def initialize(context)
+        @session = context.session
+        @session[:split] ||= {}
+      end
+
+      def [](key)
+        @session[:split][key]
+      end
+
+      def []=(key, value)
+        @session[:split][key] = value
+      end
+
+      def delete(key)
+        @session[:split].delete(key)
+      end
+
+      def keys
+        @session[:split].keys
+      end
+
+    end
+  end
+end

data/lib/split/trial.rb

@@ -0,0 +1,43 @@
+module Split
+  class Trial
+    attr_accessor :experiment
+    attr_writer :alternative
+
+    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?
+    end
+
+    def alternative
+      @alternative ||=  if experiment.winner
+                          experiment.winner
+                        end
+    end
+
+    def complete!
+      alternative.increment_completion if alternative
+    end
+
+    def choose!
+      choose
+      record!
+    end
+    
+    def record!
+      alternative.increment_participation
+    end
+
+    def choose
+      if experiment.winner
+        self.alternative = experiment.winner
+      else
+        self.alternative = experiment.next_alternative
+      end
+    end
+    
+    def alternative_name=(name)
+      self.alternative= self.experiment.alternatives.find{|a| a.name == name }
+    end
+  end
+end