fat_core 5.6.1 → 7.0.1

data/lib/fat_core/string.rb

@@ -93,26 +93,6 @@ module FatCore
       r.gsub('XzXzXcbXzXzX', '\\}')
     end
 
-    # Convert a string representing a date with only digits, hyphens, or slashes
-    # to a Date.
-    #
-    # @example
-    #   "20090923".as_date.iso -> "2009-09-23"
-    #   "2009/09/23".as_date.iso -> "2009-09-23"
-    #   "2009-09-23".as_date.iso -> "2009-09-23"
-    #   "2009-9-23".as_date.iso -> "2009-09-23"
-    #
-    # @return [Date] the translated Date
-    def as_date
-      if self =~ %r{(?<yr>\d\d\d\d)[-/]?(?<mo>\d\d?)[-/]?(?<dy>\d\d?)}
-        ::Date.new(
-          Regexp.last_match[:yr].to_i,
-          Regexp.last_match[:mo].to_i,
-          Regexp.last_match[:dy].to_i,
-        )
-      end
-    end
-
     UPPERS = ('A'..'Z').to_a
     REGEXP_META_CHARACTERS = "\\$()*+.<>?[]^{|}".chars.freeze
 
@@ -153,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
@@ -199,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
@@ -212,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)
@@ -249,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
@@ -262,22 +241,32 @@ 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. Remove all periods, commas, apostrophes, and asterisks (the
+    #    punctuation characters) from both self and `matcher`,
+    # 3. 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
+    # 4. 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,
+    # 5. 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,
+    # 6. 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
+    # 7. 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
+    # 8. Require each component to match some part of self, and
+    # 9. 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'
@@ -287,22 +276,16 @@ module FatCore
     # @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
+      matcher = matcher.clean.strip.gsub(/[\*.,']/, '')
+      target = clean.gsub(/[\*.,']/, '')
+      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))
@@ -337,7 +320,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)
@@ -408,3 +390,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,8 +1,8 @@
 # frozen_string_literal: true
 
 module FatCore
-  MAJOR = 5
-  MINOR = 6
+  MAJOR = 7
+  MINOR = 0
   PATCH = 1
 
   # FatCore version number

data/lib/fat_core.rb

@@ -1,5 +1,5 @@
-require 'date'
-require 'active_support'
+# 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