verdict 0.1.1 → 0.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZDNjZTFjMmI3OTZlMDQyOTlkYTdjYzU5ZmNhZjMxYjcxODVhYmZmMQ==
-  data.tar.gz: !binary |-
-    MGU5YWNkZDY2YmIzNjhmZDAwNjFkODIzZGI0MGRmZjMwMWEwYzFlZg==
+SHA1:
+  metadata.gz: bc058be7df27d778fc5c3d4333c1570c64edccc3
+  data.tar.gz: 7095d5c3a2e6408f29018ea2490f978debe05ed9
 SHA512:
-  metadata.gz: !binary |-
-    MDI2ZDI3OTVhYjljZjU1Y2NiNDAyMWMwYTIyMTU1NTgwZGNhNTEzNWI0Nzdl
-    ZWYwNGM2MDA1ODE3ZWE5ZjFkOGZlZmI5MWRkY2IxOTI2ZDQ4MzZjNTA4N2Ex
-    MmYxZmNhMmYzOGM3Y2FkNTFiMDhmMTQ1ZjUwMzBjZjE2ZTViMGU=
-  data.tar.gz: !binary |-
-    YTYxYTM4NGMxNjUwOWUyM2ZkYjI2NTZhOTFmOGRlYjMzMWQ1ZjU4YmIzOTUy
-    ZDQ2OTA0ZjNmZmY1OWJjMWVlOTI3NjliNzFmNmRkZjBkYzQ3NjNhNDIyODE1
-    NjQxYmM0YjI3MGE1MTc0N2E4NWQ2MjczMDRhYmM0N2I1YTAxZDk=
+  metadata.gz: 0a74b192fd5d4a03a6524e9c8f88d761b8eb2e83e6eb33957f46d429d526d9506eaf9787ae6d3665a80424d077f32d1dbb72498b1c7a81bb6a5380d581662155
+  data.tar.gz: c73434af18dcaf65c05689daf3686ddc42a9bd6334018be0d7369fd577742c92ad6630ca4b82d539ba7ddb3aaa6a379a0a0204aa35cb9375dac3e09bd14b7229

data/lib/verdict/assignment.rb

@@ -2,12 +2,13 @@ class Verdict::Assignment
 
   attr_reader :experiment, :subject_identifier, :group, :created_at
 
-  def initialize(experiment, subject_identifier, group, originally_created_at)
+  def initialize(experiment, subject_identifier, group, originally_created_at, temporary = false)
     @experiment         = experiment
     @subject_identifier = subject_identifier
     @group              = group
     @returning          = !originally_created_at.nil?
     @created_at         = originally_created_at || Time.now.utc
+    @temporary          = temporary
   end
 
   def subject
@@ -18,6 +19,14 @@ class Verdict::Assignment
     !group.nil?
   end
 
+  def permanent?
+    !@temporary
+  end
+
+  def temporary?
+    @temporary
+  end
+
   def returning
     self.class.new(@experiment, @subject_identifier, @group, @created_at)
   end

data/lib/verdict/experiment.rb

@@ -38,14 +38,20 @@ class Verdict::Experiment
     segmenter.groups[handle.to_s]
   end
 
-  def groups(segmenter_class = Verdict::Segmenter::StaticPercentage, &block)
-    return @segmenter.groups unless block_given?
+  def groups(segmenter_class = Verdict::FixedPercentageSegmenter, &block)
+    return segmenter.groups unless block_given?
     @segmenter ||= segmenter_class.new(self)
     @segmenter.instance_eval(&block)
     @segmenter.verify!
     return self
   end
 
+  def rollout_percentage(percentage, rollout_group_name = :enabled)
+    groups(Verdict::RolloutSegmenter) do
+      group rollout_group_name, percentage
+    end
+  end
+
   def qualify(&block)
     @qualifier = block
   end
@@ -72,8 +78,8 @@ class Verdict::Experiment
     segmenter.groups.keys
   end
 
-  def subject_assignment(subject_identifier, group, originally_created_at = nil)
-    Verdict::Assignment.new(self, subject_identifier, group, originally_created_at)
+  def subject_assignment(subject_identifier, group, originally_created_at, temporary = false)
+    Verdict::Assignment.new(self, subject_identifier, group, originally_created_at, temporary)
   end
 
   def subject_conversion(subject_identifier, goal, created_at = Time.now.utc)
@@ -84,6 +90,7 @@ class Verdict::Experiment
     identifier = retrieve_subject_identifier(subject)
     conversion = subject_conversion(identifier, goal)
     event_logger.log_conversion(conversion)
+    segmenter.conversion_feedback(identifier, subject, conversion)
     conversion
   rescue Verdict::EmptySubjectIdentifier
     raise unless disqualify_empty_identifier?
@@ -194,25 +201,30 @@ class Verdict::Experiment
   end
 
   def should_store_assignment?(assignment)
-    !assignment.returning? && (store_unqualified? || assignment.qualified?)
+    assignment.permanent? && !assignment.returning? && (store_unqualified? || assignment.qualified?)
   end
 
   def assignment_with_unqualified_persistence(subject_identifier, subject, context)
-    fetch_assignment(subject_identifier) || (
-      subject_qualifies?(subject, context) ? 
-        subject_assignment(subject_identifier, @segmenter.assign(subject_identifier, subject, context), nil) :
-        subject_assignment(subject_identifier, nil, nil)
-    )
+    previous_assignment = fetch_assignment(subject_identifier)
+    return previous_assignment unless previous_assignment.nil?
+    if subject_qualifies?(subject, context)
+      group = segmenter.assign(subject_identifier, subject, context)
+      subject_assignment(subject_identifier, group, nil, group.nil?)
+    else
+      subject_assignment(subject_identifier, nil, nil)
+    end
   end
 
   def assignment_without_unqualified_persistence(subject_identifier, subject, context)
     if subject_qualifies?(subject, context)
-      fetch_assignment(subject_identifier) ||
-        subject_assignment(subject_identifier, @segmenter.assign(subject_identifier, subject, context), nil)
+      previous_assignment = fetch_assignment(subject_identifier)
+      return previous_assignment unless previous_assignment.nil?
+      group = segmenter.assign(subject_identifier, subject, context)
+      subject_assignment(subject_identifier, group, nil, group.nil?)
     else 
       subject_assignment(subject_identifier, nil, nil)
     end
-  end  
+  end
 
   def subject_identifier(subject)
     subject.respond_to?(:id) ? subject.id : subject.to_s

data/lib/verdict/fixed_percentage_segmenter.rb

@@ -0,0 +1,52 @@
+class Verdict::FixedPercentageSegmenter < Verdict::Segmenter
+
+  class Group < Verdict::Group
+
+    attr_reader :percentile_range
+
+    def initialize(experiment, handle, percentile_range)
+      super(experiment, handle)
+      @percentile_range = percentile_range
+    end
+
+    def percentage_size
+      percentile_range.end - percentile_range.begin
+    end
+
+    def to_s
+      "#{handle} (#{percentage_size}%)"
+    end
+
+    def as_json(options = {})
+      super(options).merge(percentage: percentage_size)
+    end
+  end
+
+  def initialize(experiment)
+    super
+    @total_percentage_segmented = 0
+  end
+
+  def verify!
+    raise Verdict::SegmentationError, "Should segment exactly 100% of the cases, but segments add up to #{@total_percentage_segmented}%." if @total_percentage_segmented != 100
+  end
+
+  def register_group(handle, size)
+    percentage = size.kind_of?(Hash) && size[:percentage] ? size[:percentage] : size
+    n = case percentage
+      when :rest; 100 - @total_percentage_segmented
+      when :half; 50
+      when Integer; percentage
+      else Integer(percentage)
+    end
+
+    group = Group.new(experiment, handle, @total_percentage_segmented ... (@total_percentage_segmented + n))
+    @total_percentage_segmented += n
+    return group
+  end
+
+  def assign(identifier, subject, context)
+    percentile = Digest::MD5.hexdigest("#{@experiment.handle}#{identifier}").to_i(16) % 100
+    groups.values.find { |group| group.percentile_range.include?(percentile) }
+  end
+end

data/lib/verdict/rollout_segmenter.rb

@@ -0,0 +1,53 @@
+class Verdict::RolloutSegmenter < Verdict::Segmenter
+
+  class Group < Verdict::Group
+
+    attr_reader :percentile_range
+
+    def initialize(experiment, handle, percentile_range)
+      super(experiment, handle)
+      @percentile_range = percentile_range
+    end
+
+    def percentage_size
+      percentile_range.end - percentile_range.begin
+    end
+
+    def to_s
+      "#{handle} (#{percentage_size}%)"
+    end
+
+    def as_json(options = {})
+      super(options).merge(percentage: percentage_size)
+    end
+  end
+
+  def initialize(experiment)
+    super
+    @total_percentage_segmented = 0
+  end
+
+  def verify!
+    raise Verdict::SegmentationError, "Should segment less than 100% of the cases, but segments add up to #{@total_percentage_segmented}%." if @total_percentage_segmented >= 100
+  end
+
+  def register_group(handle, size)
+    percentage = size.kind_of?(Hash) && size[:percentage] ? size[:percentage] : size
+    n = case percentage
+      when :rest; 100 - @total_percentage_segmented
+      when :half; 50
+      when Integer; percentage
+      else Integer(percentage)
+    end
+
+    group = Group.new(experiment, handle, @total_percentage_segmented ... (@total_percentage_segmented + n))
+    @total_percentage_segmented += n
+    return group
+  end
+
+  def assign(identifier, subject, context)
+    percentile = Digest::MD5.hexdigest("#{@experiment.handle}#{identifier}").to_i(16) % 100
+    groups.values.find { |group| group.percentile_range.include?(percentile) }
+  end
+
+end

data/lib/verdict/segmenter.rb

@@ -1,78 +1,87 @@
 require 'digest/md5'
 
-module Verdict::Segmenter
-
-  class Base
-
-    attr_reader :experiment, :groups
-
-    def initialize(experiment)
-      @experiment = experiment
-      @groups = {}
-    end
-
-    def verify!
-    end
-
-    def group(identifier, subject, context)
-      raise NotImplementedError
-    end
+# Base class of all segmenters.
+#
+# The segmenter is responsible for assigning subjects to groups. You can
+# implement any assignment strategy you like by subclassing this class and
+# using it in your experiment.
+#
+# - You should implement the register_group method for the experiment definition DSL
+#   to make the system aware of the groups that the segmenter could return. 
+# - The verify! method is called after all the groups have been defined, so it can
+#   detect internal inconsistencies in the group definitions.
+# - The assign method is where your assignment magic lives.
+class Verdict::Segmenter
+
+  # The experiment to which this segmenter is associated
+  attr_reader :experiment
+
+  # A hash of the groups that are defined in this experiment, indexed by their
+  # handle. The assign method should return one of the groups in this hash
+  attr_reader :groups
+
+  def initialize(experiment)
+    @experiment = experiment
+    @groups = {}
   end
 
-  class StaticPercentage < Base
-
-    class Group < Verdict::Group
-
-      attr_reader :percentile_range
-
-      def initialize(experiment, handle, percentile_range)
-        super(experiment, handle)
-        @percentile_range = percentile_range
-      end
-
-      def percentage_size
-        percentile_range.end - percentile_range.begin
-      end
-
-      def to_s
-        "#{handle} (#{percentage_size}%)"
-      end
-
-      def as_json(options = {})
-        super(options).merge(percentage: percentage_size)
-      end
-    end
+  # DSL method to register a group. It calls the register_group method of the
+  # segmenter implementation
+  def group(handle, *args, &block)
+    group = register_group(handle, *args)
+    @groups[group.handle] = group
+    group.instance_eval(&block) if block_given?
+  end
 
-    def initialize(experiment)
-      super
-      @total_percentage_segmented = 0
-    end
+  # The group method is called from the experiment definition DSL.
+  # It should register a new group to the segmenter, with the given handle.
+  #
+  # - The handle parameter is a symbol that uniquely identifies the group within
+  #   this experiment.
+  # - The return value of this method should be a Verdict::Group instance.
+  def register_group(handle, *args)
+    raise NotImplementedError
+  end
 
-    def verify!
-      raise Verdict::SegmentationError, "Should segment exactly 100% of the cases, but segments add up to #{@total_percentage_segmented}%." if @total_percentage_segmented != 100
-    end
+  # The verify! method is called after all the groups have been defined in the
+  # experiment definition DSL. You can run any consistency checks in this method, 
+  # and if anything is off, you can raise a Verdict::SegmentationError to
+  # signify the problem.
+  def verify!
+    # noop by default
+  end
 
-    def group(handle, size, &block)
-      percentage = size.kind_of?(Hash) && size[:percentage] ? size[:percentage] : size
-      n = case percentage
-        when :rest; 100 - @total_percentage_segmented
-        when :half; 50
-        when Integer; percentage
-        else Integer(percentage)
-      end
+  # The assign method is called to assign a subject to one of the groups that have been defined
+  # in the segmenter implementation.
+  #
+  # - The identifier parameter is a string that uniquely identifies the subject.
+  # - The subject paramater is the  subject instance that was passed to the framework,
+  #   when the application code calls Experiment#assign or Experiment#switch.
+  # - The context parameter is an object that was passed to the framework, you can use this
+  #   object any way you like in your segmenting logic.
+  #
+  # This method should return the Verdict::Group instance to which the subject should be assigned.
+  # This instance should be one of the group instance that was registered in the definition DSL.
+  def assign(identifier, subject, context)
+    raise NotImplementedError
+  end
 
-      group = Group.new(experiment, handle, @total_percentage_segmented ... (@total_percentage_segmented + n))
-      @groups[group.handle] = group
-      @total_percentage_segmented += n
-      group.instance_eval(&block) if block_given?
-      return group
-    end
 
-    def assign(identifier, subject, context)
-      percentile = Digest::MD5.hexdigest("#{@experiment.handle}#{identifier}").to_i(16) % 100
-      _, group = groups.find { |_, group| group.percentile_range.include?(percentile) }
-      raise Verdict::SegmentationError, "Could not get segment for subject #{identifier.inspect}!" unless group
-      group
-    end
+  # This method is called whenever a subjects converts to a goal, i.e., when Experiment#convert
+  # is called. You can use this to implement a feedback loop in your segmenter.
+  #
+  # - The identifier parameter is a string that uniquely identifies the subject.
+  # - The subject paramater is the  subject instance that was passed to the framework,
+  #   when the application code calls Experiment#assign or Experiment#switch.
+  # - The conversion parameter is a Verdict::Conversion instance that describes what
+  #   goal the subject converted to.
+  #
+  # The return value of this method is not used.
+  def conversion_feedback(identifier, subject, conversion)
+    # noop by default
   end
 end
+
+require 'verdict/static_segmenter'
+require 'verdict/fixed_percentage_segmenter'
+require 'verdict/rollout_segmenter'

data/lib/verdict/static_segmenter.rb

@@ -0,0 +1,24 @@
+class Verdict::StaticSegmenter < Verdict::Segmenter
+
+  class Group < Verdict::Group
+
+    attr_reader :subject_identifiers
+
+    def initialize(experiment, handle, subject_identifiers)
+      super(experiment, handle)
+      @subject_identifiers = subject_identifiers
+    end
+
+    def as_json(options = {})
+      super(options).merge(subject_identifiers: subject_identifiers)
+    end
+  end
+
+  def register_group(handle, subject_identifiers)
+    Group.new(experiment, handle, subject_identifiers)
+  end
+
+  def assign(identifier, subject, context)
+    groups.values.find { |group| group.subject_identifiers.include?(identifier) }
+  end
+end

data/lib/verdict/version.rb

@@ -1,3 +1,3 @@
 module Verdict
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/test/experiment_test.rb

@@ -153,6 +153,20 @@ class ExperimentTest < MiniTest::Unit::TestCase
     e.assign(mock('subject'))
   end
 
+  def test_dont_store_when_segmenter_returns_nil
+    mock_store = Verdict::Storage::MockStorage.new
+    e = Verdict::Experiment.new('test') do
+      groups { group :all, 100 }
+      storage mock_store, store_unqualified: true
+    end
+
+    e.segmenter.stubs(:assign).returns(nil)
+    mock_store.expects(:store_assignment).never
+
+    assignment = e.assign(mock('subject'))
+    assert !assignment.qualified?
+  end
+
   def test_disqualify
     e = Verdict::Experiment.new('test') do
       groups { group :all, 100 }
@@ -177,12 +191,16 @@ class ExperimentTest < MiniTest::Unit::TestCase
   end
 
   def test_conversion_event_logging
-    e = Verdict::Experiment.new('test')
+    e = Verdict::Experiment.new('test')do
+      groups { group :all, 100 }
+    end
 
+    subject = stub(id: 'test_subject')
     e.stubs(:event_logger).returns(logger = mock('logger'))
     logger.expects(:log_conversion).with(kind_of(Verdict::Conversion))
+    e.segmenter.expects(:conversion_feedback).with('test_subject', subject, kind_of(Verdict::Conversion))
 
-    conversion = e.convert(subject = stub(id: 'test_subject'), :my_goal)
+    conversion = e.convert(subject, :my_goal)
     assert_equal 'test_subject', conversion.subject_identifier
     assert_equal :my_goal, conversion.goal 
   end
@@ -229,7 +247,7 @@ class ExperimentTest < MiniTest::Unit::TestCase
       storage storage_mock
     end
 
-    storage_mock.expects(:retrieve_assignment).returns(e.subject_assignment(mock('subject_identifier'), e.group(:all)))
+    storage_mock.expects(:retrieve_assignment).returns(e.subject_assignment(mock('subject_identifier'), e.group(:all), nil))
     storage_mock.expects(:store_assignment).raises(Verdict::StorageError, 'storage write issues')
     rescued_assignment = e.assign(stub(id: 456))
     assert !rescued_assignment.qualified?

data/test/{static_percentage_segmenter_test.rb → fixed_percentage_segmenter_test.rb}

@@ -1,15 +1,9 @@
 require 'test_helper'
 
-class StaticPercentageSegmenterTest < MiniTest::Unit::TestCase
-
-  MockExperiment = Struct.new(:handle)
-
-  def setup
-    Verdict.repository.clear
-  end
+class FixedPercentageSegmenterTest < MiniTest::Unit::TestCase
 
   def test_add_up_to_100_percent
-    s = Verdict::Segmenter::StaticPercentage.new(MockExperiment.new('test'))
+    s = Verdict::FixedPercentageSegmenter.new(Verdict::Experiment.new('test'))
     s.group :segment1, 1
     s.group :segment2, 54
     s.group :segment3, 27
@@ -24,7 +18,7 @@ class StaticPercentageSegmenterTest < MiniTest::Unit::TestCase
   end
 
   def test_definition_ofhalf_and_rest
-    s = Verdict::Segmenter::StaticPercentage.new(MockExperiment.new('test'))
+    s = Verdict::FixedPercentageSegmenter.new(Verdict::Experiment.new('test'))
     s.group :first_half, :half
     s.group :second_half, :rest
     s.verify!
@@ -36,7 +30,7 @@ class StaticPercentageSegmenterTest < MiniTest::Unit::TestCase
 
   def test_raises_if_less_than_100_percent
     assert_raises(Verdict::SegmentationError) do
-      s = Verdict::Segmenter::StaticPercentage.new(MockExperiment.new('test'))
+      s = Verdict::FixedPercentageSegmenter.new(Verdict::Experiment.new('test'))
       s.group :too_little, 99
       s.verify!
     end
@@ -44,14 +38,14 @@ class StaticPercentageSegmenterTest < MiniTest::Unit::TestCase
 
   def test_raises_if_greather_than_100_percent
     assert_raises(Verdict::SegmentationError) do
-      s = Verdict::Segmenter::StaticPercentage.new(MockExperiment.new('test'))
+      s = Verdict::FixedPercentageSegmenter.new(Verdict::Experiment.new('test'))
       s.group :too_much, 101
       s.verify!
     end
   end
 
   def test_consistent_assignment_for_subjects
-    s = Verdict::Segmenter::StaticPercentage.new(MockExperiment.new('test'))
+    s = Verdict::FixedPercentageSegmenter.new(Verdict::Experiment.new('test'))
     s.group :first_half, :half
     s.group :second_half, :rest
     s.verify!
@@ -63,7 +57,7 @@ class StaticPercentageSegmenterTest < MiniTest::Unit::TestCase
   end
 
   def test_fair_segmenting
-    s = Verdict::Segmenter::StaticPercentage.new(MockExperiment.new('test'))
+    s = Verdict::FixedPercentageSegmenter.new(Verdict::Experiment.new('test'))
     s.group :first_third, 33
     s.group :second_third, 33
     s.group :final_third, :rest
@@ -82,7 +76,7 @@ class StaticPercentageSegmenterTest < MiniTest::Unit::TestCase
   end
 
   def test_group_json_export
-    s = Verdict::Segmenter::StaticPercentage.new(MockExperiment.new('test'))
+    s = Verdict::FixedPercentageSegmenter.new(Verdict::Experiment.new('test'))
     s.group :first_third, 33
     s.group :rest, :rest
     s.verify!

data/test/rollout_segmenter_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class RolloutPercentageSegmenterTest < MiniTest::Unit::TestCase
+
+  def setup
+    @experiment = Verdict::Experiment.new('test') do
+      rollout_percentage 50
+    end
+  end
+
+  def test_assignment
+    included_subject = stub(id: 1)
+    excluded_subject = stub(id: 2)
+    
+    included_assignment = @experiment.assign(included_subject)
+    assert included_assignment.qualified?
+    assert included_assignment.permanent?
+
+    excluded_assignment = @experiment.assign(excluded_subject)
+    assert !excluded_assignment.qualified?
+    assert excluded_assignment.temporary?
+  end
+
+  def test_group_json_representation
+    json = JSON.parse(@experiment.segmenter.groups['enabled'].to_json)
+    assert_equal 'enabled', json['handle']
+    assert_equal 50, json['percentage']
+  end
+end

data/test/static_segmenter_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class StaticSegmenterTest < MiniTest::Unit::TestCase
+
+  def setup
+    @segmenter = Verdict::StaticSegmenter.new(Verdict::Experiment.new('test'))
+    @segmenter.group :beta, ['id1', 'id2']
+  end
+
+  def test_group_definition
+    assert_equal ['beta'], @segmenter.groups.keys
+    assert_equal ['id1', 'id2'], @segmenter.groups['beta'].subject_identifiers
+  end
+
+  def test_group_json_representation
+    json = JSON.parse(@segmenter.groups['beta'].to_json)
+    assert_equal 'beta', json['handle']
+    assert_equal ['id1', 'id2'], json['subject_identifiers']
+  end
+
+  def test_assigment
+    assert_equal @segmenter.groups['beta'], @segmenter.assign('id2', stub(id: 'id2'), nil)
+    assert_equal nil, @segmenter.assign('id3', stub(id: 'id3'), nil)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: verdict
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Shopify
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-17 00:00:00.000000000 Z
+date: 2014-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -28,56 +28,56 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: mocha
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Shopify Experiments classes
@@ -99,10 +99,13 @@ files:
 - lib/verdict/conversion.rb
 - lib/verdict/event_logger.rb
 - lib/verdict/experiment.rb
+- lib/verdict/fixed_percentage_segmenter.rb
 - lib/verdict/group.rb
 - lib/verdict/metadata.rb
 - lib/verdict/railtie.rb
+- lib/verdict/rollout_segmenter.rb
 - lib/verdict/segmenter.rb
+- lib/verdict/static_segmenter.rb
 - lib/verdict/storage.rb
 - lib/verdict/tasks.rake
 - lib/verdict/version.rb
@@ -111,11 +114,13 @@ files:
 - test/event_logger_test.rb
 - test/experiment_test.rb
 - test/experiments_repository_test.rb
+- test/fixed_percentage_segmenter_test.rb
 - test/group_test.rb
 - test/memory_subject_storage_test.rb
 - test/metadata_test.rb
 - test/redis_subject_storage_test.rb
-- test/static_percentage_segmenter_test.rb
+- test/rollout_segmenter_test.rb
+- test/static_segmenter_test.rb
 - test/test_helper.rb
 - verdict.gemspec
 homepage: http://github.com/Shopify/verdict
@@ -127,17 +132,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.4
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: A library to centrally define experiments for your application, and collect
@@ -148,10 +153,11 @@ test_files:
 - test/event_logger_test.rb
 - test/experiment_test.rb
 - test/experiments_repository_test.rb
+- test/fixed_percentage_segmenter_test.rb
 - test/group_test.rb
 - test/memory_subject_storage_test.rb
 - test/metadata_test.rb
 - test/redis_subject_storage_test.rb
-- test/static_percentage_segmenter_test.rb
+- test/rollout_segmenter_test.rb
+- test/static_segmenter_test.rb
 - test/test_helper.rb
-has_rdoc: