fat_core 4.11.0 → 4.12.1

data/spec/lib/enumerable_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'fat_core/enumerable'
 
 describe Enumerable do
-  it 'should be able to emit in groups of size k' do
+  it 'enumerates groups of size k' do
     letters = ('a'..'z').to_a
     letters.groups_of(3).each do |k, grp|
       expect(grp.class).to eq Array
@@ -16,18 +16,18 @@ describe Enumerable do
     end
   end
 
-  it 'should be able to yield each with flags' do
+  it 'enumerates each with first and last flags' do
     letters = ('a'..'z').to_a
     letters.each_with_flags do |l, first, last|
       if l == 'a'
-        expect(first).to eq true
-        expect(last).to eq false
+        expect(first).to be true
+        expect(last).to be false
       elsif l == 'z'
-        expect(first).to eq false
-        expect(last).to eq true
+        expect(first).to be false
+        expect(last).to be true
       else
-        expect(first).to eq false
-        expect(last).to eq false
+        expect(first).to be false
+        expect(last).to be false
       end
     end
   end

data/spec/lib/hash_spec.rb

@@ -2,19 +2,19 @@ require 'spec_helper'
 require 'fat_core/hash'
 
 describe Hash do
-  it 'should be able to find keys with a value == to X' do
+  it 'finds keys with a value == to X' do
     hh = { :a => 1, :b => 2, :c => 1 }
     expect(hh.keys_with_value(1)).to eq [:a, :c]
     expect(hh.keys_with_value(9)).to eq []
   end
 
-  it 'should be able to delete entries with a value == to X' do
+  it 'deletes entries with a value == to X' do
     hh = { :a => 1, :b => 2, :c => 1 }
     expect(hh.delete_with_value(1)).to eq({ :b => 2 })
     expect(hh.delete_with_value(9)).to eq hh
   end
 
-  it 'should be able to map keys to new keys' do
+  it 'maps keys to new keys' do
     hh = { :a => 1, :b => 2, :c => 1 }
     remap = { :a => :d, :b => :e, :c => :f }
     expect(hh.remap_keys(remap)).to eq({ :d => 1, :e => 2, :f => 1 })

data/spec/lib/kernel_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'fat_core/kernel'
 
 describe Kernel do
-  it 'should know how to time a block of code' do
+  it 'knows how to time a block of code' do
     $stdout = StringIO.new
     result = time_it 'do something' do
       (1..10_000_000).each { |k| k * k }

data/spec/lib/nil_spec.rb

@@ -2,15 +2,15 @@ require 'spec_helper'
 require 'fat_core/nil'
 
 describe NilClass do
-  it 'should respond to entitle' do
+  it 'responds to entitle' do
     expect(nil.entitle).to eq ''
   end
 
-  it 'should respond to tex_quote' do
+  it 'responds to tex_quote' do
     expect(nil.tex_quote).to eq ''
   end
 
-  it 'should respond to commas' do
+  it 'responds to commas' do
     expect(nil.commas).to eq ''
   end
 end

data/spec/lib/numeric_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'fat_core/numeric'
 
 describe Numeric do
-  it 'should implement signum function' do
+  it 'implements signum function' do
     # Integers
     expect(33.signum).to eq 1
     expect(-33.signum).to eq(-1)
@@ -14,26 +14,26 @@ describe Numeric do
     expect(0.0.signum).to eq 0
   end
 
-  it 'should provide a tex_quote method for erb docs' do
+  it 'provides a tex_quote method for erb docs' do
     expect(195.45.tex_quote).to eq '195.45'
   end
 
-  it 'should be able to report if its a whole number' do
+  it 'knows if its a whole number' do
     expect(236.whole?).to be true
     expect(236.5555.whole?).to be false
   end
 
-  it 'should properly round up' do
+  it 'properly rounds up' do
     expect(236.5555.commas(2)).to eq '236.56'
     expect(-236.5555.commas(2)).to eq '-236.56'
   end
 
-  it 'should properly round down' do
+  it 'properly rounds down' do
     expect(236.5512.commas(2)).to eq '236.55'
     expect(-236.5512.commas(2)).to eq '-236.55'
   end
 
-  it 'should place commas properly' do
+  it 'places commas properly' do
     expect(123_456_789.0123.commas(2)).to eq '123,456,789.01'
     expect(-123_456_789.0123.commas(2)).to eq '-123,456,789.01'
 
@@ -44,22 +44,22 @@ describe Numeric do
     expect(-123_456_789.00.commas).to eq '-123,456,789'
   end
 
-  it 'should be able to convert a non-fractional float to an int' do
+  it 'converts a non-fractional float to an int' do
     expect(195.45.int_if_whole).to eq 195.45
     expect(195.0.int_if_whole).to eq 195
     expect(195.0.int_if_whole.is_a?(Integer)).to be true
   end
 
-  it 'should place commas properly with no fraction' do
+  it 'places commas properly with no fraction' do
     expect(123_456_789.commas).to eq '123,456,789'
     expect(-123_456_789.commas).to eq '-123,456,789'
   end
 
-  it 'should not place commas in a number with exponent' do
+  it 'does not place commas in a number with exponent' do
     expect(123_456.789e100.commas).to eq '1.23456789e+105'
   end
 
-  it 'should be able to convert itself into an H:M:S string' do
+  it 'converts itself into an H:M:S string' do
     expect(60.secs_to_hms).to eq('00:01:00')
     expect(120.secs_to_hms).to eq('00:02:00')
     expect(6584.secs_to_hms).to eq('01:49:44')

data/spec/lib/range_spec.rb

@@ -3,7 +3,7 @@ require 'fat_core/range'
 
 describe Range do
   describe 'set operations' do
-    it 'should know if it is a subset of another range' do
+    it 'knows if it is a subset of another range' do
       expect((4..8)).to be_subset_of((2..9))
       expect((4..8)).to be_subset_of((4..8))
       expect((4..8)).not_to be_subset_of((2..7))
@@ -11,7 +11,7 @@ describe Range do
       expect((4..8)).not_to be_subset_of((11..20))
     end
 
-    it 'should know if it is a proper subset of another range' do
+    it 'knows if it is a proper subset of another range' do
       expect((4..8)).to be_proper_subset_of((2..9))
       expect((4..8)).to be_proper_subset_of((4..9))
       expect((4..8)).not_to be_proper_subset_of((4..8))
@@ -20,7 +20,7 @@ describe Range do
       expect((4..8)).not_to be_proper_subset_of((11..20))
     end
 
-    it 'should know if it is a superset of another range' do
+    it 'knows if it is a superset of another range' do
       expect((4..8)).to be_superset_of((5..7))
       expect((4..8)).to be_superset_of((6..8))
       expect((4..8)).to be_superset_of((4..7))
@@ -34,7 +34,7 @@ describe Range do
       expect((4..8)).not_to be_superset_of((9..20))
     end
 
-    it 'should know if it is a proper superset of another range' do
+    it 'knows if it is a proper superset of another range' do
       expect((4..8)).to be_proper_superset_of((5..7))
       expect((4..8)).to be_proper_superset_of((6..8))
       expect((4..8)).to be_proper_superset_of((4..7))
@@ -48,7 +48,7 @@ describe Range do
       expect((4..8)).not_to be_proper_superset_of((9..20))
     end
 
-    it 'should know its intersection with another range' do
+    it 'knows its intersection with another range' do
       expect(((0..10) & (5..20))).to eq((5..10))
       expect(((0..10) & (5..20))).to eq((5..20) & (0..10))
       expect(((0..10) & (10..20))).to eq((10..10))
@@ -58,7 +58,7 @@ describe Range do
       expect(((0..10) & (15..20))).to be_nil
     end
 
-    it 'should know its union with another range' do
+    it 'knows its union with another range' do
       expect(((0..10) + (5..20))).to eq((0..20))
       expect(((0..10) + (5..20))).to eq((5..20) + (0..10))
       expect(((0..10) + (10..20))).to eq((0..20))
@@ -72,7 +72,7 @@ describe Range do
       expect(((15..20) & (0..10))).to be_nil
     end
 
-    it 'should know the difference with another range' do
+    it 'knows the difference with another range' do
       # Other is same as self
       expect(((4..10) - (4..10)).size).to eq(0)
       expect(((4..10) - (4..10))).to be_empty
@@ -104,12 +104,12 @@ describe Range do
   end
 
   describe 'joining' do
-    it 'should be able to join contiguous ranges' do
+    it 'can join contiguous ranges' do
       expect((0..3).join(4..8)).to eq((0..8))
       expect((4..8).join(0..3)).to eq((0..8))
     end
 
-    it 'should return nil on join of non-contiguous ranges' do
+    it 'returns nil on join of non-contiguous ranges' do
       expect((0..3).join(5..8)).to be_nil
       expect((0...3).join(4..8)).to be_nil
 
@@ -117,22 +117,22 @@ describe Range do
       expect((4..8).join(0...3)).to be_nil
     end
 
-    it 'should work with Floats, allowing single-point overlap' do
+    it 'works with Floats, allowing single-point overlap' do
       expect((0.0..3.0).join(3.0..8.2)).to eq((0.0..8.2))
       expect((3.0..8.2).join(0.0..3.0)).to eq((0.0..8.2))
     end
   end
 
   describe 'spanning' do
-    it 'should be able to determine whether it is spanned by a set of ranges' do
+    it 'can determine whether it is spanned by a set of ranges' do
       expect((0..10)).to be_spanned_by([(0..3), (4..6), (7..10)])
     end
 
-    it 'should be determine that overlapping ranges do not span' do
+    it 'can determine that overlapping ranges do not span' do
       expect((0..10)).to_not be_spanned_by([(0..3), (3..6), (7..10)])
     end
 
-    it 'should allow spanning ranges to be any Enumerable' do
+    it 'allows spanning ranges to be any Enumerable' do
       require 'set'
       set = [(0..3), (4..6), (7..10)].to_set
       expect((0..10)).to be_spanned_by(set)
@@ -140,7 +140,7 @@ describe Range do
       expect((0..10)).to_not be_spanned_by(set)
     end
 
-    it 'should allow the spanning set to be wider than itself' do
+    it 'allows the spanning set to be wider than itself' do
       set = [(0..3), (4..6), (7..10)].to_set
       expect((2..8)).to be_spanned_by(set)
       expect((5..6)).to be_spanned_by(set)
@@ -148,7 +148,7 @@ describe Range do
   end
 
   describe 'overlapping a single range' do
-    it 'should know if another range overlaps it' do
+    it 'knows if another range overlaps it' do
       expect((0..10).overlaps?(-3..5)).to be_truthy
       expect((0..10).overlaps?(3..5)).to be_truthy
       expect((0..10).overlaps?(8..15)).to be_truthy
@@ -165,116 +165,116 @@ describe Range do
       expect((-11..-1).overlaps?(0..10)).to be_falsy
     end
 
-    it 'should be able to determine whether a set contains covered overlaps' do
+    it 'can determine whether a set contains covered overlaps' do
       expect(Range.overlaps_among?([(0..3), (2..6), (7..10)])).to be true
       expect((0..10).overlaps_among?([(0..3), (2..6), (7..10)])).to be true
     end
 
-    it 'should not care about overlaps outside self' do
+    it 'does not care about overlaps outside self' do
       expect(Range.overlaps_among?([(0..3), (2..6), (7..10)])).to be true
       expect((11..15).overlaps_among?([(0..3), (2..6), (7..10)])).to be false
     end
 
-    it 'should not count contiguous ranges as overlapping' do
+    it 'does not consider contiguous ranges as overlapping' do
       expect(Range.overlaps_among?([(0..3), (4..6), (7..10)])).to be false
     end
 
-    it 'should not count non-contiguous ranges as overlapping' do
+    it 'does not consider non-contiguous ranges as overlapping' do
       expect(Range.overlaps_among?([(0..3), (4..6), (8..10)])).to be false
     end
 
-    it 'should not count an empty set as overlapping' do
+    it 'does not consider an empty set as overlapping' do
       expect(Range.overlaps_among?([])).to be false
     end
   end
 
-  describe 'coverage gaps' do
-    it 'should return an empty array if ranges completely cover' do
+  describe '#gaps' do
+    it 'returns an empty array if ranges completely cover' do
       expect((0..10).gaps([(-1..3), (4..8), (9..11)])).to be_empty
     end
 
-    it 'should return array for itself if ranges are empty' do
+    it 'returns array for itself if ranges are empty' do
       expect((0..10).gaps([])).to eq([(0..10)])
     end
 
-    it 'should return an array of gaps' do
+    it 'returns an array of gaps' do
       gaps = (0..10).gaps([(0..3), (5..6), (9..10)])
       expect(gaps[0]).to eq((4..4))
       expect(gaps[1]).to eq((7..8))
     end
 
-    it 'should allow ranges to extend before and after self' do
+    it 'allows ranges to extend before and after self' do
       gaps = (0..10).gaps([(-3..3), (4..6), (7..13)])
       expect(gaps).to be_empty
     end
 
-    it 'should not include parts before or after in gaps' do
+    it 'does not include parts before or after in gaps' do
       gaps = (0..10).gaps([(-10..-8), (-3..3), (7..13), (30..40)])
       expect(gaps.size).to eq(1)
       expect(gaps[0]).to eq((4..6))
     end
 
-    it 'should return gaps at beginning and end' do
+    it 'includes gaps at beginning and end' do
       gaps = (0..10).gaps([(2..3), (4..6), (7..8)])
       expect(gaps[0]).to eq((0..1))
       expect(gaps[1]).to eq((9..10))
     end
 
-    it 'should work even if ranges are out of order' do
+    it 'works even if ranges are out of order' do
       gaps = (0..10).gaps([(2..3), (30..40), (7..8), (-10..-8), (4..6)])
       expect(gaps[0]).to eq((0..1))
       expect(gaps[1]).to eq((9..10))
     end
 
-    it 'should notice single point coverage' do
+    it 'notices single point coverage' do
       gaps = (0..10).gaps([(4..4), (5..5), (6..6)])
       expect(gaps[0]).to eq((0..3))
       expect(gaps[1]).to eq((7..10))
     end
 
-    it 'should work for a single-point range' do
+    it 'works for a single-point range' do
       gaps = (3..3).gaps([(0..2), (4..4), (5..5), (6..6)])
       expect(gaps[0]).to eq((3..3))
     end
 
-    it 'should work even if ranges overlap' do
+    it 'works even if ranges overlap' do
       gaps = (0..10).gaps([(-2..3), (2..8), (4..10)])
       expect(gaps).to be_empty
     end
   end
 
-  describe 'coverage overlaps' do
-    it 'should return an empty array if ranges are empty' do
+  describe '#overlaps' do
+    it 'returns an empty array if ranges are empty' do
       expect((0..10).overlaps([])).to be_empty
     end
 
-    it 'should return an empty array if ranges is same as self' do
+    it 'returns an empty array if ranges is same as self' do
       expect((0..10).overlaps([(0..10)])).to be_empty
     end
 
-    it 'should return an empty array if ranges is wider than self' do
+    it 'returns an empty array if ranges is wider than self' do
       expect((0..10).overlaps([(-5..15)])).to be_empty
     end
 
-    it 'should return an empty array if ranges is narrower than self' do
+    it 'returns an empty array if ranges is narrower than self' do
       expect((0..10).overlaps([(5..8)])).to be_empty
     end
 
-    it 'should return an array of overlaps' do
+    it 'returns an array of overlaps' do
       overlaps = (0..10).overlaps([(0..3), (2..6), (4..10)])
       expect(overlaps.size).to eq(2)
       expect(overlaps[0]).to eq((2..3))
       expect(overlaps[1]).to eq((4..6))
     end
 
-    it 'should not return any overlaps before self' do
+    it 'does not return any overlaps before self' do
       overlaps = (0..10).overlaps([(-5..-3), (-4..-1), (0..3), (2..6), (4..10)])
       expect(overlaps.size).to eq(2)
       expect(overlaps[0]).to eq((2..3))
       expect(overlaps[1]).to eq((4..6))
     end
 
-    it 'should not return any overlaps after self' do
+    it 'does not return any overlaps after self' do
       overlaps = (0..10).overlaps([(0..3), (2..6), (4..15), (11..20)])
       expect(overlaps.size).to eq(2)
       expect(overlaps[0]).to eq((2..3))