qfill 0.0.4 → 0.1.0

data/spec/qfill/origin_spec.rb

@@ -1,55 +1,65 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill::Origin do
-  context "#new" do
-    context "with no arguments" do
-      it "should raise ArgumentError" do
-       expect { Qfill::Origin.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::Origin.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::Origin.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::Origin.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 backfill" do
-      before :each do
-        @arguments = {  :name => "High List",
-                        :elements => [1, 2],
-                        :backfill => "Medium List" }
+
+    context 'with backfill' do
+      before do
+        @arguments = {  name: 'High List',
+                        elements: [1, 2],
+                        backfill: 'Medium List' }
       end
-      it "should instantiate with elements" do
-        Qfill::Origin.new(@arguments).backfill.should == 'Medium List'
+
+      it 'instantiates with elements' do
+        expect(described_class.new(@arguments).backfill).to eq('Medium List')
       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],
-                        :backfill => "Medium List",
-                        :filter => @filter }
+        @arguments = {  name: 'High List',
+                        elements: [1, 2],
+                        backfill: 'Medium List',
+                        filter: @filter }
       end
-      it "should instantiate with processor" do
-        Qfill::Origin.new(@arguments).filter.should be_a(Qfill::Filter)
-        Qfill::Origin.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

data/spec/qfill/popper_spec.rb

@@ -1,44 +1,50 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill::Popper do
-  context "#new" do
-    context "with no arguments" do
-      it "should raise ArgumentError" do
-        expect { Qfill::Popper.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::Origin.new(
-                                :name => "High List",
-                                :elements => [1, 2, 3, 'c'],
-                                :backfill => "Medium List",
-                                :filter => @filter),
-          Qfill::Origin.new( :name => "Medium List",
-                                :elements => ['e', 'f', 4, 5],
-                                :backfill => "Low List",
-                                :filter => @filter),
-          Qfill::Origin.new( :name => "Low List",
-                                :elements => [7, 8, 'd'],
-                                :backfill => nil,
-                                :filter => @filter)
+            name: 'High List',
+            elements: [1, 2, 3, 'c'],
+            backfill: 'Medium List',
+            filter: @filter
+          ),
+          Qfill::Origin.new(name: 'Medium List',
+                            elements: ['e', 'f', 4, 5],
+                            backfill: 'Low List',
+                            filter: @filter),
+          Qfill::Origin.new(name: 'Low List',
+                            elements: [7, 8, 'd'],
+                            backfill: nil,
+                            filter: @filter)
         ]
       end
-      it "should not raise any errors" do
-        expect { Qfill::Popper.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::Popper.new(*@origin_queues)
-        popper.queues.first.name.should == "High List"
-        popper.queues.last.name.should == "Low List"
+
+      it 'instantiates with name' do
+        popper = described_class.new(*@origin_queues)
+        expect(popper.queues.first.name).to eq('High List')
+        expect(popper.queues.last.name).to eq('Low List')
       end
-      it "should instantiate with elements" do
-        popper = Qfill::Popper.new(*@origin_queues)
-        popper.queues.first.elements.should == [1,2,3,'c']
-        popper.queues.last.elements.should == [7,8,'d']
+
+      it 'instantiates with elements' 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/pusher_spec.rb

@@ -1,38 +1,44 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill::Pusher do
-  context "#new" do
-    context "with no arguments" do
-      it "should raise ArgumentError" do
-        expect { Qfill::Pusher.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::Result.new({  :name => "Top Results",
-                                  :ratio => 0.4,
-                                  :list_ratios => {
-                                    "High Price" => 0.2,
-                                    "Medium Price" => 0.3,
-                                    "Low Price" => 0.5 } }),
-          Qfill::Result.new( {  :name => "Page Results",
-                                   :ratio => 0.6,
-                                   :list_ratios => {
-                                     "High Price" => 0.5,
-                                     "Medium Price" => 0.3,
-                                     "Low Price" => 0.2 } })
+          Qfill::Result.new({ name: 'Top Results',
+                              ratio: 0.4,
+                              list_ratios: {
+                                'High Price' => 0.2,
+                                'Medium Price' => 0.3,
+                                'Low Price' => 0.5
+                              } }),
+          Qfill::Result.new({ name: 'Page Results',
+                              ratio: 0.6,
+                              list_ratios: {
+                                'High Price' => 0.5,
+                                'Medium Price' => 0.3,
+                                'Low Price' => 0.2
+                              } })
         ]
       end
-      it "should not raise any errors" do
-        expect { Qfill::Pusher.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::Pusher.new(*@origin_queues)
-        popper.queues.first.name.should == "Top Results"
-        popper.queues.last.name.should == "Page Results"
+
+      it 'instantiates with name' do
+        popper = described_class.new(*@origin_queues)
+        expect(popper.queues.first.name).to eq('Top Results')
+        expect(popper.queues.last.name).to eq('Page Results')
       end
     end
   end
-
 end

data/spec/qfill/result_spec.rb

@@ -1,57 +1,68 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill::Result do
-  context "#new" do
-    context "with no arguments" do
-      it "should raise ArgumentError" do
-        expect { Qfill::Result.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 => "Best Results" }
+
+    context 'with name' do
+      before do
+        @arguments = { name: 'Best Results' }
       end
-      it "should not raise any errors" do
-        expect { Qfill::Result.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::Result.new(@arguments).name.should == 'Best Results'
+
+      it 'instantiates with name' do
+        expect(described_class.new(@arguments).name).to eq('Best Results')
       end
     end
-    context "with ratio" do
-      before :each do
-        @arguments = {  :name => "Best Results",
-                        :ratio => 0.5 }
+
+    context 'with ratio' do
+      before do
+        @arguments = {  name: 'Best Results',
+                        ratio: 0.5 }
       end
-      it "should instantiate with elements" do
-        Qfill::Result.new(@arguments).ratio.should == 0.5
+
+      it 'instantiates with elements' do
+        expect(described_class.new(@arguments).ratio).to eq(0.5)
       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 => "Best Results",
-                        :ratio => 0.5,
-                        :filter => @filter }
+        @arguments = {  name: 'Best Results',
+                        ratio: 0.5,
+                        filter: @filter }
       end
-      it "should instantiate with filter" do
-        Qfill::Result.new(@arguments).filter.should be_a(Qfill::Filter)
-        Qfill::Result.new(@arguments).filter.should == @filter
+
+      it 'instantiates with filter' do
+        expect(described_class.new(@arguments).filter).to be_a(Qfill::Filter)
+        expect(described_class.new(@arguments).filter).to eq(@filter)
       end
     end
-    context "with list_ratios" do
-      before :each do
-        @arguments = {  :name => "Best Results",
-                        :ratio => 0.5,
-                        :list_ratios => {
-                          "High Price" => 0.4,
-                          "Medium Price" => 0.3,
-                          "Low Price" => 0.3 } }
-      end
-      it "should instantiate with elements" do
-        Qfill::Result.new(@arguments).list_ratios["High Price"].should == 0.4
+
+    context 'with list_ratios' do
+      before do
+        @arguments = {  name: 'Best Results',
+                        ratio: 0.5,
+                        list_ratios: {
+                          'High Price' => 0.4,
+                          'Medium Price' => 0.3,
+                          'Low Price' => 0.3
+                        } }
+      end
+
+      it 'instantiates with elements' do
+        expect(described_class.new(@arguments).list_ratios['High Price']).to eq(0.4)
       end
     end
   end
-
 end

data/spec/qfill_spec.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 describe Qfill do
-  it "should have string version" do
-    Qfill::VERSION.should be_a(String)
+  it 'has string version' do
+    expect(Qfill::VERSION).to be_a(String)
   end
 
-  it "should have major, minor & patch version levels" do
-    Qfill::VERSION.should =~ /\d+\.\d+\.\d+/
+  it 'has major, minor & patch version levels' do
+    expect(Qfill::VERSION).to match(/\d+\.\d+\.\d+/)
   end
-
 end

data/spec/spec_helper.rb

@@ -1,49 +1,22 @@
+# frozen_string_literal: true
+
 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
-# loaded once.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'byebug' if RUBY_ENGINE == 'ruby'
+require 'support/helper'
+require 'support/random_object'
+
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
+  config.include Support::Helper
 
   # Run specs in random order to surface order dependencies. If you find an
   # order dependency and want to debug it, you can fix the order by providing
   # the seed, which is printed after each run.
   #     --seed 1234
   config.order = 'random'
+  config.before do
+    stub_const('Qfill::VERBOSE', false)
+  end
 end
-
-# TODO: Write some specs with this dude:
-#class RandomObject
-#
-#  attr_accessor :rating, :queue
-#  def initialize(options = {})
-#    @rating = options[:rating] || RandomObject.random_rating
-#    @queue = RandomObject.list_designation(self.rating)
-#  end
-#
-#  def self.random_rating
-#    rand(101) # 0 - 100
-#  end
-#
-#  def self.list_designation(rating)
-#    if rating == 0
-#      'none'
-#    elsif rating < 34
-#      'low'
-#    elsif rating < 67
-#      'medium'
-#    else
-#      'high'
-#    end
-#  end
-#
-#  def to_s
-#    "RO:#{rating}:#{queue}"
-#  end
-#end

data/spec/support/helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Support
+  module Helper
+    def build_elements(name, num)
+      array = []
+      Array.new(num).each_with_index.map do |_x, i|
+        array << "#{name}-#{i}"
+      end
+      array
+    end
+  end
+end