fat_core 1.0.3 → 1.2.0

data/spec/lib/numeric_spec.rb

@@ -1,68 +1,68 @@
 require File.dirname(File.absolute_path(__FILE__)) + '/../spec_helper.rb'
 
 describe Numeric do
-  it "should implement signum function" do
+  it 'should implement signum function' do
     # Integers
     expect(33.signum).to eq 1
-    expect(-33.signum).to eq -1
+    expect(-33.signum).to eq(-1)
     expect(0.signum).to eq 0
 
     # Floats
     expect(33.45.signum).to eq 1
-    expect(-33.45.signum).to eq -1
+    expect(-33.45.signum).to eq(-1)
     expect(0.0.signum).to eq 0
   end
 
-  it "should provide a tex_quote method for erb docs" do
+  it 'should provide a tex_quote method for erb docs' do
     expect(195.45.tex_quote).to eq '195.45'
   end
 
-  it "should provide a human-readable inspect for BigDecimal" do
+  it 'should provide a human-readable inspect for BigDecimal' do
     expect(BigDecimal('33.45').inspect).to eq '33.45'
   end
 
-  it "should be able to report if its a whole number" do
+  it 'should be able to report 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 'should properly round 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 'should properly round 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
-    expect(123456789.0123.commas(2)).to eq '123,456,789.01'
-    expect(-123456789.0123.commas(2)).to eq '-123,456,789.01'
+  it 'should place 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'
 
     # if places is nil, use 4 places for numbers with a fractional
     # part and 0 places for numbers without
-    expect(-123456789.0123456.commas).to eq '-123,456,789.0123'
-    expect(-123456789.0.commas).to eq '-123,456,789'
-    expect(-123456789.00.commas).to eq '-123,456,789'
+    expect(-123_456_789.0123456.commas).to eq '-123,456,789.0123'
+    expect(-123_456_789.0.commas).to eq '-123,456,789'
+    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 'should be able to convert 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.class).to eq Fixnum
+    expect(195.0.int_if_whole.is_a?(Integer)).to be true
   end
 
-  it "should place commas properly with no fraction" do
-    expect(123456789.commas).to eq '123,456,789'
-    expect(-123456789.commas).to eq '-123,456,789'
+  it 'should place 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
-    expect(123456.789e100.commas).to eq '1.23456789e+105'
+  it 'should 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 'should be able to convert 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/period_spec.rb

@@ -35,7 +35,7 @@ describe Period do
 
     it 'should raise a ArgumentError if initialized otherwise' do
       expect {
-        Period.new(2013-01-01, 2013-12-31)
+        Period.new(2013 - 1 - 1, 2013 - 12 - 31)
       }.to raise_error ArgumentError
     end
   end
@@ -289,14 +289,13 @@ describe Period do
     end
 
     it 'should be able to convert itself to fractional months' do
-      expect(Period.new('2013-01-01', '2013-01-01').months).to eq(1/30.436875)
-      expect(Period.new('2013-01-01', '2013-12-31').months(30)).
-        to eq(365 / 30.0)
+      expect(Period.new('2013-01-01', '2013-01-01').months).to eq(1 / 30.436875)
+      expect(Period.new('2013-01-01', '2013-12-31').months(30)).to eq(365 / 30.0)
       expect(Period.new('2013-01-01', '2013-06-30').months.round(0)).to eq(6.0)
     end
 
     it 'should be able to convert itself to fractional years' do
-      expect(Period.new('2013-01-01', '2013-01-01').years).to eq(1/365.2425)
+      expect(Period.new('2013-01-01', '2013-01-01').years).to eq(1 / 365.2425)
       expect(Period.new('2013-01-01', '2013-12-31').years(365)).to eq(1.0)
       expect(Period.new('2013-01-01', '2013-06-30').years.round(1)).to eq(0.5)
     end
@@ -416,7 +415,7 @@ describe Period do
 
     it 'should be able to chunk into biweeks' do
       chunks = Period.new('2009-12-29', '2013-01-10').chunks(size: :biweek)
-      expect(chunks.size).to be >=(26*3)
+      expect(chunks.size).to be >= (26 * 3)
       expect(chunks[0].first.iso).to eq('2010-01-04')
       expect(chunks[0].last.iso).to eq('2010-01-17')
       expect(chunks[1].first.iso).to eq('2010-01-18')
@@ -454,9 +453,9 @@ describe Period do
     end
 
     it 'should raise error for invalid chunk name' do
-      expect do
+      expect {
         Period.new('2012-12-28', '2012-12-31').chunks(size: :wally)
-      end.to raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     it 'should not include a partial final chunk by default' do
@@ -466,7 +465,7 @@ describe Period do
 
     it 'should include a partial final chunk if partial_last' do
       chunks = Period.new('2012-01-01', '2012-03-30')
-                     .chunks(size: :month, partial_last: true)
+                 .chunks(size: :month, partial_last: true)
       expect(chunks.size).to eq(3)
       expect(chunks.last.first).to eq(Date.parse('2012-03-01'))
       expect(chunks.last.last).to eq(Date.parse('2012-03-30'))
@@ -474,7 +473,7 @@ describe Period do
 
     it 'should include a final chunk beyond end_date if round_up' do
       chunks = Period.new('2012-01-01', '2012-03-30')
-                     .chunks(size: :month, round_up_last: true)
+                 .chunks(size: :month, round_up_last: true)
       expect(chunks.size).to eq(3)
       expect(chunks.last.first).to eq(Date.parse('2012-03-01'))
       expect(chunks.last.last).to eq(Date.parse('2012-03-31'))
@@ -489,7 +488,7 @@ describe Period do
 
     it 'should include a partial initial chunk by if partial_first' do
       chunks = Period.new('2012-01-13', '2012-03-31')
-                     .chunks(size: :month, partial_first: true)
+                 .chunks(size: :month, partial_first: true)
       expect(chunks.size).to eq(3)
       expect(chunks[0].first).to eq(Date.parse('2012-01-13'))
       expect(chunks[0].last).to eq(Date.parse('2012-01-31'))
@@ -497,7 +496,7 @@ describe Period do
 
     it 'should include a final chunk beyond end_date if round_up' do
       chunks = Period.new('2012-01-01', '2012-03-30')
-                     .chunks(size: :month, round_up_last: true)
+                 .chunks(size: :month, round_up_last: true)
       expect(chunks.size).to eq(3)
       expect(chunks.last.first).to eq(Date.parse('2012-03-01'))
       expect(chunks.last.last).to eq(Date.parse('2012-03-31'))

data/spec/lib/range_spec.rb

@@ -1,8 +1,8 @@
 require File.dirname(File.absolute_path(__FILE__)) + '/../spec_helper.rb'
 
 describe Range do
-  describe "set operations" do
-    it "should know if it is a subset of another range" do
+  describe 'set operations' do
+    it 'should know 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))
@@ -10,7 +10,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 'should know if it is a proper subset of another range' do
       expect((4..8)).to be_proper_subset_of((2..9))
       expect((4..8)).not_to be_proper_subset_of((4..8))
       expect((4..8)).not_to be_proper_subset_of((2..7))
@@ -18,7 +18,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 'should know 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))
@@ -32,7 +32,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 'should know if it is a proper superset of another range' do
       expect((4..8)).to be_proper_superset_of((5..7))
       expect((4..8)).not_to be_proper_superset_of((6..8))
       expect((4..8)).not_to be_proper_superset_of((4..7))
@@ -46,17 +46,17 @@ 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 'should know 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))
-   end
+    end
 
-    it "intersection should return nil if there is no overlap" do
+    it 'intersection should return nil if there is no overlap' do
       expect(((0..10) & (15..20))).to be_nil
     end
 
-    it "should know its union with another range" do
+    it 'should know 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))
@@ -65,12 +65,12 @@ describe Range do
       expect(((0..5) + (6..20))).to eq((0..20))
     end
 
-    it "union should return nil if there is no overlap" do
+    it 'union should return nil if there is no overlap' do
       expect(((0..10) & (15..20))).to be_nil
       expect(((15..20) & (0..10))).to be_nil
     end
 
-    it "should know the difference with another range" do
+    it 'should know 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
@@ -101,13 +101,13 @@ describe Range do
     end
   end
 
-  describe "joining" do
-    it "should be able to join contiguous ranges" do
-      expect((0..3).join(4..8)).to eq (0..8)
-      expect((4..8).join(0..3)).to eq (0..8)
+  describe 'joining' do
+    it 'should be able to 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 'should return 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
 
@@ -115,22 +115,22 @@ describe Range do
       expect((4..8).join(0...3)).to be_nil
     end
 
-    it "should work 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)
+    it 'should work 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
+  describe 'spanning' do
+    it 'should be able to 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 'should be 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 'should allow 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)
@@ -138,15 +138,15 @@ 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 'should allow 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)
     end
   end
 
-  describe "overlapping a single range" do
-    it "should know if another range overlaps it" do
+  describe 'overlapping a single range' do
+    it 'should know 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
@@ -163,114 +163,114 @@ 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 'should be able to determine whether a set contains covered overlaps' do
       expect((0..10)).to have_overlaps_within([(0..3), (2..6), (7..10)])
     end
 
-    it "should not care about overlaps outside range" do
+    it 'should not care about overlaps outside range' do
       expect((11..15)).to_not have_overlaps_within([(0..3), (2..6), (7..10)])
     end
 
-    it "should not count contiguous ranges as overlapping" do
+    it 'should not count contiguous ranges as overlapping' do
       expect((0..10)).to_not have_overlaps_within([(0..3), (4..6), (7..10)])
     end
 
-    it "should not count non-contiguous ranges as overlapping" do
+    it 'should not count non-contiguous ranges as overlapping' do
       expect((0..10)).to_not have_overlaps_within([(0..3), (4..6), (8..10)])
     end
 
-    it "should not count an empty set as overlapping" do
+    it 'should not count an empty set as overlapping' do
       expect((0..10)).to_not have_overlaps_within([])
     end
   end
 
-  describe "coverage gaps" do
-    it "should return an empty array if ranges completely cover" do
+  describe 'coverage gaps' do
+    it 'should return 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 'should return 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 'should return 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 'should allow 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 'should 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 'should return 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 'should work 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 'should notice 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 'should work 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 'should work 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 'coverage overlaps' do
+    it 'should return 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 'should return 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 'should return 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 'should return 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 'should return 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 'should 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 'should 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))

data/spec/lib/string_spec.rb

@@ -55,33 +55,33 @@ the people, for the people, shall not perish from the earth."
     ##123456789012345678901234567890123456789012345678901234567890123456789|
   end
 
-  describe "class methods" do
-    it "should be able to generate a random string" do
+  describe 'class methods' do
+    it 'should be able to generate a random string' do
       ss = String.random(100)
       expect(ss.class).to eq String
       expect(ss.size).to eq 100
     end
   end
 
-  describe "instance methods" do
-    it "should be able to clean up white space in a string" do
+  describe 'instance methods' do
+    it 'should be able to clean up white space in a string' do
       expect('   string    here  '.clean).to eq 'string here'
     end
 
-    it "should be able to convert a digital date to iso form" do
-      expect("20140521".digdate2iso).to eq '2014-05-21'
+    it 'should be able to convert a digital date to iso form' do
+      expect('20140521'.digdate2iso).to eq '2014-05-21'
     end
 
-    it "should wrap a short string" do
-      expect("hello, world".wrap).to eq "hello, world"
+    it 'should wrap a short string' do
+      expect('hello, world'.wrap).to eq 'hello, world'
     end
 
-    it "should wrap a long string" do
-      @getty.wrap.split("\n").each {|l| expect(l.length).to be <= 70}
+    it 'should wrap a long string' do
+      @getty.wrap.split("\n").each { |l| expect(l.length).to be <= 70 }
     end
 
-    it "should wrap a long string with a hangining indent" do
-      @getty.wrap(70, 10).split("\n").each {|l| expect(l.length).to be <= 70}
+    it 'should wrap a long string with a hangining indent' do
+      @getty.wrap(70, 10).split("\n").each { |l| expect(l.length).to be <= 70 }
       @getty.wrap(70, 10).split("\n")[1..-1].each do |l|
         expect(l).to match(/^          /)
       end
@@ -93,14 +93,14 @@ the people, for the people, shall not perish from the earth."
       expect(@getty.wrap(70, 10).split("\n")[23]).to match(/^#{twenty_fourth_line}/)
     end
 
-    it "should be able to quote special TeX characters" do
-      expect("$10,000".tex_quote).to eq("\\$10,000")
-      expect("would~~have".tex_quote).to eq("would\\textasciitilde{}\\textasciitilde{}have")
-      expect("<hello>".tex_quote).to eq("\\textless{}hello\\textgreater{}")
-      expect("{hello}".tex_quote).to eq("\\{hello\\}")
+    it 'should be able to quote special TeX characters' do
+      expect('$10,000'.tex_quote).to eq('\\$10,000')
+      expect('would~~have'.tex_quote).to eq('would\\textasciitilde{}\\textasciitilde{}have')
+      expect('<hello>'.tex_quote).to eq('\\textless{}hello\\textgreater{}')
+      expect('{hello}'.tex_quote).to eq('\\{hello\\}')
     end
 
-    it "should be able to determine is it's a valid number" do
+    it 'should be able to determine is it\'s a valid number' do
       expect('88'.number?).to be true
       expect('-88'.number?).to be true
       expect('8.008'.number?).to be true
@@ -111,7 +111,7 @@ the people, for the people, shall not perish from the earth."
       expect('hello world'.number?).to be false
     end
 
-    it "should be able to convert a string to a regular expression" do
+    it 'should be able to convert a string to a regular expression' do
       re = "/hello((\s+)(world))?/".to_regexp
       expect(re.class).to eq Regexp
       expect(re.casefold?).to be true
@@ -129,101 +129,98 @@ the people, for the people, shall not perish from the earth."
       expect(re.multiline?).to be false
     end
 
-    it "should be able to convert itself to a sym" do
-      expect("joke".as_sym).to eq :joke
-      expect("hello world".as_sym).to eq :hello_world
+    it 'should be able to convert itself to a sym' do
+      expect('joke'.as_sym).to eq :joke
+      expect('hello world'.as_sym).to eq :hello_world
       expect("hello world   it's me".as_sym).to eq :hello_world_its_me
-      expect("Street1".as_sym).to eq :street1
+      expect('Street1'.as_sym).to eq :street1
     end
 
-    it "should do nothing in response to as_string" do
-      expect("joke".as_string).to eq "joke"
-      expect("hello world".as_string).to eq "hello world"
+    it 'should do nothing in response to as_string' do
+      expect('joke'.as_string).to eq 'joke'
+      expect('hello world'.as_string).to eq 'hello world'
       expect("hello world   it's me".as_string)
         .to eq "hello world   it's me"
     end
 
-    it "should be able to fuzzy match with another string" do
-      expect("Hello, world".fuzzy_match('or')).to be_truthy
-      expect("Hello, world".fuzzy_match('ox')).to be_falsy
+    it 'should be able to fuzzy match with another string' do
+      expect('Hello, world'.fuzzy_match('or')).to be_truthy
+      expect('Hello, world'.fuzzy_match('ox')).to be_falsy
     end
 
-    it "should be able to match with another string containing re" do
-      expect("Hello, world".matches_with('/or/')).to be_truthy
-      expect("Hello, world".matches_with('/ox/')).to be_falsy
+    it 'should be able to match with another string containing re' do
+      expect('Hello, world'.matches_with('/or/')).to be_truthy
+      expect('Hello, world'.matches_with('/ox/')).to be_falsy
     end
 
-    it "should be able to match with another string containing string" do
-      expect("Hello, world".matches_with('or')).to be_truthy
-      expect("Hello, world".matches_with('ox')).to be_falsy
+    it 'should be able to match with another string containing string' do
+      expect('Hello, world'.matches_with('or')).to be_truthy
+      expect('Hello, world'.matches_with('ox')).to be_falsy
     end
 
-    it "should be able to fuzzy match space-separated parts" do
-      expect("Hello world".fuzzy_match('hel or')).to be_truthy
-      expect("Hello, world".fuzzy_match('hel ox')).to be_falsy
+    it 'should be able to fuzzy match space-separated parts' do
+      expect('Hello world'.fuzzy_match('hel or')).to be_truthy
+      expect('Hello, world'.fuzzy_match('hel ox')).to be_falsy
     end
 
-    it "should be able to fuzzy match colon-separated parts" do
-      expect("Hello:world".fuzzy_match('hel:or')).to be_truthy
-      expect("Hello:world".fuzzy_match('hel:ox')).to be_falsy
+    it 'should be able to fuzzy match colon-separated parts' do
+      expect('Hello:world'.fuzzy_match('hel:or')).to be_truthy
+      expect('Hello:world'.fuzzy_match('hel:ox')).to be_falsy
     end
 
-    it "should be able to fuzzy match colon-separated parts" do
-      expect("Hello:world".fuzzy_match('hel:or')).to be_truthy
-      expect("Hello:world".fuzzy_match('hel:ox')).to be_falsy
+    it 'should be able to fuzzy match colon-separated parts' do
+      expect('Hello:world'.fuzzy_match('hel:or')).to be_truthy
+      expect('Hello:world'.fuzzy_match('hel:ox')).to be_falsy
     end
 
-    it "should return the matched text" do
-      expect("Hello:world".fuzzy_match('hel')).to eq('Hel')
-      expect("Hello:world".fuzzy_match('hel:or')).to eq('Hello:wor')
-      expect("Hello:world".matches_with('/^h.*r/')).to eq('Hello:wor')
+    it 'should return the matched text' do
+      expect('Hello:world'.fuzzy_match('hel')).to eq('Hel')
+      expect('Hello:world'.fuzzy_match('hel:or')).to eq('Hello:wor')
+      expect('Hello:world'.matches_with('/^h.*r/')).to eq('Hello:wor')
     end
 
-    it "should ignore periods, commas, and apostrophes when matching" do
+    it 'should ignore periods, commas, and apostrophes when matching' do
       expect("St. Luke's".fuzzy_match('st lukes')).to eq('St Lukes')
-      expect("St Lukes".fuzzy_match('st. luke\'s')).to eq('St Lukes')
-      expect("St Lukes, Inc.".fuzzy_match('st luke inc')).to eq('St Lukes Inc')
-      expect("E*TRADE".fuzzy_match('etrade')).to eq('ETRADE')
+      expect('St Lukes'.fuzzy_match('st. luke\'s')).to eq('St Lukes')
+      expect('St Lukes, Inc.'.fuzzy_match('st luke inc')).to eq('St Lukes Inc')
+      expect('E*TRADE'.fuzzy_match('etrade')).to eq('ETRADE')
     end
 
-    it "should be able to properly capitalize a string as a title" do
+    it 'should be able to properly capitalize a string as a title' do
       # Capitalize little words only at beginning and end
-      expect("the cat in the hat".entitle).to eq('The Cat in the Hat')
-      expect("dr".entitle).to eq('Dr')
-      expect("cr".entitle).to eq('Cr')
+      expect('the cat in the hat'.entitle).to eq('The Cat in the Hat')
+      expect('dr'.entitle).to eq('Dr')
+      expect('cr'.entitle).to eq('Cr')
       # Capitalize all consonants size if >= 3
-      expect("tr".entitle).to eq('Tr')
-      expect("trd".entitle).to eq('TRD')
+      expect('tr'.entitle).to eq('Tr')
+      expect('trd'.entitle).to eq('TRD')
       # Don't capitalize c/o
-      expect("IBM c/o watson".entitle).to eq('Ibm c/o Watson')
+      expect('IBM c/o watson'.entitle).to eq('Ibm c/o Watson')
       # Capitlaize p.o.
-      expect("p.o. box 123".entitle).to eq('P.O. Box 123')
+      expect('p.o. box 123'.entitle).to eq('P.O. Box 123')
       # Don't capitalize ordinals
-      expect("22nd of september".entitle).to eq('22nd of September')
+      expect('22nd of september'.entitle).to eq('22nd of September')
       # Capitalize common abbrevs
-      expect("US BANK".entitle).to eq('US Bank')
-      expect("NW territory".entitle).to eq('NW Territory')
+      expect('US BANK'.entitle).to eq('US Bank')
+      expect('NW territory'.entitle).to eq('NW Territory')
       # Leave word starting with numbers alone
-      expect("apartment 33-B".entitle).to eq('Apartment 33-B')
+      expect('apartment 33-B'.entitle).to eq('Apartment 33-B')
       # Assume all consanants is an acronym
-      expect("the cbs network".entitle).to eq('The CBS Network')
+      expect('the cbs network'.entitle).to eq('The CBS Network')
       # Capitalize both parts of a hyphenated word
-      expect("the hitler-stalin pact".entitle).
-        to eq('The Hitler-Stalin Pact')
+      expect('the hitler-stalin pact'.entitle).to eq('The Hitler-Stalin Pact')
     end
 
-    it "should be able to compute its Levenshtein distance from another string" do
+    it 'should be able to compute its Levenshtein distance from another string' do
       expect('Something'.distance('Smoething')).to eq 1
       expect('Something'.distance('Smoething', block_size: 0)).to eq 2
       expect('Something'.distance('meSothing', block_size: 1)).to eq 4
       expect('Something'.distance('meSothing', block_size: 2)).to eq 2
       expect('SomethingElse'.distance('Encyclopedia')).to eq 10
-      expect('SomethingElseUnrelated'.
-              distance('EncyclopediaBritanica',
-                       max_distance: 40)).to eq 21
-      expect('SomethingElseUnrelated'.
-              distance('EncyclopediaBritanica',
-                       max_distance: 15)).to eq 15
+      expect('SomethingElseUnrelated'.distance('EncyclopediaBritanica', max_distance: 40))
+        .to eq 21
+      expect('SomethingElseUnrelated'.distance('EncyclopediaBritanica',
+                                               max_distance: 15)).to eq 15
     end
   end
 end