fat_core 7.2.0 → 7.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a1056fe04e707d5c3a9693876c26536997f14a2a22e8b431fc8c5012b30ec92
-  data.tar.gz: e8e58c146a069ca694c07f42ffda4ebd255a8e8f7faa7fc65ad3f07de95206f7
+  metadata.gz: 3aced327c9c27abf23f852ce1db5e3347cb1b26558d9c4c337937db9773d1dde
+  data.tar.gz: 4cb7f01cae67351e9865476ab40f87ddf37375b1dec7a14e725633288c3b78eb
 SHA512:
-  metadata.gz: 474f00944f264d40761579329b2665d5119bb03b2758d7f4752f42f0fab6ded67162bd26c94db88e895bb19838500355f3abd7aba879b3d01bb8047ecc9990ec
-  data.tar.gz: 303429d1884c5e344e90c3214f9566fc3ea753a6a7eda8d1df34e317b202cd02dcce8001eb3cc7e134eb348aecf99f2e059b8015d78af0c0c097b6bc39c2fe74
+  metadata.gz: d90173d7c849ca52ab67e1ccb14af60e7171c16c39b5b482d3df08d6f080e8b2ebdf1f18b89122c3554186cc35d6ae572b84d06d584f3a9a01f674ef9a2f5b8a
+  data.tar.gz: 895eeef8c783f150bb1cb28283c1ff4e4ffdec5ab94cb6889ad1fcbe60e4475ac7326d2c45b3cd5b50b76bb518a52c1866ed70c42c525c1c8d76facab7780e32

data/CHANGELOG.md

@@ -0,0 +1,97 @@
+- [Version 7.3.0](#org5f61e5a)
+  - [String](#org633deb6)
+- [Version 7.1.1](#org003674c)
+  - [String](#org5df7dd5)
+- [Version 7.0.0 from Version 6.0.0](#org3aecf27)
+  - [Enumerable](#orgff23338)
+  - [Hash](#org408609b)
+  - [Numeric](#org138cd73)
+  - [Range](#orgdebd7ac)
+  - [String](#org075bb7e)
+  - [Kernel](#org545d137)
+
+
+<a id="org5f61e5a"></a>
+
+# Version 7.3.0
+
+
+<a id="org633deb6"></a>
+
+## String
+
+Another visit to String#fuzzy\_match to ensure that a subject string is matched by its own matcher. This bug got tickled when 'Amazon.com' failed to match 'Amazon.com', which just isn't right.
+
+
+<a id="org003674c"></a>
+
+# Version 7.1.1
+
+
+<a id="org5df7dd5"></a>
+
+## String
+
+-   `String#fuzzy_match` make period, comma, asterisk, and apostrophes optional in matcher instead of just deleting them and in the subject string replace periods and commas with spaces so they still act as word separators.
+    
+    Before `'WWW.WOLFRAM.COM'.fuzzy_match('www:wolfram')` would not match because the periods were just eliminated so the matcher was looking for a word starting with 'wolfram' but the subject string was converted to 'WWWWOLFRAMCOM' so no match. Now it is converted to 'WWW WOLFRAM COM' so the match succeeds.
+
+
+<a id="org3aecf27"></a>
+
+# Version 7.0.0 from Version 6.0.0
+
+
+<a id="orgff23338"></a>
+
+## Enumerable
+
+-   Remove `#groups_of` as duplicative of `each_slice`
+
+
+<a id="org408609b"></a>
+
+## Hash
+
+-   Rename `delete_with_value` to `delete_with_values!` to make it clear that the Hash is modified in place,
+-   Add `delete_with_value` as a non-mutating variant
+-   Change arg to `keys_with_value(vals)` to allow variable arguments for multiple values instead of requiring an Array,
+-   Allow `<<` operator to merge any `Enumerable` as well as a `Hash`
+
+
+<a id="org138cd73"></a>
+
+## Numeric
+
+-   Enhance `#tex_quote` to put special numbers such as `Math::PI`, `Math::E`, and `Float::INFINITY` in TeX notation, so, e.g., Complex(Math::E, Math:PI).tex\_quote will render to "$\\pi+e i$", Rationals will be rendered as fractions, etc.
+
+
+<a id="orgdebd7ac"></a>
+
+## Range
+
+-   `Range#gaps` now better handles Ranges with countable endpoints that need `:succ` and `:pred` methods,
+-   `tex_quote` applies `#tex_quote` to endpoints if they respond to a `#tex_quote` method,
+-   Check argument Ranges to `#gaps`, `#spanned_by?`, and `#overlaps` for compatibility with the subject Range,
+
+
+<a id="org075bb7e"></a>
+
+## String
+
+-   `String#fuzzy_match` changes the semantics of the string matcher argument:
+    1.  an internal ':' preceded and followed by non-whitespace now only applies to the word following it to indicate that the word must be a word boundary, so 'hel:wor' matches 'Shell worms' as well as 'Hello, world'.
+    2.  an internal ':' preceded by whitespace but followed by non-whitespace is also treated as requiring a word boundary for the following word but not the preceding word, as in 1, so 'hel :wor'
+    3.  but an internal ':' preceded by non-whitespace but followed by whitespace requires a word boundary after the preceding word, so 'hel: wor'
+    4.  a lone matcher now allows a match anywhere in the subject text regardless of boundaries; the prior version added a word boundary restriction to the bare matcher, so before 'zz' would not match "Pizza" since 'zz' did not occur at the end of word, but now 'zz' will match "Pizza". Rule 3 above allows putting a boundary restriction on the matcher with 'zz: ' as before.
+    5.  Leading and trailing ':' continue to require the text to occur at the beginning or end, respectively, of the subject string, so ':hel' and 'ld:' match "Hello, world" but ':wor' and 'wor:' do not.
+-   `String#number` no longer considers a hex number with a decimal point to be in the form of a number
+-   provide a :pred method in a refinement accesses with 'using StringPred
+-   `String#entitle` no longer tries to detect general acronyms for upper case handling since it was unreliable. Thus, `"ibm corporation".enetitle` becomers "Ibm Corporation" rather than "IBM corporation."
+
+
+<a id="org545d137"></a>
+
+## Kernel
+
+-   removed the `Kernel.time_it` method since Benchmark already does this better.

data/CHANGELOG.org

@@ -1,3 +1,8 @@
+* Version 7.3.0
+** String
+Another visit to String#fuzzy_match to ensure that a subject string is matched
+by its own matcher.  This bug got tickled when 'Amazon.com' failed to match
+'Amazon.com', which just isn't right.
 * Version 7.1.1
 ** String
 - =String#fuzzy_match= make period, comma, asterisk, and apostrophes optional

data/lib/fat_core/string.rb

@@ -225,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'
@@ -261,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
@@ -385,6 +379,37 @@ module FatCore
 
     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

data/lib/fat_core/version.rb

@@ -2,7 +2,7 @@
 
 module FatCore
   MAJOR = 7
-  MINOR = 2
+  MINOR = 3
   PATCH = 0
 
   # FatCore version number

data/spec/lib/string_spec.rb

@@ -270,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
@@ -290,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
@@ -310,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
@@ -342,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.2.0
+  version: 7.3.0
 platform: ruby
 authors:
 - Daniel E. Doherty
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-29 00:00:00.000000000 Z
+date: 2026-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -86,6 +86,7 @@ files:
 - ".simplecov"
 - ".travis.yml"
 - ".yardopts"
+- CHANGELOG.md
 - CHANGELOG.org
 - Gemfile
 - LICENSE.txt