qfill 0.0.3 → 0.1.1

data/lib/qfill/strategy/drain_to_empty.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Qfill
+  module Strategy
+    class DrainToEmpty < Qfill::Strategy::Base
+      NAME = :drain_to_empty
+
+      def on_fill!
+        preferred_potential_ratio = 0
+        preferred_potential = 0
+        result.list_ratios.each do |list_name, list_ratio|
+          poppy = result.preferred.select { |x| x == list_name }
+          next unless poppy
+
+          preferred_potential_ratio += list_ratio
+          num = popper[list_name].elements.length
+          preferred_potential += num
+          result.max_tracker[list_name] = num
+        end
+        result.preferred_potential = preferred_potential
+        result.preferred_potential_ratio = preferred_potential_ratio
+      end
+
+      def result_max!
+        result.max = if result.preferred_potential_ratio.positive?
+                       [
+                         (result.preferred_potential / result.preferred_potential_ratio),
+                         primary_list_total,
+                         remaining
+                       ].min
+                     else
+                       [
+                         primary_list_total,
+                         remaining
+                       ].min
+                     end
+      end
+
+      def fill_up_to_ratio!
+        popper.primary.each do |queue|
+          array_to_push = popper.next_objects!(queue.name, [result.max, remaining].min)
+          self.added = result.push(array_to_push, queue.name)
+          popper.current_index = popper.index_of(queue.name)
+          bump!
+          puts "[fill_up_to_ratio!]#{self}[Q:#{queue.name}][added:#{added}]" if Qfill::VERBOSE
+          break if is_full?
+        end
+      end
+
+      def fill_according_to_list_ratios!
+        # Are there any elements in preferred queues that we should add?
+        return unless result.preferred_potential.positive?
+
+        # Setup a ratio modifier for the non-preferred queues
+        result.list_ratios.each do |list_name, list_ratio|
+          max_from_list = if result.max_tracker[list_name]
+                            [result.max_tracker[list_name], remaining].min
+                          else
+                            Qfill::Result.get_limit_from_max_and_ratio(
+                              result.max, list_ratio, remaining
+                            )
+                          end
+          array_to_push = popper.next_objects!(list_name, max_from_list)
+          self.added = result.push(array_to_push, list_name)
+          popper.current_index = popper.index_of(list_name)
+          bump!
+          puts "[fill_according_to_list_ratios!]#{self}[#{list_name}][added:#{added}]" if Qfill::VERBOSE
+          break if is_full?
+        end
+      end
+    end
+  end
+end

data/lib/qfill/strategy/drain_to_limit.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Qfill
+  module Strategy
+    class DrainToLimit < Qfill::Strategy::Base
+      NAME = :drain_to_limit
+
+      def on_fill!
+        # NOOP
+      end
+
+      def result_max!
+        result.max = Qfill::Result.get_limit_from_max_and_ratio(primary_list_total, result.ratio, remaining)
+      end
+
+      def fill_up_to_ratio!
+        num_primary = popper.primary.length
+        ratio = 1.0 / num_primary # 1 divided by the number of queues
+        max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, ratio, remaining)
+        popper.primary.each_with_index do |queue, idx|
+          # Are there leftovers that will be missed by a straight ratio'd iteration?
+          mod = result.max % num_primary
+          max_from_list += (mod / num_primary).ceil if idx.zero? && mod.positive?
+          array_to_push = popper.next_objects!(queue.name, [max_from_list, remaining].min)
+          self.added = result.push(array_to_push, queue.name)
+          popper.current_index = popper.index_of(queue.name)
+          puts "[fill_up_to_ratio!]#{self}[Q:#{queue.name}][added:#{added}]" if Qfill::VERBOSE
+          bump!
+          break if is_full?
+        end
+      end
+
+      def fill_according_to_list_ratios!
+        result.list_ratios.each do |list_name, list_ratio|
+          max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, list_ratio, remaining)
+          array_to_push = popper.next_objects!(list_name, max_from_list)
+          self.added = result.push(array_to_push, list_name)
+          popper.current_index = popper.index_of(list_name)
+          puts "[fill_according_to_list_ratios!]#{self}[#{list_name}][added:#{added}]" if Qfill::VERBOSE
+          bump!
+          break if is_full?
+        end
+      end
+    end
+  end
+end

data/lib/qfill/strategy/sample.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Qfill
+  module Strategy
+    class Sample < Qfill::Strategy::Base
+      NAME = :sample
+
+      def on_fill!
+        # NOOP
+      end
+
+      def result_max!
+        result.max = Qfill::Result.get_limit_from_max_and_ratio(primary_list_total, result.ratio, remaining)
+      end
+
+      def fill_up_to_ratio!
+        ratio = 1.0 / popper.primary.length # 1 divided by the number of queues
+        max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, ratio, remaining)
+        while !is_full? && !result.is_full? && !popper.totally_empty? && (origin_list = popper.current_list)
+          array_to_push = popper.next_objects!(origin_list.name, [max_from_list, remaining].min)
+          self.added = result.push(array_to_push, origin_list.name)
+          bump!
+          puts "[fill_up_to_ratio!]#{self}[Added:#{added}][Max List:#{max_from_list}][ratio:#{ratio}][added:#{added}]" if Qfill::VERBOSE
+          popper.set_next_as_current!
+        end
+      end
+
+      def fill_according_to_list_ratios!
+        # 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? && !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], remaining)
+          array_to_push = popper.next_objects!(list_ratio_tuple[0], max_from_list)
+          self.added = result.push(array_to_push, list_ratio_tuple[0])
+          bump!
+          puts "[fill_according_to_list_ratios!]#{self}[#{list_ratio_tuple[0]}][added:#{added}]" if Qfill::VERBOSE
+          result.set_next_as_current!
+          break if is_full?
+        end
+      end
+    end
+  end
+end

data/lib/qfill/strategy/time_slice.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Qfill
+  module Strategy
+    # Qfill::Manager.new(
+    #   :popper => popper,
+    #   :strategy_options => {
+    #     :window_size => 20,
+    #     :window_units => "minutes" # "days", "hours", "minutes", "seconds",
+    #     # NOTE: pane_size/units can't be larger than the window_size/units
+    #     :pane_size => 2
+    #     :pane_units => "seconds" # "days", "hours", "minutes", "seconds",
+    #   },
+    # )
+    class TimeSlice < Qfill::Strategy::Sample
+      NAME = :time_slice
+
+      def on_fill!
+        # NOOP
+      end
+
+      CONVERSIONS = {
+        %w[seconds seconds] => 1,
+        %w[seconds minutes] => 60,
+        %w[seconds hours] => 60 * 60,
+        %w[seconds days] => 60 * 60 * 24,
+        %w[minutes minutes] => 1,
+        %w[minutes hours] => 60,
+        %w[minutes days] => 60 * 24,
+        %w[hours hours] => 1,
+        %w[hours days] => 24,
+        %w[days days] => 1
+      }.freeze
+
+      # If window_units == "minutes" and pane_units == "seconds", and
+      #    window_size == 20 and pane_size == 2
+      # Then there would be (20 * CONVERSIONS[[pane_units, window_units]]) / pane_size
+      #   i.e.              (20 * 60) / 2
+      #   i.e.              600 individual panes in the (time) window, where each pane is a "result"
+      def default_pusher
+        ratio = 1 / num_panes.to_f
+        array = Range.new(1, num_panes).each_with_object([]) do |pane_num, arr|
+          arr << { name: pane_num.to_s, ratio: ratio }
+        end
+        Qfill::Pusher.from_array_of_hashes(array)
+      end
+
+      def window_size
+        strategy_options[:window_size]
+      end
+
+      def window_units
+        strategy_options[:window_units]
+      end
+
+      def pane_size
+        strategy_options[:pane_size]
+      end
+
+      def pane_units
+        strategy_options[:pane_units]
+      end
+
+      def conversion
+        conversion_idx = [pane_units, window_units]
+        conv = CONVERSIONS[conversion_idx]
+        raise ArgumentError, "pane_units: #{pane_units} must not be larger than window_units: #{window_units}" unless conv
+
+        conv
+      end
+
+      def num_panes
+        ((window_size * conversion) / pane_size)
+      end
+
+      def result_max!
+        result.max = Qfill::Result.get_limit_from_max_and_ratio(primary_list_total, result.ratio, remaining)
+      end
+
+      def fill_up_to_ratio!
+        ratio = 1.0 / popper.primary.length # 1 divided by the number of queues
+        max_from_list = Qfill::Result.get_limit_from_max_and_ratio(result.max, ratio, remaining)
+        while !is_full? && (take = [max_from_list, remaining].min) && (!result.is_full? || take == 1) && !popper.totally_empty? && (origin_list = popper.current_list)
+          array_to_push = popper.next_objects!(origin_list.name, take)
+          self.added = result.push(array_to_push, origin_list.name)
+          bump!
+          puts "[fill_up_to_ratio!]#{self}[Added:#{added}][Max List:#{max_from_list}][ratio:#{ratio}][take:#{take}]" if Qfill::VERBOSE
+          popper.set_next_as_current!
+        end
+      end
+
+      def fill_according_to_list_ratios!
+        # puts "#{!is_full?} && #{result.fill_count} >= #{result.max} && #{!self.popper.totally_empty?} && #{result.current_list_ratio}"
+        while !is_full? && !popper.totally_empty? && (list_ratio_tuple = result.current_list_ratio) && (take = Qfill::Result.get_limit_from_max_and_ratio(result.max, list_ratio_tuple[1], remaining)) && (!result.is_full? || take == 1)
+          array_to_push = popper.next_objects!(list_ratio_tuple[0], take)
+          self.added = result.push(array_to_push, list_ratio_tuple[0])
+          bump!
+          puts "[fill_according_to_list_ratios!]#{self}[#{list_ratio_tuple[0]}][added:#{added}]" if Qfill::VERBOSE
+          result.set_next_as_current!
+          break if is_full?
+        end
+      end
+    end
+  end
+end

data/lib/qfill/strategy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Qfill
+  # A Strategy defines how to process the elements in the queues
+  module Strategy
+  end
+end
+
+require 'qfill/strategy/base'
+require 'qfill/strategy/drain_to_empty'
+require 'qfill/strategy/drain_to_limit'
+require 'qfill/strategy/sample'
+require 'qfill/strategy/time_slice'

data/lib/qfill/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Qfill
-  VERSION = "0.0.3"
+  VERSION = '0.1.1'
 end

data/lib/qfill.rb

@@ -1,13 +1,16 @@
-require "qfill/version"
-require "qfill/filter"
-require "qfill/list"
-require "qfill/list_set"
-require "qfill/origin"
-require "qfill/result"
-require "qfill/popper"
-require "qfill/pusher"
-require "qfill/manager"
+# frozen_string_literal: true
+
+require 'qfill/version'
+require 'qfill/filter'
+require 'qfill/list'
+require 'qfill/list_set'
+require 'qfill/origin'
+require 'qfill/popper'
+require 'qfill/pusher'
+require 'qfill/manager'
+require 'qfill/result'
+require 'qfill/strategy'
 
 module Qfill
-  # Your code goes here...
+  VERBOSE = ENV['QFILL_VERBOSE'] == 'true'
 end

data/maintenance-branch

@@ -0,0 +1 @@
+master

data/qfill.gemspec

@@ -1,15 +1,16 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'qfill/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "qfill"
+  gem.name          = 'qfill'
   gem.version       = Qfill::VERSION
-  gem.authors       = ["Peter Boling"]
-  gem.email         = ["peter.boling@gmail.com"]
-  gem.description   = %q{Advanced Queue Transformation}
-  gem.summary       = %q{You have a set of arrays that need to be turned into a different set of arrays
+  gem.authors       = ['Peter Boling']
+  gem.email         = ['peter.boling@gmail.com']
+  gem.description   = 'Advanced Queue Transformation'
+  gem.summary       = 'You have a set of arrays that need to be turned into a different set of arrays
 according to a potentially non-uniform set of rules.
 
 Now you can easily turn this:
@@ -24,13 +25,14 @@ result_b # => [3,5,7,9]
 result_c # => [4,6,8]
 
 by specifying filters for handling each transformation.
-}
-  gem.homepage      = ""
+'
+  gem.homepage      = 'https://github.com/pboling/qfill'
 
-  gem.files         = `git ls-files`.split($/)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = ['lib']
 
-  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rake', '~> 13'
+  gem.add_development_dependency 'rspec', '~> 3'
 end

data/spec/qfill/filter_spec.rb

@@ -1,43 +1,52 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill::Filter do
-  context "#new" do
-    context "with processor" do
-      before :each do
-        @lambda = -> (object) { !object.nil? }
+  describe '#new' do
+    context 'with processor' do
+      before do
+        @lambda = ->(object) { !object.nil? }
       end
-      it "should instantiate with processor" do
-        Qfill::Filter.new(@lambda).should be_a(Qfill::Filter)
+
+      it 'instantiates with processor' do
+        expect(described_class.new(@lambda)).to be_a(described_class)
       end
     end
 
-    context "with processor and arguments" do
-      before :each do
-        @lambda = -> (object, first, second) { !object.nil? && first == first && second == 'second' }
-        @arguments = ['first','second']
+    context 'with processor and arguments' do
+      before do
+        @lambda = ->(object, first, second) { !object.nil? && first == first && second == 'second' }
+        @arguments = %w[first second]
       end
-      it "should instantiate with processor" do
-        Qfill::Filter.new(@lambda, *@arguments).should be_a(Qfill::Filter)
+
+      it 'instantiates with processor' do
+        expect(described_class.new(@lambda, *@arguments)).to be_a(described_class)
       end
     end
   end
 
-  context "#run" do
-    before :each do
-      @lambda = -> (object, first, second) { !object.nil? && first == first && second == 'second' }
-      @arguments = ['first','second']
-      @filter = Qfill::Filter.new(@lambda, *@arguments)
+  describe '#run' do
+    before do
+      @lambda = ->(object, first, second) { !object.nil? && first == first && second == 'second' }
+      @arguments = %w[first second]
+      @filter = described_class.new(@lambda, *@arguments)
     end
-    it "should return the correct result" do
-      @filter.run('not nil').should == true
+
+    it 'returns the correct result' do
+      expect(@filter.run('not nil')).to eq(true)
     end
-    context "with extra arguments" do
-      before :each do
-        @lambda = -> (object, special_arg1, special_arg2, first, second, third) { !object.nil? && first == first && second == 'second' && special_arg1 = 'this' && special_arg2 == 'thing' && third == 'third' }
-        @arguments = ['first','second','third']
-        @filter = Qfill::Filter.new(@lambda, *@arguments)
+
+    context 'with extra arguments' do
+      before do
+        @lambda = lambda { |object, _special_arg1, special_arg2, first, second, third|
+          !object.nil? && first == first && second == 'second' && special_arg1 = 'this' && special_arg2 == 'thing' && third == 'third'
+        }
+        @arguments = %w[first second third]
+        @filter = described_class.new(@lambda, *@arguments)
       end
-      it "should properly use arity" do
-        @filter.run('not nil', 'this', 'thing').should == true
+
+      it 'properlies use arity' do
+        expect(@filter.run('not nil', 'this', 'thing')).to eq(true)
       end
     end
   end

data/spec/qfill/list_set_spec.rb

@@ -1,36 +1,41 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill::ListSet do
-  context "#new" do
-    context "with no arguments" do
-      it "should raise ArgumentError" do
-        expect { Qfill::ListSet.new() }.to raise_error(ArgumentError)
+  describe '#new' do
+    context 'with no arguments' do
+      it 'raises ArgumentError' do
+        expect { described_class.new }.to raise_error(ArgumentError)
       end
     end
-    context "with arguments" do
-      before :each do
-        @filter = Qfill::Filter.new( -> (object) { object.is_a?(Numeric)} )
+
+    context 'with arguments' do
+      before do
+        @filter = Qfill::Filter.new(->(object) { object.is_a?(Numeric) })
         @origin_queues = [
           Qfill::List.new(
-            :name => "High List",
-            :elements => [1, 2, 3, 'c'],
-            :filter => @filter),
-          Qfill::List.new( :name => "Medium List",
-                               :elements => ['e', 'f', 4, 5],
-                               :filter => @filter),
-          Qfill::List.new( :name => "Low List",
-                               :elements => [7, 8, 'd'],
-                               :filter => @filter)
+            name: 'High List',
+            elements: [1, 2, 3, 'c'],
+            filter: @filter
+          ),
+          Qfill::List.new(name: 'Medium List',
+                          elements: ['e', 'f', 4, 5],
+                          filter: @filter),
+          Qfill::List.new(name: 'Low List',
+                          elements: [7, 8, 'd'],
+                          filter: @filter)
         ]
       end
-      it "should not raise any errors" do
-        expect { Qfill::ListSet.new(*@origin_queues) }.to_not raise_error
+
+      it 'does not raise any errors' do
+        expect { described_class.new(*@origin_queues) }.not_to raise_error
       end
-      it "should instantiate with name" do
-        popper = Qfill::ListSet.new(*@origin_queues)
-        popper.queues.first.elements.should == [1,2,3,'c']
-        popper.queues.last.elements.should == [7,8,'d']
+
+      it 'instantiates with name' do
+        popper = described_class.new(*@origin_queues)
+        expect(popper.queues.first.elements).to eq([1, 2, 3, 'c'])
+        expect(popper.queues.last.elements).to eq([7, 8, 'd'])
       end
     end
   end
-
 end

data/spec/qfill/list_spec.rb

@@ -1,44 +1,52 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill::List do
-  context "#new" do
-    context "with no arguments" do
-      it "should raise ArgumentError" do
-        expect { Qfill::List.new() }.to raise_error(ArgumentError)
+  describe '#new' do
+    context 'with no arguments' do
+      it 'raises ArgumentError' do
+        expect { described_class.new }.to raise_error(ArgumentError)
       end
     end
-    context "with name" do
-      before :each do
-        @arguments = { :name => "High List" }
+
+    context 'with name' do
+      before do
+        @arguments = { name: 'High List' }
       end
-      it "should not raise any errors" do
-        expect { Qfill::List.new(@arguments) }.to_not raise_error
+
+      it 'does not raise any errors' do
+        expect { described_class.new(@arguments) }.not_to raise_error
       end
-      it "should instantiate with name" do
-        Qfill::List.new(@arguments).name.should == 'High List'
+
+      it 'instantiates with name' do
+        expect(described_class.new(@arguments).name).to eq('High List')
       end
     end
-    context "with elements" do
-      before :each do
-        @arguments = {  :name => "High List",
-                        :elements => [1,2] }
+
+    context 'with elements' do
+      before do
+        @arguments = {  name: 'High List',
+                        elements: [1, 2] }
       end
-      it "should instantiate with elements" do
-        Qfill::List.new(@arguments).elements.should == [1,2]
+
+      it 'instantiates with elements' do
+        expect(described_class.new(@arguments).elements).to eq([1, 2])
       end
     end
-    context "with filter" do
-      before :each do
-        lambda = -> (object) { !object.nil? }
+
+    context 'with filter' do
+      before do
+        lambda = ->(object) { !object.nil? }
         @filter = Qfill::Filter.new(lambda)
-        @arguments = {  :name => "High List",
-                        :elements => [1, 2],
-                        :filter => @filter }
+        @arguments = {  name: 'High List',
+                        elements: [1, 2],
+                        filter: @filter }
       end
-      it "should instantiate with processor" do
-        Qfill::List.new(@arguments).filter.should be_a(Qfill::Filter)
-        Qfill::List.new(@arguments).filter.should == @filter
+
+      it 'instantiates with processor' do
+        expect(described_class.new(@arguments).filter).to be_a(Qfill::Filter)
+        expect(described_class.new(@arguments).filter).to eq(@filter)
       end
     end
   end
-
 end