fat_core 6.0.0 → 7.1.1

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'rdoc/task'
@@ -19,14 +21,25 @@ YARD::Rake::YardocTask.new do |t|
 end
 
 RSpec::Core::RakeTask.new(:spec, :tag) do |t|
-  t.rspec_opts = '--tag ~online -f p'
+  t.rspec_opts = '--tag ~online -f d'
 end
 
 ########################################################################
 # Rubocop tasks
 ########################################################################
-require 'rubocop/rake_task'
+# 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
 
-RuboCop::RakeTask.new
+desc "Run rubocop under `bundle exec`"
+task :rubocop do
+  opts = (ENV['RUBOCOP_OPTS'] || '').split
+  Bundler.with_unbundled_env do
+    sh 'bundle', 'exec', 'rubocop', *opts
+  end
+end
 
 task :default => [:spec, :rubocop]

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'bundler/setup'
 require 'fat_core/all'

data/fat_core.gemspec

@@ -1,4 +1,5 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 require_relative 'lib/fat_core/version'
 
@@ -9,15 +10,15 @@ Gem::Specification.new do |spec|
   spec.email         = ['ded@ddoherty.net']
   spec.summary       = 'some useful core extensions'
   spec.description   = <<~DESC
-    Useful extensions to Date, String, Range and other classes
-    including useful Date extensions for dealing with US Federal
-    and New York Stock Exchange holidays and working days, a useful
+    Useful extensions to Enumerable and String, Range and other classes. A
     Enumerable#each_with_flags for flagging first and last items in the
-    iteration, (also for Hash), set operations on Ranges
+    iteration, operations on Ranges for testing contiguity, gaps in sets of
+    Ranges, and performing set operations on Ranges.  String#fuzzy_match
+    for user-friendly matchers to test for matching.
   DESC
   spec.homepage      = 'https://github.com/ddoherty03/fat_core.git'
   spec.license       = 'MIT'
-  spec.required_ruby_version = '>= 2.2.2'
+  spec.required_ruby_version = '>= 3.2.2'
   spec.metadata['yard.run'] = 'yri' # use "yard" to build full HTML docs.
 
   spec.files = %x[git ls-files -z].split("\x0")

data/lib/fat_core/all.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
-require 'fat_core/array'
-require 'fat_core/bigdecimal'
-require 'fat_core/enumerable'
-require 'fat_core/hash'
-require 'fat_core/kernel'
-require 'fat_core/nil'
-require 'fat_core/numeric'
-require 'fat_core/range'
-require 'fat_core/string'
-require 'fat_core/symbol'
+require_relative 'array'
+require_relative 'bigdecimal'
+require_relative 'enumerable'
+require_relative 'hash'
+require_relative 'nil'
+require_relative 'numeric'
+require_relative 'range'
+require_relative 'string'
+require_relative 'symbol'

data/lib/fat_core/array.rb

@@ -21,10 +21,10 @@ module FatCore
       result
     end
 
-    # Return an Array that is the difference between this Array and +other+, but
-    # without removing duplicates as the Array#- method does. All items of this
-    # Array are included in the result unless they also appear in the +other+
-    # Array.
+    # Return an Array that is the difference between this Array and +other+,
+    # but without removing duplicates as the Array#- method does. All items of
+    # this Array are included in the result unless they also appear in any of
+    # the +other+ Arrays.
     def diff_with_dups(*others)
       result = []
       each do |itm|
@@ -35,7 +35,7 @@ module FatCore
 
     # Convert this array into a single string by (1) applying #to_s to each
     # element and (2) joining the elements with the string given by the sep:
-    # paramater. By default the sep parameter is ', '. You may use a different
+    # parameter. By default the sep parameter is ', '. You may use a different
     # separation string in the case when there are only two items in the list
     # by supplying a two_sep parameter.  You may also supply a difference
     # separation string to separate the second-last and last items in the

data/lib/fat_core/enumerable.rb

@@ -2,21 +2,6 @@
 
 # Useful extensions to the core Enumerable module.
 module Enumerable
-  # Yield items in groups of n, for each group yield the group number, starting
-  # with zero and an Array of n items, or all remaining items if less than n.
-  #
-  #    ('a'..'z').to_a.groups_of(5) do |k, grp|
-  #      # On each iteration, grp is an Array of the next 5 items except the
-  #      # last group, which contains only ['z'].
-  #    end
-  def groups_of(num)
-    k = -1
-    group_by do
-      k += 1
-      k.div(num)
-    end
-  end
-
   # Yield each item together with two booleans that indicate whether the item is
   # the first or last item in the Enumerable.
   #

data/lib/fat_core/hash.rb

@@ -10,6 +10,9 @@
 # require 'fat_core/hash'
 # ```
 #
+
+require_relative 'enumerable'
+
 module FatCore
   # It provides a couple of methods for manipulating the keys of a Hash:
   # `#remap_keys` for translating the current set of keys to a new set provided by
@@ -59,23 +62,50 @@ module FatCore
 
     # @group Deletion
     #
-    # Remove from the hash all keys that have values == to given value or that
-    # include the given value if the hash has an Enumerable for a value
+    # Remove from the hash in place all keys that have values == to the given
+    # value or values.
     #
     # @example
     #   h = { a: 1, b: 2, c: 3, d: 2, e: 1 }
-    #   h.delete_with_value(2) #=> { a: 1, c: 3, e: 1 }
-    #   h.delete_with_value([1, 3]) #=> { b: 2, d: 2 }
+    #   h.delete_with_value!(2)
+    #   h  #=> { a: 1, c: 3, e: 1 }
+    #   h.delete_with_value!(1, 3)
+    #   h  #=> { b: 2, d: 2 }
     #
     # @param val [Object, Enumerable<Object>] value to test for
     # @return [Hash] hash having entries === v or including v deleted
-    def delete_with_value(val)
-      keys_with_value(val).each do |k|
-        delete(k)
+    def delete_with_value!(*val)
+      val.each do |v|
+        keys_with_value(v).each do |k|
+          delete(k)
+        end
       end
       self
     end
 
+    #
+    # Return a copy of the Hash a Hash with all keys that have values == to the
+    # given value or values.
+    #
+    # @example
+    #   h = { a: 1, b: 2, c: 3, d: 2, e: 1 }
+    #   h.delete_with_value(2) #=> { a: 1, c: 3, e: 1 }
+    #   h => { a: 1, b: 2, c: 3, d: 2, e: 1 }
+    #   h.delete_with_value(1, 3) #=> { b: 2, d: 2 }
+    #   h => { a: 1, b: 2, c: 3, d: 2, e: 1 }
+    #
+    # @param val [Object, Enumerable<Object>] value to test for
+    # @return [Hash] hash having entries === v or including v deleted
+    def delete_with_value(*val)
+      hsh = clone
+      val.each do |v|
+        hsh.keys_with_value(v).each do |k|
+          hsh.delete(k)
+        end
+      end
+      hsh
+    end
+
     # @group Key Manipulation
     #
     # Return all keys in hash that have a value == to the given value or have an
@@ -88,10 +118,12 @@ module FatCore
     #
     # @param val [Object, Enumerable<Object>] value to test for
     # @return [Array<Object>] the keys with value or values v
-    def keys_with_value(val)
+    def keys_with_value(*vals)
       keys = []
-      each_pair do |k, v|
-        keys << k if self[k] == val || (v.respond_to?(:include?) && v.include?(val))
+      vals.each do |val|
+        each_pair do |k, v|
+          keys << k if self[k] == val || (v.respond_to?(:include?) && v.include?(val))
+        end
       end
       keys
     end
@@ -136,7 +168,12 @@ module FatCore
     end
 
     def <<(other)
-      merge(other)
+      case other
+      when Hash
+        merge(other)
+      when Enumerable
+        merge(other.flatten.each_slice(2).to_h)
+      end
     end
   end
 end

data/lib/fat_core/numeric.rb

@@ -153,7 +153,54 @@ module FatCore
     # Quote self for use in TeX documents.  Since number components are not
     # special to TeX, this just applies `#to_s`
     def tex_quote
-      to_s.tex_quote
+      case self
+      when Float
+        if self == Float::INFINITY
+          "$\\infty$"
+        elsif self == -Float::INFINITY
+          "$-\\infty$"
+        elsif self == Math::PI
+          "$\\pi$"
+        elsif self == Math::E
+          "$e$"
+        else
+          to_s.tex_quote
+        end
+      when Rational
+        "$\\frac{#{numerator}}{#{denominator}}$"
+      when Complex
+        if imaginary.zero?
+          real.int_if_whole.tex_quote
+        elsif imaginary == 1.0
+          if real == Math::PI
+            "$\\pi+i$"
+          elsif real == Math::E
+            "$e+i$"
+          else
+            "$#{real.int_if_whole}+i$"
+          end
+        elsif imaginary == Math::PI
+          if real == Math::PI
+            "$\\pi+\\pi i$"
+          elsif real == Math::E
+            "$e+\\pi i$"
+          else
+            "$#{real.int_if_whole}+\\pi i$"
+          end
+        elsif imaginary == Math::E
+          if real == Math::PI
+            "$\\pi+e i$"
+          elsif real == Math::E
+            "$e+e i$"
+          else
+            "$#{real.int_if_whole}+e i$"
+          end
+        else
+          "$#{real.int_if_whole}+#{imaginary.int_if_whole}i$"
+        end
+      else
+        to_s.tex_quote
+      end
     end
   end
 end

data/lib/fat_core/range.rb

@@ -12,8 +12,13 @@
 #    coverage,
 # 5. provide a definition for sorting Ranges based on sorting by the min values
 #    and sizes of the Ranges.
+
+require_relative 'string'
+
 module FatCore
   module Range
+    using StringPred
+
     # @group Operations
 
     # Return a range that concatenates this range with other if it is contiguous
@@ -29,9 +34,9 @@ module FatCore
     # @see contiguous? For the definition of "contiguous"
     def join(other)
       if left_contiguous?(other)
-        ::Range.new(min, other.max)
-      elsif right_contiguous?(other)
         ::Range.new(other.min, max)
+      elsif right_contiguous?(other)
+        ::Range.new(min, other.max)
       end
     end
 
@@ -53,30 +58,48 @@ module FatCore
     # @param ranges [Array<Range>]
     # @return [Array<Range>]
     def gaps(ranges)
-      if ranges.empty?
-        [clone]
-      elsif spanned_by?(ranges)
-        []
-      else
-        # TODO: does not work unless min and max respond to :succ
-        ranges = ranges.sort_by(&:min)
-        gaps = []
-        cur_point = min
-        ranges.each do |rr|
-          break if rr.min > max
-
-          if rr.min > cur_point
-            start_point = cur_point
-            end_point = rr.min.pred
-            gaps << (start_point..end_point)
-            cur_point = rr.max.succ
-          elsif rr.max >= cur_point
-            cur_point = rr.max.succ
-          end
+      return [clone] if ranges.empty?
+
+      msg = "#{ranges.first.min.class} range incompatible with #{min.class} Range"
+      raise ArgumentError, msg unless compatible?(ranges)
+
+      return [] if spanned_by?(ranges)
+
+      ranges = ranges.select { |r| r.overlaps?(self) }.sort
+      self_is_continuous = ranges.map(&:minmax).flatten.any? { |p| !p.respond_to?(:succ) }
+      gaps = []
+      cur_point = min
+      ranges.each do |rr|
+        # Loop Invariant: cur_point is the last element in the self Range
+        # NOT covered by the given ranges or the gaps so far.
+        break if cur_point == max
+
+        if (self_is_continuous && rr.min > cur_point) ||
+           (!self_is_continuous && rr.min > cur_point)
+          # There is a gap between the cur_point within self and the start
+          # of this range, rr, so we need to record it.
+          start_point = cur_point
+          end_point = self_is_continuous ? rr.min : rr.min.pred
+          gaps << (start_point..end_point)
         end
-        gaps << (cur_point..max) if cur_point <= max
-        gaps
+        cur_point =
+          if rr.max.is_a?(String) && rr.max[-1].match?(/[Zz9]/)
+            # This is a real kludge that stems from the fact that 'z'.succ <
+            # 'z', so the test for gaps at the end of the self range
+            # believes there is a gap when there is none.  This ensures that
+            # cur_point is set to something > rr.max when it is one of the
+            # problematic strings ending in 'Z', 'z', or '9', all of whose
+            # successors sort less than them.
+            rr.max + rr.max[-1]
+          else
+            self_is_continuous ? rr.max : rr.max.succ
+          end
       end
+      # Add any gap between the last of the ranges and the end of self.
+      if cur_point <= max
+        gaps << (cur_point..max)
+      end
+      gaps
     end
 
     # Within this range return an Array of Ranges representing the overlaps
@@ -90,31 +113,34 @@ module FatCore
     # @param ranges [Array<Range>] ranges to search for overlaps
     # @return [Array<Range>] overlaps with ranges but inside this Range
     def overlaps(ranges)
-      if ranges.empty? || spanned_by?(ranges)
-        []
-      else
-        ranges = ranges.sort_by(&:min)
-        overlaps = []
-        cur_point = nil
-        ranges.each do |rr|
-          # Skip ranges outside of self
-          next if rr.max < min || rr.min > max
-
-          # Initialize cur_point to max of first range
-          if cur_point.nil?
-            cur_point = rr.max
-            next
-          end
-          # We are on the second or later range
-          if rr.min < cur_point
-            start_point = rr.min
-            end_point = cur_point
-            overlaps << (start_point..end_point)
-          end
+      return [] if ranges.empty?
+
+      msg = "#{ranges.first.min.class} range incompatible with #{min.class} Range"
+      raise ArgumentError, msg unless compatible?(ranges)
+
+      return [] if spanned_by?(ranges)
+
+      ranges = ranges.sort_by(&:min)
+      overlaps = []
+      cur_point = nil
+      ranges.each do |rr|
+        # Skip ranges outside of self
+        next if rr.max < min || rr.min > max
+
+        # Initialize cur_point to max of first range
+        if cur_point.nil?
           cur_point = rr.max
+          next
+        end
+        # We are on the second or later range
+        if rr.min < cur_point
+          start_point = rr.min
+          end_point = cur_point
+          overlaps << (start_point..end_point)
         end
-        overlaps
+        cur_point = rr.max
       end
+      overlaps
     end
 
     # Return a Range that represents the intersection between this range and the
@@ -193,12 +219,24 @@ module FatCore
     #
     # @return [String]
     def tex_quote
-      to_s.tex_quote
+      minq =
+        if min.respond_to?(:tex_quote)
+          min.tex_quote
+        else
+          min.to_s
+        end
+      maxq =
+        if max.respond_to?(:tex_quote)
+          max.tex_quote
+        else
+          max.to_s
+        end
+      "(#{minq}..#{maxq})"
     end
 
     # @group Queries
 
-    # Is self on the left of and contiguous to other?  Whether one range is
+    # Is other on the left of and contiguous to self?  Whether one range is
     # "contiguous" to another has two cases:
     #
     # 1. If the elements of the Range on the left respond to the #succ method
@@ -219,14 +257,14 @@ module FatCore
     # @param other [Range] other range to test for contiguity
     # @return [Boolean] is self left_contiguous with other
     def left_contiguous?(other)
-      if max.respond_to?(:succ)
-        max.succ == other.min
+      if other.max.respond_to?(:succ)
+        other.max.succ == min
       else
-        max == other.min
+        other.max == min
       end
     end
 
-    # Is self on the right of and contiguous to other?  Whether one range is
+    # Is other on the right of and contiguous to self?  Whether one range is
     # "contiguous" to another has two cases:
     #
     # 1. If the elements of the Range on the left respond to the #succ method
@@ -247,10 +285,10 @@ module FatCore
     # @param other [Range] other range to test for contiguity
     # @return [Boolean] is self right_contiguous with other
     def right_contiguous?(other)
-      if other.max.respond_to?(:succ)
-        other.max.succ == min
+      if max.respond_to?(:succ)
+        max.succ == other.min
       else
-        other.max == min
+        max == other.min
       end
     end
 
@@ -348,6 +386,11 @@ module FatCore
     # @param ranges [Array<Range>]
     # @return [Boolean]
     def spanned_by?(ranges)
+      return empty? if ranges.empty?
+
+      msg = "#{ranges.first.min.class} range incompatible with #{min.class} Range"
+      raise ArgumentError, msg unless compatible?(ranges)
+
       joined_range = nil
       ranges.sort.each do |r|
         unless joined_range
@@ -385,6 +428,16 @@ module FatCore
       [min, max] <=> other.minmax
     end
 
+    def compatible?(ranges)
+      numeric_ok = min.is_a?(Numeric) && max.is_a?(Numeric)
+      if numeric_ok
+        ranges.map.all? { |r| r.min.is_a?(Numeric) && r.max.is_a?(Numeric) }
+      else
+        self_class = min.class
+        ranges.map.all? { |r| r.min.is_a?(self_class) && r.max.is_a?(self_class) }
+      end
+    end
+
     module ClassMethods
       # Return whether any of the `ranges` overlap one another
       #