fat_core 7.1.3 → 7.3.0

data/Rakefile

@@ -24,16 +24,12 @@ RSpec::Core::RakeTask.new(:spec, :tag) do |t|
   t.rspec_opts = '--tag ~online -f d'
 end
 
+require "gem_docs"
+GemDocs.install
+
 ########################################################################
 # Rubocop tasks
 ########################################################################
-# Option A (recommended): Keep using Bundler and run rubocop via `bundle exec`.
-# This wrapper task ensures the rubocop run uses the gems from your Gemfile,
-# even when you invoke `rake rubocop` (no need to remember `bundle exec rake`).
-#
-# You can pass extra RuboCop CLI flags with the RUBOCOP_OPTS environment variable:
-#   RUBOCOP_OPTS="--format simple" rake rubocop
-
 desc "Run rubocop under `bundle exec`"
 task :rubocop do
   opts = (ENV['RUBOCOP_OPTS'] || '').split

data/lib/fat_core/all.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative '../fat_core'
 require_relative 'array'
 require_relative 'bigdecimal'
 require_relative 'enumerable'

data/lib/fat_core/string.rb

@@ -8,6 +8,9 @@ require_relative 'numeric'
 
 module FatCore
   module String
+    UPPERS = ('A'..'Z').to_a
+    REGEXP_META_CHARACTERS = "\\$()*+.<>?[]^{|}".chars.freeze
+
     # @group Transforming
     # :section: Transforming
 
@@ -93,22 +96,29 @@ module FatCore
       r.gsub('XzXzXcbXzXzX', '\\}')
     end
 
-    UPPERS = ('A'..'Z').to_a
-    REGEXP_META_CHARACTERS = "\\$()*+.<>?[]^{|}".chars.freeze
-
-    private
+    # Rather than truncate a String to make it fit a given length, this method
+    # removes characters from the middle of the string to make it fit the
+    # given size.  This is often preferable to truncating at the end or
+    # beginning of a String because the most important information is often at
+    # the start or end of a String.  By default the missing middle is
+    # indicated by a single '~' character, but you can set it to any string,
+    # even the empty string with the `ellipsis:` parameter.
+    def gut(max_size, ellipsis: '~', squeeze: nil)
+      return self if size <= max_size
 
-    def upper?
-      UPPERS.include?(self[0])
-    end
-
-    # Return true if all the letters in self are upper case
-    def all_upper?
-      tr('^A-Za-z', '').split('').all? { |c| ('A'..'Z').to_a.include? c }
+      s =
+        if squeeze
+          tr(squeeze, '')
+        else
+          self
+        end
+      chars_to_cut = (s.size - max_size) + ellipsis.size
+      chars_to_keep = s.size - chars_to_cut
+      start_chars = chars_to_keep / 2 + (chars_to_keep.odd? ? 1 : 0)
+      end_chars = chars_to_keep - start_chars
+      s[0..start_chars - 1] + ellipsis + s[-end_chars..-1]
     end
 
-    public
-
     # Return self capitalized according to the conventions for capitalizing
     # titles of books or articles. Tries to follow the rules of the University
     # of Chicago's *A Manual of Style*, Section 7.123, except to the extent that
@@ -215,33 +225,32 @@ module FatCore
       DamerauLevenshtein.distance(self, other.to_s, 1, 10)
     end
 
-    # Return the matched portion of self, minus punctuation characters, if self
-    # matches the string `matcher` using the following notion of matching:
+    # Return the matched portion of self, with fuzzy-match punctuation normalized,
+    # if self matches `matcher` using the following rules:
     #
-    # 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,
-    # 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,
-    # 8. Treat ending ':' in the matcher as anchoring the match to the
-    #    end of the target string,
-    # 9. Require each component to match some part of self, and
-    # 10. Ignore case in the match
+    # 1. Remove leading and trailing whitespace in the subject and matcher and
+    #    collapse internal whitespace to a single space.
+    # 2. In ordinary fuzzy matching, treat periods and commas between non-space
+    #    characters as word separators.  Otherwise ignore periods and commas.
+    #    Ignore apostrophes and asterisks, so the matcher need not reproduce
+    #    those punctuation characters exactly.
+    # 3. Escape regular-expression metacharacters in an ordinary matcher.  A
+    #    matcher enclosed in '/' characters is instead treated as a regular
+    #    expression and matched against the original, unnormalized subject.
+    # 4. Treat internal ':stuff' or ' :stuff' in an ordinary matcher as the
+    #    equivalent of /\bstuff.*/, that is, match a word beginning with stuff.
+    # 5. Treat internal 'stuff: ' as the equivalent of /stuff\b.*/, that is,
+    #    require stuff to end at a word boundary and then match anything after it.
+    # 6. A colon with no spaces around it belongs to the following component, so
+    #    'some:stuff' requires 'some' followed somewhere by a word beginning with
+    #    'stuff', i.e. /some.*\bstuff/i.
+    # 7. Treat a leading ':' as anchoring the match to the beginning of the
+    #    normalized subject.
+    # 8. Treat a trailing ':' as anchoring the match to the end of the normalized
+    #    subject.
+    # 9. Require each component of an ordinary matcher to match some part of the
+    #    subject, in order.
+    # 10. Ignore case in both fuzzy and regular-expression matching.
     #
     # @example
     #   "St. Luke's Hospital".fuzzy_match('st lukes') #=> 'St Lukes'
@@ -251,28 +260,23 @@ module FatCore
     #   "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'
+    #   "Amazon.com".fuzzy_match('Amazon.com') #=> 'Amazon com'
+    #   "Price is $12.50".fuzzy_match('/\$12\.50/') #=> '$12.50'
     #
-    # @param matcher [String] pattern to test against where ':' is wildcard
-    # @return [String] the unpunctuated part of self that matched
-    # @return [nil] if self did not match matcher
+    # @param matcher [String] fuzzy matcher, or a regular expression enclosed in /
+    # @return [String] the portion of the subject that matched
+    # @return [nil] if the subject did not match
     def fuzzy_match(matcher)
-      # 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
+      if matcher.match?(%r{\A/.*/\z})
+        regexp = Regexp.new(matcher[1...-1], Regexp::IGNORECASE)
+        subject = self
+      else
+        subject = fuzzy_match_clean(self)
+        matcher = fuzzy_match_clean(matcher)
+        regexp = Regexp.new(fuzzy_match_regexp(matcher), Regexp::IGNORECASE)
+      end
       matched_text =
-        if (match = regexp.match(target))
+        if (match = regexp.match(subject))
           match[0]
         end
       matched_text
@@ -373,6 +377,48 @@ module FatCore
       to_f.commas(places)
     end
 
+    private
+
+    def fuzzy_match_regexp(matcher)
+      start_anchor = matcher.start_with?(':')
+      end_anchor = matcher.end_with?(':')
+      matcher = matcher.delete_prefix(':') if start_anchor
+      matcher = matcher.delete_suffix(':') if end_anchor
+      parts = matcher.split(/(:\s+|:|\s+)/)
+      regexp_string = parts.map { |part|
+        case part
+        when /\A:\s+\z/
+          "\\b.*"
+        when ':'
+          ".*\\b"
+        when /\A\s+\z/
+          '.*'
+        else
+          Regexp.escape(part)
+        end
+      }.join
+      regexp_string = "\\A#{regexp_string}" if start_anchor
+      regexp_string = "#{regexp_string}\\z" if end_anchor
+      regexp_string
+    end
+
+    def fuzzy_match_clean(string)
+      string
+        .clean
+        .gsub(/(?<=\S)[.,](?=\S)/, ' ')
+        .gsub(/[.,*']/, '')
+        .clean
+    end
+
+    def upper?
+      UPPERS.include?(self[0])
+    end
+
+    # Return true if all the letters in self are upper case
+    def all_upper?
+      tr('^A-Za-z', '').split('').all? { |c| ('A'..'Z').to_a.include? c }
+    end
+
     module ClassMethods
       # @group Generating
       # :section: Generating

data/lib/fat_core/version.rb

@@ -2,8 +2,8 @@
 
 module FatCore
   MAJOR = 7
-  MINOR = 1
-  PATCH = 3
+  MINOR = 3
+  PATCH = 0
 
   # FatCore version number
   VERSION = [MAJOR, MINOR, PATCH].compact.join('.')

data/lib/fat_core.rb

@@ -3,5 +3,15 @@
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/object/deep_dup'
 
-require 'fat_core/version'
-require 'fat_core/patches'
+# Gem Overview (extracted from README.org by gem_docs)
+#
+# * Introduction
+# ~fat-core~ is somewhat of a grab bag of core class extensions that I have
+# found useful across several projects.  It's higgeldy-piggeldy nature reflects
+# the fact that none of them are important enough to deserve a gem of their own,
+# but nonetheless need to be collected in one place to reduce redundancy across
+# projects and provide a focused place to develop and test them.
+module FatCore
+  require 'fat_core/version'
+  require 'fat_core/patches'
+end

data/spec/lib/string_spec.rb

@@ -158,6 +158,15 @@ the people, for the people, shall not perish from the earth."
       end
     end
 
+    it 'guts a string in the middle' do
+      expect('hello'.gut(10)).to eq('hello')
+      expect('helloworld'.gut(6)).to eq('hel~ld')
+      expect('Class A Common Stock'.gut(15)).to eq("Class A~n Stock")
+      expect('Class A Common Stock'.gut(15, ellipsis: '...')).to eq("Class ... Stock")
+      expect('Class A Common Stock'.gut(15, ellipsis: '')).to eq("Class A n Stock")
+      expect('Class A Common Stock'.gut(16, ellipsis: '', squeeze: ' ')).to eq("ClassAComonStock")
+    end
+
     it 'converts a string to a regular expression' do
       # Ignores case by default
       re = "/hello((\s+)(world))?/".as_regexp
@@ -261,6 +270,49 @@ the people, for the people, shall not perish from the earth."
         expect('Hello, world'.fuzzy_match('ox')).to be_falsy
       end
 
+      it 'matches an exact match' do
+        expect('Amazon.com'.fuzzy_match('Amazon.com')).to be_truthy
+        expect('Hello:world'.fuzzy_match('Hello:world')).to be_truthy
+        expect('2+2=4'.fuzzy_match('2+2=4')).to be_truthy
+        expect('Whodunnit?'.fuzzy_match('Whodunnit?')).to be_truthy
+        expect('(I like (lisp))'.fuzzy_match('(I like (lisp))')).to be_truthy
+        # expect('Price is $12.50'.fuzzy_match('Price is $12.50')).to be_truthy
+        expect('foo[bar]'.fuzzy_match('foo[bar]')).to be_truthy
+        expect('a^b'.fuzzy_match('a^b')).to be_truthy
+        expect('foo|bar'.fuzzy_match('foo|bar')).to be_truthy
+        expect('path\\name'.fuzzy_match('path\\name')).to be_truthy
+        expect('Acme Co., Inc.'.fuzzy_match('Acme Co., Inc.')).to be_truthy
+        expect("St. Luke's Hospital".fuzzy_match("St. Luke's Hospital")).to be_truthy
+        expect('E*TRADE'.fuzzy_match('E*TRADE')).to be_truthy
+      end
+
+      it 'fuzzy matches ordinary strings against themselves' do
+        [
+          'Amazon.com',
+          'Amazon, Inc.',
+          'St. Luke\'s Hospital',
+          'E*TRADE',
+          'WWW.WOLFRAM.COM',
+          'Smith, Jones & Brown',
+          'Acme Co., Inc.',
+          'Hello, world.',
+        ].each do |string|
+          expect(string.fuzzy_match(string)).to be_truthy
+        end
+      end
+
+      it 'escapes regexp special characters in ordinary matchers' do
+        expect('Price is $12.50'.fuzzy_match('Price is $12.50')).to be_truthy
+        expect('Use a+b'.fuzzy_match('Use a+b')).to be_truthy
+        expect('Maybe yes?'.fuzzy_match('Maybe yes?')).to be_truthy
+        expect('Pick (one)'.fuzzy_match('Pick (one)')).to be_truthy
+      end
+
+      it 'honors regexp special characters in slash-delimited matchers' do
+        expect('Hello world'.fuzzy_match('/^hello.*world$/')).to be_truthy
+        expect('Hello world'.fuzzy_match('/^world/')).to be_falsy
+      end
+
       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
@@ -281,10 +333,14 @@ the people, for the people, shall not perish from the earth."
         expect('Hello, what is with the world?'.fuzzy_match('at wi or')).to be_truthy
       end
 
+      it 'does not normalize the subject for regexp matchers' do
+        expect('Price is $12.50'.fuzzy_match('/\\$12\\.50/')).to eq('$12.50')
+        expect('Price is $12.50'.fuzzy_match('/\\$12 50/')).to be_nil
+      end
+
       it 'fuzzy matches colon-separated parts' do
         expect('Hello:world'.fuzzy_match('hel:wor')).to be_truthy
         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
@@ -301,6 +357,8 @@ the people, for the people, shall not perish from the earth."
         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
+        # A colon at the end of a word in the matcher should require a word-boundary there.
+        expect('Hello:world'.fuzzy_match('hel: wor')).to be_falsy
       end
 
       it 'requires end-anchor for ending colon' do
@@ -333,9 +391,8 @@ the people, for the people, shall not perish from the earth."
         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
+        expect('The $1 Dollar Store'.fuzzy_match('$1 stor')).to be_truthy
       end
 
       it 'performs examples in documentation' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fat_core
 version: !ruby/object:Gem::Version
-  version: 7.1.3
+  version: 7.3.0
 platform: ruby
 authors:
 - Daniel E. Doherty
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-28 00:00:00.000000000 Z
+date: 2026-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -86,9 +86,11 @@ files:
 - ".simplecov"
 - ".travis.yml"
 - ".yardopts"
+- CHANGELOG.md
 - CHANGELOG.org
 - Gemfile
 - LICENSE.txt
+- README.md
 - README.org
 - Rakefile
 - TODO.org