split 2.1.0 → 2.2.0

data/.travis.yml

@@ -5,9 +5,13 @@ rvm:
 gemfile:
   - gemfiles/4.1.gemfile
   - gemfiles/4.2.gemfile
+  - gemfiles/5.0.gemfile
 
 before_install:
   - gem install bundler
 
+script:
+  - RAILS_ENV=test bundle exec rake spec && bundle exec codeclimate-test-reporter
+
 cache: bundler
 sudo: false

data/Appraisals

@@ -5,3 +5,8 @@ end
 appraise "4.2" do
   gem "rails", "~> 4.2"
 end
+
+appraise "5.0" do
+  gem "rails", "~> 5.0"
+  gem "sinatra", github: "sinatra/sinatra"
+end

data/CHANGELOG.md

@@ -1,6 +1,28 @@
+## 2.2.0 (November 11th, 2016)
+
+Features:
+
+- Remove dependency on Redis::Namespace (@bschaeffer, #425)
+- Make resetting on experiment change optional (@moggyboy, #430)
+- Add ability to force alternative on dashboard (@ccallebs, #437)
+
+Bugfixes:
+
+- Fix variations reset across page loads for multiple=control and improve coverage (@Vasfed, #432)
+
+Misc:
+
+- Remove Explicit Return (@BradHudson, #441)
+- Update Redis config docs (@bschaeffer, #422)
+- Harden HTTP Basic snippet against timing attacks (@eliotsykes, #443)
+- Removed a couple old ruby 1.8 hacks (@andrew, #456)
+- Run tests on rails 5 (@andrew, #457)
+- Fixed a few codeclimate warnings (@andrew, #458)
+- Use codeclimate for test coverage (@andrew #455)
+
 ## 2.1.0 (August 8th, 2016)
 
-Features
+Features:
 
 - Support REDIS_PROVIDER variable used in Heroku (@kartikluke, #426)
 

data/Gemfile

@@ -3,3 +3,4 @@ source "https://rubygems.org"
 gemspec
 
 gem "appraisal"
+gem "codeclimate-test-reporter"

data/README.md

@@ -8,9 +8,8 @@ Split is designed to be hacker friendly, allowing for maximum customisation and
 
 [![Gem Version](https://badge.fury.io/rb/split.svg)](http://badge.fury.io/rb/split)
 [![Build Status](https://secure.travis-ci.org/splitrb/split.svg?branch=master)](http://travis-ci.org/splitrb/split)
-[![Code Climate](https://codeclimate.com/github/splitrb/split.svg)](https://codeclimate.com/github/splitrb/split)
-[![Coverage Status](http://img.shields.io/coveralls/splitrb/split.svg)](https://coveralls.io/r/splitrb/split)
-
+[![Code Climate](https://codeclimate.com/github/splitrb/split/badges/gpa.svg)](https://codeclimate.com/github/splitrb/split)
+[![Test Coverage](https://codeclimate.com/github/splitrb/split/badges/coverage.svg)](https://codeclimate.com/github/splitrb/split/coverage)
 
 
 # Backers
@@ -436,8 +435,22 @@ mount Split::Dashboard, at: 'split'
 You may want to password protect that page, you can do so with `Rack::Auth::Basic` (in your split initializer file)
 
 ```ruby
+# Rails apps or apps that already depend on activesupport
+Split::Dashboard.use Rack::Auth::Basic do |username, password|
+  # Protect against timing attacks:
+  # - Use & (do not use &&) so that it doesn't short circuit.
+  # - Use `variable_size_secure_compare` to stop length information leaking
+  ActiveSupport::SecurityUtils.variable_size_secure_compare(username, ENV["SPLIT_USERNAME"]) &
+    ActiveSupport::SecurityUtils.variable_size_secure_compare(password, ENV["SPLIT_PASSWORD"])
+end
+
+# Apps without activesupport
 Split::Dashboard.use Rack::Auth::Basic do |username, password|
-  username == 'admin' && password == 'p4s5w0rd'
+  # Protect against timing attacks:
+  # - Use & (do not use &&) so that it doesn't short circuit.
+  # - Use digests to stop length information leaking
+  Rack::Utils.secure_compare(::Digest::SHA256.hexdigest(username), ::Digest::SHA256.hexdigest(ENV["SPLIT_USERNAME"])) &
+    Rack::Utils.secure_compare(::Digest::SHA256.hexdigest(password), ::Digest::SHA256.hexdigest(ENV["SPLIT_PASSWORD"]))
 end
 ```
 
@@ -469,11 +482,16 @@ Split.configure do |config|
   config.persistence = Split::Persistence::SessionAdapter
   #config.start_manually = false ## new test will have to be started manually from the admin panel. default false
   config.include_rails_helper = true
-  config.redis_url = "custom.redis.url:6380"
+  config.redis = "redis://custom.redis.url:6380"
 end
 ```
 
-Split looks for the Redis host in the environment variable ```REDIS_URL``` then defaults to ```localhost:6379``` if not specified by configure block.
+Split looks for the Redis host in the environment variable `REDIS_URL` then
+defaults to `redis://localhost:6379` if not specified by configure block.
+
+On platforms like Heroku, Split will use the value of `REDIS_PROVIDER` to
+determine which env variable key to use when retrieving the host config. This
+defaults to `REDIS_URL`.
 
 ### Filtering
 
@@ -694,7 +712,7 @@ 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'`
+String: `Split.redis = 'redis://localhost:6379'`
 
 Redis: `Split.redis = $redis`
 
@@ -705,11 +723,11 @@ appropriately.
 Here's our `config/split.yml`:
 
 ```yml
-development: localhost:6379
-test: localhost:6379
-staging: redis1.example.com:6379
-fi: localhost:6379
-production: redis1.example.com:6379
+development: redis://localhost:6379
+test: redis://localhost:6379
+staging: redis://redis1.example.com:6379
+fi: redis://localhost:6379
+production: redis://redis1.example.com:6379
 ```
 
 And our initializer:
@@ -725,18 +743,22 @@ 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](https://github.com/defunkt/redis-namespace) library, which
-Split uses by default to separate the keys it manages from other keys
-in your Redis server.
+This feature can be provided by the [redis-namespace](https://github.com/defunkt/redis-namespace)
+library. To configure Split to use `Redis::Namespace`, do the following:
 
-Simply use the `Split.redis.namespace` accessor:
+1. Add `redis-namespace` to your Gemfile:
 
-```ruby
-Split.redis.namespace = "split:blog"
-```
+  ```ruby
+  gem 'redis-namespace'
+  ```
+
+2. Configure `Split.redis` to use a `Redis::Namespace` instance (possible in an
+   intializer):
 
-We recommend sticking this in your initializer somewhere after Redis
-is configured.
+  ```ruby
+  redis = Redis.new(url: ENV['REDIS_URL']) # or whatever config you want
+  Split.redis = Redis::Namespace.new(:your_namespace, redis: redis)
+  ```
 
 ## Outside of a Web Session
 

data/gemfiles/4.1.gemfile

@@ -3,6 +3,7 @@
 source "https://rubygems.org"
 
 gem "appraisal"
+gem "codeclimate-test-reporter"
 gem "rails", "~> 4.1"
 
 gemspec :path => "../"

data/gemfiles/4.2.gemfile

@@ -3,6 +3,7 @@
 source "https://rubygems.org"
 
 gem "appraisal"
+gem "codeclimate-test-reporter"
 gem "rails", "~> 4.2"
 
 gemspec :path => "../"

data/gemfiles/5.0.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "appraisal"
+gem "codeclimate-test-reporter"
+gem "rails", "~> 5.0"
+gem "sinatra", :github => "sinatra/sinatra"
+
+gemspec :path => "../"

data/lib/split.rb

@@ -11,6 +11,7 @@
    metric
    persistence
    encapsulated_helper
+   redis_interface
    trial
    user
    version
@@ -19,36 +20,27 @@
 end
 
 require 'split/engine' if defined?(Rails)
-require 'redis/namespace'
 
 module Split
   extend self
   attr_accessor :configuration
 
   # 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`.
+  #   1. A redis URL (valid for `Redis.new(url: url)`)
+  #   2. an options hash compatible with `Redis.new`
+  #   3. or a valid Redis instance (one that responds to `#smembers`). Likely,
+  #      this will be an instance of either `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
+    @redis = if server.is_a?(String)
+      Redis.new(:url => server, :thread_safe => true)
+    elsif server.is_a?(Hash)
+      Redis.new(server.merge(:thread_safe => true))
+    elsif server.respond_to?(:smembers)
+      server
     else
-      @redis = Redis::Namespace.new(:split, :redis => server)
+      raise ArgumentError,
+        "You must supply a url, options hash or valid Redis connection instance"
     end
   end
 
@@ -56,7 +48,7 @@ module Split
   # create a new one.
   def redis
     return @redis if @redis
-    self.redis = self.configuration.redis_url
+    self.redis = self.configuration.redis
     self.redis
   end
 

data/lib/split/alternative.rb

@@ -34,7 +34,6 @@ module Split
     def p_winner(goal = nil)
       field = set_prob_field(goal)
       @p_winner = Split.redis.hget(key, field).to_f
-      return @p_winner
     end
 
     def set_p_winner(prob, goal = nil)

data/lib/split/configuration.rb

@@ -15,6 +15,7 @@ module Split
     attr_accessor :algorithm
     attr_accessor :store_override
     attr_accessor :start_manually
+    attr_accessor :reset_manually
     attr_accessor :on_trial
     attr_accessor :on_trial_choose
     attr_accessor :on_trial_complete
@@ -24,7 +25,7 @@ module Split
     attr_accessor :on_before_experiment_delete
     attr_accessor :include_rails_helper
     attr_accessor :beta_probability_simulations
-    attr_accessor :redis_url
+    attr_accessor :redis
 
     attr_reader :experiments
 
@@ -211,7 +212,17 @@ module Split
       @algorithm = Split::Algorithms::WeightedSample
       @include_rails_helper = true
       @beta_probability_simulations = 10000
-      @redis_url = ENV.fetch(ENV.fetch('REDIS_PROVIDER', 'REDIS_URL'), 'localhost:6379')
+      @redis = ENV.fetch(ENV.fetch('REDIS_PROVIDER', 'REDIS_URL'), 'redis://localhost:6379')
+    end
+
+    def redis_url=(value)
+      warn '[DEPRECATED] `redis_url=` is deprecated in favor of `redis=`'
+      self.redis = value
+    end
+
+    def redis_url
+      warn '[DEPRECATED] `redis_url` is deprecated in favor of `redis`'
+      self.redis
     end
 
     private

data/lib/split/dashboard.rb

@@ -30,6 +30,11 @@ module Split
       erb :index
     end
 
+    post '/force_alternative' do
+      Split::User.new(self)[params[:experiment]] = params[:alternative]
+      redirect url('/')
+    end
+
     post '/experiment' do
       @experiment = Split::ExperimentCatalog.find(params[:experiment])
       @alternative = Split::Alternative.new(params[:alternative], params[:experiment])

data/lib/split/dashboard/public/dashboard-filtering.js

@@ -2,7 +2,7 @@ $(function() {
   $('#filter').on('keyup', function() {
     $input = $(this);
 
-    if ($input.val() == '') {
+    if ($input.val() === '') {
       $('div.experiment').show();
       return false;
     }
@@ -21,7 +21,7 @@ $(function() {
 
   $('#toggle-active').on('click', function() {
     $button = $(this);
-    if ($button.val() == 'Hide active') {
+    if ($button.val() === 'Hide active') {
       $button.val('Show active');
     } else {
       $button.val('Hide active');
@@ -32,7 +32,7 @@ $(function() {
 
   $('#toggle-completed').on('click', function() {
     $button = $(this);
-    if ($button.val() == 'Hide completed') {
+    if ($button.val() === 'Hide completed') {
       $button.val('Show completed');
     } else {
       $button.val('Hide completed');

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

@@ -51,6 +51,10 @@
           <% if alternative.control? %>
             <em>control</em>
           <% end %>
+          <form action="<%= url('force_alternative') + '?experiment=' + experiment.name %>" method='post'>
+            <input type='hidden' name='alternative' value='<%= h alternative.name %>'>
+            <input type="submit" value="Force for current user" class="green">
+          </form>
         </td>
         <td><%= alternative.participant_count %></td>
         <td><%= alternative.unfinished_count %></td>

data/lib/split/encapsulated_helper.rb

@@ -26,21 +26,8 @@ module Split
       end
     end
 
-    def ab_test(*arguments)
-      ret = split_context_shim.ab_test(*arguments)
-      # TODO there must be a better way to pass a block straight
-      # through to the original ab_test
-      if block_given?
-        if defined?(capture) # a block in a rails view
-          block = Proc.new { yield(ret) }
-          concat(capture(ret, &block))
-          false
-        else
-          yield(ret)
-        end
-      else
-        ret
-      end
+    def ab_test(*arguments,&block)
+      split_context_shim.ab_test(*arguments,&block)
     end
 
     private

data/lib/split/experiment.rb

@@ -80,29 +80,15 @@ module Split
       validate!
 
       if new_record?
-        Split.redis.sadd(:experiments, name)
         start unless Split.configuration.start_manually
-        @alternatives.reverse.each {|a| Split.redis.lpush(name, a.name)}
-        goals_collection.save
-        save_metadata
-      else
-        existing_alternatives = load_alternatives_from_redis
-        existing_goals = Split::GoalsCollection.new(@name).load_from_redis
-        existing_metadata = load_metadata_from_redis
-        unless existing_alternatives == @alternatives.map(&:name) && existing_goals == @goals && existing_metadata == @metadata
-          reset
-          @alternatives.each(&:delete)
-          goals_collection.delete
-          delete_metadata
-          Split.redis.del(@name)
-          @alternatives.reverse.each {|a| Split.redis.lpush(name, a.name)}
-          goals_collection.save
-          save_metadata
-        end
+      elsif experiment_configuration_has_changed?
+        reset unless Split.configuration.reset_manually
       end
 
-      Split.redis.hset(experiment_config_key, :resettable, resettable)
-      Split.redis.hset(experiment_config_key, :algorithm, algorithm.to_s)
+      persist_experiment_configuration if new_record? || experiment_configuration_has_changed?
+
+      redis.hset(experiment_config_key, :resettable, resettable)
+      redis.hset(experiment_config_key, :algorithm, algorithm.to_s)
       self
     end
 
@@ -115,7 +101,7 @@ module Split
     end
 
     def new_record?
-      !Split.redis.exists(name)
+      !redis.exists(name)
     end
 
     def ==(obj)
@@ -149,8 +135,9 @@ module Split
     end
 
     def winner
-      if w = Split.redis.hget(:experiment_winner, name)
-        Split::Alternative.new(w, name)
+      experiment_winner = redis.hget(:experiment_winner, name)
+      if experiment_winner
+        Split::Alternative.new(experiment_winner, name)
       else
         nil
       end
@@ -161,7 +148,7 @@ module Split
     end
 
     def winner=(winner_name)
-      Split.redis.hset(:experiment_winner, name, winner_name.to_s)
+      redis.hset(:experiment_winner, name, winner_name.to_s)
     end
 
     def participant_count
@@ -173,21 +160,21 @@ module Split
     end
 
     def reset_winner
-      Split.redis.hdel(:experiment_winner, name)
+      redis.hdel(:experiment_winner, name)
     end
 
     def start
-      Split.redis.hset(:experiment_start_times, @name, Time.now.to_i)
+      redis.hset(:experiment_start_times, @name, Time.now.to_i)
     end
 
     def start_time
-      t = Split.redis.hget(:experiment_start_times, @name)
+      t = redis.hget(:experiment_start_times, @name)
       if t
         # Check if stored time is an integer
         if t =~ /^[-+]?[0-9]+$/
-          t = Time.at(t.to_i)
+          Time.at(t.to_i)
         else
-          t = Time.parse(t)
+          Time.parse(t)
         end
       end
     end
@@ -205,11 +192,11 @@ module Split
     end
 
     def version
-      @version ||= (Split.redis.get("#{name.to_s}:version").to_i || 0)
+      @version ||= (redis.get("#{name}:version").to_i || 0)
     end
 
     def increment_version
-      @version = Split.redis.incr("#{name}:version")
+      @version = redis.incr("#{name}:version")
     end
 
     def key
@@ -247,24 +234,21 @@ module Split
     def delete
       Split.configuration.on_before_experiment_delete.call(self)
       if Split.configuration.start_manually
-        Split.redis.hdel(:experiment_start_times, @name)
+        redis.hdel(:experiment_start_times, @name)
       end
-      alternatives.each(&:delete)
       reset_winner
-      Split.redis.srem(:experiments, name)
-      Split.redis.del(name)
-      goals_collection.delete
-      delete_metadata
+      redis.srem(:experiments, name)
+      remove_experiment_configuration
       Split.configuration.on_experiment_delete.call(self)
       increment_version
     end
 
     def delete_metadata
-      Split.redis.del(metadata_key)
+      redis.del(metadata_key)
     end
 
     def load_from_redis
-      exp_config = Split.redis.hgetall(experiment_config_key)
+      exp_config = redis.hgetall(experiment_config_key)
 
       options = {
         resettable: exp_config['resettable'],
@@ -297,8 +281,6 @@ module Split
     end
 
     def estimate_winning_alternative(goal = nil)
-      # TODO - refactor out functionality to work with and without goals
-
       # initialize a hash of beta distributions based on the alternatives' conversion rates
       beta_params = calc_beta_params(goal)
 
@@ -395,11 +377,11 @@ module Split
     end
 
     def calc_time=(time)
-      Split.redis.hset(experiment_config_key, :calc_time, time)
+      redis.hset(experiment_config_key, :calc_time, time)
     end
 
     def calc_time
-      Split.redis.hget(experiment_config_key, :calc_time).to_i
+      redis.hget(experiment_config_key, :calc_time).to_i
     end
 
     def jstring(goal = nil)
@@ -418,11 +400,11 @@ module Split
     end
 
     def load_metadata_from_configuration
-      metadata = Split.configuration.experiment_for(@name)[:metadata]
+      Split.configuration.experiment_for(@name)[:metadata]
     end
 
     def load_metadata_from_redis
-      meta = Split.redis.get(metadata_key)
+      meta = redis.get(metadata_key)
       JSON.parse(meta) unless meta.nil?
     end
 
@@ -437,22 +419,49 @@ module Split
     end
 
     def load_alternatives_from_redis
-      case Split.redis.type(@name)
+      case redis.type(@name)
       when 'set' # convert legacy sets to lists
-        alts = Split.redis.smembers(@name)
-        Split.redis.del(@name)
-        alts.reverse.each {|a| Split.redis.lpush(@name, a) }
-        Split.redis.lrange(@name, 0, -1)
+        alts = redis.smembers(@name)
+        redis.del(@name)
+        alts.reverse.each {|a| redis.lpush(@name, a) }
+        redis.lrange(@name, 0, -1)
       else
-        Split.redis.lrange(@name, 0, -1)
+        redis.lrange(@name, 0, -1)
       end
     end
 
-    def save_metadata
-      Split.redis.set(metadata_key, @metadata.to_json) unless @metadata.nil?
+    private
+
+    def redis
+      Split.redis
     end
 
-    private
+    def redis_interface
+      RedisInterface.new
+    end
+
+    def persist_experiment_configuration
+      redis_interface.add_to_set(:experiments, name)
+      redis_interface.persist_list(name, @alternatives.map(&:name))
+      goals_collection.save
+      redis.set(metadata_key, @metadata.to_json) unless @metadata.nil?
+    end
+
+    def remove_experiment_configuration
+      @alternatives.each(&:delete)
+      goals_collection.delete
+      delete_metadata
+      redis.del(@name)
+    end
+
+    def experiment_configuration_has_changed?
+      existing_alternatives = load_alternatives_from_redis
+      existing_goals = Split::GoalsCollection.new(@name).load_from_redis
+      existing_metadata = load_metadata_from_redis
+      existing_alternatives != @alternatives.map(&:name) ||
+        existing_goals != @goals ||
+        existing_metadata != @metadata
+    end
 
     def goals_collection
       Split::GoalsCollection.new(@name, @goals)