split 0.5.0 → 0.6.0

data/lib/split/configuration.rb

@@ -1,20 +1,9 @@
 module Split
   class Configuration
-    BOTS = {
-      'Baidu' => 'Chinese spider',
-      'Gigabot' => 'Gigabot spider',
-      'Googlebot' => 'Google spider',
-      'libwww-perl' => 'Perl client-server library loved by script kids',
-      'lwp-trivial' => 'Another Perl library loved by script kids',
-      'msnbot' => 'Microsoft bot',
-      'SiteUptime' => 'Site monitoring services',
-      'Slurp' => 'Yahoo spider',
-      'WordPress' => 'WordPress spider',
-      'ZIBB' => 'ZIBB spider',
-      'ZyBorg' => 'Zyborg? Hmmm....'
-    }
+    attr_accessor :bots
     attr_accessor :robot_regex
     attr_accessor :ignore_ip_addresses
+    attr_accessor :ignore_filter
     attr_accessor :db_failover
     attr_accessor :db_failover_on_db_error
     attr_accessor :db_failover_allow_parameter_override
@@ -24,13 +13,64 @@ module Split
     attr_accessor :persistence
     attr_accessor :algorithm
 
+    def bots
+      @bots ||= {
+        # Indexers
+        "AdsBot-Google" => 'Google Adwords',
+        'Baidu' => 'Chinese search engine',
+        'Gigabot' => 'Gigabot spider',
+        'Googlebot' => 'Google spider',
+        'msnbot' => 'Microsoft bot',
+        'bingbot' => 'Microsoft bing bot',
+        'rogerbot' => 'SeoMoz spider',
+        'Slurp' => 'Yahoo spider',
+        'Sogou' => 'Chinese search engine',
+        "spider" => 'generic web spider',
+        'WordPress' => 'WordPress spider',
+        'ZIBB' => 'ZIBB spider',
+        'YandexBot' => 'Yandex spider',
+        # HTTP libraries
+        'Apache-HttpClient' => 'Java http library',
+        'AppEngine-Google' => 'Google App Engine',
+        "curl" => 'curl unix CLI http client',
+        'ColdFusion' => 'ColdFusion http library',
+        "EventMachine HttpClient" => 'Ruby http library',
+        "Go http package" => 'Go http library',
+        'Java' => 'Generic Java http library',
+        'libwww-perl' => 'Perl client-server library loved by script kids',
+        'lwp-trivial' => 'Another Perl library loved by script kids',
+        "Python-urllib" => 'Python http library',
+        "PycURL" => 'Python http library',
+        "Test Certificate Info" => 'C http library?',
+        "Wget" => 'wget unix CLI http client',
+        # URL expanders / previewers
+        'awe.sm' => 'Awe.sm URL expander',
+        "bitlybot" => 'bit.ly bot',
+        "facebookexternalhit" => 'facebook bot',
+        'LongURL' => 'URL expander service',
+        'Twitterbot' => 'Twitter URL expander',
+        'UnwindFetch' => 'Gnip URL expander',
+        # Uptime monitoring
+        'check_http' => 'Nagios monitor',
+        'NewRelicPinger' => 'NewRelic monitor',
+        'Panopta' => 'Monitoring service',
+        "Pingdom" => 'Pingdom monitoring',
+        'SiteUptime' => 'Site monitoring services',
+        # ???
+        "DigitalPersona Fingerprint Software" => 'HP Fingerprint scanner',
+        "ShowyouBot" => 'Showyou iOS app spider',
+        'ZyBorg' => 'Zyborg? Hmmm....',
+      }
+    end
+
     def disabled?
       !enabled
     end
 
     def experiment_for(name)
       if normalized_experiments
-        normalized_experiments[name]
+        # TODO symbols
+        normalized_experiments[name.to_sym]
       end
     end
 
@@ -39,37 +79,44 @@ module Split
       @metrics = {}
       if self.experiments
         self.experiments.each do |key, value|
-          metric_name = value[:metric]
+          metric_name = value_for(value, :metric).to_sym rescue nil
           if metric_name
             @metrics[metric_name] ||= []
-            @metrics[metric_name] << Split::Experiment.load_from_configuration(key)
+            @metrics[metric_name] << Split::Experiment.new(key)
           end
         end
       end
       @metrics
     end
-    
+
     def normalized_experiments
       if @experiments.nil?
         nil
       else
         experiment_config = {}
-        @experiments.keys.each do | name |
-          experiment_config[name] = {}
+        @experiments.keys.each do |name|
+          experiment_config[name.to_sym] = {}
         end
-        @experiments.each do | experiment_name, settings|
-          experiment_config[experiment_name][:alternatives] = normalize_alternatives(settings[:alternatives]) if settings[:alternatives] 
+
+        @experiments.each do |experiment_name, settings|
+          if alternatives = value_for(settings, :alternatives)
+            experiment_config[experiment_name.to_sym][:alternatives] = normalize_alternatives(alternatives)
+          end
+
+          if goals = value_for(settings, :goals)
+            experiment_config[experiment_name.to_sym][:goals] = goals
+          end
         end
+
         experiment_config
       end
     end
-    
-    
+
     def normalize_alternatives(alternatives)
       given_probability, num_with_probability = alternatives.inject([0,0]) do |a,v|
         p, n = a
-        if v.kind_of?(Hash) && v[:percent]
-          [p + v[:percent], n + 1]
+        if percent = value_for(v, :percent)
+          [p + percent, n + 1]
         else
           a
         end
@@ -80,14 +127,15 @@ module Split
 
       if num_with_probability.nonzero?
         alternatives = alternatives.map do |v|
-          if v.kind_of?(Hash) && v[:name] && v[:percent]
-            { v[:name] => v[:percent] / 100.0 }
-          elsif v.kind_of?(Hash) && v[:name]
-            { v[:name] => unassigned_probability }
+          if (name = value_for(v, :name)) && (percent = value_for(v, :percent))
+            { name => percent / 100.0 }
+          elsif name = value_for(v, :name)
+            { name => unassigned_probability }
           else
             { v => unassigned_probability }
           end
         end
+
         [alternatives.shift, alternatives]
       else
         alternatives = alternatives.dup
@@ -95,9 +143,13 @@ module Split
       end
     end
 
+    def robot_regex
+      @robot_regex ||= /\b(?:#{escaped_bots.join('|')})\b|\A\W*\z/i
+    end
+
     def initialize
-      @robot_regex = /\b(#{BOTS.keys.join('|')})\b/i
       @ignore_ip_addresses = []
+      @ignore_filter = proc{ |request| is_robot? || is_ignored_ip_address? }
       @db_failover = false
       @db_failover_on_db_error = proc{|error|} # e.g. use Rails logger here
       @db_failover_allow_parameter_override = false
@@ -107,5 +159,17 @@ module Split
       @persistence = Split::Persistence::SessionAdapter
       @algorithm = Split::Algorithms::WeightedSample
     end
+
+    private
+
+    def value_for(hash, key)
+      if hash.kind_of?(Hash)
+        hash[key.to_s] || hash[key.to_sym]
+      end
+    end
+
+    def escaped_bots
+      bots.map { |key, _| Regexp.escape(key) }
+    end
   end
 end

data/lib/split/dashboard/public/style.css

@@ -160,6 +160,10 @@ body {
   margin:30px 0;
 }
 
+.experiment_with_goal {
+  margin: -32px 0 30px 0;
+}
+
 .experiment .experiment-header {
   background: #f4f4f4;
   background: -webkit-gradient(linear, left top, left bottom,
@@ -177,14 +181,18 @@ body {
 
 .experiment h2 {
   color:#888;
-  margin: 12px 0 0;
+  margin: 12px 0 12px 0;
   font-size: 1em;
   font-weight:bold;
   float:left;
   text-shadow:0 1px 0 rgba(255,255,255,0.8);
 }
 
-.experiment h2 .version{
+.experiment h2 .goal {
+  font-style: italic;
+}
+
+.experiment h2 .version {
   font-style:italic;
   font-size:0.8em;
   color:#bbb;

data/lib/split/dashboard/views/_experiment.erb

@@ -1,20 +1,28 @@
-<div class="experiment">
+<% unless goal.nil? %>
+  <% experiment_class = "experiment experiment_with_goal" %>
+<% else %>
+  <% experiment_class = "experiment" %>
+<% end %>
+<div class="<%= experiment_class %>">
   <div class="experiment-header">
     <h2>
       Experiment: <%= experiment.name %>
       <% if experiment.version > 1 %><span class='version'>v<%= experiment.version %></span><% end %>
+      <% unless goal.nil? %><span class='goal'>Goal:<%= goal %></span><% end %>
     </h2>
 
-    <div class='inline-controls'>
-      <small><%= experiment.start_time ? experiment.start_time.strftime('%Y-%m-%d') : 'Unknown' %></small>
-      <form action="<%= url "/reset/#{experiment.name}" %>" method='post' onclick="return confirmReset()">
-        <input type="submit" value="Reset Data">
-      </form>
-      <form action="<%= url "/#{experiment.name}" %>" method='post' onclick="return confirmDelete()">
-        <input type="hidden" name="_method" value="delete"/>
-        <input type="submit" value="Delete" class="red">
-      </form>
-    </div>
+    <% if goal.nil? %>
+      <div class='inline-controls'>
+        <small><%= experiment.start_time ? experiment.start_time.strftime('%Y-%m-%d') : 'Unknown' %></small>
+        <form action="<%= url "/reset/#{experiment.name}" %>" method='post' onclick="return confirmReset()">
+          <input type="submit" value="Reset Data">
+        </form>
+        <form action="<%= url "/#{experiment.name}" %>" method='post' onclick="return confirmDelete()">
+          <input type="hidden" name="_method" value="delete"/>
+          <input type="submit" value="Delete" class="red">
+        </form>
+      </div>
+    <% end %>
   </div>
   <table>
     <tr>
@@ -27,7 +35,7 @@
       <th>Finish</th>
     </tr>
 
-    <% total_participants = total_completed = 0 %>
+    <% total_participants = total_completed = total_unfinished = 0 %>
     <% experiment.alternatives.each do |alternative| %>
       <tr>
         <td>
@@ -38,23 +46,23 @@
         </td>
         <td><%= alternative.participant_count %></td>
         <td><%= alternative.unfinished_count %></td>
-        <td><%= alternative.completed_count %></td>
+        <td><%= alternative.completed_count(goal) %></td>
         <td>
-          <%= number_to_percentage(alternative.conversion_rate) %>%
-          <% if experiment.control.conversion_rate > 0 && !alternative.control? %>
-            <% if alternative.conversion_rate > experiment.control.conversion_rate %>
+          <%= number_to_percentage(alternative.conversion_rate(goal)) %>%
+          <% if experiment.control.conversion_rate(goal) > 0 && !alternative.control? %>
+            <% if alternative.conversion_rate(goal) > experiment.control.conversion_rate(goal) %>
               <span class='better'>
-                +<%= number_to_percentage((alternative.conversion_rate/experiment.control.conversion_rate)-1) %>%
+                +<%= number_to_percentage((alternative.conversion_rate(goal)/experiment.control.conversion_rate(goal))-1) %>%
               </span>
-            <% elsif alternative.conversion_rate < experiment.control.conversion_rate %>
+            <% elsif alternative.conversion_rate(goal) < experiment.control.conversion_rate(goal) %>
               <span class='worse'>
-                <%= number_to_percentage((alternative.conversion_rate/experiment.control.conversion_rate)-1) %>%
+                <%= number_to_percentage((alternative.conversion_rate(goal)/experiment.control.conversion_rate(goal))-1) %>%
               </span>
             <% end  %>
           <% end %>
         </td>
         <td>
-          <span title='z-score: <%= round(alternative.z_score, 3) %>'><%= confidence_level(alternative.z_score) %></span>
+          <span title='z-score: <%= round(alternative.z_score(goal), 3) %>'><%= confidence_level(alternative.z_score(goal)) %></span>
         </td>
         <td>
           <% if experiment.winner %>
@@ -73,13 +81,14 @@
       </tr>
 
       <% total_participants += alternative.participant_count %>
-      <% total_completed += alternative.completed_count %>
+      <% total_unfinished += alternative.unfinished_count %>
+      <% total_completed += alternative.completed_count(goal) %>
     <% end %>
 
     <tr class="totals">
       <td>Totals</td>
       <td><%= total_participants %></td>
-      <td><%= total_participants - total_completed %></td>
+      <td><%= total_unfinished %></td>
       <td><%= total_completed %></td>
       <td>N/A</td>
       <td>N/A</td>

data/lib/split/dashboard/views/_experiment_with_goal_header.erb

@@ -0,0 +1,14 @@
+<div class="experiment">
+  <div class="experiment-header">
+      <div class='inline-controls'>
+        <small><%= experiment.start_time ? experiment.start_time.strftime('%Y-%m-%d') : 'Unknown' %></small>
+        <form action="<%= url "/reset/#{experiment.name}" %>" method='post' onclick="return confirmReset()">
+          <input type="submit" value="Reset Data">
+        </form>
+        <form action="<%= url "/#{experiment.name}" %>" method='post' onclick="return confirmDelete()">
+          <input type="hidden" name="_method" value="delete"/>
+          <input type="submit" value="Delete" class="red">
+        </form>
+      </div>
+  </div>
+</div>

data/lib/split/dashboard/views/index.erb

@@ -2,7 +2,14 @@
   <p class="intro">The list below contains all the registered experiments along with the number of test participants, completed and conversion rate currently in the system.</p>
 
   <% @experiments.each do |experiment| %>
-    <%= erb :_experiment, :locals => {:experiment => experiment} %>
+    <% if experiment.goals.empty? %>
+      <%= erb :_experiment, :locals => {:goal => nil, :experiment => experiment} %>
+    <% else %>
+      <%= erb :_experiment_with_goal_header, :locals => {:experiment => experiment} %>
+      <% experiment.goals.each do |g| %>
+        <%= erb :_experiment, :locals => {:goal => g, :experiment => experiment} %>
+      <% end %>
+    <% end %>
   <% end %>
 <% else %>
   <p class="intro">No experiments have started yet, you need to define them in your code and introduce them to your users.</p>

data/lib/split/experiment.rb

@@ -3,40 +3,134 @@ module Split
     attr_accessor :name
     attr_writer :algorithm
     attr_accessor :resettable
+    attr_accessor :goals
+    attr_accessor :alternatives
 
-    def initialize(name, options = {})      
+    def initialize(name, options = {})
       options = {
-          :resettable => true,
-        }.merge(options)
-       
-      @name = name.to_s 
-      @alternatives = options[:alternatives]  if !options[:alternatives].nil?
-      
-      if !options[:algorithm].nil?    
-        @algorithm = options[:algorithm].is_a?(String) ? options[:algorithm].constantize : options[:algorithm]
+        :resettable => true,
+      }.merge(options)
+
+      @name = name.to_s
+
+      alts = options[:alternatives] || []
+
+      if alts.length == 1
+        if alts[0].is_a? Hash
+          alts = alts[0].map{|k,v| {k => v} }
+        end
       end
-      
-      if !options[:resettable].nil?
-        @resettable = options[:resettable].is_a?(String) ? options[:resettable] == 'true' : options[:resettable]
+
+      if alts.empty?
+        exp_config = Split.configuration.experiment_for(name)
+        if exp_config
+          alts = load_alternatives_from_configuration
+          options[:goals] = load_goals_from_configuration
+          options[:resettable] = exp_config[:resettable]
+          options[:algorithm] = exp_config[:algorithm]
+        end
       end
-      
-      if !options[:alternative_names].nil? 
-        @alternatives = options[:alternative_names].map do |alternative|
-                          Split::Alternative.new(alternative, name)
-                        end
+
+      self.alternatives = alts
+      self.goals = options[:goals]
+      self.algorithm = options[:algorithm]
+      self.resettable = options[:resettable]
+    end
+
+    def self.all
+      Split.redis.smembers(:experiments).map {|e| find(e)}
+    end
+
+    def self.find(name)
+      if Split.redis.exists(name)
+        obj = self.new name
+        obj.load_from_redis
+      else
+        obj = nil
       end
-      
-      
+      obj
     end
-    
-    def algorithm
-      @algorithm ||= Split.configuration.algorithm
+
+    def self.find_or_create(label, *alternatives)
+      experiment_name_with_version, goals = normalize_experiment(label)
+      name = experiment_name_with_version.to_s.split(':')[0]
+
+      exp = self.new name, :alternatives => alternatives, :goals => goals
+      exp.save
+      exp
+    end
+
+    def save
+      validate!
+
+      if new_record?
+        Split.redis.sadd(:experiments, name)
+        Split.redis.hset(:experiment_start_times, @name, Time.now)
+        @alternatives.reverse.each {|a| Split.redis.lpush(name, a.name)}
+        @goals.reverse.each {|a| Split.redis.lpush(goals_key, a)} unless @goals.nil?
+      else
+
+        existing_alternatives = load_alternatives_from_redis
+        existing_goals = load_goals_from_redis
+        unless existing_alternatives == @alternatives.map(&:name) && existing_goals == @goals
+          reset
+          @alternatives.each(&:delete)
+          delete_goals
+          Split.redis.del(@name)
+          @alternatives.reverse.each {|a| Split.redis.lpush(name, a.name)}
+          @goals.reverse.each {|a| Split.redis.lpush(goals_key, a)} unless @goals.nil?
+        end
+      end
+
+      Split.redis.hset(experiment_config_key, :resettable, resettable)
+      Split.redis.hset(experiment_config_key, :algorithm, algorithm.to_s)
+      self
+    end
+
+    def validate!
+      if @alternatives.empty? && Split.configuration.experiment_for(@name).nil?
+        raise ExperimentNotFound.new("Experiment #{@name} not found")
+      end
+      @alternatives.each {|a| a.validate! }
+      unless @goals.nil? || goals.kind_of?(Array)
+        raise ArgumentError, 'Goals must be an array'
+      end
+    end
+
+    def new_record?
+      !Split.redis.exists(name)
     end
 
     def ==(obj)
       self.name == obj.name
     end
 
+    def [](name)
+      alternatives.find{|a| a.name == name}
+    end
+
+    def algorithm
+      @algorithm ||= Split.configuration.algorithm
+    end
+
+    def algorithm=(algorithm)
+      @algorithm = algorithm.is_a?(String) ? algorithm.constantize : algorithm
+    end
+
+    def resettable=(resettable)
+      @resettable = resettable.is_a?(String) ? resettable == 'true' : resettable
+    end
+
+    def alternatives=(alts)
+      @alternatives = alts.map do |alternative|
+        if alternative.kind_of?(Split::Alternative)
+          alternative
+        else
+          Split::Alternative.new(alternative, @name)
+        end
+      end
+    end
+
     def winner
       if w = Split.redis.hget(:experiment_winner, name)
         Split::Alternative.new(w, name)
@@ -44,7 +138,11 @@ module Split
         nil
       end
     end
-    
+
+    def winner=(winner_name)
+      Split.redis.hset(:experiment_winner, name, winner_name.to_s)
+    end
+
     def participant_count
       alternatives.inject(0){|sum,a| sum + a.participant_count}
     end
@@ -57,26 +155,10 @@ module Split
       Split.redis.hdel(:experiment_winner, name)
     end
 
-    def winner=(winner_name)
-      Split.redis.hset(:experiment_winner, name, winner_name.to_s)
-    end
-
     def start_time
       t = Split.redis.hget(:experiment_start_times, @name)
       Time.parse(t) if t
     end
-    
-    def [](name)
-      alternatives.find{|a| a.name == name} 
-    end
-
-    def alternatives
-      @alternatives.dup
-    end
-
-    def alternative_names
-      @alternatives.map(&:name)
-    end
 
     def next_alternative
       winner || random_alternative
@@ -106,6 +188,10 @@ module Split
       end
     end
 
+    def goals_key
+      "#{name}:goals"
+    end
+
     def finished_key
       "#{key}:finished"
     end
@@ -125,139 +211,73 @@ module Split
       reset_winner
       Split.redis.srem(:experiments, name)
       Split.redis.del(name)
+      delete_goals
       increment_version
     end
 
-    def new_record?
-      !Split.redis.exists(name)
+    def delete_goals
+      Split.redis.del(goals_key)
     end
 
-    def save
-      if new_record?
-        Split.redis.sadd(:experiments, name)
-        Split.redis.hset(:experiment_start_times, @name, Time.now)
-        @alternatives.reverse.each {|a| Split.redis.lpush(name, a.name) }
-      else
-        Split.redis.del(name)
-        @alternatives.reverse.each {|a| Split.redis.lpush(name, a.name) }
-      end
-      config_key = Split::Experiment.experiment_config_key(name)
-      Split.redis.hset(config_key, :resettable, resettable)
-      Split.redis.hset(config_key, :algorithm, algorithm.to_s)
-      self
+    def load_from_redis
+      exp_config = Split.redis.hgetall(experiment_config_key)
+      self.resettable = exp_config['resettable']
+      self.algorithm = exp_config['algorithm']
+      self.alternatives = load_alternatives_from_redis
+      self.goals = load_goals_from_redis
     end
 
-    def self.load_alternatives_for(name)
-      if Split.configuration.experiment_for(name)
-        load_alternatives_from_configuration_for(name)
+    protected
+
+    def self.normalize_experiment(label)
+      if Hash === label
+        experiment_name = label.keys.first
+        goals = label.values.first
       else
-        load_alternatives_from_redis_for(name)
+        experiment_name = label
+        goals = []
       end
+      return experiment_name, goals
     end
 
-    def self.load_alternatives_from_configuration_for(name)
-      alts = Split.configuration.experiment_for(name)[:alternatives]
-      raise ArgumentError, "Experiment configuration is missing :alternatives array" if alts.nil?
-      if alts.is_a?(Hash)
-        alts.keys
-      else
-        alts.flatten
-      end
+    def experiment_config_key
+      "experiment_configurations/#{@name}"
     end
 
-    def self.load_alternatives_from_redis_for(name)
-      case Split.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)
+    def load_goals_from_configuration
+      goals = Split.configuration.experiment_for(@name)[:goals]
+      if goals.nil?
+        goals = []
       else
-        Split.redis.lrange(name, 0, -1)
+        goals.flatten
       end
     end
 
-    def self.load_from_configuration(name)
-      exp_config = Split.configuration.experiment_for(name) || {}
-      self.new(name, :alternative_names => load_alternatives_for(name), 
-                           :resettable => exp_config[:resettable], 
-                           :algorithm => exp_config[:algorithm])
+    def load_goals_from_redis
+      Split.redis.lrange(goals_key, 0, -1)
     end
 
-    def self.load_from_redis(name)
-      exp_config = Split.redis.hgetall(experiment_config_key(name))
-      self.new(name, :alternative_names => load_alternatives_for(name),
-                      :resettable => exp_config['resettable'], 
-                      :algorithm => exp_config['algorithm'])     
-    end
-    
-    def self.experiment_config_key(name)
-      "experiment_configurations/#{name}"
-    end
-
-    def self.all
-      Array(all_experiment_names_from_redis + all_experiment_names_from_configuration).map {|e| find(e)}
-    end
-
-    def self.all_experiment_names_from_redis
-      Split.redis.smembers(:experiments)
-    end
-
-    def self.all_experiment_names_from_configuration
-      Split.configuration.experiments ? Split.configuration.experiments.keys : []
-    end
-
-
-    def self.find(name)
-      if Split.configuration.experiment_for(name)
-        obj = load_from_configuration(name)
-      elsif Split.redis.exists(name)
-        obj = load_from_redis(name)
+    def load_alternatives_from_configuration
+      alts = Split.configuration.experiment_for(@name)[:alternatives]
+      raise ArgumentError, "Experiment configuration is missing :alternatives array" unless alts
+      if alts.is_a?(Hash)
+        alts.keys
       else
-        obj = nil
+        alts.flatten
       end
-      obj
     end
 
-    def self.find_or_create(key, *alternatives)
-      name = key.to_s.split(':')[0]
-
-      if alternatives.length == 1
-        if alternatives[0].is_a? Hash
-          alternatives = alternatives[0].map{|k,v| {k => v} }
-        end
-      end
-
-      alts = initialize_alternatives(alternatives, name)
-
-      if Split.redis.exists(name)
-        existing_alternatives = load_alternatives_for(name)
-        if existing_alternatives == alts.map(&:name)
-          experiment = self.new(name, :alternative_names => alternatives)
-        else
-          exp = self.new(name, :alternative_names => existing_alternatives)
-          exp.reset
-          exp.alternatives.each(&:delete)
-          experiment = self.new(name, :alternative_names =>alternatives)
-          experiment.save
-        end
+    def load_alternatives_from_redis
+      case Split.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)
       else
-        experiment = self.new(name, :alternative_names => alternatives)
-        experiment.save
+        Split.redis.lrange(@name, 0, -1)
       end
-      return experiment
-
     end
 
-    def self.initialize_alternatives(alternatives, name)
-
-      unless alternatives.all? { |a| Split::Alternative.valid?(a) }
-        raise ArgumentError, 'Alternatives must be strings'
-      end
-
-      alternatives.map do |alternative|
-        Split::Alternative.new(alternative, name)
-      end
-    end
   end
 end