sinmetrics 0.0.4 → 0.0.5

data/.gitignore

@@ -0,0 +1,3 @@
+coverage
+pkg
+*.gemspec

data/Rakefile

@@ -1,11 +1,29 @@
 require 'rubygems'
 require 'rake'
-require 'echoe'
 
-Echoe.new('sinmetrics', '0.0.4') do |p|
-  p.description    = "Some metrics helpers for the Sinatra web framework"
-  p.url            = "http://github.com/lpetre/sinmetrics"
-  p.author         = "Luke Petre"
-  p.email          = "lpetre@gmail.com"
-  p.rdoc_pattern   = []
+task :default => :spec
+
+begin
+  require 'spec/rake/spectask'
+  desc "Run all examples"
+  Spec::Rake::SpecTask.new('spec') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ['-cubfs']
+  end
+
+  Spec::Rake::SpecTask.new('spec:rcov') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = ['-cfs']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'gems,spec/,examples/']
+  end
+  
+  require 'spec/rake/verify_rcov'
+  RCov::VerifyTask.new(:verify_rcov => 'spec:rcov') do |t|
+    t.threshold = 77.0
+    t.require_exact_threshold = false
+  end
+  
+rescue LoadError
+  puts "spec targets require RSpec"
 end

data/lib/sinmetrics.rb

@@ -7,5 +7,6 @@ end
 
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/sinmetrics')
 
+require 'abingo'
 require 'kontagent'
 require 'mixpanel'

data/lib/sinmetrics/abingo.rb

@@ -0,0 +1,274 @@
+#This class is outside code's main interface into the ABingo A/B testing framework.
+#Unless you're fiddling with implementation details, it is the only one you need worry about.
+
+#Usage of ABingo, including practical hints, is covered at http://www.bingocardcreator.com/abingo
+
+begin
+  require 'sinatra/base'
+  require 'active_support'
+rescue LoadError
+  retry if require 'rubygems'
+  raise
+end
+
+
+module Sinatra  
+  class AbingoObject
+    
+    #Defined options:
+    #  :enable_specification => if true, allow params[test_name] to override the calculated value for a test.
+    def initialize app={}
+      if app.respond_to?(:options)
+        @app = app
+        [:identity, :enable_specification, :cache, :salt].each do |var|
+          begin
+            instance_variable_set("@#{var}", app.options.send("abingo_#{var}"))
+          rescue NoMethodError
+          end
+        end
+      else
+        [:identity, :enable_specification, :cache, :salt].each do |var|
+          instance_variable_set("@#{var}", app[var]) if app.has_key?(var)
+        end
+      end      
+      @identity ||= rand(10 ** 10).to_i.to_s
+      @cache ||= ActiveSupport::Cache::MemoryStore.new
+      @salt ||= ''
+    end
+
+    attr_reader :app, :enable_specification, :cache, :salt
+    attr_accessor :identity
+
+    #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 flip(test_name)
+      if block_given?
+        yield(test(test_name, [true, false]))
+      else
+        test(test_name, [true, false])
+      end
+    end
+
+    #This is the meat of A/Bingo.
+    #options accepts
+    #  :multiple_participation (true or false)
+    #  :conversion  name of conversion to listen for  (alias: conversion_name)
+    def test(test_name, alternatives, options = {})
+      short_circuit = cache.read("Abingo::Experiment::short_circuit(#{test_name})".gsub(" ", "_"))
+      unless short_circuit.nil?
+        return short_circuit  #Test has been stopped, pick canonical alternative.
+      end
+    
+      unless Experiment.exists?(self, test_name)
+        conversion_name = options[:conversion] || options[:conversion_name]
+        Experiment.start_experiment!(self, test_name, parse_alternatives(alternatives), conversion_name)
+      end
+
+      choice = find_alternative_for_user(test_name, alternatives)
+      participating_tests = cache.read("Abingo::participating_tests::#{identity}") || []
+    
+      #Set this user to participate in this experiment, and increment participants count.
+      if options[:multiple_participation] || !(participating_tests.include?(test_name))
+        participating_tests = participating_tests.dup if participating_tests.frozen?
+        unless participating_tests.include?(test_name)
+          participating_tests << test_name
+          cache.write("Abingo::participating_tests::#{identity}", participating_tests)
+        end
+        Alternative.score_participation(self, test_name)
+      end
+
+      if block_given?
+        yield(choice)
+      else
+        choice
+      end
+    end
+
+    #Scores conversions for tests.
+    #test_name_or_array supports three types of input:
+    #
+    #A conversion name: scores a conversion for any test the user is participating in which
+    #  is listening to the specified conversion.
+    #
+    #A test name: scores a conversion for the named test if the user is participating in it.
+    #
+    #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 bingo!(name = nil, options = {})
+      if name.kind_of? Array
+        name.map do |single_test|
+          self.bingo!(single_test, options)
+        end
+      else
+        if name.nil?
+          #Score all participating tests
+          participating_tests = cache.read("Abingo::participating_tests::#{identity}") || []
+          participating_tests.each do |participating_test|
+            self.bingo!(participating_test, options)
+          end
+        else #Could be a test name or conversion name.
+          conversion_name = name.gsub(" ", "_")
+          tests_listening_to_conversion = cache.read("Abingo::tests_listening_to_conversion#{conversion_name}")
+          if tests_listening_to_conversion
+            if tests_listening_to_conversion.size > 1
+              tests_listening_to_conversion.map do |individual_test|
+                self.score_conversion!(individual_test.to_s, options)
+              end
+            elsif tests_listening_to_conversion.size == 1
+              test_name_str = tests_listening_to_conversion.first.to_s
+              self.score_conversion!(test_name_str, options)
+            end
+          else
+            #No tests listening for this conversion.  Assume it is just a test name.
+            test_name_str = name.to_s
+            self.score_conversion!(test_name_str, options)
+          end
+        end
+      end
+    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)
+    #so it can be as complicated as we want.
+    #   Integer => a number 1 through N
+    #   Range   => a number within the range
+    #   Array   => an element of the array.
+    #   Hash    => assumes a hash of something to int.  We pick one of the 
+    #              somethings, weighted accorded to the ints provided.  e.g.
+    #              {:a => 2, :b => 3} produces :a 40% of the time, :b 60%.
+    #
+    #Alternatives are always represented internally as an array.
+    def parse_alternatives(alternatives)
+      if alternatives.kind_of? Array
+        return alternatives
+      elsif alternatives.kind_of? Integer
+        return (1..alternatives).to_a
+      elsif alternatives.kind_of? Range
+        return alternatives.to_a
+      elsif alternatives.kind_of? Hash
+        alternatives_array = []
+        alternatives.each do |key, value|
+          if value.kind_of? Integer
+            alternatives_array += [key] * value
+          else
+            raise "You gave a hash with #{key} => #{value} as an element.  The value must be an integral weight."
+          end
+        end
+        return alternatives_array
+      else
+        raise "I don't know how to turn [#{alternatives}] into an array of alternatives."
+      end
+    end
+
+    def 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)
+      end
+      alternative_array
+    end
+
+    def find_alternative_for_user(test_name, alternatives)
+      alternatives_array = 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 modulo_choice(test_name, choices_count)
+      Digest::MD5.hexdigest(salt.to_s + test_name + self.identity.to_s).to_i(16) % choices_count
+    end
+
+    def score_conversion!(test_name, options = {})
+      test_name.gsub!(" ", "_")
+      participating_tests = cache.read("Abingo::participating_tests::#{identity}") || []
+      if options[:assume_participation] || participating_tests.include?(test_name)
+        cache_key = "Abingo::conversions(#{identity},#{test_name}"
+        if options[:multiple_conversions] || !cache.read(cache_key)
+          Alternative.score_conversion(self, test_name)
+          if cache.exist?(cache_key)
+            cache.increment(cache_key)
+          else
+            cache.write(cache_key, 1)
+          end
+        end
+      end
+    end
+  end
+  
+  module AbingoObject::ConversionRate
+    def conversion_rate
+      1.0 * conversions / participants
+    end
+
+    def pretty_conversion_rate
+      sprintf("%4.2f%%", conversion_rate * 100)
+    end
+  end
+  
+  module AbingoHelper
+    def abingo
+      env['abingo.helper'] ||= AbingoObject.new(self)
+    end
+    
+    def ab_test(test_name, alternatives = nil, options = {})
+      if (abingo.enable_specification && !params[test_name].blank?)
+        choice = params[test_name]
+      elsif (alternatives.nil?)
+        choice = abingo.flip(test_name)
+      else
+        choice = abingo.test(test_name, alternatives, options)
+      end
+
+      if block_given?
+        yield(choice)
+      else
+        choice
+      end
+    end
+    
+    alias ab abingo
+  end
+  
+  class AbingoSettings
+    def initialize app, &blk
+      @app = app
+      instance_eval &blk
+    end
+    %w[identity backend enable_specification cache salt].each do |param|
+      class_eval %[
+        def #{param} val, &blk
+          @app.set :abingo_#{param}, val
+        end
+      ]
+    end
+  end
+
+  module Abingo
+    def abingo &blk
+      AbingoSettings.new(self, &blk)
+    end
+    
+    def self.registered app
+      app.helpers AbingoHelper
+    end
+  end
+  
+  Application.register Abingo
+end
+
+Abingo = Sinatra::AbingoObject
+
+require 'dm-core'
+require 'dm-aggregates'
+require 'dm-observer'
+require 'dm-timestamps'
+require 'dm-adjust'
+require 'abingo/statistics'
+require 'abingo/alternative'
+require 'abingo/experiment'

data/lib/sinmetrics/abingo/alternative.rb

@@ -0,0 +1,30 @@
+class Abingo::Alternative
+  include Abingo::ConversionRate
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :content, String
+  property :lookup, String, :length => 32, :index => true
+  property :weight, Integer, :default => 1
+  property :participants, Integer, :default => 0
+  property :conversions, Integer, :default => 0
+
+  belongs_to :experiment
+
+  def self.calculate_lookup(abingo, test_name, alternative_name)
+    Digest::MD5.hexdigest(abingo.salt + test_name + alternative_name.to_s)
+  end
+
+  def self.score_conversion(abingo, test_name)
+    viewed_alternative = abingo.find_alternative_for_user(test_name,
+      Abingo::Experiment.alternatives_for_test(abingo, test_name))
+    all(:lookup => self.calculate_lookup(abingo, test_name, viewed_alternative)).adjust!(:conversions => 1)
+  end
+
+  def self.score_participation(abingo, test_name)
+    viewed_alternative = abingo.find_alternative_for_user(test_name,
+      Abingo::Experiment.alternatives_for_test(abingo, test_name))
+    all(:lookup => self.calculate_lookup(abingo, test_name, viewed_alternative)).adjust!(:participants => 1)
+  end
+
+end

data/lib/sinmetrics/abingo/experiment.rb

@@ -0,0 +1,103 @@
+class Abingo::Experiment
+  include DataMapper::Resource
+  include Abingo::Statistics
+  include Abingo::ConversionRate
+
+  property :test_name, String, :key => true
+  property :status, String
+  
+  has n, :alternatives, "Alternative"
+
+  def cache_keys
+  ["Abingo::Experiment::exists(#{test_name})".gsub(" ", "_"),
+    "Abingo::Experiment::#{test_name}::alternatives".gsub(" ","_"),
+    "Abingo::Experiment::short_circuit(#{test_name})".gsub(" ", "_")
+  ]
+  end
+  
+  def before_destroy
+    cache_keys.each do |key|
+      Abingo.cache.delete key
+    end
+    true
+  end
+
+  def participants
+    alternatives.sum(:participants)
+  end
+
+  def conversions
+    alternatives.sum(:conversions)
+  end
+
+  def best_alternative
+    alternatives.max do |a,b|
+      a.conversion_rate <=> b.conversion_rate
+    end
+  end
+
+  def self.exists?(abingo, test_name)
+    cache_key = "Abingo::Experiment::exists(#{test_name})".gsub(" ", "_")
+    ret = abingo.cache.fetch(cache_key) do
+      count = Abingo::Experiment.count(:conditions => {:test_name => test_name})
+      count > 0 ? count : nil
+    end
+    (!ret.nil?)
+  end
+
+  def self.alternatives_for_test(abingo, test_name)
+    cache_key = "Abingo::#{test_name}::alternatives".gsub(" ","_")    
+    abingo.cache.fetch(cache_key) do
+      experiment = Abingo::Experiment.first(:test_name => test_name)      
+      alternatives_array = abingo.cache.fetch(cache_key) do
+        tmp_array = experiment.alternatives.map do |alt|
+          [alt.content, alt.weight]
+        end
+        tmp_hash = tmp_array.inject({}) {|hash, couplet| hash[couplet[0]] = couplet[1]; hash}
+        abingo.parse_alternatives(tmp_hash)
+      end
+      alternatives_array
+    end
+  end
+
+  def self.start_experiment!(abingo, test_name, alternatives_array, conversion_name = nil)
+    conversion_name ||= test_name
+    conversion_name.gsub!(" ", "_")
+    cloned_alternatives_array = alternatives_array.clone
+    Abingo::Experiment.transaction do |txn|
+      experiment = Abingo::Experiment.first_or_create(:test_name => test_name)
+      experiment.alternatives.destroy  #Blows away alternatives for pre-existing experiments.
+      while (cloned_alternatives_array.size > 0)
+        alt = cloned_alternatives_array[0]
+        weight = cloned_alternatives_array.size - (cloned_alternatives_array - [alt]).size
+        experiment.alternatives << Abingo::Alternative.new(:content => alt, :weight => weight,
+          :lookup => Abingo::Alternative.calculate_lookup(abingo, test_name, alt))
+        cloned_alternatives_array -= [alt]
+      end
+      experiment.status = "Live"
+      experiment.save
+      abingo.cache.write("Abingo::Experiment::exists(#{test_name})".gsub(" ", "_"), 1)
+
+      #This might have issues in very, very high concurrency environments...
+
+      tests_listening_to_conversion = abingo.cache.read("Abingo::tests_listening_to_conversion#{conversion_name}") || []
+      tests_listening_to_conversion = tests_listening_to_conversion.dup if tests_listening_to_conversion.frozen?
+      tests_listening_to_conversion << test_name unless tests_listening_to_conversion.include? test_name
+      abingo.cache.write("Abingo::tests_listening_to_conversion#{conversion_name}", tests_listening_to_conversion)
+      experiment
+    end
+  end
+
+  def end_experiment!(abingo, final_alternative, conversion_name = nil)
+    conversion_name ||= test_name
+    Abingo::Experiment.transaction do
+      alternatives.each do |alternative|
+        alternative.lookup = "Experiment completed.  #{alternative.id}"
+        alternative.save!
+      end
+      update(:status => "Finished")
+      abingo.cache.write("Abingo::Experiment::short_circuit(#{test_name})".gsub(" ", "_"), final_alternative)
+    end
+  end
+
+end

data/lib/sinmetrics/abingo/statistics.rb

@@ -0,0 +1,90 @@
+#Designed to be included into Abingo::Experiment, but you can feel free to adapt this
+#to anything you want.
+
+module Abingo::Statistics
+
+  HANDY_Z_SCORE_CHEATSHEET = [[0.10, 1.29], [0.05, 1.65], [0.01, 2.33], [0.001, 3.08]]
+  
+  PERCENTAGES = {0.10 => '90%', 0.05 => '95%', 0.01 => '99%', 0.001 => '99.9%'}
+  
+  DESCRIPTION_IN_WORDS = {0.10 => 'fairly confident', 0.05 => 'confident',
+                         0.01 => 'very confident', 0.001 => 'extremely confident'}
+  def zscore
+    if alternatives.size != 2
+      raise "Sorry, can't currently automatically calculate statistics for A/B tests with > 2 alternatives."
+    end
+
+    if (alternatives[0].participants == 0) || (alternatives[1].participants == 0)
+      raise "Can't calculate the z score if either of the alternatives lacks participants."
+    end
+
+    cr1 = alternatives[0].conversion_rate
+    cr2 = alternatives[1].conversion_rate
+
+    n1 = alternatives[0].participants
+    n2 = alternatives[1].participants
+
+    numerator = cr1 - cr2
+    frac1 = cr1 * (1 - cr1) / n1
+    frac2 = cr2 * (1 - cr2) / n2
+
+    numerator / ((frac1 + frac2) ** 0.5)
+  end
+
+  def p_value
+    index = 0
+    z = zscore
+    z = z.abs
+    found_p = nil
+    while index < HANDY_Z_SCORE_CHEATSHEET.size do
+      if (z > HANDY_Z_SCORE_CHEATSHEET[index][1])
+        found_p = HANDY_Z_SCORE_CHEATSHEET[index][0]
+      end
+      index += 1
+    end
+    found_p
+  end
+
+  def is_statistically_significant?(p = 0.05)
+    p_value <= p
+  end
+  
+  def pretty_conversion_rate
+    sprintf("%4.2f%%", conversion_rate * 100)
+  end
+
+  def describe_result_in_words
+    begin
+      z = zscore
+    rescue
+      return "Could not execute the significance test because one or more of the alternatives has not been seen yet."
+    end
+    p = p_value
+
+    words = ""
+    if (alternatives[0].participants < 10) || (alternatives[1].participants < 10)
+      words += "Take these results with a grain of salt since your samples are so small: "
+    end
+
+    alts = alternatives - [best_alternative]
+    worst_alternative = alts.first
+
+    words += "The best alternative you have is: [#{best_alternative.content}], which had "
+    words += "#{best_alternative.conversions} conversions from #{best_alternative.participants} participants "
+    words += "(#{best_alternative.pretty_conversion_rate}).  The other alternative was [#{worst_alternative.content}], "
+    words += "which had #{worst_alternative.conversions} conversions from #{worst_alternative.participants} participants "
+    words += "(#{worst_alternative.pretty_conversion_rate}).  "
+
+    if (p.nil?)
+      words += "However, this difference is not statistically significant."
+    else
+      words += "This difference is #{PERCENTAGES[p]} likely to be statistically significant, which means you can be "
+      words += "#{DESCRIPTION_IN_WORDS[p]} that it is the result of your alternatives actually mattering, rather than "
+      words += "being due to random chance.  However, this statistical test can't measure how likely the currently "
+      words += "observed magnitude of the difference is to be accurate or not.  It only says \"better\", not \"better "
+      words += "by so much\"."
+    end
+    words
+  end
+
+end

data/spec/abingo_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe 'Sinatra Abingo' do
+  
+  it 'should be configurable standalone' do
+    ab = Abingo.new :identity => 'abcd'
+  end
+  
+  it 'should be configurable w/in sinatra' do
+    class AbingoApp < Sinatra::Base
+      register Sinatra::Abingo
+      abingo do
+        identity 'abcd'
+      end
+    end
+  
+    app = AbingoApp.new
+  end
+
+end
+
+describe 'Abingo Specs' do
+  before :each do
+    @abingo = Abingo.new
+  end
+    
+  it "should automatically assign identity" do
+    @abingo.identity.should_not be_nil
+  end
+
+  it "should parse alternatives" do
+    array = %w{a b c}
+    @abingo.parse_alternatives(array).should == array
+    @abingo.parse_alternatives(65).size.should == 65
+    @abingo.parse_alternatives(2..5).size.should == 4
+    @abingo.parse_alternatives(2..5).should_not include(1)
+  end
+  
+  it "should create experiments" do
+    Abingo::Experiment.count.should == 0
+    Abingo::Alternative.count.should == 0
+    alternatives = %w{A B}
+    alternative_selected = @abingo.test("unit_test_sample_A", alternatives)
+    Abingo::Experiment.count.should == 1
+    Abingo::Alternative.count.should == 2
+    alternatives.should include(alternative_selected)
+  end
+  
+  it "should be able to call exists" do
+    @abingo.test("exist words right", %w{does does_not})
+    Abingo::Experiment.exists?(@abingo, "exist words right").should be_true
+    Abingo::Experiment.exists?(@abingo, "other words right").should_not be_true
+  end
+  
+  it "should pick alternatives consistently" do
+    alternative_picked = @abingo.test("consistency_test", 1..100)
+    100.times do
+      @abingo.test("consistency_test", 1..100).should == alternative_picked
+    end
+  end
+
+  it "should have working participation" do
+    new_tests = %w{participationA participationB participationC}
+    new_tests.map do |test_name|
+      @abingo.test(test_name, 1..5)
+    end
+
+    participating_tests = @abingo.cache.read("Abingo::participating_tests::#{@abingo.identity}") || []
+
+    new_tests.map do |test_name|
+      participating_tests.should include(test_name)
+    end
+  end
+
+  it "should count participants" do
+    test_name = "participants_counted_test"
+    alternative = @abingo.test(test_name, %w{a b c})
+
+    ex = Abingo::Experiment.first(:test_name => test_name)
+    lookup = Abingo::Alternative.calculate_lookup(@abingo, test_name, alternative)
+    chosen_alt = Abingo::Alternative.first(:lookup => lookup)
+    ex.participants.should == 1
+    chosen_alt.participants.should == 1
+  end
+
+  it "should track conversions by test name" do
+    test_name = "conversion_test_by_name"
+    alternative = @abingo.test(test_name, %w{a b c})
+    @abingo.bingo!(test_name)
+    ex = Abingo::Experiment.first(:test_name => test_name)
+    lookup = Abingo::Alternative.calculate_lookup(@abingo, test_name, alternative)
+    chosen_alt = Abingo::Alternative.first(:lookup => lookup)
+    ex.conversions.should == 1
+    chosen_alt.conversions.should == 1
+
+    @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.
+    ex = Abingo::Experiment.first(:test_name => test_name)
+    ex.conversions.should == 1
+  end
+
+  it "should track conversions by conversion name" do
+    conversion_name = "purchase"
+    tests = %w{conversionTrackingByConversionNameA conversionTrackingByConversionNameB conversionTrackingByConversionNameC}
+    tests.map do |test_name|
+      @abingo.test(test_name, %w{A B}, :conversion => conversion_name)
+    end
+
+    @abingo.bingo!(conversion_name)
+    tests.map do |test_name|
+      ex = Abingo::Experiment.first(:test_name => test_name)
+      ex.conversions.should == 1
+    end
+  end
+
+  it "should be possible to short circuit tests" do
+    conversion_name = "purchase"
+    test_name = "short circuit test"
+    alt_picked = @abingo.test(test_name, %w{A B}, :conversion => conversion_name)
+    ex = Abingo::Experiment.first(:test_name => test_name)
+    alt_not_picked = (%w{A B} - [alt_picked]).first
+
+    ex.end_experiment!(@abingo, alt_not_picked, conversion_name)
+
+    ex.reload
+    ex.status.should == "Finished"
+    
+    @abingo.bingo!(test_name)  #Should not be counted, test is over.
+    ex.conversions.should == 0
+
+    old_identity = @abingo.identity
+    @abingo.identity = "shortCircuitTestNewIdentity"
+    @abingo.test(test_name, %w{A B}, :conversion => conversion_name)
+    @abingo.identity = old_identity
+    ex.reload
+
+    # Original identity counted, new identity not counted b/c test stopped
+    ex.participants.should == 1
+  end
+end  
+  

data/spec/kontagent_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'Sinatra Kontagent' do
+  
+  it 'should be configurable standalone' do
+    kontagent = Kontagent.new :api_key => '1234', :secret => '5678'
+  end
+  
+  it 'should be configurable w/in sinatra' do
+    class KontagentApp < Sinatra::Base
+      register Sinatra::Kontagent
+      kontagent do
+        api_key "1234"
+        secret  "5678"
+      end
+    end
+    
+    app = KontagentApp.new
+  end
+    
+  
+end  
+  

data/spec/mixpanel_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Sinatra Mixpanel' do  
+
+  it 'should be configurable standalone' do
+    mp = Mixpanel.new :token => "abcdefghijklmnopqrstuvwyxz"
+  end
+  
+  it 'should be configurable w/in sinatra' do
+    class MixpanelApp < Sinatra::Base
+      register Sinatra::Mixpanel
+      mixpanel do
+        token "abcdefghijklmnopqrstuvwyxz"
+      end
+    end
+    
+    app = MixpanelApp.new
+  end
+end  
+  

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'spec'
+require 'sinmetrics'
+
+# establish in-memory database for testing
+DataMapper.setup(:default, "sqlite3::memory:")
+
+Spec::Runner.configure do |config|
+  # reset database before each example is run
+  config.before(:each) { DataMapper.auto_migrate! }
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Luke Petre
@@ -14,11 +14,94 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-05 00:00:00 +01:00
+date: 2010-04-14 00:00:00 +01:00
 default_executable: 
-dependencies: []
-
-description: Some metrics helpers for the Sinatra web framework
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 2
+        version: 0.10.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: dm-aggregates
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 2
+        version: 0.10.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: dm-observer
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 2
+        version: 0.10.2
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: dm-timestamps
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 2
+        version: 0.10.2
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: dm-adjust
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 2
+        version: 0.10.2
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - 5
+        version: 2.3.5
+  type: :runtime
+  version_requirements: *id006
+description: A full-featured metrics extension for the sinatra webapp framework
 email: lpetre@gmail.com
 executables: []
 
@@ -27,25 +110,27 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- Manifest
+- .gitignore
 - README
 - Rakefile
 - lib/sinmetrics.rb
+- lib/sinmetrics/abingo.rb
+- lib/sinmetrics/abingo/alternative.rb
+- lib/sinmetrics/abingo/experiment.rb
+- lib/sinmetrics/abingo/statistics.rb
 - lib/sinmetrics/kontagent.rb
 - lib/sinmetrics/mixpanel.rb
-- sinmetrics.gemspec
+- spec/abingo_spec.rb
+- spec/kontagent_spec.rb
+- spec/mixpanel_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: http://github.com/lpetre/sinmetrics
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --line-numbers
-- --inline-source
-- --title
-- Sinmetrics
-- --main
-- README
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -60,15 +145,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version 
       segments: 
-      - 1
-      - 2
-      version: "1.2"
+      - 0
+      version: "0"
 requirements: []
 
-rubyforge_project: sinmetrics
+rubyforge_project: 
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Some metrics helpers for the Sinatra web framework
+summary: simple sinatra metrics extension
 test_files: []
 

data/Manifest

@@ -1,6 +0,0 @@
-Manifest
-README
-Rakefile
-lib/sinmetrics.rb
-lib/sinmetrics/kontagent.rb
-lib/sinmetrics/mixpanel.rb

data/sinmetrics.gemspec

@@ -1,29 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{sinmetrics}
-  s.version = "0.0.4"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Luke Petre"]
-  s.date = %q{2010-04-05}
-  s.description = %q{Some metrics helpers for the Sinatra web framework}
-  s.email = %q{lpetre@gmail.com}
-  s.files = ["Manifest", "README", "Rakefile", "lib/sinmetrics.rb", "lib/sinmetrics/kontagent.rb", "lib/sinmetrics/mixpanel.rb", "sinmetrics.gemspec"]
-  s.homepage = %q{http://github.com/lpetre/sinmetrics}
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Sinmetrics", "--main", "README"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{sinmetrics}
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Some metrics helpers for the Sinatra web framework}
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end