fat_core 5.6.1 → 7.0.1

data/spec/lib/range_spec.rb

@@ -1,103 +1,106 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fat_core/range'
 
 describe Range do
   describe 'set operations' 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))
-      expect((4..8)).not_to be_subset_of((5..8))
-      expect((4..8)).not_to be_subset_of((11..20))
+      expect((4..8).subset_of?(2..9)).to be true
+      expect((4..8).subset_of?(4..8)).to be true
+      expect((4..8).subset_of?(2..7)).to be false
+      expect((4..8).subset_of?(5..8)).to be false
+      expect((4..8).subset_of?(11..20)).to be false
     end
 
     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))
-      expect((4..8)).not_to be_proper_subset_of((2..7))
-      expect((4..8)).not_to be_proper_subset_of((5..8))
-      expect((4..8)).not_to be_proper_subset_of((11..20))
+      expect((4..8).proper_subset_of?(2..9)).to be true
+      expect((4..8).proper_subset_of?(4..9)).to be true
+      expect((4..8).proper_subset_of?(4..8)).to be false
+      expect((4..8).proper_subset_of?(2..7)).to be false
+      expect((4..8).proper_subset_of?(5..8)).to be false
+      expect((4..8).proper_subset_of?(11..20)).to be false
     end
 
     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))
-      expect((4..8)).to be_superset_of((4..8))
-      expect((4..8)).not_to be_superset_of((2..9))
-      expect((4..8)).not_to be_superset_of((2..8))
-      expect((4..8)).not_to be_superset_of((4..9))
-      expect((4..8)).not_to be_superset_of((8..20))
-      expect((4..8)).not_to be_superset_of((0..4))
-      expect((4..8)).not_to be_superset_of((0..3))
-      expect((4..8)).not_to be_superset_of((9..20))
+      expect((4..8).superset_of?(5..7)).to be true
+      expect((4..8).superset_of?(6..8)).to be true
+      expect((4..8).superset_of?(4..7)).to be true
+      expect((4..8).superset_of?(4..8)).to be true
+      expect((4..8).superset_of?(2..9)).to be false
+      expect((4..8).superset_of?(2..8)).to be false
+      expect((4..8).superset_of?(4..9)).to be false
+      expect((4..8).superset_of?(8..20)).to be false
+      expect((4..8).superset_of?(0..4)).to be false
+      expect((4..8).superset_of?(0..3)).to be false
+      expect((4..8).superset_of?(9..20)).to be false
     end
 
     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))
-      expect((4..8)).not_to be_proper_superset_of((4..8))
-      expect((4..8)).not_to be_proper_superset_of((2..9))
-      expect((4..8)).not_to be_proper_superset_of((2..8))
-      expect((4..8)).not_to be_proper_superset_of((4..9))
-      expect((4..8)).not_to be_proper_superset_of((8..20))
-      expect((4..8)).not_to be_proper_superset_of((0..4))
-      expect((4..8)).not_to be_proper_superset_of((0..3))
-      expect((4..8)).not_to be_proper_superset_of((9..20))
+      expect((4..8).proper_superset_of?(5..7)).to be true
+      expect((4..8).proper_superset_of?(6..8)).to be true
+      expect((4..8).proper_superset_of?(4..7)).to be true
+      expect((4..8).proper_superset_of?(4..8)).to be false
+      expect((4..8).proper_superset_of?(2..9)).to be false
+      expect((4..8).proper_superset_of?(2..8)).to be false
+      expect((4..8).proper_superset_of?(4..9)).to be false
+      expect((4..8).proper_superset_of?(8..20)).to be false
+      expect((4..8).proper_superset_of?(0..4)).to be false
+      expect((4..8).proper_superset_of?(0..3)).to be false
+      expect((4..8).proper_superset_of?(9..20)).to be false
+      expect((4..8).proper_superset_of?(4..8)).to be false
     end
 
     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))
+      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
 
     it 'intersection should return nil if there is no overlap' do
-      expect(((0..10) & (15..20))).to be_nil
+      expect((0..10) & (15..20)).to be_nil
     end
 
     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))
+      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)
 
       # For discrete values, union should work on contiguous ranges
-      expect(((0..5) + (6..20))).to eq((0..20))
+      expect((0..5) + (6..20)).to eq(0..20)
     end
 
     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
+      expect((0..10) & (15..20)).to be_nil
+      expect((15..20) & (0..10)).to be_nil
     end
 
     it 'knows the difference with another range' do
       # Other is same as self
       # xrubocop:disable Lint/BinaryOperatorWithIdenticalOperands
       expect(((4..10) - (4..10)).size).to eq(0)
-      expect(((4..10) - (4..10))).to be_empty
+      expect((4..10) - (4..10)).to be_empty
       # xrubocop:enable Lint/BinaryOperatorWithIdenticalOperands
 
       # Other is proper subset of self
-      expect(((4..10) - (6..7)).first).to eq((4..5))
-      expect(((4..10) - (6..7)).last).to eq((8..10))
-      expect(((4..10) - (6..10)).first).to eq((4..5))
-      expect(((4..10) - (4..7)).last).to eq((8..10))
+      expect(((4..10) - (6..7)).first).to eq(4..5)
+      expect(((4..10) - (6..7)).last).to eq(8..10)
+      expect(((4..10) - (6..10)).first).to eq(4..5)
+      expect(((4..10) - (4..7)).last).to eq(8..10)
 
       # Other overlaps on the left
       expect(((4..10) - (0..6)).size).to eq(1)
-      expect(((4..10) - (0..6)).first).to eq((7..10))
+      expect(((4..10) - (0..6)).first).to eq(7..10)
 
       expect(((4..10) - (4..6)).size).to eq(1)
-      expect(((4..10) - (4..6)).first).to eq((7..10))
+      expect(((4..10) - (4..6)).first).to eq(7..10)
 
       # Other overlaps on the right
       expect(((4..10) - (7..11)).size).to eq(1)
-      expect(((4..10) - (7..11)).first).to eq((4..6))
+      expect(((4..10) - (7..11)).first).to eq(4..6)
 
       expect(((4..10) - (7..10)).size).to eq(1)
-      expect(((4..10) - (7..10)).last).to eq((4..6))
+      expect(((4..10) - (7..10)).last).to eq(4..6)
 
       # Other does not overlap
       expect((4..10) - (13..20)).to eq([(4..10)])
@@ -107,8 +110,8 @@ describe Range do
 
   describe 'joining' 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))
+      expect((0..3).join(4..8)).to eq(0..8)
+      expect((4..8).join(0..3)).to eq(0..8)
     end
 
     it 'returns nil on join of non-contiguous ranges' do
@@ -120,51 +123,51 @@ describe Range do
     end
 
     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))
+      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 '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)])
+      expect((0..10).spanned_by?([(0..3), (4..6), (7..10)])).to be true
     end
 
     it 'can determine that overlapping ranges do not span' do
-      expect((0..10)).not_to be_spanned_by([(0..3), (3..6), (7..10)])
+      expect((0..10).spanned_by?([(0..3), (3..6), (7..10)])).to be false
     end
 
     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)
+      expect((0..10).spanned_by?(set)).to be true
       set = [(0...3), (4..6), (7..10)].to_set
-      expect((0..10)).not_to be_spanned_by(set)
+      expect((0..10).spanned_by?(set)).to be false
     end
 
     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)
+      expect((2..8).spanned_by?(set)).to be true
+      expect((5..6).spanned_by?(set)).to be true
     end
   end
 
   describe 'overlapping a single range' do
     it 'knows if another range overlaps it' do
-      expect((0..10)).to be_overlaps(-3..5)
-      expect((0..10)).to be_overlaps(3..5)
-      expect((0..10)).to be_overlaps(8..15)
-      expect((0..10)).to be_overlaps(0..10)
-      expect((0..10)).not_to be_overlaps(11..12)
-      expect((0..10)).not_to be_overlaps(-11..-1)
+      expect((0..10).overlaps?(-3..5)).to be true
+      expect((0..10).overlaps?(3..5)).to be true
+      expect((0..10).overlaps?(8..15)).to be true
+      expect((0..10).overlaps?(0..10)).to be true
+      expect((0..10).overlaps?(11..12)).to be false
+      expect((0..10).overlaps?(-11..-1)).to be false
 
       # Order of operands should not matter
-      expect((-3..5)).to be_overlaps(0..10)
-      expect((3..5)).to be_overlaps(0..10)
-      expect((8..15)).to be_overlaps(0..10)
-      expect((0..10)).to be_overlaps(0..10)
-      expect((11..12)).not_to be_overlaps(0..10)
-      expect((-11..-1)).not_to be_overlaps(0..10)
+      expect((-3..5).overlaps?(0..10)).to be true
+      expect((3..5).overlaps?(0..10)).to be true
+      expect((8..15).overlaps?(0..10)).to be true
+      expect((0..10).overlaps?(0..10)).to be true
+      expect((11..12).overlaps?(0..10)).to be false
+      expect((-11..-1).overlaps?(0..10)).to be false
     end
 
     it 'can determine whether a set contains covered overlaps' do
@@ -201,8 +204,12 @@ describe Range 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))
+      expect(gaps[0]).to eq(4..4)
+      expect(gaps[1]).to eq(7..8)
+    end
+
+    it 'returns gaps for letter ranges' do
+      expect(('a'..'z').gaps([('a'..'g'), ('j'..'s'), ('t'..'z')])).to eq([Range.new('h', 'i')])
     end
 
     it 'allows ranges to extend before and after self' do
@@ -213,36 +220,40 @@ describe Range 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))
+      expect(gaps[0]).to eq(4..6)
     end
 
     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))
+      expect(gaps[0]).to eq(0..1)
+      expect(gaps[1]).to eq(9..10)
     end
 
     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))
+      expect(gaps[0]).to eq(0..1)
+      expect(gaps[1]).to eq(9..10)
     end
 
     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))
+      expect(gaps[0]).to eq(0..3)
+      expect(gaps[1]).to eq(7..10)
     end
 
     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))
+      expect(gaps[0]).to eq(3..3)
     end
 
     it 'works even if ranges overlap' do
       gaps = (0..10).gaps([(-2..3), (2..8), (4..10)])
       expect(gaps).to be_empty
     end
+
+    it 'raises an error if argument types are incompatible' do
+      expect { ('A'..'F').gaps([(1..5), (6..11)]) }.to raise_error(/incompatible/)
+    end
   end
 
   describe '#overlaps' do
@@ -265,22 +276,22 @@ describe Range 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))
+      expect(overlaps[0]).to eq(2..3)
+      expect(overlaps[1]).to eq(4..6)
     end
 
     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))
+      expect(overlaps[0]).to eq(2..3)
+      expect(overlaps[1]).to eq(4..6)
     end
 
     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))
-      expect(overlaps[1]).to eq((4..6))
+      expect(overlaps[0]).to eq(2..3)
+      expect(overlaps[1]).to eq(4..6)
     end
   end
 end

data/spec/lib/string_spec.rb

@@ -2,7 +2,6 @@
 
 require 'spec_helper'
 require 'fat_core/string'
-require 'fat_core/date'
 
 describe String do
   describe 'class methods' do
@@ -97,6 +96,22 @@ the people, for the people, shall not perish from the earth."
       expect('   string    here  '.clean).to eq 'string here'
     end
 
+    using StringPred
+
+    it 'computes predecessor to String' do
+      expect("B".pred).to eq("A")
+      expect("C".pred).to eq("B")
+      expect("D".pred).to eq("C")
+      expect("Z".pred).to eq("Y")
+      expect("AAA".pred).to eq("9ZZ")
+      expect("A".pred).to eq("9")
+      expect("BBA".pred).to eq("BAZ")
+      expect("00123".pred).to eq("00122")
+      expect("9999".succ).to eq("10000")
+      expect("00000".pred).to eq("a9999")
+      expect { "00123+".pred }.to raise_error(/undefined method/)
+    end
+
     describe 'numeric strings' do
       it 'converts a numeric string to a commified form' do
         expect('20140521'.commas).to eq '20,140,521'
@@ -139,19 +154,10 @@ the people, for the people, shall not perish from the earth."
         expect('-8.008'.number?).to be true
         expect('8.008e33'.number?).to be true
         expect('-8.008e33'.number?).to be true
-        expect('0x8.008').to be_number
         expect('hello world'.number?).to be false
       end
     end
 
-    it 'converts a digital date to a Date' do
-      expect('20140521'.as_date.iso).to eq '2014-05-21'
-      expect('2014-05-21'.as_date.iso).to eq '2014-05-21'
-      expect('2014/05/21'.as_date.iso).to eq '2014-05-21'
-      expect('2014/5/21'.as_date.iso).to eq '2014-05-21'
-      expect('201X/5/21'.as_date).to be_nil
-    end
-
     it 'converts a string to a regular expression' do
       # Ignores case by default
       re = "/hello((\s+)(world))?/".as_regexp
@@ -214,7 +220,7 @@ the people, for the people, shall not perish from the earth."
       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('sherLOCK c/o watson'.entitle).to eq('Sherlock c/o Watson')
       # Capitlaize p.o.
       expect('p.o. box 123'.entitle).to eq('P.O. Box 123')
       # Don't capitalize ordinals
@@ -224,8 +230,6 @@ the people, for the people, shall not perish from the earth."
       expect('nw territory'.entitle).to eq('NW Territory')
       # Leave word starting with numbers alone
       expect('apartment 33-B'.entitle).to eq('Apartment 33-B')
-      # Assume all uppercase is an acronym
-      expect('the ABC network'.entitle).to eq('The ABC Network')
       # But not if the whole string is uppercase
       expect('THE ABC NETWORK'.entitle).to eq('The Abc Network')
       # Capitalize both parts of a hyphenated word
@@ -253,14 +257,10 @@ the people, for the people, shall not perish from the earth."
     describe 'Fuzzy Matching' do
       it 'fuzzy matches with another string' do
         expect('Hello, world'.fuzzy_match('wor')).to be_truthy
+        expect('Hello, world'.fuzzy_match('orl')).to be_truthy
         expect('Hello, world'.fuzzy_match('ox')).to be_falsy
       end
 
-      it 'fuzzy matches 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 'fuzzy matches space-separated parts' do
         expect('Hello world'.fuzzy_match('hel wor')).to be_truthy
         expect('Hello, world'.fuzzy_match('hel ox')).to be_falsy
@@ -268,22 +268,35 @@ the people, for the people, shall not perish from the earth."
 
       it 'fuzzy matches colon-separated parts' do
         expect('Hello:world'.fuzzy_match('hel:wor')).to be_truthy
-        expect('Hello:world'.fuzzy_match('hel:ox')).to be_falsy
+        expect('Hello:world'.fuzzy_match('hel :wor')).to be_truthy
+        expect('Hello:world'.fuzzy_match('hel: wor')).to be_falsy
+        expect('Hello:world'.fuzzy_match('hel:orld')).to be_falsy
+        expect("Hello, 'world'".fuzzy_match('hel:wor')).to be_truthy
+        expect('Hello "world"'.fuzzy_match('hel:world')).to be_truthy
       end
 
-      it 'treats an internal `:stuff in the matcher as \bstuff.*?\b' do
+      it 'treats an internal `:stuff` as \bstuff.*' do
         expect('Hello, what is with the world?'.fuzzy_match('wha:wi:wor')).to be_truthy
+        expect('Hello, what is with the world?'.fuzzy_match('hat :wi :wor')).to be_truthy
         expect('Hello:world'.fuzzy_match('what:or')).to be_falsy
         expect('Hello, what=+&is (with) the world?'.fuzzy_match('wha:wi:wor')).to be_truthy
       end
 
+      it 'treats an internal `stuff: ` as stuff\b.*' do
+        expect('Hello, what is with the world?'.fuzzy_match('llo: th: :wor')).to be_truthy
+        expect('Hello:world'.fuzzy_match('llox: ')).to be_falsy
+        expect('Hello, what=+&is (with) the world?'.fuzzy_match('at: ith: the')).to be_truthy
+      end
+
       it 'requires end-anchor for ending colon' do
         expect('Hello, to the world'.fuzzy_match('hel:world:')).to eq('Hello to the world')
+        expect('Hello, to the world   '.fuzzy_match('hel:world:')).to eq('Hello to the world')
         expect('Hello, to the world today'.fuzzy_match('to:world:')).to be_nil
       end
 
       it 'requires start-anchor for leading colon' do
         expect('Hello, to the world'.fuzzy_match(':hel:the')).to eq('Hello to the')
+        expect('   Hello, to the world'.fuzzy_match(':hel:the')).to eq('Hello to the')
         expect('Hello, to the world today'.fuzzy_match(':world:today')).to be_nil
       end
 
@@ -307,6 +320,51 @@ the people, for the people, shall not perish from the earth."
         expect('The 1 Dollar Store'.fuzzy_match('1 stor')).to be_truthy
         expect('The $1 Dollar Store'.fuzzy_match('$1 stor')).to be_falsy
       end
+
+      it 'performs examples in documentation' do
+        expect("St. Luke's".fuzzy_match('st lukes')).to eq('St Lukes')
+        expect("St. Luke's Hospital".fuzzy_match('st lukes')).to eq('St Lukes')
+        expect("St. Luke's Hospital".fuzzy_match('luk:hosp')).to eq('Lukes Hosp')
+        expect("St. Luke's Hospital".fuzzy_match('st:spital')).to be_nil
+        expect("St. Luke's Hospital".fuzzy_match('st spital')).to eq('St Lukes Hospital')
+        expect("St. Luke's Hospital".fuzzy_match('st:laks')).to be_nil
+        expect("St. Luke's Hospital".fuzzy_match(':lukes')).to be_nil
+        expect("St. Luke's Hospital".fuzzy_match('lukes:hospital')).to eq('Lukes Hospital')
+      end
+    end
+
+    describe '#matches_with' do
+      it 'matches with another string containing a plain string' do
+        expect('Hello, world'.matches_with('or')).to be_truthy
+        expect('Hello, world'.matches_with('ox')).to be_falsy
+      end
+
+      it 'matches 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 'performs examples in documentation with just strings' do
+        expect("St. Luke's".matches_with('st lukes')).to eq('St Lukes')
+        expect("St. Luke's Hospital".matches_with('st lukes')).to eq('St Lukes')
+        expect("St. Luke's Hospital".matches_with('luk:hosp')).to eq('Lukes Hosp')
+        expect("St. Luke's Hospital".matches_with('st:spital')).to be_nil
+        expect("St. Luke's Hospital".matches_with('st spital')).to eq('St Lukes Hospital')
+        expect("St. Luke's Hospital".matches_with('st:laks')).to be_nil
+        expect("St. Luke's Hospital".matches_with(':lukes')).to be_nil
+        expect("St. Luke's Hospital".matches_with('lukes:hospital')).to eq('Lukes Hospital')
+      end
+
+      it 'performs examples in documentation with regexes' do
+        expect("St. Luke's".matches_with('/st\s*lukes/')).to eq('St Lukes')
+        expect("St. Luke's Hospital".matches_with('/st lukes/')).to eq('St Lukes')
+        expect("St. Luke's Hospital".matches_with('/luk.*\bhosp/')).to eq('Lukes Hosp')
+        expect("St. Luke's Hospital".matches_with('/st(.*)spital\z/')).to eq('St Lukes Hospital')
+        expect("St. Luke's Hospital".matches_with('/st spital/')).to be_nil
+        expect("St. Luke's Hospital".matches_with('/st.*laks/')).to be_nil
+        expect("St. Luke's Hospital".matches_with('/\Alukes/')).to be_nil
+        expect("St. Luke's Hospital".matches_with('/lukes hospital/')).to eq('Lukes Hospital')
+      end
     end
   end
 end

data/spec/lib/symbol_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fat_core/symbol'
 

data/spec/spec_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'simplecov'
 SimpleCov.command_name 'Rspec'
 
@@ -8,7 +10,7 @@ require 'pry'
 require 'debug'
 
 require 'active_support/testing/time_helpers'
-require 'fat_core'
+require_relative '../lib/fat_core/all'
 
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat_core
 version: !ruby/object:Gem::Version
-  version: 5.6.1
+  version: 7.0.1
 platform: ruby
 authors:
 - Daniel E. Doherty
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-03-19 00:00:00.000000000 Z
+date: 2025-11-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -73,35 +74,33 @@ description: |
   iteration, (also for Hash), set operations on Ranges
 email:
 - ded@ddoherty.net
-executables:
-- easter
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".envrc"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".simplecov"
 - ".travis.yml"
 - ".yardopts"
+- CHANGELOG.org
 - Gemfile
 - LICENSE.txt
 - README.org
 - Rakefile
 - TODO.org
 - bin/console
-- bin/easter
 - fat_core.gemspec
 - lib/fat_core.rb
 - lib/fat_core/ChangeLog
 - lib/fat_core/all.rb
 - lib/fat_core/array.rb
 - lib/fat_core/bigdecimal.rb
-- lib/fat_core/date.rb
 - lib/fat_core/enumerable.rb
 - lib/fat_core/hash.rb
-- lib/fat_core/kernel.rb
 - lib/fat_core/nil.rb
 - lib/fat_core/numeric.rb
 - lib/fat_core/patches.rb
@@ -111,10 +110,8 @@ files:
 - lib/fat_core/version.rb
 - spec/lib/array_spec.rb
 - spec/lib/big_decimal_spec.rb
-- spec/lib/date_spec.rb
 - spec/lib/enumerable_spec.rb
 - spec/lib/hash_spec.rb
-- spec/lib/kernel_spec.rb
 - spec/lib/nil_class_spec.rb
 - spec/lib/numeric_spec.rb
 - spec/lib/range_spec.rb
@@ -126,6 +123,7 @@ licenses:
 - MIT
 metadata:
   yard.run: yri
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -140,7 +138,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.5.23
+signing_key:
 specification_version: 4
 summary: some useful core extensions
 test_files: []

data/bin/easter

@@ -1,45 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "debug"
-require 'fat_core/date'
-
-usage = <<~HELP
-  USAGE:
-     easter             -- print the date of Easter for the current year
-     easter year        -- print the date of Easter for the given year
-     easter year1 year2 -- print the dates of Easter from year1 to year2
-
-  Note: if the date of Easter is the earliest possible, it is marked with a '<';
-        if it is the latest date possible, it is marked with a '>'
-HELP
-first, last = *ARGV
-first ||= Date.today.year
-last ||= Date.today.year
-
-if first.to_s.match?(/--help|-h/)
-  puts usage
-  exit(1)
-end
-
-begin
-  first = Integer(first)
-  last = Integer(last)
-rescue ArgumentError
-  warn "!!Error: invalid year number given\n\n"
-  puts usage
-  exit(2)
-end
-
-(first..last).each do |yr|
-  easter = Date.easter(yr)
-  sig =
-    if easter.month == 4 && easter.day >= 25
-      ' >'
-    elsif easter.month == 3 && easter.day <= 22
-      ' <'
-    else
-      ''
-    end
-  puts "Easter #{yr}: #{easter.iso}#{sig}"
-end