ab-split 1.0.0

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+# frozen_string_literal: true
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'appraisal'
+
+RSpec::Core::RakeTask.new('spec')
+
+task :default => :spec

data/ab-split.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
+$:.push File.expand_path("../lib", __FILE__)
+require "split/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ab-split"
+  s.version     = Split::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.licenses    = ['MIT']
+  s.authors     = ["aibotyu"]
+  s.email       = ["284894567@qq.com"]
+  s.homepage    = "https://github.com/WeiGangqiang/split"
+  s.summary     = "Rack based split testing framework"
+
+  s.metadata    = {
+   "homepage_uri" => "https://github.com/WeiGangqiang/split",
+   "changelog_uri" => "https://github.com/WeiGangqiang/split/blob/master/CHANGELOG.md",
+   "source_code_uri" => "https://github.com/WeiGangqiang/split",
+   "bug_tracker_uri" => "https://github.com/WeiGangqiang/split/issues",
+   "wiki_uri" => "https://github.com/WeiGangqiang/split/wiki",
+   "mailing_list_uri" => "https://github.com/WeiGangqiang/split/split-ruby"
+ }
+
+  s.required_ruby_version = '>= 1.9.3'
+  s.required_rubygems_version = '>= 2.0.0'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'redis',           '>= 2.1'
+  s.add_dependency 'sinatra',         '>= 1.2.6'
+  s.add_dependency 'simple-random',   '>= 0.9.3'
+
+  s.add_development_dependency 'bundler',     '>= 1.17'
+  s.add_development_dependency 'simplecov',   '~> 0.15'
+  s.add_development_dependency 'rack-test',   '~> 0.6'
+  s.add_development_dependency 'rake',        '~> 12'
+  s.add_development_dependency 'rspec',       '~> 3.7'
+  s.add_development_dependency 'pry',         '~> 0.10'
+  s.add_development_dependency 'fakeredis',   '~> 0.7'
+  s.add_development_dependency 'rails',       '>= 4.2'
+end

data/gemfiles/4.2.gemfile

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

data/gemfiles/5.0.gemfile

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

data/gemfiles/5.1.gemfile

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

data/gemfiles/5.2.gemfile

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

data/gemfiles/6.0.gemfile

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

data/lib/split.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+require 'redis'
+
+require 'split/algorithms/block_randomization'
+require 'split/algorithms/weighted_sample'
+require 'split/algorithms/whiplash'
+require 'split/alternative'
+require 'split/configuration'
+require 'split/encapsulated_helper'
+require 'split/exceptions'
+require 'split/experiment'
+require 'split/experiment_catalog'
+require 'split/extensions/string'
+require 'split/goals_collection'
+require 'split/helper'
+require 'split/combined_experiments_helper'
+require 'split/metric'
+require 'split/persistence'
+require 'split/redis_interface'
+require 'split/trial'
+require 'split/user'
+require 'split/version'
+require 'split/zscore'
+require 'split/engine' if defined?(Rails)
+
+module Split
+  extend self
+  attr_accessor :configuration
+
+  # Accepts:
+  #   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)
+    @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
+      raise ArgumentError,
+        "You must supply a url, options hash or valid Redis connection instance"
+    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 = self.configuration.redis
+    self.redis
+  end
+
+  # Call this method to modify defaults in your initializers.
+  #
+  # @example
+  #   Split.configure do |config|
+  #     config.ignore_ip_addresses = '192.168.2.1'
+  #   end
+  def configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+end
+
+# Check to see if being run in a Rails application.  If so, wait until before_initialize to run configuration so Gems that create ENV variables have the chance to initialize first.
+if defined?(::Rails)
+  class Railtie < Rails::Railtie
+    config.before_initialize { Split.configure {} }
+  end
+else
+  Split.configure {}
+end

data/lib/split/algorithms/block_randomization.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# Selects alternative with minimum count of participants
+# If all counts are even (i.e. all are minimum), samples from all possible alternatives
+
+module Split
+  module Algorithms
+    module BlockRandomization
+      class << self
+        def choose_alternative(experiment)
+          minimum_participant_alternatives(experiment.alternatives).sample
+        end
+
+        private
+
+        def minimum_participant_alternatives(alternatives)
+          alternatives_by_count = alternatives.group_by(&:participant_count)
+          min_group = alternatives_by_count.min_by { |k, v| k }
+          min_group.last
+        end
+      end
+    end
+  end
+end

data/lib/split/algorithms/weighted_sample.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Split
+  module Algorithms
+    module WeightedSample
+      def self.choose_alternative(experiment)
+        weights = experiment.alternatives.map(&:weight)
+
+        total = weights.inject(:+)
+        point = rand * total
+
+        experiment.alternatives.zip(weights).each do |n,w|
+          return n if w >= point
+          point -= w
+        end
+      end
+    end
+  end
+end

data/lib/split/algorithms/whiplash.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+# A multi-armed bandit implementation inspired by
+# @aaronsw and victorykit/whiplash
+require 'simple-random'
+
+module Split
+  module Algorithms
+    module Whiplash
+      class << self
+        def choose_alternative(experiment)
+          experiment[best_guess(experiment.alternatives)]
+        end
+
+        private
+
+        def arm_guess(participants, completions)
+          a = [participants, 0].max
+          b = [participants-completions, 0].max
+          s = SimpleRandom.new; s.set_seed; s.beta(a+fairness_constant, b+fairness_constant)
+        end
+
+        def best_guess(alternatives)
+          guesses = {}
+          alternatives.each do |alternative|
+            guesses[alternative.name] = arm_guess(alternative.participant_count, alternative.all_completed_count)
+          end
+          gmax = guesses.values.max
+          best = guesses.keys.select { |name| guesses[name] ==  gmax }
+          best.sample
+        end
+
+        def fairness_constant
+          7
+        end
+      end
+    end
+  end
+end

data/lib/split/alternative.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+module Split
+  class Alternative
+    attr_accessor :name
+    attr_accessor :experiment_name
+    attr_accessor :weight
+    attr_accessor :recorded_info
+
+    def initialize(name, experiment_name)
+      @experiment_name = experiment_name
+      if Hash === name
+        @name = name.keys.first
+        @weight = name.values.first
+      else
+        @name = name
+        @weight = 1
+      end
+      @p_winner = 0.0
+    end
+
+    def to_s
+      name
+    end
+
+    def goals
+      self.experiment.goals
+    end
+
+    def p_winner(goal = nil)
+      field = set_prob_field(goal)
+      @p_winner = Split.redis.hget(key, field).to_f
+    end
+
+    def set_p_winner(prob, goal = nil)
+      field = set_prob_field(goal)
+      Split.redis.hset(key, field, prob.to_f)
+    end
+
+    def participant_count
+      Split.redis.hget(key, 'participant_count').to_i
+    end
+
+    def participant_count=(count)
+      Split.redis.hset(key, 'participant_count', count.to_i)
+    end
+
+    def completed_count(goal = nil)
+      field = set_field(goal)
+      Split.redis.hget(key, field).to_i
+    end
+
+    def all_completed_count
+      if goals.empty?
+        completed_count
+      else
+        goals.inject(completed_count) do |sum, g|
+          sum + completed_count(g)
+        end
+      end
+    end
+
+    def unfinished_count
+      participant_count - all_completed_count
+    end
+
+    def set_field(goal)
+      field = "completed_count"
+      field += ":" + goal unless goal.nil?
+      return field
+    end
+
+    def set_prob_field(goal)
+      field = "p_winner"
+      field += ":" + goal unless goal.nil?
+      return field
+    end
+
+    def set_completed_count(count, goal = nil)
+      field = set_field(goal)
+      Split.redis.hset(key, field, count.to_i)
+    end
+
+    def increment_participation
+      Split.redis.hincrby key, 'participant_count', 1
+    end
+
+    def increment_completion(goal = nil)
+      field = set_field(goal)
+      Split.redis.hincrby(key, field, 1)
+    end
+
+    def control?
+      experiment.control.name == self.name
+    end
+
+    def conversion_rate(goal = nil)
+      return 0 if participant_count.zero?
+      (completed_count(goal).to_f)/participant_count.to_f
+    end
+
+    def experiment
+      Split::ExperimentCatalog.find(experiment_name)
+    end
+
+    def z_score(goal = nil)
+      # p_a = Pa = proportion of users who converted within the experiment split (conversion rate)
+      # p_c = Pc = proportion of users who converted within the control split (conversion rate)
+      # n_a = Na = the number of impressions within the experiment split
+      # n_c = Nc = the number of impressions within the control split
+
+      control = experiment.control
+      alternative = self
+
+      return 'N/A' if control.name == alternative.name
+
+      p_a = alternative.conversion_rate(goal)
+      p_c = control.conversion_rate(goal)
+
+      n_a = alternative.participant_count
+      n_c = control.participant_count
+
+      # can't calculate zscore for P(x) > 1
+      return 'N/A' if p_a > 1 || p_c > 1
+
+      Split::Zscore.calculate(p_a, n_a, p_c, n_c)
+    end
+
+    def extra_info
+      data = Split.redis.hget(key, 'recorded_info')
+      if data && data.length > 1
+        begin
+          JSON.parse(data)
+        rescue
+          {}
+        end
+      else
+        {}
+      end
+    end
+
+    def record_extra_info(k, value = 1)
+      @recorded_info = self.extra_info || {}
+
+      if value.kind_of?(Numeric)
+        @recorded_info[k] ||= 0
+        @recorded_info[k] += value
+      else
+        @recorded_info[k] = value
+      end
+
+      Split.redis.hset key, 'recorded_info', (@recorded_info || {}).to_json
+    end
+
+    def save
+      Split.redis.hsetnx key, 'participant_count', 0
+      Split.redis.hsetnx key, 'completed_count', 0
+      Split.redis.hsetnx key, 'p_winner', p_winner
+      Split.redis.hsetnx key, 'recorded_info', (@recorded_info || {}).to_json
+    end
+
+    def validate!
+      unless String === @name || hash_with_correct_values?(@name)
+        raise ArgumentError, 'Alternative must be a string'
+      end
+    end
+
+    def reset
+      Split.redis.hmset key, 'participant_count', 0, 'completed_count', 0, 'recorded_info', nil
+      unless goals.empty?
+        goals.each do |g|
+          field = "completed_count:#{g}"
+          Split.redis.hset key, field, 0
+        end
+      end
+    end
+
+    def delete
+      Split.redis.del(key)
+    end
+
+    private
+
+    def hash_with_correct_values?(name)
+      Hash === name && String === name.keys.first && Float(name.values.first) rescue false
+    end
+
+    def key
+      "#{experiment_name}:#{name}"
+    end
+  end
+end