split 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.mdown

@@ -0,0 +1,177 @@
+# Split
+## Rack based split testing framework
+
+Split is a rack based ab testing framework designed to work with Rails, Sinatra or any other rack based app.
+
+Split is heavily inspired by the Abingo and Vanity rails ab testing plugins and Resque in its use of Redis.
+
+## Requirements
+
+Split uses redis as a datastore.
+
+If you're on OS X, Homebrew is the simplest way to install Redis:
+
+    $ brew install redis
+    $ redis-server /usr/local/etc/redis.conf
+
+You now have a Redis daemon running on 6379.
+
+## Setup
+
+If you are using bundler add split to your Gemfile:
+
+    gem 'split'
+
+Then run:
+
+    bundle install
+
+Otherwise install the gem:
+
+    gem install split
+
+and require it in your project:
+
+    require 'split'
+
+### Rails
+
+Split is autoloaded when rails starts up, as long as you've configured redis it will 'just work'.
+
+### Sinatra
+
+To configure sinatra with Split you need to enable sessions and mix in the helper methods. Add the following lines at the top of your sinatra app:
+
+    class MySinatraApp < Sinatra::Base
+      enable :sessions
+      helpers Split::Helper
+
+      get '/' do
+      ...
+    end
+
+## Usage
+
+To begin your ab test use the `ab_test` method, naming your experiment with the first argument and then the different variants which you wish to test on as the other arguments.
+
+`ab_test` returns one of the alternatives, if a user has already seen that test they will get the same alternative as before, which you can use to split your code on.
+
+It can be used to render different templates, show different text or any other case based logic.
+
+`finished` is used to make a completion of an experiment, or conversion.
+
+Example: View
+
+    <% ab_test("login_button", "/images/button1.jpg", "/images/button2.jpg") do |button_file| %>
+      <%= img_tag(button_file, :alt => "Login!") %>
+    <% end %>
+
+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)
+    end
+
+Example: Conversion tracking (in a controller!)
+
+    def buy_new_points
+      #some business logic
+      finished("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! <% finished("signup_page_redesign") >
+
+## Web Interface
+
+Split comes with a Sinatra-based front end to get an overview of how your experiments are doing.
+
+You can mount this inside your app using Rack::URLMap in your `config.ru`
+
+    require 'split/dashboard'
+
+    run Rack::URLMap.new \
+      "/"       => Your::App.new,
+      "/split" => Split::Dashboard.new
+
+You may want to password protect that page, you can do so with `Rack::Auth::Basic`
+
+    Split::Dashboard.use Rack::Auth::Basic do |username, password|
+      username == 'admin' && password == 'p4s5w0rd'
+    end
+
+## Configuration
+
+You may want to change the Redis host and port Split connects to, or
+set various other options at startup.
+
+Split has a `redis` setter which can be given a string or a Redis
+object. This means if you're already using Redis in your app, Split
+can re-use the existing connection.
+
+String: `Split.redis = 'localhost:6379'`
+
+Redis: `Split.redis = $redis`
+
+For our rails app we have a `config/initializers/split.rb` file where
+we load `config/split.yml` by hand and set the Redis information
+appropriately.
+
+Here's our `config/split.yml`:
+
+    development: localhost:6379
+    test: localhost:6379
+    staging: redis1.example.com:6379
+    fi: localhost:6379
+    production: redis1.example.com:6379
+
+And our initializer:
+
+    rails_root = ENV['RAILS_ROOT'] || File.dirname(__FILE__) + '/../..'
+    rails_env = ENV['RAILS_ENV'] || 'development'
+
+    split_config = YAML.load_file(rails_root + '/config/split.yml')
+    Split.redis = split_config[rails_env]
+
+## Namespaces
+
+If you're running multiple, separate instances of Split you may want
+to namespace the keyspaces so they do not overlap. This is not unlike
+the approach taken by many memcached clients.
+
+This feature is provided by the [redis-namespace][rs] library, which
+Split uses by default to separate the keys it manages from other keys
+in your Redis server.
+
+Simply use the `Split.redis.namespace` accessor:
+
+    Split.redis.namespace = "resque:GitHub"
+
+We recommend sticking this in your initializer somewhere after Redis
+is configured.
+
+## Contributors
+
+Special thanks to the following people for submitting patches:
+
+* Lloyd Pick
+* Jeffery Chupp
+
+## Note on Patches/Pull Requests
+
+ * Fork the project.
+ * Make your feature addition or bug fix.
+ * Add tests for it. This is important so I don't break it in a
+   future version unintentionally.
+ * Commit, do not mess with rakefile, version, or history.
+   (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+ * Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2011 Andrew Nesbitt. See LICENSE for details.
+
+
+n.b don't pass the same alternative twice!

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/lib/split.rb

@@ -0,0 +1,50 @@
+require 'rubygems'
+require 'split/experiment'
+require 'split/alternative'
+require 'split/helper'
+require 'redis/namespace'
+
+module Split
+  extend self
+  # Accepts:
+  #   1. A 'hostname:port' string
+  #   2. A 'hostname:port:db' string (to select the Redis db)
+  #   3. A 'hostname:port/namespace' string (to set the Redis namespace)
+  #   4. A redis URL string 'redis://host:port'
+  #   5. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`,
+  #      or `Redis::Namespace`.
+  def redis=(server)
+    if server.respond_to? :split
+      if server =~ /redis\:\/\//
+        redis = Redis.connect(:url => server, :thread_safe => true)
+      else
+        server, namespace = server.split('/', 2)
+        host, port, db = server.split(':')
+        redis = Redis.new(:host => host, :port => port,
+          :thread_safe => true, :db => db)
+      end
+      namespace ||= :split
+
+      @redis = Redis::Namespace.new(namespace, :redis => redis)
+    elsif server.respond_to? :namespace=
+        @redis = server
+    else
+      @redis = Redis::Namespace.new(:split, :redis => server)
+    end
+  end
+
+  # Returns the current Redis connection. If none has been created, will
+  # create a new one.
+  def redis
+    return @redis if @redis
+    self.redis = 'localhost:6379'
+    self.redis
+  end
+end
+
+if defined?(Rails)
+  class ActionController::Base
+    ActionController::Base.send :include, Split::Helper
+    ActionController::Base.helper Split::Helper
+  end
+end

data/lib/split/alternative.rb

@@ -0,0 +1,77 @@
+module Split
+  class Alternative
+    attr_accessor :name
+    attr_accessor :participant_count
+    attr_accessor :completed_count
+    attr_accessor :experiment_name
+
+    def initialize(name, experiment_name, counters = {})
+      @experiment_name = experiment_name
+      @name = name
+      @participant_count = counters['participant_count'].to_i
+      @completed_count = counters['completed_count'].to_i
+    end
+
+    def increment_participation
+      @participant_count +=1
+      self.save
+    end
+
+    def increment_completion
+      @completed_count +=1
+      self.save
+    end
+
+    def conversion_rate
+      return 0 if participant_count.zero?
+      (completed_count.to_f/participant_count.to_f)
+    end
+    
+    def z_score      
+      # CTR_E = the CTR within the experiment split
+      # CTR_C = the CTR within the control split
+      # E = the number of impressions within the experiment split
+      # C = the number of impressions within the control split
+      
+      experiment = Split::Experiment.find(@experiment_name)
+      control = experiment.alternatives[0]
+      alternative = self
+      
+      return 'N/A' if control.name == alternative.name
+      
+      ctr_e = alternative.conversion_rate
+      ctr_c = control.conversion_rate
+
+      e = alternative.participant_count
+      c = control.participant_count
+
+      standard_deviation = ((ctr_e / ctr_c**3) * ((e*ctr_e)+(c*ctr_c)-(ctr_c*ctr_e)*(c+e))/(c*e)) ** 0.5
+      
+      z_score = ((ctr_e / ctr_c) - 1) / standard_deviation
+    end
+
+    def save
+      if Split.redis.hgetall("#{experiment_name}:#{name}")
+        Split.redis.hset "#{experiment_name}:#{name}", 'participant_count', @participant_count
+        Split.redis.hset "#{experiment_name}:#{name}", 'completed_count', @completed_count
+      else
+        Split.redis.hmset "#{experiment_name}:#{name}", 'participant_count', 'completed_count', @participant_count, @completed_count
+      end
+    end
+
+    def self.find(name, experiment_name)
+      counters = Split.redis.hgetall "#{experiment_name}:#{name}"
+      self.new(name, experiment_name, counters)
+    end
+
+    def self.find_or_create(name, experiment_name)
+      self.find(name, experiment_name) || self.create(name, experiment_name)
+    end
+
+    def self.create(name, experiment_name)
+      alt = self.new(name, experiment_name)
+      alt.save
+      alt
+    end
+  end
+end

data/lib/split/dashboard.rb

@@ -0,0 +1,35 @@
+require 'sinatra/base'
+require 'split'
+
+module Split
+  class Dashboard < Sinatra::Base
+    dir = File.dirname(File.expand_path(__FILE__))
+
+    set :views,  "#{dir}/dashboard/views"
+    set :public, "#{dir}/dashboard/public"
+    set :static, true
+
+    helpers do
+      def url(*path_parts)
+        [ path_prefix, path_parts ].join("/").squeeze('/')
+      end
+
+      def path_prefix
+        request.env['SCRIPT_NAME']
+      end
+    end
+
+    get '/' do
+      @experiments = Split::Experiment.all
+      erb :index
+    end
+
+    post '/:experiment' do
+      @experiment = Split::Experiment.find(params[:experiment])
+      @alternative = Split::Alternative.find(params[:alternative], params[:experiment])
+      @experiment.winner = @alternative.name
+      @experiment.save
+      redirect url('/')
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+html, body, div, span, applet, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+a, abbr, acronym, address, big, cite, code,
+del, dfn, em, font, img, ins, kbd, q, s, samp,
+small, strike, strong, sub, sup, tt, var,
+dl, dt, dd, ul, li,
+form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td {
+	margin: 0;
+	padding: 0;
+	border: 0;
+	outline: 0;
+	font-weight: inherit;
+	font-style: normal;
+	font-size: 100%;
+	font-family: inherit;
+}
+
+:focus {
+	outline: 0;
+}
+
+body {
+	line-height: 1;
+}
+
+ul {
+	list-style: none;
+}
+
+table {
+	border-collapse: collapse;
+	border-spacing: 0;
+}
+
+caption, th, td {
+	text-align: left;
+	font-weight: normal;
+}
+
+blockquote:before, blockquote:after,
+q:before, q:after {
+	content: "";
+}
+
+blockquote, q {
+	quotes: "" "";
+}

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

@@ -0,0 +1,34 @@
+html { background:#efefef; font-family:Arial, Verdana, sans-serif; font-size:13px; }
+body { padding:0; margin:0; }
+
+.header { background:#000; padding:8px 5% 0 5%; border-bottom:1px solid #444;border-bottom:5px solid #0080FF;}
+.header h1 { color:#333; font-size:90%; font-weight:bold; margin-bottom:6px;}
+.header ul li { display:inline;}
+.header ul li a { color:#fff; text-decoration:none; margin-right:10px; display:inline-block;  padding:8px; -webkit-border-top-right-radius:6px; -webkit-border-top-left-radius:6px; -moz-border-radius-topleft:6px; -moz-border-radius-topright:6px; }
+.header ul li a:hover { background:#333;}
+.header ul li.current a { background:#0080FF; font-weight:bold; color:#fff;}
+
+#main { padding:10px 5%; background:#fff; overflow:hidden; }
+#main .logo { float:right; margin:10px;}
+#main span.hl { background:#efefef; padding:2px;}
+#main h1 { margin:10px 0; font-size:190%; font-weight:bold; color:#0080FF;}
+#main h2 { margin:10px 0; font-size:130%;}
+#main table { width:100%; margin:10px 0;}
+#main table tr td, #main table tr th { border:1px solid #ccc; padding:6px;}
+#main table tr th { background:#efefef; color:#888; font-size:80%; font-weight:bold;}
+#main table tr td.no-data { text-align:center; padding:40px 0; color:#999; font-style:italic; font-size:130%;}
+#main a { color:#111;}
+#main p { margin:5px 0;}
+#main p.intro { margin-bottom:15px; font-size:85%; color:#999; margin-top:0; line-height:1.3;}
+#main h1.wi { margin-bottom:5px;}
+#main p.sub { font-size:95%; color:#999;}
+
+#main table.queues { width:40%;}
+
+#main table .totals td{ background:#eee; font-weight:bold; }
+
+#footer { padding:10px 5%; background:#efefef; color:#999; font-size:85%; line-height:1.5; border-top:5px solid #ccc; padding-top:10px;}
+#footer p a { color:#999;}
+
+
+

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

@@ -0,0 +1,56 @@
+<h1>Split Dashboard</h1>
+<p class="intro">The list below contains all the registered experiments along with the number of test participants, completed and conversion rate currently in the system.</p>
+
+<% @experiments.each do |experiment| %>
+  <h2><%= experiment.name %></h2>
+  <table class="queues">
+    <tr>
+      <th>Alternative Name</th>
+      <th>Participants</th>
+      <th>Non-finished</th>
+      <th>Completed</th>
+      <th>Conversion Rate</th>
+      <th>Z-Score</th>
+      <th>Winner</th>
+    </tr>
+
+    <% total_participants = total_completed = 0 %>
+    <% experiment.alternatives.each do |alternative| %>
+      <tr>
+        <td><%= alternative.name %></td>
+        <td><%= alternative.participant_count %></td>
+        <td><%= alternative.participant_count - alternative.completed_count %></td>
+        <td><%= alternative.completed_count %></td>
+        <td><%= (alternative.conversion_rate * 100).round(2) %>%</td>
+        <td><%= alternative.z_score %></td>
+        <td>
+          <% if experiment.winner %>
+            <% if experiment.winner.name == alternative.name %>
+              Winner
+            <% else %>
+              Loser
+            <% end %>
+          <% else %>
+            <form action="<%= url experiment.name %>" method='post'>
+              <input type='hidden' name='alternative' value='<%= alternative.name %>'>
+              <input type="submit" value="Use this">
+            </form>
+          <% end %>
+        </td>
+      </tr>
+
+      <% total_participants += alternative.participant_count %>
+      <% total_completed += alternative.completed_count %>
+    <% end %>
+
+    <tr class="totals">
+      <td>Totals</td>
+      <td><%= total_participants %></td>
+      <td><%= total_participants - total_completed %></td>
+      <td><%= total_completed %></td>
+      <td>N/A</td>
+      <td>N/A</td>
+      <td>N/A</td>
+    </tr>
+  </table>
+<% end %>

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

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta content='text/html; charset=utf-8' http-equiv='Content-Type'>
+<link href="<%= url 'reset.css' %>" media="screen" rel="stylesheet" type="text/css">
+<link href="<%= url 'style.css' %>" media="screen" rel="stylesheet" type="text/css">
+
+<title>Split</title>
+
+</head>
+<body>
+  <div class="header"></div>
+
+  <div id="main">
+    <%= yield %>
+  </div>
+
+  <div id="footer">
+    <p>Powered by <a href="http://github.com/andrew/split">Split</a> v<%=Split::VERSION %></p>
+  </div>
+</body>
+</html>

data/lib/split/experiment.rb

@@ -0,0 +1,59 @@
+module Split
+  class Experiment
+    attr_accessor :name
+    attr_accessor :alternatives
+    attr_accessor :winner
+
+    def initialize(name, *alternatives)
+      @name = name.to_s
+      @alternatives = alternatives
+    end
+
+    def winner
+      if w = Split.redis.hget(:experiment_winner, name)
+        return Split::Alternative.find(w, name)
+      else
+        nil
+      end
+    end
+
+    def winner=(winner_name)
+      Split.redis.hset(:experiment_winner, name, winner_name.to_s)
+    end
+
+    def alternatives
+      @alternatives.map {|a| Split::Alternative.find_or_create(a, name)}
+    end
+
+    def next_alternative
+      winner || alternatives.sort_by{|a| a.participant_count + rand}.first
+    end
+
+    def save
+      Split.redis.sadd(:experiments, name)
+      @alternatives.each {|a| Split.redis.sadd(name, a) }
+    end
+
+    def self.all
+      Array(Split.redis.smembers(:experiments)).map {|e| find(e)}
+    end
+
+    def self.find(name)
+      if Split.redis.exists(name)
+        self.new(name, *Split.redis.smembers(name))
+      else
+        raise 'Experiment not found'
+      end
+    end
+
+    def self.find_or_create(name, *alternatives)
+      if Split.redis.exists(name)
+        return self.new(name, *Split.redis.smembers(name))
+      else
+        experiment = self.new(name, *alternatives)
+        experiment.save
+        return experiment
+      end
+    end
+  end
+end

data/lib/split/helper.rb

@@ -0,0 +1,28 @@
+module Split
+  module Helper
+    def ab_test(experiment_name, *alternatives)
+      experiment = Split::Experiment.find_or_create(experiment_name, *alternatives)
+      return experiment.winner.name if experiment.winner
+
+      if ab_user[experiment_name]
+        return ab_user[experiment_name]
+      else
+        alternative = experiment.next_alternative
+        alternative.increment_participation
+        ab_user[experiment_name] = alternative.name
+        return alternative.name
+      end
+    end
+
+    def finished(experiment_name)
+      alternative_name = ab_user[experiment_name]
+      alternative = Split::Alternative.find(alternative_name, experiment_name)
+      alternative.increment_completion
+      session[:split].delete(experiment_name)
+    end
+
+    def ab_user
+      session[:split] ||= {}
+    end
+  end
+end

data/lib/split/version.rb

@@ -0,0 +1,3 @@
+module Split
+  VERSION = "0.1.0"
+end

data/spec/experiment_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'split/experiment'
+
+describe Split::Experiment do
+  before(:each) { Split.redis.flushall }
+
+  it "should have a name" do
+    experiment = Split::Experiment.new('basket_text', 'Basket', "Cart")
+    experiment.name.should eql('basket_text')
+  end
+  
+  it "should have alternatives" do
+    experiment = Split::Experiment.new('basket_text', 'Basket', "Cart")
+    experiment.alternatives.length.should be 2
+  end
+  
+  it "should save to redis" do
+    experiment = Split::Experiment.new('basket_text', 'Basket', "Cart")
+    experiment.save
+    Split.redis.exists('basket_text').should be true
+  end
+  
+  it "should return an existing experiment" do
+    experiment = Split::Experiment.new('basket_text', 'Basket', "Cart")
+    experiment.save
+    Split::Experiment.find('basket_text').name.should eql('basket_text')
+  end
+
+  describe 'winner' do
+    it "should have no winner initially" do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+      experiment.winner.should be_nil
+    end
+
+    it "should allow you to specify a winner" do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+      experiment.winner = 'red'
+
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+      experiment.winner.name.should == 'red'
+    end
+  end
+
+  describe 'next_alternative' do
+    it "should return a random alternative from those with the least participants" do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
+
+      Split::Alternative.find('blue', 'link_color').increment_participation
+      Split::Alternative.find('red', 'link_color').increment_participation
+
+      experiment.next_alternative.name.should == 'green'
+    end
+
+    it "should always return the winner if one exists" do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
+      green = Split::Alternative.find('green', 'link_color')
+      experiment.winner = 'green'
+
+      experiment.next_alternative.name.should == 'green'
+      green.increment_participation
+
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red', 'green')
+      experiment.next_alternative.name.should == 'green'
+    end
+  end
+end
+

data/spec/helper_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Split::Helper do
+  include Split::Helper
+
+  before(:each) do
+    Split.redis.flushall
+    @session = {}
+  end
+
+  describe "ab_test" do
+    it "should assign a random alternative to a new user when there are an equal number of alternatives assigned" do
+      ab_test('link_color', 'blue', 'red')
+      ['red', 'blue'].should include(ab_user['link_color'])
+    end
+
+    it "should increment the participation counter after assignment to a new user" do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+
+      previous_red_count = Split::Alternative.find('red', 'link_color').participant_count
+      previous_blue_count = Split::Alternative.find('blue', 'link_color').participant_count
+
+      ab_test('link_color', 'blue', 'red')
+
+      new_red_count = Split::Alternative.find('red', 'link_color').participant_count
+      new_blue_count = Split::Alternative.find('blue', 'link_color').participant_count
+
+      (new_red_count + new_blue_count).should eql(previous_red_count + previous_blue_count + 1)
+    end
+
+    it "should return the given alternative for an existing user" do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+      alternative = ab_test('link_color', 'blue', 'red')
+      repeat_alternative = ab_test('link_color', 'blue', 'red')
+      alternative.should eql repeat_alternative
+    end
+
+    it 'should always return the winner if one is present' do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+      experiment.winner = "orange"
+
+      ab_test('link_color', 'blue', 'red').should == 'orange'
+    end
+  end
+
+  describe 'finished' do
+    it 'should increment the counter for the completed alternative' do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+      alternative_name = ab_test('link_color', 'blue', 'red')
+
+      previous_completion_count = Split::Alternative.find(alternative_name, 'link_color').completed_count
+
+      finished('link_color')
+
+      new_completion_count = Split::Alternative.find(alternative_name, 'link_color').completed_count
+
+      new_completion_count.should eql(previous_completion_count + 1)
+    end
+
+    it "should clear out the user's participation from their session" do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+      alternative_name = ab_test('link_color', 'blue', 'red')
+
+      previous_completion_count = Split::Alternative.find(alternative_name, 'link_color').completed_count
+
+      session[:split].should == {"link_color" => alternative_name}
+      finished('link_color')
+      session[:split].should == {}
+    end
+  end
+  
+  describe 'conversions' do
+    it 'should return a conversion rate for an alternative' do
+      experiment = Split::Experiment.find_or_create('link_color', 'blue', 'red')
+      alternative_name = ab_test('link_color', 'blue', 'red')
+      
+      previous_convertion_rate = Split::Alternative.find(alternative_name, 'link_color').conversion_rate
+      previous_convertion_rate.should eql(0.0)
+
+      finished('link_color')
+      
+      new_convertion_rate = Split::Alternative.find(alternative_name, 'link_color').conversion_rate
+      new_convertion_rate.should eql(1.0)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'split'
+
+def session
+  @session ||= {}
+end

data/split.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "split/version"
+
+Gem::Specification.new do |s|
+  s.name        = "split"
+  s.version     = Split::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andrew Nesbitt"]
+  s.email       = ["andrewnez@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Rack based split testing framework}
+
+  s.rubyforge_project = "split"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency(%q<redis>, ["~>  2.1"])
+  s.add_dependency(%q<redis-namespace>, ["~>  0.10.0"])
+  s.add_dependency(%q<sinatra>, ["~>  1.2.6"])
+
+  # Development Dependencies
+  s.add_development_dependency(%q<rspec>, ["~>  2.6"])
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification 
+name: split
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Andrew Nesbitt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-17 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        version: "2.1"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: redis-namespace
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 0
+        version: 0.10.0
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 6
+        version: 1.2.6
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 6
+        version: "2.6"
+  type: :development
+  version_requirements: *id004
+description: 
+email: 
+- andrewnez@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.mdown
+- Rakefile
+- lib/split.rb
+- lib/split/alternative.rb
+- lib/split/dashboard.rb
+- lib/split/dashboard/public/reset.css
+- lib/split/dashboard/public/style.css
+- lib/split/dashboard/views/index.erb
+- lib/split/dashboard/views/layout.erb
+- lib/split/experiment.rb
+- lib/split/helper.rb
+- lib/split/version.rb
+- spec/experiment_spec.rb
+- spec/helper_spec.rb
+- spec/spec_helper.rb
+- split.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: split
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Rack based split testing framework
+test_files: 
+- spec/experiment_spec.rb
+- spec/helper_spec.rb
+- spec/spec_helper.rb