qfill 0.0.3 → 0.0.4

data/lib/qfill.rb

@@ -9,5 +9,5 @@ require "qfill/pusher"
 require "qfill/manager"
 
 module Qfill
-  # Your code goes here...
+  VERBOSE = false
 end

data/lib/qfill/list_set.rb

@@ -17,6 +17,12 @@ module Qfill
       return self.queues.find { |queue| queue.name == key }
     end
 
+    def index_of(queue_name)
+      index = self.queues.index { |queue| queue.name == queue_name }
+      return index if index
+      raise "Fuck #{index} index is missing for #{queue_name}"
+    end
+
     def reset!
       self.current_index = 0
     end

data/lib/qfill/manager.rb

@@ -5,87 +5,162 @@
 #)
 module Qfill
   class Manager
-    attr_accessor :all_list_max, :popper, :pusher, :fill_count, :strategy
+    attr_accessor :all_list_max, :popper, :pusher, :fill_count, :strategy, :result
 
-    STRATEGY_OPTIONS = [:drain, :sample]
+    STRATEGY_OPTIONS = [:drain_to_limit, :drain_to_empty, :sample]
 
     def initialize(options = {})
       unless options[:popper] && options[:pusher]
         raise ArgumentError, "#{self.class}: popper and pusher are required options for #{self.class}.new(options)"
       end
       unless options[:strategy].nil? || STRATEGY_OPTIONS.include?(options[:strategy])
-        raise ArgumentError, "#{self.class}: strategy is optional, but must be one of #{STRATEGY_OPTIONS.inspect} if provided"
+        if options[:strategy] == :drain
+          warn "Qfill strategy :drain has been renamed :drain_to_limit, please update your code."
+          options[:strategy] = :drain_to_limit
+        else
+          raise ArgumentError, "#{self.class}: strategy is optional, but must be one of #{STRATEGY_OPTIONS.inspect} if provided"
+        end
       end
       @popper = options[:popper]
       @pusher = options[:pusher]
       # Provided by user, or defaults to the total number of primary elements in popper list set
-      @all_list_max = options[:all_list_max] ? [options[:all_list_max], self.popper.get_primary_elements].min : self.popper.get_primary_elements
+      @all_list_max = options[:all_list_max] ? [options[:all_list_max], self.popper.count_primary_elements].min : self.popper.count_primary_elements
       @fill_count = 0
-      @strategy = options[:strategy] || :drain # or :sample
+      @strategy = options[:strategy] || :drain_to_limit # or :drain_to_empty or :sample
     end
 
     def fill!
-      while !is_full? && !self.popper.primary_empty? && (result = self.pusher.current_list)
-        self.fill_to_ratio!(result, self.all_list_max)
+      while !is_full? && !self.popper.primary_empty? && (self.result = self.pusher.current_list)
+        if self.current_strategy == :drain_to_empty
+          preferred_potential_ratio = 0
+          preferred_potential = 0
+          self.result.list_ratios.each do |list_name, list_ratio|
+            poppy = self.result.preferred.select {|x| x == list_name}
+            if poppy
+              preferred_potential_ratio += list_ratio
+              num = self.popper[list_name].elements.length
+              preferred_potential += num
+              self.result.max_tracker[list_name] = num
+            end
+          end
+          self.result.preferred_potential = preferred_potential
+          self.result.preferred_potential_ratio = preferred_potential_ratio
+        end
+        self.fill_to_ratio!
         self.pusher.set_next_as_current!
+        self.result.elements.shuffle! if self.result.shuffle
       end
     end
 
-    def fill_to_ratio!(result, all_list_max)
-      result.max = Qfill::Result.get_limit_from_max_and_ratio(all_list_max, result.ratio)
+    def fill_to_ratio!
+      case self.current_strategy
+        when :drain_to_empty then
+          result.max = self.result.preferred_potential_ratio > 0 ? [(self.result.preferred_potential / self.result.preferred_potential_ratio), self.remaining_to_fill].min : self.remaining_to_fill
+        when :drain_to_limit, :sample then
+          result.max = Qfill::Result.get_limit_from_max_and_ratio(self.remaining_to_fill, result.ratio)
+      end
+      #result.max = Qfill::Result.get_limit_from_max_and_ratio(self.all_list_max, result.ratio)
       if !result.list_ratios.empty?
-        self.fill_according_to_list_ratios!(result)
+        self.fill_according_to_list_ratios!
       else
-        self.fill_up_to_ratio!(result)
+        self.fill_up_to_ratio!
       end
     end
 
-    def fill_according_to_list_ratios!(result)
+    def remaining_to_fill
+      self.all_list_max - self.fill_count
+    end
+
+    # Go through the queues this result should be filled from and push elements from them onto the current result list.
+    def fill_according_to_list_ratios!
       added = 0
-      if self.strategy == :drain
-        result.list_ratios.each do |list_name, list_ratio|
-          #puts "fill_according_to_list_ratios!, :drain, #{list_name}: Primary remaining => #{self.popper.get_primary_elements}"
-          max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, list_ratio)
-          array_to_push = self.popper.next_objects!(list_name, max_from_list)
-          added = result.push(array_to_push, list_name)
-        end
-        self.fill_count += added
-      elsif self.strategy == :sample
-        while !is_full? && !result.is_full? && !self.popper.totally_empty? && (list_ratio_tuple = result.current_list_ratio)
-          #puts "fill_according_to_list_ratios!, :sample, #{list_ratio_tuple[0]}: Primary remaining => #{self.popper.get_primary_elements}"
-          max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, list_ratio_tuple[1])
-          array_to_push = self.popper.next_objects!(list_ratio_tuple[0], max_from_list)
-          added = result.push(array_to_push, list_ratio_tuple[0])
-          self.fill_count += added
-          result.set_next_as_current!
-        end
+      tally = 0
+      ratio_modifier = 1
+      case self.current_strategy
+        when :drain_to_empty then
+          # Are there any elements in preferred queues that we should add?
+          if self.result.preferred_potential > 0
+            # Setup a ratio modifier for the non-preferred queues
+            result.list_ratios.each do |list_name, list_ratio|
+              max_from_list = self.result.max_tracker[list_name] || Qfill::Result.get_limit_from_max_and_ratio(result.max, list_ratio)
+              array_to_push = self.popper.next_objects!(list_name, max_from_list)
+              self.popper.current_index = self.popper.index_of(list_name)
+              added = result.push(array_to_push, list_name)
+              puts "[fill_according_to_list_ratios!]#{self}[#{list_name}][added:#{added}]" if Qfill::VERBOSE
+              tally += added
+            end
+            self.fill_count += tally
+          end
+        when :drain_to_limit
+          result.list_ratios.each do |list_name, list_ratio|
+            max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, list_ratio)
+            array_to_push = self.popper.next_objects!(list_name, max_from_list)
+            self.popper.current_index = self.popper.index_of(list_name)
+            added = result.push(array_to_push, list_name)
+            puts "[fill_according_to_list_ratios!]#{self}[#{list_name}][added:#{added}]" if Qfill::VERBOSE
+            tally += added
+          end
+          self.fill_count += tally
+        when :sample then
+          #puts "#{!is_full?} && #{result.fill_count} >= #{result.max} && #{!self.popper.totally_empty?} && #{(list_ratio_tuple = result.current_list_ratio)}"
+          while !is_full? && !result.is_full? && !self.popper.totally_empty? && (list_ratio_tuple = result.current_list_ratio)
+            max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, list_ratio_tuple[1])
+            array_to_push = self.popper.next_objects!(list_ratio_tuple[0], max_from_list)
+            added = result.push(array_to_push, list_ratio_tuple[0])
+            self.fill_count += added
+            puts "[fill_according_to_list_ratios!]#{self}[#{list_ratio_tuple[0]}][added:#{added}]" if Qfill::VERBOSE
+            result.set_next_as_current!
+          end
       end
     end
 
-    def fill_up_to_ratio!(result)
-      ratio = 1.0 / self.popper.primary.length
-      max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, ratio)
+    # Go through the primary (non backfill) queues in the popper and push elements from them onto the current result list.
+    def fill_up_to_ratio!
       added = 0
-      if self.strategy == :drain
+      tally = 0
+      if self.current_strategy == :drain_to_empty
         self.popper.primary.each do |queue|
-          #puts "fill_up_to_ratio!, :drain max #{max_from_list}, #{queue.name}: Primary remaining => #{self.popper.get_primary_elements}"
-          array_to_push = self.popper.next_objects!(queue.name, max_from_list)
+          array_to_push = self.popper.next_objects!(queue.name, result.max)
           added = result.push(array_to_push, queue.name)
+          self.popper.current_index = self.popper.index_of(queue.name)
+          puts "[fill_up_to_ratio!]#{self}[Q:#{queue.name}][added:#{added}]" if Qfill::VERBOSE
+          tally += added
         end
         self.fill_count += added
-      elsif self.strategy == :sample
-        while !is_full? && !result.is_full? && !self.popper.totally_empty? && (origin_list = self.popper.current_list)
-          #puts "fill_up_to_ratio!, :sample max #{max_from_list}, #{origin_list.name}: Primary remaining => #{self.popper.get_primary_elements}"
-          array_to_push = self.popper.next_objects!(origin_list.name, max_from_list)
-          added = result.push(array_to_push, origin_list.name)
-          self.fill_count += added
-          self.popper.set_next_as_current!
+      else
+        ratio = 1.0 / self.popper.primary.length # 1 divided by the number of queues
+        max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, ratio)
+        if self.current_strategy == :drain_to_limit
+          self.popper.primary.each do |queue|
+            array_to_push = self.popper.next_objects!(queue.name, max_from_list)
+            added = result.push(array_to_push, queue.name)
+            self.popper.current_index = self.popper.index_of(queue.name)
+            puts "[fill_up_to_ratio!]#{self}[Q:#{queue.name}][added:#{added}]" if Qfill::VERBOSE
+            tally += added
+          end
+          self.fill_count += tally
+        elsif self.current_strategy == :sample
+          while !is_full? && !result.is_full? && !self.popper.totally_empty? && (origin_list = self.popper.current_list)
+            array_to_push = self.popper.next_objects!(origin_list.name, max_from_list)
+            added = result.push(array_to_push, origin_list.name)
+            self.fill_count += added
+            puts "[fill_up_to_ratio!]#{self}[Added:#{added}][Max List:#{max_from_list}][ratio:#{ratio}][added:#{added}]" if Qfill::VERBOSE
+            self.popper.set_next_as_current!
+          end
         end
       end
     end
 
+    def current_strategy
+      (result.strategy || self.strategy)
+    end
+
     def is_full?
       self.fill_count >= self.all_list_max
     end
+
+    def to_s
+      "[#{self.current_strategy}][Result Max:#{result.max}][All Max:#{self.all_list_max}][Current Max:#{self.result.max}][Filled:#{self.fill_count}][Primary #:#{self.popper.count_primary_elements}]"
+    end
   end
 end

data/lib/qfill/popper.rb

@@ -81,14 +81,14 @@ module Qfill
     end
 
     def primary_empty?
-      self.get_primary_elements == 0
+      self.count_primary_elements == 0
     end
 
     def totally_empty?
       self.get_total_elements == 0
     end
 
-    def get_primary_elements
+    def count_primary_elements
       self.primary.inject(0) {|counter, queue| counter += queue.elements.length}
     end
 

data/lib/qfill/pusher.rb

@@ -44,9 +44,9 @@ module Qfill
       super(*args)
       with_ratio = self.queues.map {|x| x.ratio}.compact
       ratio_to_split = (1 - with_ratio.inject(0, :+))
-      if ratio_to_split < 0
-        raise ArgumentError, "#{self.class}: mismatched ratios for queues #{with_ratio.join(' + ')} must not total more than 1"
-      end
+      #if ratio_to_split < 0
+      #  raise ArgumentError, "#{self.class}: mismatched ratios for queues #{with_ratio.join(' + ')} must not total more than 1"
+      #end
       num_without_ratio = self.queues.length - with_ratio.length
       if num_without_ratio > 0 && ratio_to_split <= 1
         equal_portion = ratio_to_split / num_without_ratio

data/lib/qfill/result.rb

@@ -1,13 +1,18 @@
+# :preferred is used for :draim_to_empty
+# :ratio is used for the other strategies
 # Qfill::Result.new(:name => "Best Results",
 #                      :filter => filter3,
 #                      :ratio => 0.5,
 #                      :list_ratios => {
 #                        "High List" => 0.4,
 #                        "Medium List" => 0.2,
-#                        "Low List" => 0.4 } )
+#                        "Low List" => 0.4 },
+#                      :preferred => ["High List", "Medium List"]
+# )
 module Qfill
   class Result < Qfill::List
-    attr_accessor :ratio, :list_ratios, :fill_tracker, :fill_count, :validate, :filter, :current_list_ratio_index, :max
+    attr_accessor :ratio, :list_ratios, :fill_tracker, :fill_count, :current_count, :validate, :current_list_ratio_index, :max,
+                  :strategy, :shuffle, :preferred, :preferred_potential, :preferred_potential_ratio, :max_tracker
 
     def self.get_limit_from_max_and_ratio(all_list_max, ratio)
       limit = (all_list_max * ratio).round(0)
@@ -27,10 +32,17 @@ module Qfill
       if ratio_leftover < 0
         raise ArgumentError, "#{self.class}: invalid list_ratios for queue '#{self.name}'. List Ratios (#{with_ratio.join(' + ')}) must not total more than 1"
       end
-      @ratio = options[:ratio]
+      @ratio = options[:ratio] || 1
       @max = 0
+      @preferred = options[:preferred] # Used by :drain_to_empty and :drain_to_limit
+      @preferred_potential = 0
+      @preferred_potential_ratio = 0
+      @strategy = options[:strategy] # nil, :drain_to_limit, :drain_to_empty or :sample
       @fill_tracker = {}
+      @max_tracker = {}
       @fill_count = 0
+      @current_count = 0
+      @shuffle = options[:shuffle] || false
       @current_list_ratio_index = 0 # Used by :sample strategy
       @validate = self.use_validation?
     end
@@ -42,6 +54,7 @@ module Qfill
     def push(objects, list_name)
       self.validate!(list_name)
       added = 0
+      self.fill_tracker[list_name] ||= 0
       objects.each do |object|
         if self.allow?(object, list_name)
           self.bump_fill_tracker!(list_name)
@@ -68,9 +81,9 @@ module Qfill
     end
 
     def bump_fill_tracker!(list_name)
-      self.fill_tracker[list_name] ||= 0
       self.fill_tracker[list_name] += 1
       self.fill_count += 1
+      self.current_count += 1
     end
 
     # Does the queue being pushed into match one of the list_ratios
@@ -107,14 +120,15 @@ module Qfill
 
     def reset!
       self.current_list_ratio_index = 0
+      self.current_count = 0
     end
 
     def is_full?
-      self.fill_count >= self.max
+      self.current_count >= self.max
     end
 
     def to_s
-      "Qfill::Result: ratio: #{self.ratio}, list_ratios: #{self.list_ratios}, fill_tracker: #{self.fill_tracker}, fill_count: #{self.fill_count}, filter: #{!!self.filter ? 'Yes' : 'No'}, current_list_ratio_index: #{self.current_list_ratio_index}, max: #{self.max}"
+      "Qfill::Result: ratio: #{self.ratio}, list_ratios: #{self.list_ratios}, fill_tracker: #{self.fill_tracker}, fill_count: #{self.fill_count}, current_count: #{self.current_count}, filter: #{!!self.filter ? 'Yes' : 'No'}, current_list_ratio_index: #{self.current_list_ratio_index}, max: #{self.max}"
     end
   end
 end

data/lib/qfill/version.rb

@@ -1,3 +1,3 @@
 module Qfill
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/spec/qfill/manager_spec.rb

@@ -1,97 +1,259 @@
 require 'spec_helper'
 describe Qfill::Manager do
-  context "#new" do
-    context "with no arguments" do
-      it "should raise ArgumentError" do
-        expect { Qfill::Manager.new() }.to raise_error(ArgumentError)
-      end
-    end
-    context "with only popper" do
-      it "should raise ArgumentError" do
-        popper = Qfill::Popper.from_array_of_hashes(
-          [{ :name => "High List",
-            :elements => [1,2,3]}] )
-        expect { Qfill::Manager.new(:popper => popper) }.to raise_error(ArgumentError)
-      end
-    end
-    context "with only pusher" do
-      it "should raise ArgumentError" do
-        pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "Some Result",
-             :ratio => 0.25 }] )
-        expect { Qfill::Manager.new(:pusher => pusher) }.to raise_error(ArgumentError)
-      end
-    end
-    context "with popper and pusher" do
+  #context "#new" do
+  #  context "with no arguments" do
+  #    it "should raise ArgumentError" do
+  #      expect { Qfill::Manager.new() }.to raise_error(ArgumentError)
+  #    end
+  #  end
+  #  context "with only popper" do
+  #    it "should raise ArgumentError" do
+  #      popper = Qfill::Popper.from_array_of_hashes(
+  #        [{ :name => "High List",
+  #          :elements => [1,2,3]}] )
+  #      expect { Qfill::Manager.new(:popper => popper) }.to raise_error(ArgumentError)
+  #    end
+  #  end
+  #  context "with only pusher" do
+  #    it "should raise ArgumentError" do
+  #      pusher = Qfill::Pusher.from_array_of_hashes(
+  #        [{ :name => "Some Result",
+  #           :ratio => 0.25 }] )
+  #      expect { Qfill::Manager.new(:pusher => pusher) }.to raise_error(ArgumentError)
+  #    end
+  #  end
+  #  context "with popper and pusher" do
+  #    before :each do
+  #      @popper = Qfill::Popper.from_array_of_hashes(
+  #        [{ :name => "High List",
+  #           :elements => [1,2,3]}] )
+  #      @pusher = Qfill::Pusher.from_array_of_hashes(
+  #        [{ :name => "Some Result",
+  #           :ratio => 0.25 }] )
+  #      @arguments = {
+  #        :pusher => @pusher,
+  #        :popper => @popper
+  #      }
+  #    end
+  #    it "should not raise any errors" do
+  #      expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+  #    end
+  #    it "should instantiate with pusher" do
+  #      Qfill::Manager.new(@arguments).pusher.should == @pusher
+  #    end
+  #    it "should instantiate with popper" do
+  #      Qfill::Manager.new(@arguments).popper.should == @popper
+  #    end
+  #  end
+  #  context "with popper and pusher and all_list_max smaller than # total elements" do
+  #    before :each do
+  #      @popper = Qfill::Popper.from_array_of_hashes(
+  #        [{ :name => "High List",
+  #           :elements => [1,2,3]}] )
+  #      @pusher = Qfill::Pusher.from_array_of_hashes(
+  #        [{ :name => "Some Result",
+  #           :ratio => 0.25 }] )
+  #      @arguments = {
+  #        :pusher => @pusher,
+  #        :popper => @popper,
+  #        :all_list_max => 2
+  #      }
+  #    end
+  #    it "should not raise any errors" do
+  #      expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+  #    end
+  #    it "should instantiate with pusher" do
+  #      Qfill::Manager.new(@arguments).pusher.should == @pusher
+  #    end
+  #    it "should instantiate with popper" do
+  #      Qfill::Manager.new(@arguments).popper.should == @popper
+  #    end
+  #    it "should instantiate with all_list_max" do
+  #      Qfill::Manager.new(@arguments).all_list_max.should == 2
+  #    end
+  #  end
+  #  context "all_list_max greater than # total elements" do
+  #    before :each do
+  #      @popper = Qfill::Popper.from_array_of_hashes(
+  #        [{ :name => "High List",
+  #           :elements => [1,2,3]}] )
+  #      @pusher = Qfill::Pusher.from_array_of_hashes(
+  #        [{ :name => "Some Result",
+  #           :ratio => 0.25 }] )
+  #      @arguments = {
+  #        :pusher => @pusher,
+  #        :popper => @popper,
+  #        :all_list_max => 666
+  #      }
+  #    end
+  #    it "should instantiate with all_list_max" do
+  #      Qfill::Manager.new(@arguments).all_list_max.should == 3
+  #    end
+  #  end
+  #end
+  context "strategy => :sample" do
+    context "backfill => false" do
       before :each do
         @popper = Qfill::Popper.from_array_of_hashes(
-          [{ :name => "High List",
-             :elements => [1,2,3]}] )
+          # We will create 4 queues, high, medium, low, and none.
+          # These might be queue of things that have ratings, and the none queue for things which have not yet been rated.
+          # The backfill route of the queues then, assuming we want people to rate the things that are not yet rated,
+          #   but not at the expense of hte experience, would be:
+          # high => medium => none => low
+          [{:name => 'high',
+            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
+            :backfill => 'medium'},
+           {:name => "medium",
+            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
+            :backfill => 'none'},
+           {:name => 'low',
+            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
+            :backfill => false},
+           {:name => 'none',
+            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
+            :backfill => 'low' }] )
         @pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "Some Result",
+          [{ :name => "first",
+             :list_ratios => {
+               'high' => 0.5,
+               'medium' => 0.1,
+               'none' => 0.4
+             },
+             :ratio => 0.25 },
+           { :name => "second",
+             :ratio => 0.50 },
+           { :name => "third",
              :ratio => 0.25 }] )
         @arguments = {
           :pusher => @pusher,
-          :popper => @popper
+          :popper => @popper,
+          :all_list_max => 40,
+          :strategy => :sample
         }
       end
-      it "should not raise any errors" do
-        expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+      context "#new" do
+        it "should not raise any errors" do
+          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+        end
       end
-      it "should instantiate with pusher" do
-        Qfill::Manager.new(@arguments).pusher.should == @pusher
+      context "#fill!" do
+        it "should instantiate with pusher" do
+          expect { Qfill::Manager.new(@arguments).fill!  }.to_not raise_error
+        end
       end
-      it "should instantiate with popper" do
-        Qfill::Manager.new(@arguments).popper.should == @popper
+      context "results" do
+        before(:each) do
+          @manager = Qfill::Manager.new(@arguments)
+        end
+        context "before fill!" do
+          it "should calculate the correct popper total elements" do
+            @manager.popper.get_total_elements.should == 36
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.count_primary_elements == 36
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 0
+          end
+        end
+        context "after fill!" do
+          before(:each) do
+            @manager.fill!
+          end
+          it "should calculate the correct popper total elements" do
+            @manager.popper.get_total_elements.should == 0
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.count_primary_elements == 0
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 36
+          end
+        end
       end
     end
-    context "with popper and pusher and all_list_max smaller than # total elements" do
+    context "backfill => true" do
       before :each do
         @popper = Qfill::Popper.from_array_of_hashes(
-          [{ :name => "High List",
-             :elements => [1,2,3]}] )
+          # We will create 4 queues, high, medium, low, and none.
+          # These might be queue of things that have ratings, and the none queue for things which have not yet been rated.
+          # The backfill route of the queues then, assuming we want people to rate the things that are not yet rated,
+          #   but not at the expense of hte experience, would be:
+          # high => medium => none => low
+          [{:name => 'high',
+            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
+            :backfill => 'medium'},
+           {:name => "medium",
+            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
+            :backfill => 'none'},
+           {:name => 'low',
+            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
+            :backfill => true},
+           {:name => 'none',
+            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
+            :backfill => 'low' }] )
         @pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "Some Result",
+          [{ :name => "first",
+             :list_ratios => {
+               'high' => 0.5,
+               'medium' => 0.1,
+               'none' => 0.4
+             },
+             :ratio => 0.25 },
+           { :name => "second",
+             :ratio => 0.50 },
+           { :name => "third",
              :ratio => 0.25 }] )
         @arguments = {
           :pusher => @pusher,
           :popper => @popper,
-          :all_list_max => 2
+          :all_list_max => 40,
+          :strategy => :sample
         }
       end
-      it "should not raise any errors" do
-        expect { Qfill::Manager.new(@arguments) }.to_not raise_error
-      end
-      it "should instantiate with pusher" do
-        Qfill::Manager.new(@arguments).pusher.should == @pusher
-      end
-      it "should instantiate with popper" do
-        Qfill::Manager.new(@arguments).popper.should == @popper
-      end
-      it "should instantiate with all_list_max" do
-        Qfill::Manager.new(@arguments).all_list_max.should == 2
+      context "#new" do
+        it "should not raise any errors" do
+          expect { Qfill::Manager.new(@arguments) }.to_not raise_error
+        end
       end
-    end
-    context "all_list_max greater than # total elements" do
-      before :each do
-        @popper = Qfill::Popper.from_array_of_hashes(
-          [{ :name => "High List",
-             :elements => [1,2,3]}] )
-        @pusher = Qfill::Pusher.from_array_of_hashes(
-          [{ :name => "Some Result",
-             :ratio => 0.25 }] )
-        @arguments = {
-          :pusher => @pusher,
-          :popper => @popper,
-          :all_list_max => 666
-        }
+      context "#fill!" do
+        it "should instantiate with pusher" do
+          expect { Qfill::Manager.new(@arguments).fill!  }.to_not raise_error
+        end
       end
-      it "should instantiate with all_list_max" do
-        Qfill::Manager.new(@arguments).all_list_max.should == 3
+      context "results" do
+        before(:each) do
+          @manager = Qfill::Manager.new(@arguments)
+        end
+        context "before fill!" do
+          it "should calculate the correct popper total elements" do
+            @manager.popper.get_total_elements.should == 36
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.count_primary_elements == 27
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 0
+          end
+        end
+        context "after fill!" do
+          before(:each) do
+            @manager.fill!
+          end
+          it "should calculate the correct popper total elements" do
+            @manager.popper.get_total_elements.should == 8
+          end
+          it "should calculate the correct popper primary elements" do
+            @manager.popper.count_primary_elements == 0
+          end
+          it "should calculate the correct pusher total elements" do
+            @manager.pusher.get_total_elements.should == 28
+          end
+        end
       end
     end
   end
-  context "strategy => :sample" do
+  context "strategy :drain_to_limit" do
     context "backfill => false" do
       before :each do
         @popper = Qfill::Popper.from_array_of_hashes(
@@ -128,7 +290,7 @@ describe Qfill::Manager do
           :pusher => @pusher,
           :popper => @popper,
           :all_list_max => 40,
-          :strategy => :sample
+          :strategy => :drain_to_limit
         }
       end
       context "#new" do
@@ -150,7 +312,7 @@ describe Qfill::Manager do
             @manager.popper.get_total_elements.should == 36
           end
           it "should calculate the correct popper primary elements" do
-            @manager.popper.get_primary_elements == 36
+            @manager.popper.count_primary_elements == 36
           end
           it "should calculate the correct pusher total elements" do
             @manager.pusher.get_total_elements.should == 0
@@ -161,10 +323,10 @@ describe Qfill::Manager do
             @manager.fill!
           end
           it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 0
+            @manager.popper.get_total_elements.should == 0 # With drain_to_limit the results do not exactly match the requested ratios.
           end
           it "should calculate the correct popper primary elements" do
-            @manager.popper.get_primary_elements == 0
+            @manager.popper.count_primary_elements == 0
           end
           it "should calculate the correct pusher total elements" do
             @manager.pusher.get_total_elements.should == 36
@@ -208,7 +370,7 @@ describe Qfill::Manager do
           :pusher => @pusher,
           :popper => @popper,
           :all_list_max => 40,
-          :strategy => :sample
+          :strategy => :drain_to_limit
         }
       end
       context "#new" do
@@ -230,7 +392,7 @@ describe Qfill::Manager do
             @manager.popper.get_total_elements.should == 36
           end
           it "should calculate the correct popper primary elements" do
-            @manager.popper.get_primary_elements == 27
+            @manager.popper.count_primary_elements == 27
           end
           it "should calculate the correct pusher total elements" do
             @manager.pusher.get_total_elements.should == 0
@@ -241,19 +403,19 @@ describe Qfill::Manager do
             @manager.fill!
           end
           it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 9
+            @manager.popper.get_total_elements.should == 7 # With drain_to_limit the results do not exactly match the requested ratios.
           end
           it "should calculate the correct popper primary elements" do
-            @manager.popper.get_primary_elements == 0
+            @manager.popper.count_primary_elements == 0
           end
           it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 27
+            @manager.pusher.get_total_elements.should == 29
           end
         end
       end
     end
   end
-  context "strategy :drain" do
+  context "strategy :drain_to_empty" do
     context "backfill => false" do
       before :each do
         @popper = Qfill::Popper.from_array_of_hashes(
@@ -281,16 +443,22 @@ describe Qfill::Manager do
                'medium' => 0.1,
                'none' => 0.4
              },
-             :ratio => 0.25 },
+             :preferred => ['high', 'none']
+           },
            { :name => "second",
-             :ratio => 0.50 },
-           { :name => "third",
-             :ratio => 0.25 }] )
+             :list_ratios => {
+               'high' => 0.5,
+               'medium' => 0.4,
+               'none' => 0.1
+             },
+             :preferred => ['high', 'medium']
+           },
+           { :name => "third" }] )
         @arguments = {
           :pusher => @pusher,
           :popper => @popper,
           :all_list_max => 40,
-          :strategy => :drain
+          :strategy => :drain_to_empty
         }
       end
       context "#new" do
@@ -312,7 +480,7 @@ describe Qfill::Manager do
             @manager.popper.get_total_elements.should == 36
           end
           it "should calculate the correct popper primary elements" do
-            @manager.popper.get_primary_elements == 36
+            @manager.popper.count_primary_elements == 36
           end
           it "should calculate the correct pusher total elements" do
             @manager.pusher.get_total_elements.should == 0
@@ -323,10 +491,10 @@ describe Qfill::Manager do
             @manager.fill!
           end
           it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 0 # With drain the results do not exactly match the requested ratios.
+            @manager.popper.get_total_elements.should == 0 # With drain_to_limit the results do not exactly match the requested ratios.
           end
           it "should calculate the correct popper primary elements" do
-            @manager.popper.get_primary_elements == 0
+            @manager.popper.count_primary_elements == 0
           end
           it "should calculate the correct pusher total elements" do
             @manager.pusher.get_total_elements.should == 36
@@ -343,16 +511,16 @@ describe Qfill::Manager do
           #   but not at the expense of hte experience, would be:
           # high => medium => none => low
           [{:name => 'high',
-            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
+            :elements => %w( h1 h2 h3 h4 h5 h6 h7 h8 h9 h1 h2 h3 h4 h5 h6 h7 h8 h9 h1 h2 h3 h4 h5 h6 h7 h8 h9 h1 h2 h3 h4 h5 h6 h7 h8 h9 ),
             :backfill => 'medium'},
            {:name => "medium",
-            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
+            :elements => %w( m1 m2 m3 m4 m5 m6 m7 m8 m9 m1 m2 m3 m4 m5 m6 m7 m8 m9 m1 m2 m3 m4 m5 m6 m7 m8 m9 m1 m2 m3 m4 m5 m6 m7 m8 m9 ),
             :backfill => 'none'},
            {:name => 'low',
-            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
+            :elements => %w( l1 l2 l3 l4 l5 l6 l7 l8 l9 l1 l2 l3 l4 l5 l6 l7 l8 l9 l1 l2 l3 l4 l5 l6 l7 l8 l9 l1 l2 l3 l4 l5 l6 l7 l8 l9 ),
             :backfill => true},
            {:name => 'none',
-            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
+            :elements => %w( n1 n2 n3 n4 n5 n6 n7 n8 n9 n1 n2 n3 n4 n5 n6 n7 n8 n9 n1 n2 n3 n4 n5 n6 n7 n8 n9 n1 n2 n3 n4 n5 n6 n7 n8 n9 ),
             :backfill => 'low' }] )
         @pusher = Qfill::Pusher.from_array_of_hashes(
           [{ :name => "first",
@@ -361,7 +529,9 @@ describe Qfill::Manager do
                'medium' => 0.1,
                'none' => 0.4
              },
-             :ratio => 0.25 },
+             :ratio => 1,
+             :preferred => ['high', 'none']
+           },
            { :name => "second",
              :ratio => 0.50 },
            { :name => "third",
@@ -370,7 +540,7 @@ describe Qfill::Manager do
           :pusher => @pusher,
           :popper => @popper,
           :all_list_max => 40,
-          :strategy => :drain
+          :strategy => :drain_to_limit
         }
       end
       context "#new" do
@@ -389,10 +559,10 @@ describe Qfill::Manager do
         end
         context "before fill!" do
           it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 36
+            @manager.popper.get_total_elements.should == 144
           end
           it "should calculate the correct popper primary elements" do
-            @manager.popper.get_primary_elements == 27
+            @manager.popper.count_primary_elements == 27
           end
           it "should calculate the correct pusher total elements" do
             @manager.pusher.get_total_elements.should == 0
@@ -403,13 +573,13 @@ describe Qfill::Manager do
             @manager.fill!
           end
           it "should calculate the correct popper total elements" do
-            @manager.popper.get_total_elements.should == 7 # With drain the results do not exactly match the requested ratios.
+            @manager.popper.get_total_elements.should == 104 # With drain_to_empty the results do not exactly match the requested ratios.
           end
           it "should calculate the correct popper primary elements" do
-            @manager.popper.get_primary_elements == 0
+            @manager.popper.count_primary_elements == 0
           end
           it "should calculate the correct pusher total elements" do
-            @manager.pusher.get_total_elements.should == 29
+            @manager.pusher.get_total_elements.should == 40
           end
         end
       end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require 'qfill'
+Qfill::VERBOSE = false
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # Require this file using `require "spec_helper"` to ensure that it is only

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qfill
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-12 00:00:00.000000000 Z
+date: 2013-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec