abingo 1.1.0 → 2.0.0

data/.gitignore

@@ -1 +1,3 @@
 .svn
+abingo-test
+pkg

data/Gemfile

@@ -2,3 +2,6 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in abingo.gemspec
 gemspec
+gem "contest", :group => :test
+gem "ruby-debug19", :group => :test
+gem "pg", :group => :test

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    abingo (1.1.0)
+    abingo (2.0.0)
       rails (~> 3.0)
 
 GEM
@@ -34,19 +34,25 @@ GEM
     activesupport (3.2.9)
       i18n (~> 0.6)
       multi_json (~> 1.0)
+    archive-tar-minitar (0.5.2)
     arel (3.0.2)
     builder (3.0.4)
+    columnize (0.3.6)
+    contest (0.1.3)
     erubis (2.7.0)
     hike (1.2.1)
     i18n (0.6.1)
     journey (1.0.4)
     json (1.7.5)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
     mail (2.4.4)
       i18n (>= 0.4.0)
       mime-types (~> 1.16)
       treetop (~> 1.4.8)
     mime-types (1.19)
     multi_json (1.3.7)
+    pg (0.14.1)
     polyglot (0.3.3)
     rack (1.4.1)
     rack-cache (1.2)
@@ -73,6 +79,16 @@ GEM
     rake (10.0.2)
     rdoc (3.12)
       json (~> 1.4)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
     sprockets (2.2.1)
       hike (~> 1.2)
       multi_json (~> 1.0)
@@ -90,3 +106,6 @@ PLATFORMS
 
 DEPENDENCIES
   abingo!
+  contest
+  pg
+  ruby-debug19

data/README

@@ -19,7 +19,7 @@ Key default features:
 
 Example: View
 
-<% ab_test("login_button", ["/images/button1.jpg", "/images/button2.jpg"]) do |button_file| %>
+<% ab_test(@abingo_identity, "login_button", ["/images/button1.jpg", "/images/button2.jpg"]) do |button_file| %>
   <%= img_tag(button_file, :alt => "Login!") %>
 <% end %>
 
@@ -27,13 +27,13 @@ Example: Controller
 
 def register_new_user
   #See what level of free points maximizes users' decision to buy replacement points.
-  @starter_points = ab_test("new_user_free_points", [100, 200, 300])
+  @starter_points = ab_test(@abingo_identity, "new_user_free_points", [100, 200, 300])
 end
 
 Example: Controller
 
 def registration
-  if (ab_test("send_welcome_email"), :conversion => "purchase")
+  if (ab_test(@abingo_identity, "send_welcome_email"), :conversion => "purchase")
     #send the email, track to see if it later increases conversion to full version
   end
 end
@@ -42,12 +42,12 @@ Example: Conversion tracking (in a controller!)
 
 def buy_new_points
   #some business logic
-  bingo!("buy_new_points")  #Either a conversion named with :conversion or a test name.
+  @abingo_identity.bingo!("buy_new_points")  #Either a conversion named with :conversion or a test name.
 end
 
 Example: Conversion tracking (in a view)
 
-Thanks for signing up, dude! <% bingo!("signup_page_redesign") >
+Thanks for signing up, dude! <% @abingo_identity.bingo!("signup_page_redesign") >
 
 Example: Statistical Significance Testing
 
@@ -62,7 +62,7 @@ Abingo::Experiment.last.describe_result_in_words
 Installation
 =======
 
-1)  REQUIRED: You'll need to generate a DB migration to prepare two tables, 
+1)  REQUIRED: You'll need to generate a DB migration to prepare two tables,
 then migrate your database.  (Note: slight edits required if you use the table names
 "experiments" or "alternatives" at present.)  Note: if you are upgrading to A/Bingo 1.0.0, you'll
 want to do this again.
@@ -80,9 +80,10 @@ before_filter :set_abingo_identity
 
 def set_abingo_identity
   if (session[:abingo_identity])
-    Abingo.identity = session[:abingo_identity]
+    @abingo_identity = Abingo.identify(session[:abingo_identity])
   else
-    session[:abingo_identity] = Abingo.identity = rand(10 ** 10).to_i
+    @abingo_identity = Abingo.identify
+    session[:abingo_identity] = @abingo_identity.identity
   end
 end
 
@@ -106,4 +107,4 @@ A/Bingo defaults to using the same cache store as Rails.  If you want to change
 Abingo.cache = ActiveSupport::Cache::MemCacheStore.new("cache.example.com:12345") #best if really memcacheDB
 
 
-Copyright (c) 2009-2010 Patrick McKenzie, released under the MIT license
+Copyright (c) 2009-2010 Patrick McKenzie, released under the MIT license

data/lib/abingo.rb

@@ -14,25 +14,20 @@ ActionView::Base.send :include, AbingoViewHelper
 #Usage of ABingo, including practical hints, is covered at http://www.bingocardcreator.com/abingo
 
 class Abingo
-
-  @@VERSION = "1.1.0"
-  @@MAJOR_VERSION = "1.1"
-  cattr_reader :VERSION
-  cattr_reader :MAJOR_VERSION
-
-  #Not strictly necessary, but eh, as long as I'm here.
   cattr_accessor :salt
   @@salt = "Not really necessary."
 
   @@options ||= {}
   cattr_accessor :options
 
+  attr_accessor :identity
+
   #Defined options:
   # :enable_specification  => if true, allow params[test_name] to override the calculated value for a test.
   # :enable_override_in_session => if true, allows session[test_name] to override the calculated value for a test.
   # :expires_in => if not nil, passes expire_in to creation of per-user cache keys.  Useful for Redis, to prevent expired sessions
   #               from running wild and consuming all of your memory.
-  # :count_humans_only => Count only participation and conversions from humans.  Humans can be identified by calling Abingo.mark_human!
+  # :count_humans_only => Count only participation and conversions from humans.  Humans can be identified by calling @abingo.mark_human!
   #                       This can be done in e.g. Javascript code, which bots will typically not execute.  See FAQ for details.
   # :expires_in_for_bots => if not nil, passes expire_in to creation of per-user cache keys, but only for bots.
   #                         Only matters if :count_humans_only is on.
@@ -47,30 +42,40 @@ class Abingo
   #
   #You can overwrite Abingo's cache instance, if you would like it to not share
   #your generic Rails cache.
-  cattr_writer :cache
 
   def self.cache
-    @@cache || Rails.cache
+    @cache || Rails.cache
   end
 
-  #This method gives a unique identity to a user.  It can be absolutely anything
-  #you want, as long as it is consistent.
-  #
-  #We use the identity to determine, deterministically, which alternative a user sees.
-  #This means that if you use Abingo.identify_user on someone at login, they will
+  def self.cache=(cache)
+    @cache = cache
+  end
+
+  def self.identity=(new_identity)
+    raise RuntimeError.new("Setting identity on the class level has been deprecated. Please create an instance via: @abingo = Abingo.identify('user-id')")
+  end
+
+  def self.generate_identity
+    rand(10 ** 10).to_i.to_s
+  end
+
+  #This method identifies a user and ensures they consistently see the same alternative.
+  #This means that if you use Abingo.identify on someone at login, they will
   #always see the same alternative for a particular test which is past the login
   #screen.  For details and usage notes, see the docs.
-  def self.identity=(new_identity)
-    @@identity = new_identity.to_s
+  def self.identify(identity = nil)
+    identity ||= generate_identity
+    new(identity)
   end
 
-  def self.identity
-    @@identity ||= rand(10 ** 10).to_i.to_s
+  def initialize(identity)
+    @identity = identity
+    super
   end
 
   #A simple convenience method for doing an A/B test.  Returns true or false.
   #If you pass it a block, it will bind the choice to the variable given to the block.
-  def self.flip(test_name)
+  def flip(test_name)
     if block_given?
       yield(self.test(test_name, [true, false]))
     else
@@ -82,7 +87,7 @@ class Abingo
   #options accepts
   #  :multiple_participation (true or false)
   #  :conversion  name of conversion to listen for  (alias: conversion_name)
-  def self.test(test_name, alternatives, options = {})
+  def test(test_name, alternatives, options = {})
 
     short_circuit = Abingo.cache.read("Abingo::Experiment::short_circuit(#{test_name})".gsub(" ", "_"))
     unless short_circuit.nil?
@@ -91,42 +96,39 @@ class Abingo
 
     unless Abingo::Experiment.exists?(test_name)
       lock_key = "Abingo::lock_for_creation(#{test_name.gsub(" ", "_")})"
-      creation_required = true
-
+      lock_id  = SecureRandom.hex
       #this prevents (most) repeated creations of experiments in high concurrency environments.
       if Abingo.cache.exist?(lock_key)
-        creation_required = false
-        while Abingo.cache.exist?(lock_key)
-          sleep(0.1)
+        wait_for_lock_release(lock_key)
+      else
+        Abingo.cache.write(lock_key, lock_id, :expires_in => 5.seconds)
+        sleep(0.1)
+        if Abingo.cache.read(lock_key) == lock_id
+          conversion_name = options[:conversion] || options[:conversion_name]
+          Abingo::Experiment.start_experiment!(test_name, Abingo.parse_alternatives(alternatives), conversion_name)
+        else
+          wait_for_lock_release(lock_key)
         end
-        creation_required = Abingo::Experiment.exists?(test_name)
-      end
-
-      if creation_required
-        Abingo.cache.write(lock_key, 1, :expires_in => 5.seconds)
-        conversion_name = options[:conversion] || options[:conversion_name]
-        Abingo::Experiment.start_experiment!(test_name, self.parse_alternatives(alternatives), conversion_name)
-        Abingo.cache.delete(lock_key)
       end
+      Abingo.cache.delete(lock_key)
     end
 
     choice = self.find_alternative_for_user(test_name, alternatives)
-    participating_tests = Abingo.cache.read("Abingo::participating_tests::#{Abingo.identity}") || []
+    participating_tests = Abingo.cache.read("Abingo::participating_tests::#{self.identity}") || []
 
     #Set this user to participate in this experiment, and increment participants count.
     if options[:multiple_participation] || !(participating_tests.include?(test_name))
       unless participating_tests.include?(test_name)
         participating_tests = participating_tests + [test_name]
-        expires_in = Abingo.expires_in
-        if expires_in
-          Abingo.cache.write("Abingo::participating_tests::#{Abingo.identity}", participating_tests, {:expires_in => expires_in})
+        if self.expires_in
+          Abingo.cache.write("Abingo::participating_tests::#{self.identity}", participating_tests, {:expires_in => self.expires_in})
         else
-          Abingo.cache.write("Abingo::participating_tests::#{Abingo.identity}", participating_tests)
+          Abingo.cache.write("Abingo::participating_tests::#{self.identity}", participating_tests)
         end
       end
       #If we're only counting known humans, then postpone scoring participation until after we know the user is human.
-      if (!@@options[:count_humans_only] || Abingo.is_human?)
-        Abingo::Alternative.score_participation(test_name)
+      if (!@@options[:count_humans_only] || self.is_human?)
+        Abingo::Alternative.score_participation(test_name, choice)
       end
     end
 
@@ -137,6 +139,11 @@ class Abingo
     end
   end
 
+  def wait_for_lock_release(lock_key)
+    while Abingo.cache.exist?(lock_key)
+      sleep(0.1)
+    end
+  end
 
   #Scores conversions for tests.
   #test_name_or_array supports three types of input:
@@ -149,7 +156,7 @@ class Abingo
   #An array of either of the above: for each element of the array, process as above.
   #
   #nil: score a conversion for every test the u
-  def Abingo.bingo!(name = nil, options = {})
+  def bingo!(name = nil, options = {})
     if name.kind_of? Array
       name.map do |single_test|
         self.bingo!(single_test, options)
@@ -157,7 +164,7 @@ class Abingo
     else
       if name.nil?
         #Score all participating tests
-        participating_tests = Abingo.cache.read("Abingo::participating_tests::#{Abingo.identity}") || []
+        participating_tests = Abingo.cache.read("Abingo::participating_tests::#{self.identity}") || []
         participating_tests.each do |participating_test|
           self.bingo!(participating_test, options)
         end
@@ -182,52 +189,53 @@ class Abingo
     end
   end
 
-  def self.participating_tests(only_current = true)
-    identity = Abingo.identity
+  def participating_tests(only_current = true)
     participating_tests = Abingo.cache.read("Abingo::participating_tests::#{identity}") || []
     tests_and_alternatives = participating_tests.inject({}) do |acc, test_name|
       alternatives_key = "Abingo::Experiment::#{test_name}::alternatives".gsub(" ","_")
       alternatives = Abingo.cache.read(alternatives_key)
-      acc[test_name] = Abingo.find_alternative_for_user(test_name, alternatives)
+      acc[test_name] = find_alternative_for_user(test_name, alternatives)
       acc
     end
     if (only_current)
       tests_and_alternatives.reject! do |key, value|
-        self.cache.read("Abingo::Experiment::short_circuit(#{key})")
+        Abingo.cache.read("Abingo::Experiment::short_circuit(#{key})")
       end
     end
     tests_and_alternatives
   end
 
   #Marks that this user is human.
-  def self.human!
-    Abingo.cache.fetch("Abingo::is_human(#{Abingo.identity})",  {:expires_in => Abingo.expires_in(true)}) do
+  def human!
+    Abingo.cache.fetch("Abingo::is_human(#{self.identity})",  {:expires_in => self.expires_in(true)}) do
       #Now that we know the user is human, score participation for all their tests.  (Further participation will *not* be lazy evaluated.)
 
       #Score all tests which have been deferred.
-      participating_tests = Abingo.cache.read("Abingo::participating_tests::#{Abingo.identity}") || []
+      participating_tests = Abingo.cache.read("Abingo::participating_tests::#{self.identity}") || []
 
       #Refresh cache expiry for this user to match that of known humans.
       if (@@options[:expires_in_for_bots] && !participating_tests.blank?)
-        Abingo.cache.write("Abingo::participating_tests::#{Abingo.identity}", participating_tests, {:expires_in => Abingo.expires_in(true)})
+        Abingo.cache.write("Abingo::participating_tests::#{self.identity}", participating_tests, {:expires_in => self.expires_in(true)})
       end
 
       participating_tests.each do |test_name|
-        Alternative.score_participation(test_name)
-        if conversions = Abingo.cache.read("Abingo::conversions(#{Abingo.identity},#{test_name}")
-          conversions.times { Alternative.score_conversion(test_name) }
+        viewed_alternative = find_alternative_for_user(test_name,
+          Abingo::Experiment.alternatives_for_test(test_name))
+        Alternative.score_participation(test_name, viewed_alternative)
+        if conversions = Abingo.cache.read("Abingo::conversions(#{self.identity},#{test_name}")
+          conversions.times { Alternative.score_conversion(test_name, viewed_alternative) }
         end
       end
       true #Marks this user as human in the cache.
     end
   end
 
-  protected
-
-  def self.is_human?
-    !!Abingo.cache.read("Abingo::is_human(#{Abingo.identity})")
+  def is_human?
+    !!Abingo.cache.read("Abingo::is_human(#{self.identity})")
   end
 
+  protected
+
   #For programmer convenience, we allow you to specify what the alternatives for
   #an experiment are in a few ways.  Thus, we need to actually be able to handle
   #all of them.  We fire this parser very infrequently (once per test, typically)
@@ -264,32 +272,34 @@ class Abingo
 
   def self.retrieve_alternatives(test_name, alternatives)
     cache_key = "Abingo::Experiment::#{test_name}::alternatives".gsub(" ","_")
-    alternative_array = self.cache.fetch(cache_key) do
-      self.parse_alternatives(alternatives)
+    alternative_array = Abingo.cache.fetch(cache_key) do
+      Abingo.parse_alternatives(alternatives)
     end
     alternative_array
   end
 
-  def self.find_alternative_for_user(test_name, alternatives)
-    alternatives_array = retrieve_alternatives(test_name, alternatives)
+  def find_alternative_for_user(test_name, alternatives)
+    alternatives_array = Abingo.retrieve_alternatives(test_name, alternatives)
     alternatives_array[self.modulo_choice(test_name, alternatives_array.size)]
   end
 
   #Quickly determines what alternative to show a given user.  Given a test name
   #and their identity, we hash them together (which, for MD5, provably introduces
   #enough entropy that we don't care) otherwise
-  def self.modulo_choice(test_name, choices_count)
+  def modulo_choice(test_name, choices_count)
     Digest::MD5.hexdigest(Abingo.salt.to_s + test_name + self.identity.to_s).to_i(16) % choices_count
   end
 
-  def self.score_conversion!(test_name)
+  def score_conversion!(test_name)
     test_name.gsub!(" ", "_")
-    participating_tests = Abingo.cache.read("Abingo::participating_tests::#{Abingo.identity}") || []
+    participating_tests = Abingo.cache.read("Abingo::participating_tests::#{self.identity}") || []
     if options[:assume_participation] || participating_tests.include?(test_name)
-      cache_key = "Abingo::conversions(#{Abingo.identity},#{test_name}"
+      cache_key = "Abingo::conversions(#{self.identity},#{test_name}"
       if options[:multiple_conversions] || !Abingo.cache.read(cache_key)
-        if !options[:count_humans_only] || Abingo.is_human?
-          Abingo::Alternative.score_conversion(test_name)
+        if !options[:count_humans_only] || is_human?
+          viewed_alternative = find_alternative_for_user(test_name,
+            Abingo::Experiment.alternatives_for_test(test_name))
+          Abingo::Alternative.score_conversion(test_name, viewed_alternative)
         end
 
         if Abingo.cache.exist?(cache_key)
@@ -301,12 +311,12 @@ class Abingo
     end
   end
 
-  def self.expires_in(known_human = false)
+  def expires_in(known_human = false)
     expires_in = nil
     if (@@options[:expires_in])
       expires_in = @@options[:expires_in]
     end
-    if (@@options[:count_humans_only] && @@options[:expires_in_for_bots] && !(known_human || Abingo.is_human?))
+    if (@@options[:count_humans_only] && @@options[:expires_in_for_bots] && !(known_human || is_human?))
       expires_in = @@options[:expires_in_for_bots]
     end
     expires_in

data/lib/abingo/alternative.rb

@@ -1,3 +1,4 @@
+require "active_record"
 require "abingo/conversion_rate"
 class Abingo::Alternative < ActiveRecord::Base
   include Abingo::ConversionRate
@@ -10,15 +11,11 @@ class Abingo::Alternative < ActiveRecord::Base
     Digest::MD5.hexdigest(Abingo.salt + test_name + alternative_name.to_s)
   end
 
-  def self.score_conversion(test_name)
-    viewed_alternative = Abingo.find_alternative_for_user(test_name,
-      Abingo::Experiment.alternatives_for_test(test_name))
+  def self.score_conversion(test_name, viewed_alternative)
     self.update_all("conversions = conversions + 1", :lookup => self.calculate_lookup(test_name, viewed_alternative))
   end
 
-  def self.score_participation(test_name)
-    viewed_alternative = Abingo.find_alternative_for_user(test_name,
-      Abingo::Experiment.alternatives_for_test(test_name))
+  def self.score_participation(test_name, viewed_alternative)
     self.update_all("participants = participants + 1", :lookup => self.calculate_lookup(test_name, viewed_alternative))
   end
 

data/lib/abingo/controller/dashboard.rb

@@ -1,12 +1,8 @@
+require 'action_controller'
 class Abingo
   module Controller
     module Dashboard
-
-      if Rails::VERSION::MAJOR <= 2
-        ActionController::Base.view_paths.unshift File.join(File.dirname(__FILE__), "../views")
-      else
-        ActionController::Base.prepend_view_path File.join(File.dirname(__FILE__), "../views")
-      end
+      ActionController::Base.prepend_view_path File.join(File.dirname(__FILE__), "../views")
 
       def index
         @experiments = Abingo::Experiment.all

data/lib/abingo/experiment.rb

@@ -76,11 +76,7 @@ class Abingo::Experiment < ActiveRecord::Base
         cloned_alternatives_array -= [alt]
       end
       experiment.status = "Live"
-      if Rails::VERSION::MAJOR == 2
-        experiment.save(false)  #Calling the validation here causes problems b/c of transaction.
-      else
-        experiment.save(:validate => false)
-      end
+      experiment.save(:validate => false)
       Abingo.cache.write("Abingo::Experiment::exists(#{test_name})".gsub(" ", "_"), 1)
 
       #This might have issues in very, very high concurrency environments...

data/lib/abingo/version.rb

@@ -1,3 +1,3 @@
 class Abingo
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

data/lib/abingo_sugar.rb

@@ -5,15 +5,15 @@
 
 module AbingoSugar
 
-  def ab_test(test_name, alternatives = nil, options = {})
+  def ab_test(abingo, test_name, alternatives = nil, options = {})
     if (Abingo.options[:enable_specification] && !params[test_name].nil?)
       choice = params[test_name]
     elsif (Abingo.options[:enable_override_in_session] && !session[test_name].nil?)
       choice = session[test_name]
     elsif (alternatives.nil?)
-      choice = Abingo.flip(test_name)
+      choice = abingo.flip(test_name)
     else
-      choice = Abingo.test(test_name, alternatives, options)
+      choice = abingo.test(test_name, alternatives, options)
     end
 
     if block_given?
@@ -23,19 +23,19 @@ module AbingoSugar
     end
   end
 
-  def bingo!(test_name, options = {})
-    Abingo.bingo!(test_name, options)
+  def bingo!(abingo, test_name, options = {})
+    abingo.bingo!(test_name, options)
   end
 
   #Mark the user as a human.
-  def abingo_mark_human
+  def abingo_mark_human(abingo)
     textual_result = "1"
     begin
       a = params[:a].to_i
       b = params[:b].to_i
       c = params[:c].to_i
       if (request.method == :post && (a + b == c))
-        Abingo.human!
+        abingo.human!
       else
         textual_result = "0"
       end
@@ -43,7 +43,6 @@ module AbingoSugar
       textual_result = "0"
     end
     render :text => textual_result, :layout => false #Not actually used by browser
-
   end
 
-end
+end

data/lib/abingo_view_helper.rb

@@ -2,32 +2,28 @@
 
 module AbingoViewHelper
 
-  def ab_test(test_name, alternatives = nil, options = {}, &block)
+  def ab_test(abingo, test_name, alternatives = nil, options = {}, &block)
 
     if (Abingo.options[:enable_specification] && !params[test_name].nil?)
       choice = params[test_name]
     elsif (Abingo.options[:enable_override_in_session] && !session[test_name].nil?)
       choice = session[test_name]
     elsif (alternatives.nil?)
-      choice = Abingo.flip(test_name)
+      choice = abingo.flip(test_name)
     else
-      choice = Abingo.test(test_name, alternatives, options)
+      choice = abingo.test(test_name, alternatives, options)
     end
 
     if block
       content_tag = capture(choice, &block)
-      unless Rails::VERSION::MAJOR >= 3
-        block_called_from_erb?(block) ? concat(content_tag) : content_tag
-      else
-        content_tag
-      end
+      block_called_from_erb?(block) ? concat(content_tag) : content_tag
     else
       choice
     end
   end
 
-  def bingo!(test_name, options = {})
-    Abingo.bingo!(test_name, options)
+  def bingo!(abingo, test_name, options = {})
+    abingo.bingo!(test_name, options)
   end
 
   #This causes an AJAX post against the URL.  That URL should call Abingo.human!
@@ -41,5 +37,5 @@ module AbingoViewHelper
     end
     script.nil? ? "" : %Q|<script type="text/javascript">#{script}</script>|
   end
-  
-end
+
+end

data/test/abingo_test.rb

@@ -1,14 +1,20 @@
-require 'test_helper'
+require_relative 'test_helper'
 
-class AbingoTest < ActiveSupport::TestCase
+class AbingoTest < Test::Unit::TestCase
 
-  #Wipes cache, D/B prior to doing a test run.
-  Abingo.cache.clear
-  Abingo::Experiment.delete_all
-  Abingo::Alternative.delete_all
+  setup do
+    Abingo.options = {}
+  end
+
+  teardown do
+    Abingo.cache.clear
+    Abingo::Experiment.delete_all
+    Abingo::Alternative.delete_all
+  end
 
   test "identity automatically assigned" do
-    assert Abingo.identity != nil
+    abingo = Abingo.identify
+    assert abingo.identity != nil
   end
 
   test "alternative parsing" do
@@ -23,31 +29,35 @@ class AbingoTest < ActiveSupport::TestCase
     assert_equal 0, Abingo::Experiment.count
     assert_equal 0, Abingo::Alternative.count
     alternatives = %w{A B}
-    alternative_selected = Abingo.test("unit_test_sample_A", alternatives)
+    abingo = Abingo.identify
+    alternative_selected = abingo.test("unit_test_sample_A", alternatives)
     assert_equal 1, Abingo::Experiment.count
     assert_equal 2, Abingo::Alternative.count
     assert alternatives.include?(alternative_selected)
   end
 
   test "exists works right" do
-    Abingo.test("exist works right", %w{does does_not})
+    abingo = Abingo.identify
+    abingo.test("exist works right", %w{does does_not})
     assert Abingo::Experiment.exists?("exist works right")
   end
 
   test "alternatives picked consistently" do
-    alternative_picked = Abingo.test("consistency_test", 1..100)
+    abingo = Abingo.identify
+    alternative_picked = abingo.test("consistency_test", 1..100)
     100.times do
-      assert_equal alternative_picked, Abingo.test("consistency_test", 1..100)
+      assert_equal alternative_picked, abingo.test("consistency_test", 1..100)
     end
   end
 
   test "participation works" do
     new_tests = %w{participationA participationB participationC}
+    abingo = Abingo.identify
     new_tests.map do |test_name|
-      Abingo.test(test_name, 1..5)
+      abingo.test(test_name, 1..5)
     end
 
-    participating_tests = Abingo.cache.read("Abingo::participating_tests::#{Abingo.identity}") || []
+    participating_tests = Abingo.cache.read("Abingo::participating_tests::#{abingo.identity}") || []
 
     new_tests.map do |test_name|
       assert participating_tests.include? test_name
@@ -56,7 +66,8 @@ class AbingoTest < ActiveSupport::TestCase
 
   test "participants counted" do
     test_name = "participants_counted_test"
-    alternative = Abingo.test(test_name, %w{a b c})
+    abingo = Abingo.identify
+    alternative = abingo.test(test_name, %w{a b c})
 
     ex = Abingo::Experiment.find_by_test_name(test_name)
     lookup = Abingo::Alternative.calculate_lookup(test_name, alternative)
@@ -67,14 +78,15 @@ class AbingoTest < ActiveSupport::TestCase
 
   test "conversion tracking by test name" do
     test_name = "conversion_test_by_name"
-    alternative = Abingo.test(test_name, %w{a b c})
-    Abingo.bingo!(test_name)
+    abingo = Abingo.identify
+    alternative = abingo.test(test_name, %w{a b c})
+    abingo.bingo!(test_name)
     ex = Abingo::Experiment.find_by_test_name(test_name)
     lookup = Abingo::Alternative.calculate_lookup(test_name, alternative)
     chosen_alt = Abingo::Alternative.find_by_lookup(lookup)
     assert_equal 1, ex.conversions
     assert_equal 1, chosen_alt.conversions
-    Abingo.bingo!(test_name)
+    abingo.bingo!(test_name)
 
     #Should still only have one because this conversion should not be double counted.
     #We haven't specified that in the test options.
@@ -82,13 +94,14 @@ class AbingoTest < ActiveSupport::TestCase
   end
 
   test "conversion tracking by conversion name" do
+    abingo = Abingo.identify
     conversion_name = "purchase"
     tests = %w{conversionTrackingByConversionNameA conversionTrackingByConversionNameB conversionTrackingByConversionNameC}
     tests.map do |test_name|
-      Abingo.test(test_name, %w{A B}, :conversion => conversion_name)
+      abingo.test(test_name, %w{A B}, :conversion => conversion_name)
     end
 
-    Abingo.bingo!(conversion_name)
+    abingo.bingo!(conversion_name)
     tests.map do |test_name|
       assert_equal 1, Abingo::Experiment.find_by_test_name(test_name).conversions
     end
@@ -97,7 +110,8 @@ class AbingoTest < ActiveSupport::TestCase
   test "short circuiting works" do
     conversion_name = "purchase"
     test_name = "short circuit test"
-    alt_picked = Abingo.test(test_name, %w{A B}, :conversion => conversion_name)
+    abingo = Abingo.identify
+    alt_picked = abingo.test(test_name, %w{A B}, :conversion => conversion_name)
     ex = Abingo::Experiment.find_by_test_name(test_name)
     alt_not_picked = (%w{A B} - [alt_picked]).first
 
@@ -105,14 +119,12 @@ class AbingoTest < ActiveSupport::TestCase
 
     ex.reload
     assert_equal "Finished", ex.status
-    
-    Abingo.bingo!(test_name)  #Should not be counted, test is over.
+
+    abingo.bingo!(test_name)  #Should not be counted, test is over.
     assert_equal 0, ex.conversions
 
-    old_identity = Abingo.identity
-    Abingo.identity = "shortCircuitTestNewIdentity"
-    Abingo.test(test_name, %w{A B}, :conversion => conversion_name)
-    Abingo.identity = old_identity
+    new_bingo = Abingo.identify("shortCircuitTestNewIdentity")
+    new_bingo.test(test_name, %w{A B}, :conversion => conversion_name)
     ex.reload
     assert_equal 1, ex.participants  #Original identity counted, new identity not counted b/c test stopped
   end
@@ -125,35 +137,56 @@ class AbingoTest < ActiveSupport::TestCase
     threads = []
     5.times do
       threads << Thread.new do
-        Abingo.test(test_name, alternatives, conversion_name)
-        1
+        abingo = Abingo.identify
+        abingo.test(test_name, alternatives, :conversion => conversion_name)
+        ActiveRecord::Base.connection.close
       end
     end
-    sleep(10)
+    threads.each(&:join)
     assert_equal 1, Abingo::Experiment.count_by_sql(["select count(id) from experiments where test_name = ?", test_name])
   end
 
+  test "proper conversions with concurrency" do
+    test_name = "conversion_concurrency_test"
+    alternatives = %w{foo bar}
+    threads = []
+    alternatives.size.times do |i|
+      threads << Thread.new do
+        abingo = Abingo.identify(i)
+        abingo.test(test_name, alternatives)
+        abingo.bingo!(test_name)
+        sleep(0.3) if i == 0
+        ActiveRecord::Base.connection.close
+      end
+    end
+    threads.each(&:join)
+    ex = Abingo::Experiment.find_by_test_name(test_name)
+    ex.alternatives.each do |alternative|
+      assert_equal 1, alternative.conversions
+    end
+  end
+
   test "non-humans are ignored for participation and conversions if not explicitly counted" do
     Abingo.options[:count_humans_only] = true
     Abingo.options[:expires_in] = 1.hour
     Abingo.options[:expires_in_for_bots] = 3.seconds
-    first_identity = Abingo.identity = "unsure_if_human#{Time.now.to_i}"
+    first_identity = Abingo.identify("unsure_if_human#{Time.now.to_i}")
     test_name = "are_you_a_human"
-    Abingo.test(test_name, %w{does_not matter})
+    first_identity.test(test_name, %w{does_not matter})
 
-    assert_false Abingo.is_human?, "Identity not marked as human yet."
+    assert !first_identity.is_human?, "Identity not marked as human yet."
 
     ex = Abingo::Experiment.find_by_test_name(test_name)
-    Abingo.bingo!(test_name)
+    first_identity.bingo!(test_name)
     assert_equal 0, ex.participants, "Not human yet, so should have no participants."
     assert_equal 0, ex.conversions, "Not human yet, so should have no conversions."
 
-    Abingo.human!
-    
+    first_identity.human!
+
     #Setting up second participant who doesn't convert.
-    Abingo.identity = "unsure_if_human_2_#{Time.now.to_i}"
-    Abingo.test(test_name, %w{does_not matter})
-    Abingo.human!
+    second_identity = Abingo.identify("unsure_if_human_2_#{Time.now.to_i}")
+    second_identity.test(test_name, %w{does_not matter})
+    second_identity.human!
 
     ex = Abingo::Experiment.find_by_test_name(test_name)
     assert_equal 2, ex.participants, "Now that we're human, our participation should matter."
@@ -161,27 +194,27 @@ class AbingoTest < ActiveSupport::TestCase
   end
 
   test "Participating tests for a given identity" do
-    Abingo.identity = "test_participant"
+    abingo = Abingo.identify("test_participant")
     test_names = (1..3).map {|t| "participating_test_test_name #{t}"}
     test_alternatives = %w{yes no}
-    test_names.each {|test_name| Abingo.test(test_name, test_alternatives)}
+    test_names.each {|test_name| abingo.test(test_name, test_alternatives)}
     ex = Abingo::Experiment.last
     ex.end_experiment!("no")  #End final of 3 tests, leaving 2 presently running
 
-    assert_equal 2, Abingo.participating_tests.size  #Pairs for two tests
-    Abingo.participating_tests.each do |key, value|
+    assert_equal 2, abingo.participating_tests.size  #Pairs for two tests
+    abingo.participating_tests.each do |key, value|
       assert test_names.include? key
       assert test_alternatives.include? value
     end
-    
-    assert_equal 3, Abingo.participating_tests(false).size #pairs for three tests
-    Abingo.participating_tests(false).each do |key, value|
+
+    assert_equal 3, abingo.participating_tests(false).size #pairs for three tests
+    abingo.participating_tests(false).each do |key, value|
       assert test_names.include? key
       assert test_alternatives.include? value
     end
 
-    Abingo.identity = "test_nonparticipant"
-    assert_equal({}, Abingo.participating_tests)
+    non_participant = Abingo.identify("test_nonparticipant")
+    assert_equal({}, non_participant.participating_tests)
   end
 
 end

data/test/test_helper.rb

@@ -1,34 +1,59 @@
-require 'rubygems'
-require 'rails'
+#require 'rubygems'
+#require 'rails'
+#
+#require 'rails/all'
+require 'test/unit'
+require 'contest'
+require 'pg'
+require 'active_support/cache'
+require 'active_support/cache/memory_store'
+require_relative '../lib/abingo'
+ActiveRecord::Base.establish_connection(
+  :adapter => "postgresql",
+  :database => "abingo-test")
+ActiveRecord::Schema.define do
+  create_table "experiments", :force => true do |t|
+    t.string "test_name"
+    t.string "status"
+    t.timestamps
+  end
 
-if Rails::VERSION::MAJOR.to_i >= 3
-  require 'rails/all'
-  require 'test/unit'
+  add_index "experiments", "test_name"
+  #add_index "experiments", "created_on"
 
-  require 'active_support'
-  require 'active_support/railtie'
-  require 'active_support/core_ext'
-  require 'active_support/test_case'
+  create_table "alternatives", :force => true do |t|
+    t.integer :experiment_id
+    t.string :content
+    t.string :lookup, :limit => 32
+    t.integer :weight, :default => 1
+    t.integer :participants, :default => 0
+    t.integer :conversions, :default => 0
+  end
 
-  require 'action_controller'
-  require 'action_controller/caching'
-  require 'active_record'
-  require 'active_record/base'
-  
-  require 'rails'
-  require 'rails/application'
-
-  require 'rails/railtie'
-
-  #We need to load the whole Rails application to properly initialize Rails.cache and other constants.  Oh boy.
-  #We're going to parse it out of RAILS_PATH/config.ru using a little metaprogramming magic.
-  require ::File.expand_path('../../../../../config/environment',  __FILE__)
-  lines = File.open(::File.expand_path('../../../../../config.ru',  __FILE__)).readlines.select {|a| a =~ /::Application/}
-  application_name = lines.first[/[^ ]*::/].gsub(":", "")
-  Kernel.const_get(application_name).const_get("Application").initialize!
-else
-  #Rails 2 testing
-  require 'active_support'
-  require 'active_support/test_case'
+  add_index "alternatives", "experiment_id"
+  add_index "alternatives", "lookup"  #Critical for speed, since we'll primarily be updating by that.
 end
-
+Abingo.cache = ActiveSupport::Cache::MemoryStore.new
+#
+#require 'active_support'
+#require 'active_support/railtie'
+#require 'active_support/core_ext'
+#require 'active_support/test_case'
+#
+#require 'action_controller'
+#require 'action_controller/caching'
+#require 'active_record'
+#require 'active_record/base'
+#
+#require 'rails'
+#require 'rails/application'
+#
+#require 'rails/railtie'
+#
+##We need to load the whole Rails application to properly initialize Rails.cache and other constants.  Oh boy.
+##We're going to parse it out of RAILS_PATH/config.ru using a little metaprogramming magic.
+#require ::File.expand_path('../../../../../config/environment',  __FILE__)
+#lines = File.open(::File.expand_path('../../../../../config.ru',  __FILE__)).readlines.select {|a| a =~ /::Application/}
+#application_name = lines.first[/[^ ]*::/].gsub(":", "")
+#Kernel.const_get(application_name).const_get("Application").initialize!
+#

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: abingo
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70225544745500 !ruby/object:Gem::Requirement
+  requirement: &70288958337380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70225544745500
+  version_requirements: *70288958337380
 description: A split testing framework for Rails 3.x.x
 email:
 - me@glenngillen.com
@@ -50,10 +50,8 @@ files:
 - lib/abingo/views/dashboard/index.erb
 - lib/abingo_sugar.rb
 - lib/abingo_view_helper.rb
-- strip.rb
 - test/abingo_test.rb
 - test/test_helper.rb
-- uninstall.rb
 homepage: https://github.com/glenngillen/abingo
 licenses: []
 post_install_message: 
@@ -68,7 +66,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3437429555840451377
+      hash: -1837967124242571080
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -77,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -3437429555840451377
+      hash: -1837967124242571080
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.15

data/strip.rb

@@ -1,11 +0,0 @@
-require 'find'
-require 'fileutils'
-def find_and_delete(path, pattern)
-  Find.find(path) do |f|
-	if !File.file?(f) and f[pattern]
-	  FileUtils.rm_rf(f)
-	end
-  end
-end
-# print all the ruby files
-find_and_delete(".", /\.svn$/)

data/uninstall.rb

@@ -1 +0,0 @@
-# Uninstall hook code here