conductor 0.0.0 → 0.2.9

data/Rakefile

@@ -5,18 +5,16 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "conductor"
-    gem.summary = %Q{let's you just try things while always maximizing towards a goal (e.g. purchase, signups, etc)}
+    gem.summary = %Q{lets you just try things while always maximizing towards a goal (e.g. purchase, signups, etc)}
     gem.description = %Q{Conductor is the bastard child of a/b testing and personalization.  It throws everything you know about creating a web site our the window and lets you just "try stuff" without ever having to worry about not maximing your site's "purpose."  Have a new landing page?  Just throw it to the conductor.  Want to try different price points - conductor.  Different form designs?  Conductor.  Conductor will rotate all alternatives through the mix and eventually settle on the top performing of all, without you having to do anything other than just creating.  Think "intelligent A/B testing" on steriods.}
     gem.email = "jlippiner@noctivity.com"
     gem.homepage = "http://github.com/noctivityinc/conductor"
     gem.authors = ["Noctivity"]
     gem.rubyforge_project = "conductor"
+    gem.files =  FileList["[A-Z]*", "{generators,lib}/**/*", "init.rb"]
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
-  Jeweler::RubyforgeTasks.new do |rubyforge|
-    rubyforge.doc_task = "rdoc"
-  end
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.2.9

data/generators/conductor_migration/conductor_migration_generator.rb

@@ -0,0 +1,10 @@
+class ConductorMigrationGenerator < Rails::Generator::Base
+  require 'conductor'
+  
+  def manifest
+    record do |m|
+      m.migration_template 'conductor_migration.rb', 'db/migrate', 
+        :assigns => {:version => Conductor.MAJOR_VERSION.gsub(".", "")}
+    end
+  end
+end

data/generators/conductor_migration/templates/conductor_migration.rb

@@ -0,0 +1,56 @@
+#Creates the database tables, plus indexes, you'll need to use Conductor.
+
+class ConductorMigration<%= version -%>< ActiveRecord::Migration
+  def self.up
+
+    create_table "conductor_daily_experiments", :force => true do |t|
+      t.date    "activity_date"
+      t.string  "group_name"
+      t.string  "option_name"
+      t.decimal "conversion_value", :precision => 8, :scale => 2
+      t.integer "views"
+      t.integer "conversions"
+    end
+
+    add_index "conductor_daily_experiments", ["activity_date"], :name => "index_conductor_daily_experiments_on_activity_date"
+    add_index "conductor_daily_experiments", ["group_name"], :name => "index_conductor_daily_experiments_on_group_name"
+
+    create_table "conductor_raw_experiments", :force => true do |t|
+      t.string   "identity_id"
+      t.string   "group_name"
+      t.string   "option_name"
+      t.decimal  "conversion_value", :precision => 8, :scale => 2
+      t.datetime "created_at"
+      t.datetime "updated_at"
+      t.string   "goal"
+    end
+
+    create_table "conductor_weight_histories", :force => true do |t|
+      t.string   "group_name"
+      t.string   "option_name"
+      t.decimal  "weight",        :precision => 8, :scale => 2
+      t.datetime "computed_at"
+      t.integer  "launch_window"
+    end
+
+    add_index "conductor_weight_histories", ["computed_at", "group_name"], :name => "conductor_wh_date_and_group_ndx"
+
+    create_table "conductor_weighted_experiments", :force => true do |t|
+      t.string   "group_name"
+      t.string   "option_name"
+      t.decimal  "weight",      :precision => 8, :scale => 2
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+
+    add_index "conductor_weighted_experiments", ["group_name"], :name => "index_conductor_weighted_experiments_on_group_name"
+
+  end
+
+  def self.down
+    drop_table :conductor_raw_experiments
+    drop_table :conductor_daily_experiments
+    drop_table :conductor_weight_histories
+    drop_table :conductor_weighted_experiments
+  end
+end

data/init.rb

@@ -0,0 +1,4 @@
+require File.dirname(__FILE__) + '/lib/conductor/models'
+
+# ActionController::Base.send :include, AbingoSugar
+# ActionView::Base.send :include, AbingoViewHelper

data/lib/conductor.rb

@@ -0,0 +1,41 @@
+require 'conductor/experiment'
+require 'conductor/roll_up'
+require 'conductor/weights'
+
+class Conductor
+  MAX_WEIGHTING_FACTOR = 1.25
+  MINIMUM_LAUNCH_DAYS = 7
+  DBG = false
+
+  @@VERSION = "0.1.0"
+  @@MAJOR_VERSION = "1.0"
+  cattr_reader :VERSION
+  cattr_reader :MAJOR_VERSION
+
+  cattr_writer :cache
+
+  def self.cache
+    @@cache || Rails.cache
+  end
+
+  class << self
+    def identity=(value)
+      @conductor_identity = value
+    end
+
+    def identity
+      return (@conductor_identity || ActiveSupport::SecureRandom.hex(16))
+    end
+
+    def log(msg)
+      puts msg if DBG
+    end
+  end
+end
+
+
+class Array
+  def sum_it(attribute)
+    self.map {|x| x.send(attribute) }.compact.sum
+  end
+end

data/lib/conductor/experiment.rb

@@ -0,0 +1,156 @@
+class Conductor
+  class Experiment
+    class << self
+      # Selects the best option for a given group
+      #
+      # Method also saves the selection to the
+      # database so everything happens in one move
+      #
+      # options allow you to specify a specific GOAL
+      # in case you have multiple goals per site.  For example,
+      # if you are using Conductor to maximize newsletter signups
+      # and orders, you might have:
+      # {:goal => "signup"}
+      # and
+      # {:goal => "purchase" }
+      #
+      # goals are important since you can specify which goal converted
+      # with the track! method to only update records for that
+      # specific goal.
+      #
+      def pick(group_name, alternatives, options={})
+        group_name = sanitize(group_name) # => clean up and standardize
+
+        # check for previous selection
+        selection = Conductor.cache.read("Conductor::#{Conductor.identity}::Experience::#{group_name}")
+
+        unless selection
+          selection = select_option_for_group(group_name, alternatives)
+          Conductor::RawExperiment.create!({:identity_id => Conductor.identity.to_s, :group_name => group_name, :option_name => selection}.merge!(options))
+          Conductor.cache.write("Conductor::#{Conductor.identity}::Experience::#{group_name}", selection)
+        end
+
+        return selection
+      end
+
+      # returns the raw weighting table for all alternatives for a specified group
+      def weights(group_name, alternatives)
+        group_name = sanitize(group_name) # => clean up and standardize
+        return generate_weighting_table(group_name, alternatives)
+      end
+
+      # Records a conversion for the visitor.
+      #
+      # May optionally supply a conversion value and goal.
+      #
+      # Conversion value is specified as {:value => 123.45}
+      #
+      # If no goal is specified as an option, than ALL selected alternatives
+      # for the experiments for a specific user will be updated with the
+      # conversion value.  If a goal is specified, then only those
+      # records will be updated.
+      #
+      # To clarify by explaination -
+      #
+      # Assume you are selecting a landing page to maximize newsletter
+      # signups and are selecting a price point to maximize purchases.
+      # In this case you would have two goals -
+      #  - signup
+      #  - purchase
+      #
+      # Now, if we assume that for visitor 24601 a landing page and
+      # price point are selected before they signup for the newsletter,
+      # if you called track! after a newsletter signup occurred without
+      # specifying the goal, then a conversion would ALSO (and incorrectly)
+      # be recorded by the PURCHASE goal as well as the SIGNUP goal.
+      #
+      # What you needed to do was call track!({:goal => 'signup'}) to correctly record
+      # a conversion for visitor 24601 and the newsletter signup only.
+      #
+      def track!(options={})
+        value = (options.delete(:value) || 1) # => pull the conversion value and remove from hash or set value to 1
+        experiments = Conductor::RawExperiment.find(:all, :conditions => {:identity_id => Conductor.identity}.merge!(options))
+        experiments.each {|x| x.update_attributes(:conversion_value => value)} if experiments
+      end
+
+      private
+
+        def select_option_for_group(group_name, alternatives)
+          # create weighting table
+          weighting_table = generate_weighting_table(group_name, alternatives)
+
+          # make a selection from weighted hash
+          return choose_weighted(weighting_table)
+        end
+
+        # Returns a hash of alternatives with weights based on conversion
+        # e.g. {:option_a => .25, :option_b => .25, :option_c => .50}
+        #
+        # Note: We create sql where statement that includes the list of
+        # alternatives to select from in case an existing group
+        # has an option you no longer want to include in the result set
+        #
+        # TODO: store all weights for a group in cache and then weed out 
+        # those not in the alternatives list
+        #
+        def generate_weighting_table(group_name, alternatives)
+          # create the conditions after sanitizing sql.
+          option_conditions = alternatives.inject([]) {|res,x| res << "option_name = '#{sanitize(x)}'"}.join(' OR ')
+
+          conditions = "group_name = '#{group_name}' AND (#{option_conditions})"
+
+          # get the options from the database
+          weights ||= Conductor::WeightedExperiment.find(:all, :conditions => conditions)
+
+          # create selection hash
+          weighting_table = weights.inject({}) {|res, x| res.merge!({x.option_name => x.weight})}
+
+          # is anything missing?
+          options_names = weights.map(&:option_name)
+          missing = alternatives - options_names
+
+          # if anything is missing, add it to the weighted list
+          unless missing.empty?
+            max_weight = weights.empty? ? 1 : weights.max {|a,b| a.weight <=> b.weight}.weight
+            missing.each do |name|
+              weighting_table.merge!({name => max_weight * MAX_WEIGHTING_FACTOR})
+            end
+          end
+
+          return weighting_table
+        end
+
+        # selects a random float
+        def float_rand(start_num, end_num=0)
+          width = end_num-start_num
+          return (rand*width)+start_num
+        end
+
+        # choose a random option based on weights
+        # from recipe 5.11 in ruby cookbook
+        def choose_weighted(weighted)
+          sum = weighted.inject(0) do |sum, item_and_weight|
+            sum += item_and_weight[1]
+          end
+          target = float_rand(sum)
+          weighted.each do |item, weight|
+            return item if target <= weight
+            target -= weight
+          end
+        end
+
+        def normalize!(weighted)
+          sum = weighted.inject(0) do |sum, item_and_weight|
+            sum += item_and_weight[1]
+          end
+          sum = sum.to_f
+          weighted.each { |item, weight| weighted[item] = weight/sum }
+        end
+
+        def sanitize(str)
+          str.gsub(/\s/,'_').downcase
+        end
+
+    end
+  end
+end

data/lib/conductor/models/daily_experiment.rb

@@ -0,0 +1,17 @@
+# == Schema Information
+#
+# Table name: conductor_daily_experiments
+#
+#  id               :integer         not null, primary key
+#  activity_date    :date
+#  group_name       :string(255)
+#  option_name      :string(255)
+#  conversion_value :decimal(8, 2)
+#  views            :integer
+#  conversions      :integer
+#
+
+class Conductor::DailyExperiment < ActiveRecord::Base
+  set_table_name "conductor_daily_experiments"
+  named_scope :since, lambda { |a_date| { :conditions =>  ['activity_date >= ?',a_date] }}
+end

data/lib/conductor/models/raw_experiment.rb

@@ -0,0 +1,22 @@
+# == Schema Information
+#
+# Table name: conductor_raw_experiments
+#
+#  id               :integer         not null, primary key
+#  identity_id      :string(255)
+#  group_name       :string(255)
+#  option_name      :string(255)
+#  conversion_value :decimal(8, 2)
+#  created_at       :datetime
+#  updated_at       :datetime
+#
+
+class Conductor::RawExperiment < ActiveRecord::Base
+  set_table_name "conductor_raw_experiments"
+  
+  validates_presence_of :group_name, :option_name
+  
+  def created_date
+    self.created_at.strftime('%Y-%m-%d')
+  end
+end

data/lib/conductor/models/weight_history.rb

@@ -0,0 +1,14 @@
+# == Schema Information
+#
+# Table name: conductor_weight_histories
+#
+#  id          :integer         not null, primary key
+#  group_name  :string(255)
+#  option_name :string(255)
+#  weight      :decimal(8, 2)
+#  computed_at :datetime
+#
+
+class Conductor::WeightHistory < ActiveRecord::Base
+  set_table_name "conductor_weight_histories"
+end

data/lib/conductor/models/weighted_experiment.rb

@@ -0,0 +1,15 @@
+# == Schema Information
+#
+# Table name: conductor_weighted_experiments
+#
+#  id          :integer         not null, primary key
+#  group_name  :string(255)
+#  option_name :string(255)
+#  weight      :decimal(8, 2)
+#  created_at  :datetime
+#  updated_at  :datetime
+#
+
+class Conductor::WeightedExperiment < ActiveRecord::Base
+  set_table_name "conductor_weighted_experiments"
+end

data/lib/conductor/roll_up.rb

@@ -0,0 +1,25 @@
+class Conductor
+  class RollUp
+    def self.process
+      Conductor::RawExperiment.all.group_by(&:created_date).each do |day, daily_rows|
+
+        # remove all the existing data for that day
+        Conductor::DailyExperiment.delete_all(:activity_date => day)
+
+        daily_rows.group_by(&:group_name).each do |group_name, group_rows|
+          group_rows.group_by(&:option_name).each do |option_name, option_rows|
+            conversion_value = option_rows.select {|x| !x.conversion_value.nil?}.inject(0) {|res, x| res += x.conversion_value}
+            views = option_rows.count
+            conversions = option_rows.count {|x| !x.conversion_value.nil?}
+            Conductor::DailyExperiment.create!(:activity_date => day,
+                                         :group_name => group_name,
+                                         :option_name => option_name,
+                                         :conversion_value => conversion_value,
+                                         :views => views,
+                                         :conversions => conversions )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/conductor/weights.rb

@@ -0,0 +1,91 @@
+class Conductor
+  class Weights
+    class << self
+      def compute
+        Conductor::WeightedExperiment.delete_all # => remove all old data
+
+        # loop through each group and determing weight of options
+        Conductor::DailyExperiment.since(14.days.ago).group_by(&:group_name).each do |group_name, group_rows|
+          total = group_rows.sum_it(:conversion_value)
+          data = total ? compute_weights_for_group(group_name, group_rows, total) : assign_equal_weights(group_rows)
+          update_weights_in_db(group_name, data)
+        end
+      end
+
+      private
+
+        # loops through all the options for a given group and computes the weights for
+        # each alternative
+        def compute_weights_for_group(group_name, group_rows, total)
+          Conductor.log('compute_weights_for_group')
+
+          data = []
+          recently_launched = []
+          max_weight = 0
+
+          group_rows.group_by(&:option_name).each do |option_name, option_rows|
+            first_found_date = option_rows.map(&:activity_date).sort.first
+            days_ago = Date.today - first_found_date
+
+            if days_ago >= MINIMUM_LAUNCH_DAYS
+              data << compute_weight_for_option(option_name, option_rows, max_weight, total)
+            else
+              Conductor.log("adding #{option_name} to recently launched array")
+              recently_launched << {:name => option_name, :days_ago => days_ago}
+            end
+          end
+
+          data += weight_recently_launched(max_weight, recently_launched)
+          return data
+        end
+
+        def compute_weight_for_option(option_name, option_rows, max_weight, total)
+          Conductor.log("compute_weight_for_option for #{option_name}")
+
+          aggregates = {:name => option_name}
+
+          weight = option_rows.sum_it(:conversion_value) / total
+          max_weight = weight if weight > max_weight
+          aggregates.merge!({:weight => weight})
+
+          return aggregates
+        end
+
+        def weight_recently_launched(max_weight, recently_launched)
+          # loop through recently_launched to create weights for table
+          # the handicap sets a newly launched item to the max weight * MAX_WEIGHTING_FACTOR and then
+          # slowly lowers its power until the launch period is over
+          data = []
+          max_weight = 0 ? 1 : max_weight # => if a max weight could not be computed, set it to 1
+          Conductor.log("max weight: #{max_weight}")
+          recently_launched.each do |option|
+            handicap = (option[:days_ago].to_f / MINIMUM_LAUNCH_DAYS)
+            launch_window = (MINIMUM_LAUNCH_DAYS - option[:days_ago]) if MINIMUM_LAUNCH_DAYS > option[:days_ago]
+            Conductor.log("Handicap for #{option[:name]} is #{handicap} (#{option[:days_ago]} days ago)")
+            data << {:name => option[:name], :weight => max_weight * MAX_WEIGHTING_FACTOR * (1 - handicap), :launch_window => launch_window}
+          end
+          data
+        end
+
+        def assign_equal_weights(group_rows)
+          Conductor.log('assign_equal_weights')
+
+          # weight everything the same since there were no conversions
+          data = []
+          group_rows.group_by(&:option_name).each do |option_name, option_rows|
+            data << {:name => option_name, :weight => 1}
+          end
+          data
+        end
+
+        # creates new records in weights table and adds weights to weight history for reporting
+        def update_weights_in_db(group_name, data)
+          data.each { |option|
+            Conductor::WeightedExperiment.create!(:group_name => group_name, :option_name => option[:name], :weight => option[:weight])
+            Conductor::WeightHistory.create!(:group_name => group_name, :option_name => option[:name], :weight => option[:weight], :launch_window => option[:launch_window], :computed_at => Time.now)
+          }
+        end
+
+    end
+  end
+end

data/test/test_conductor.rb

@@ -1,7 +1,225 @@
 require 'helper'
 
 class TestConductor < Test::Unit::TestCase
-  def test_something_for_real
-    flunk "hey buddy, you should probably rename this file and start testing for real"
-  end
+  #Wipes cache, D/B prior to doing a test run.
+   VectorSixteen.cache.clear
+
+   test "will automatically assign an identity if none is specified" do
+     assert VectorSixteen.identity != nil
+   end
+
+   test "will select one of the specified options randomly" do
+     selected = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+     assert ["a", "b", "c"].include? selected
+   end
+
+   test "will always select the same option using the cache" do
+     VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
+
+     selected = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+     different = false
+
+     (1..100).each do |x|
+       different = true if selected != VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"])
+     end
+
+     assert !different
+   end
+
+   test "will select a lander and then successfully record a conversion" do
+     VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
+     selected = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+
+     VectorSixteen::Experiment.track!
+
+     experiments = V16::RawExperiment.find_all_by_identity_id(VectorSixteen.identity)
+     assert_equal 1, experiments.count
+     assert_equal 1, experiments.first.conversion_value
+   end
+
+   test "will select a lander and then successfully record custom conversion value" do
+      VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
+      selected = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+
+      VectorSixteen::Experiment.track!({:value => 12.34})
+
+      experiments = V16::RawExperiment.find_all_by_identity_id(VectorSixteen.identity)
+      assert_equal 1, experiments.count
+      assert_equal 12.34, experiments.first.conversion_value
+    end
+
+
+
+   test "will record three different experiments with two goals but a single conversion for all goals for the same identity" do
+     VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
+     first = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"], {:goal => 'goal_1'}) # => value must be unique
+     second = VectorSixteen::Experiment.pick('b_group', ["1", "2", "3"], {:goal => 'goal_2'}) # => value must be unique
+     third = VectorSixteen::Experiment.pick('c_group', ["zz", "xx", "yy"], {:goal => 'goal_1'}) # => value must be unique
+
+     VectorSixteen::Experiment.track!
+
+     experiments = V16::RawExperiment.find_all_by_identity_id(VectorSixteen.identity)
+     assert_equal 3, experiments.count
+     assert_equal 2, experiments.count {|x| x.goal == 'goal_1'}
+     assert_equal 3, experiments.sum_it(:conversion_value)
+   end
+
+   test "will record three different experiments with two goals but only track a conversion for goal_1" do
+     VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
+     first = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"], {:goal => 'goal_1'}) # => value must be unique
+     second = VectorSixteen::Experiment.pick('b_group', ["1", "2", "3"], {:goal => 'goal_2'}) # => value must be unique
+     third = VectorSixteen::Experiment.pick('c_group', ["zz", "xx", "yy"], {:goal => 'goal_1'}) # => value must be unique
+
+     VectorSixteen::Experiment.track!({:goal => 'goal_1'})
+
+     experiments = V16::RawExperiment.find_all_by_identity_id(VectorSixteen.identity)
+     assert_equal 3, experiments.count
+     assert_equal 2, experiments.count {|x| x.goal == 'goal_1'}
+     assert_equal 2, experiments.sum_it(:conversion_value)
+   end
+
+
+   test "will almost equally select each option if no weights exist" do
+     a = 0
+     b = 0
+     c = 0
+     (1..1000).each do |x|
+       selected_lander = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"]) # => value must be unique
+       case selected_lander
+       when 'a' then
+         a += 1
+       when 'b' then
+         b += 1
+       when 'c' then
+         c += 1
+       end
+     end
+
+     nums = [] << a << b << c
+     nums.sort!
+     range = nums.last - nums.first
+
+     assert (nums.first * 0.20) >= range
+   end
+
+   test "will correctly RollUp daily data" do
+     # seed
+     seed_raw_data(100)
+
+     # rollup
+     VectorSixteen::RollUp.process
+
+     # do some checks
+     assert V16::DailyExperiment.count > 2
+     assert V16::DailyExperiment.all.detect {|x| x.conversions > 0}
+     assert V16::DailyExperiment.all.detect {|x| x.views > 0}
+     assert V16::DailyExperiment.all.detect {|x| x.conversion_value > 0}
+   end
+
+   test "will correctly populate weighting table" do
+     # seed
+     seed_raw_data(100)
+
+     # rollup
+     VectorSixteen::RollUp.process
+
+     # compute weights
+     VectorSixteen::Weights.compute
+   end
+
+   test "will populate the weighting table with equal weights if all new options are launched" do
+     wipe
+     seed_raw_data(100, 7)
+
+     # rollup
+     VectorSixteen::RollUp.process
+
+     # compute weights
+     VectorSixteen::Weights.compute
+
+     # this makes the following assumptions:
+     # MINIMUM_LAUNCH_DAYS = 7
+     # each weight will be equal to 0.18
+     assert_equal 0.54, V16::WeightedExperiment.all.sum_it(:weight).to_f
+   end
+
+   test "will populate the weighting table with different weights" do
+     wipe
+     seed_raw_data(100, 14)
+
+     # rollup
+     VectorSixteen::RollUp.process
+
+     # compute weights
+     VectorSixteen::Weights.compute
+
+     # if this DOES NOT work then each weight will be equal to 0.18
+     assert_not_equal 0.54, V16::WeightedExperiment.all.sum_it(:weight).to_f
+   end
+
+   test "will record the new weights in the weight history table in database" do
+     wipe
+     seed_raw_data(100, 14)
+
+     # rollup
+     VectorSixteen::RollUp.process
+
+     # compute weights
+     VectorSixteen::Weights.compute
+
+     assert V16::WeightHistory.count > 1
+   end
+
+   test "will correctly record the launch window in the weight histories table" do
+     wipe
+     seed_raw_data(10, 6)
+
+     # rollup
+     VectorSixteen::RollUp.process
+
+     # compute weights
+     VectorSixteen::Weights.compute
+
+     # make sure that launch_window values can be detected
+     assert_not_nil V16::WeightHistory.find(:all, :conditions => 'launch_window > 0')
+   end
+
+   test "will return a weight 1.25 times higher than the highest weight for a newly launched and non-recorded alernative" do
+     wipe
+     seed_raw_data(100, 14)
+
+     # rollup
+     VectorSixteen::RollUp.process
+
+     # compute weights
+     VectorSixteen::Weights.compute
+
+     # get the highest weight
+     max_weight = V16::WeightedExperiment.maximum(:weight)
+
+     # pick something
+     weights = VectorSixteen::Experiment.weights('a_group', ["a", "b", "c", "f"]) # => value must be unique
+
+     assert_equal weights['f'], (max_weight * 1.25)
+   end
+
+   private
+
+   def wipe
+     V16::DailyExperiment.delete_all
+     V16::RawExperiment.delete_all
+     V16::WeightedExperiment.delete_all
+     V16::WeightHistory.delete_all
+   end
+
+   def seed_raw_data(num, days_ago=14)
+     # seed the raw data
+     (1..num).each do |x|
+       VectorSixteen.identity = ActiveSupport::SecureRandom.hex(16)
+
+       options = {:created_at => rand(days_ago).days.ago}
+       options.merge!({:conversion_value => rand(100)}) if rand() < 0.20 # => convert 20% of traffic
+       selected_lander = VectorSixteen::Experiment.pick('a_group', ["a", "b", "c"], options) # => value must be unique
+     end
+   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
-  - 0
-  version: 0.0.0
+  - 2
+  - 9
+  version: 0.2.9
 platform: ruby
 authors: 
 - Noctivity
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-26 00:00:00 -04:00
+date: 2010-09-27 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -28,14 +28,21 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
-- .document
-- .gitignore
 - LICENSE
 - README.rdoc
 - Rakefile
 - VERSION
-- conductor.gemspec
+- generators/conductor_migration/conductor_migration_generator.rb
+- generators/conductor_migration/templates/conductor_migration.rb
+- init.rb
 - lib/conductor.rb
+- lib/conductor/experiment.rb
+- lib/conductor/models/daily_experiment.rb
+- lib/conductor/models/raw_experiment.rb
+- lib/conductor/models/weight_history.rb
+- lib/conductor/models/weighted_experiment.rb
+- lib/conductor/roll_up.rb
+- lib/conductor/weights.rb
 - test/helper.rb
 - test/test_conductor.rb
 has_rdoc: true
@@ -69,7 +76,7 @@ rubyforge_project: conductor
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: let's you just try things while always maximizing towards a goal (e.g. purchase, signups, etc)
+summary: lets you just try things while always maximizing towards a goal (e.g. purchase, signups, etc)
 test_files: 
 - test/helper.rb
 - test/test_conductor.rb

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/.gitignore

@@ -1,21 +0,0 @@
-## MAC OS
-.DS_Store
-
-## TEXTMATE
-*.tmproj
-tmtags
-
-## EMACS
-*~
-\#*
-.\#*
-
-## VIM
-*.swp
-
-## PROJECT::GENERAL
-coverage
-rdoc
-pkg
-
-## PROJECT::SPECIFIC

data/conductor.gemspec

@@ -1,52 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{conductor}
-  s.version = "0.0.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Noctivity"]
-  s.date = %q{2010-09-26}
-  s.description = %q{Conductor is the bastard child of a/b testing and personalization.  It throws everything you know about creating a web site our the window and lets you just "try stuff" without ever having to worry about not maximing your site's "purpose."  Have a new landing page?  Just throw it to the conductor.  Want to try different price points - conductor.  Different form designs?  Conductor.  Conductor will rotate all alternatives through the mix and eventually settle on the top performing of all, without you having to do anything other than just creating.  Think "intelligent A/B testing" on steriods.}
-  s.email = %q{jlippiner@noctivity.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-     ".gitignore",
-     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "conductor.gemspec",
-     "lib/conductor.rb",
-     "test/helper.rb",
-     "test/test_conductor.rb"
-  ]
-  s.homepage = %q{http://github.com/noctivityinc/conductor}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{conductor}
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{let's you just try things while always maximizing towards a goal (e.g. purchase, signups, etc)}
-  s.test_files = [
-    "test/helper.rb",
-     "test/test_conductor.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end
-