fat_core 6.0.0 → 7.1.1

data/lib/fat_core/string.rb

@@ -133,18 +133,15 @@ module FatCore
         a
         an
         the
-        at
-        for
-        up
         and
         but
         or
         nor
+        at
+        for
         in
         on
-        under
         of
-        from
         as
         by
         to
@@ -179,10 +176,13 @@ module FatCore
         elsif /^(N|S|E|W|NE|NW|SE|SW)$/i.match?(w)
           # Compass directions all caps
           newwords.push(w.upcase)
+        elsif little_words.include?(w.downcase)
+          # Only capitalize at beginning or end
+          newwords.push(first || last ? w.capitalize : w.downcase)
         elsif w =~ /^[^aeiouy]*$/i && w.size > 2
           # All consonants and at least 3 chars, probably abbr
           newwords.push(w.upcase)
-        elsif w =~ /^[A-Z0-9]+\z/ && preserve_acronyms
+        elsif w =~ /[0-9]/ && w =~ /^[A-Z0-9]+\z/ && w.size <= 5 && preserve_acronyms
           # All uppercase and numbers, keep as is
           newwords.push(w)
         elsif w =~ /^(\w+)-(\w+)$/i
@@ -192,9 +192,6 @@ module FatCore
           # Last word ended with a ':'
           newwords.push(w.capitalize)
           capitalize_next = false
-        elsif little_words.include?(w.downcase)
-          # Only capitalize at beginning or end
-          newwords.push(first || last ? w.capitalize : w.downcase)
         else
           # All else
           newwords.push(w.capitalize)
@@ -229,11 +226,13 @@ module FatCore
     # @see #fuzzy_match #fuzzy_match for the specifics of string matching
     # @see #as_regexp #as_regexp for conversion of `matcher` to regular expression
     def matches_with(matcher)
+      target = clean.gsub(/[\*.,']/, '')
       if matcher.nil?
         nil
-      elsif matcher =~ %r{^\s*/}
+      elsif matcher.match?(%r{^\s*/})
         re = matcher.as_regexp
-        $& if to_s =~ re
+        md = target.match(re)
+        md[0] if md
       else
         to_s.fuzzy_match(matcher)
       end
@@ -242,22 +241,36 @@ module FatCore
     # Return the matched portion of self, minus punctuation characters, if self
     # matches the string `matcher` using the following notion of matching:
     #
-    # 1. Remove all periods, commas, apostrophes, and asterisks (the punctuation
-    #    characters) from both self and `matcher`,
-    # 2. Treat internal ':stuff' in the matcher as the equivalent of
-    #    '\bstuff.*?\b' in a regular expression, that is, match any word
+    # 1. Remove leading and trailing whitespace in the subject and the matcher
+    #    and collapse its internal whitespace to a single space,
+    # 2. In the subject string replace periods and commas with a space (so
+    #    they still act as word separators) but remove apostrophes, and
+    #    asterisks so the user need not remember whether they were used when
+    #    forming the matcher.
+    # 3. In the matcher, make any period, comma, asterisk, or apostrophe
+    #    optional for the same reason.
+    # 4. Treat internal ':stuff' or ' :stuff' in the matcher as the equivalent
+    #    of /\bstuff.*/ in a regular expression, that is, match any word
     #    starting with stuff in self,
-    # 3. Treat leading ':' in the matcher as anchoring the match to the
+    # 5. Treat internal 'stuff: ' in the matcher as the equivalent
+    #    of /.*stuff\b/ in a regular expression, that is, match any word
+    #    ending with stuff in self,
+    # 6. A colon with no spaces around it is treated as belonging to the
+    #    following word, requiring it to start with it, so 'some:stuff'
+    #    requires 'some' anywhere followed by a word beginning with 'stuff',
+    #    i.e., /some.*\bstuff/i,
+    # 7. Treat leading ':' in the matcher as anchoring the match to the
     #    beginning of the target string,
-    # 4. Treat ending ':' in the matcher as anchoring the match to the
+    # 8. Treat ending ':' in the matcher as anchoring the match to the
     #    end of the target string,
-    # 5. Require each component to match the beginning of a word boundary
-    # 6. Ignore case in the match
+    # 9. Require each component to match some part of self, and
+    # 10. Ignore case in the match
     #
     # @example
     #   "St. Luke's Hospital".fuzzy_match('st lukes') #=> 'St Lukes'
     #   "St. Luke's Hospital".fuzzy_match('luk:hosp') #=> 'Lukes Hosp'
-    #   "St. Luke's Hospital".fuzzy_match('st:spital') #=> 'St Lukes Hospital'
+    #   "St. Luke's Hospital".fuzzy_match('st:spital') #=> nil
+    #   "St. Luke's Hospital".fuzzy_match('st spital') #=> 'St Lukes Hospital'
     #   "St. Luke's Hospital".fuzzy_match('st:laks') #=> nil
     #   "St. Luke's Hospital".fuzzy_match(':lukes') #=> nil
     #   "St. Luke's Hospital".fuzzy_match('lukes:hospital:') #=> 'Lukes Hospital'
@@ -266,23 +279,20 @@ module FatCore
     # @return [String] the unpunctuated part of self that matched
     # @return [nil] if self did not match matcher
     def fuzzy_match(matcher)
-      # Remove periods, asterisks, commas, and apostrophes
-      matcher = matcher.strip.gsub(/[\*.,']/, '')
-      if matcher.start_with?(':')
-        begin_anchor = true
-        matcher.delete_prefix!(':')
-      end
-      if matcher.end_with?(':')
-        end_anchor = true
-        matcher.delete_suffix!(':')
-      end
-      target = gsub(/[\*.,']/, '')
-      matchers = matcher.split(/[: ]+/)
-      regexp_string = matchers.map { |m| ".*?\\b#{Regexp.escape(m)}.*?" }.join('\\b')
-      regexp_string.sub!(/^\.\*\?/, '')
-      regexp_string.sub!(/\.\*\?$/, '')
-      regexp_string.sub!(/\A/, '\\A') if begin_anchor
-      regexp_string.sub!(/\z/, '\\z') if end_anchor
+      # Make asterisks, periods, commas, and apostrophes optional
+      matcher = matcher.clean.gsub(/[\*.,']/, '\0?')
+      # Replace periods and commas with a space (so they are still word
+      # separators, e.g. 'WWW.WOLFRAM' -> 'WWW WOLFRAM' and 'AMZON,INC.' ->
+      # 'AMAZON INC') and remove asterisks and apostrophes
+      target = gsub(/[.,]/, ' ').gsub(/[\*']/, '').clean
+      regexp_string =
+        if matcher.match?(/[: ]/)
+          matcher.sub(/\A:/, "\\A").sub(/:\z/, "\\z")
+            .gsub(/:\s+/, "\\b.*").gsub(':', ".*\\b")
+            .gsub(/\s+/, ".*")
+        else
+          Regexp.escape(matcher)
+        end
       regexp = /#{regexp_string}/i
       matched_text =
         if (match = regexp.match(target))
@@ -317,7 +327,6 @@ module FatCore
           flags |= Regexp::MULTILINE if opts.include?('m')
         end
         flags = nil if flags.zero?
-        # body = Regexp.quote(body) if REGEXP_META_CHARACTERS.include?(body)
         Regexp.new(body, flags)
       else
         Regexp.new(Regexp.quote(self), Regexp::IGNORECASE)
@@ -388,3 +397,34 @@ class String
   # @!parse include FatCore::String
   # @!parse extend FatCore::String::ClassMethods
 end
+
+module StringPred
+  refine String do
+    # This is a kludgy version of #pred (Ruby does define it for a good
+    # reason, namely there is no unique string for which x.pred.succ == x).
+    # Still, for my Range extensions, it helps to have this limited version to
+    # produce a usable #pred for the #gaps method.
+    def pred
+      str = clean
+      return "9" if str.length == 1 && str[0] == 'A'
+      return "Z" if str.length == 1 && str[0] == 'a'
+      return "a" if str.length == 1 && str[0] == '0'
+      return "" if str.empty?
+
+      unless str.match?(/\A[A-Za-z0-9]+\z/)
+        raise NoMethodError, "undefined method :pred for \"#{self}\":String"
+      end
+
+      case str[-1]
+      when 'A'
+        str[0..-2].pred + 'Z'
+      when 'a'
+        str[0..-2].pred + 'z'
+      when '0'
+        str[0..-2].pred + '9'
+      else
+        str[0..-2] + (str[-1].ord - 1).chr
+      end
+    end
+  end
+end

data/lib/fat_core/symbol.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'fat_core/string'
+require_relative 'string'
 
 module FatCore
   module Symbol

data/lib/fat_core/version.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module FatCore
-  MAJOR = 6
-  MINOR = 0
-  PATCH = 0
+  MAJOR = 7
+  MINOR = 1
+  PATCH = 1
 
   # FatCore version number
   VERSION = [MAJOR, MINOR, PATCH].compact.join('.')

data/lib/fat_core.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/deep_dup'
 

data/spec/lib/array_spec.rb

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

data/spec/lib/big_decimal_spec.rb

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

data/spec/lib/enumerable_spec.rb

@@ -1,51 +1,41 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fat_core/enumerable'
 
 describe Enumerable 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
-      if grp.last == 'z'
-        expect(grp.size).to eq(2)
-        expect(grp).to eq(['y', 'z'])
-      else
-        expect(grp.size).to eq(3)
-        expect(grp.join).to match(/\A[a-z]{3}\z/)
+  describe '#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 be true
+          expect(last).to be false
+        elsif l == 'z'
+          expect(first).to be false
+          expect(last).to be true
+        else
+          expect(first).to be false
+          expect(last).to be false
+        end
       end
     end
-  end
 
-  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 be true
-        expect(last).to be false
-      elsif l == 'z'
-        expect(first).to be false
-        expect(last).to be true
-      else
-        expect(first).to be false
-        expect(last).to be false
-      end
+    it 'returns nil enumerating a beginless Range' do
+      bless = (..100)
+      result = bless.each_with_flags { |_l, _first, _last| 44 }
+      expect(result).to be_nil
     end
-  end
 
-  it 'returns nil enumerating a beginless Range' do
-    bless = (..100)
-    result = bless.each_with_flags { |_l, _first, _last| 44 }
-    expect(result).to be_nil
-  end
-
-  it 'enumerates an endless Range' do
-    eless = (1..)
-    num = 0
-    eless.each_with_flags do |i, _first, _last|
-      num += i
-      break if i >= 100
+    it 'enumerates an endless Range' do
+      eless = (1..)
+      num = 0
+      eless.each_with_flags do |i, _first, _last|
+        num += i
+        break if i >= 100
+      end
+      # Look at me, I'm Gauss
+      expect(num).to eq(5050)
     end
-    # Look at me, I'm Gauss
-    expect(num).to eq(5050)
   end
 end

data/spec/lib/hash_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fat_core/hash'
 
@@ -10,8 +12,8 @@ describe Hash 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
+    expect(hh.delete_with_value!(1)).to eq({ :b => 2 })
+    expect(hh.delete_with_value!(9)).to eq hh
   end
 
   it 'maps keys to new keys' do
@@ -29,4 +31,19 @@ describe Hash do
     h3 = { e: 'EEE' }
     expect(h1 << h2 << h3).to eq({ a: 'A', b: 'BB', c: 'C', d: 'DD', e: 'EEE' })
   end
+
+  it 'can take any Enumerable as a right argument' do
+    FileUtils.mkdir_p('./tmp')
+    ff = File.open('./tmp/junk', 'w')
+    ff.write("f\n", "FFFF\n", "g\n", "GGGG\n")
+    ff.close
+    ff = File.open('./tmp/junk', 'r')
+    h = { a: 'A', b: 'B', c: 'C' } << [:c, 'CC', :d, 'DD'] <<
+        { d: 'DDD', e: 'EEE' } <<
+        ff.readlines.map(&:chomp)
+    h.transform_keys!(&:to_sym)
+    ff.close
+    expect(h.keys).to include(:a, :b, :c, :d, :e, :f, :g)
+    FileUtils.rm_rf('./tmp/junk')
+  end
 end

data/spec/lib/nil_class_spec.rb

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

data/spec/lib/numeric_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fat_core/numeric'
 
@@ -16,6 +18,18 @@ describe Numeric do
 
   it 'provides a tex_quote method for erb docs' do
     expect(195.45.tex_quote).to eq '195.45'
+    expect(195.00.tex_quote).to eq '195.0'
+    expect(58743.44.tex_quote).to eq '58743.44'
+    expect(Float::INFINITY.tex_quote).to eq("$\\infty$")
+    expect((-Float::INFINITY).tex_quote).to eq("$-\\infty$")
+    expect(Complex(5, 3).tex_quote).to eq("$5+3i$")
+    expect(Complex(7, 1).tex_quote).to eq("$7+i$")
+    expect(Complex(7.00, 1).tex_quote).to eq("$7+i$")
+    expect(Complex(Math::PI, 1).tex_quote).to eq("$\\pi+i$")
+    expect(Complex(Math::E, 1).tex_quote).to eq("$e+i$")
+    expect(Complex(Math::E, Math::PI).tex_quote).to eq("$e+\\pi i$")
+    expect(Complex(Math::PI, Math::E).tex_quote).to eq("$\\pi+e i$")
+    expect(Rational(5, 3).tex_quote).to eq("$\\frac{5}{3}$")
   end
 
   it 'knows if its a whole number' do

data/spec/lib/range_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'fat_core/range'
 
@@ -206,6 +208,10 @@ describe Range do
       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
       gaps = (0..10).gaps([(-3..3), (4..6), (7..13)])
       expect(gaps).to be_empty
@@ -244,6 +250,10 @@ describe Range 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

data/spec/lib/string_spec.rb

@@ -96,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'
@@ -138,7 +154,6 @@ 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
@@ -205,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
@@ -215,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
@@ -244,37 +257,61 @@ 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
+      it 'replaces periods and commas with a space so they are still word separators' do
+        expect('WWW.WOLFRAM.COM'.fuzzy_match('wolf')).to be_truthy
+        expect('AMAZON,INC'.fuzzy_match('amazon inc')).to be_truthy
+      end
+
+      it 'modifies self by removing asterisks and apostrophes' do
+        expect('WWW*WOLFRAM*COM'.fuzzy_match('wolf')).to be_truthy
+        expect('E*TRADE'.fuzzy_match('etrade')).to be_truthy
+        expect('WWW*WOLFRAM*COM'.fuzzy_match(':wolf')).to be_falsy
+        expect('WWW.WOLFRAM.COM'.fuzzy_match('wolf')).to be_truthy
+        expect('AMAZON,INC'.fuzzy_match('amazon inc')).to be_truthy
       end
 
-      it 'fuzzy matches space-separated parts' do
+      it 'treats internal space as dot-star' do
         expect('Hello world'.fuzzy_match('hel wor')).to be_truthy
+        expect('Hello, world'.fuzzy_match('el or')).to be_truthy
         expect('Hello, world'.fuzzy_match('hel ox')).to be_falsy
+        expect('Hello, what is with the world?'.fuzzy_match('at wi or')).to be_truthy
       end
 
       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
 
@@ -289,15 +326,62 @@ the people, for the people, shall not perish from the earth."
         expect('Hello:world'.matches_with('/^h.*r/')).to eq('Hello:wor')
       end
 
-      it 'ignores periods, commas, and apostrophes when matching' do
+      it 'make periods, commas, and apostrophes optional 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. Luke's".fuzzy_match('st. luke\'s')).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('St Lukes, Inc.'.fuzzy_match('st lukes, inc')).to eq('St Lukes Inc')
         expect('E*TRADE'.fuzzy_match('etrade')).to eq('ETRADE')
         # Does not recognize non-alphanumerics as start of string.
         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`.