fat_core 2.0.1 → 3.0.0

data/lib/fat_core/enumerable.rb

@@ -1,12 +1,28 @@
 module Enumerable
-  # Yield item in groups of n
+  # 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(n)
     k = -1
     group_by { k += 1; k.div(n) }
   end
 
-  # Yield each item together with booleans that indicate whether the item is the
-  # first or last in the Enumerable.
+  # Yield each item together with two booleans that indicate whether the item is
+  # the first or last item in the Enumerable.
+  #
+  #    ('a'..'z').to_a.each with_flags do |letter, first, last|
+  #      if first
+  #        # do something special for the first item
+  #      elsif last
+  #        # do something special for the last item
+  #      else
+  #        # a middling item
+  #      end
+  #    end
   def each_with_flags
     last_k = size - 1
     each_with_index do |v, k|

data/lib/fat_core/hash.rb

@@ -1,56 +1,61 @@
-class Hash
-  # Yield each key-value pair in the Hash together with boolean flags that
-  # indicate whether the item is the first or last yielded.
-  def each_pair_with_flags
-    last_k = size - 1
-    k = 0
-    each_pair do |key, val|
-      first = (k == 0 ? true : false)
-      last  = (k == last_k ? true : false)
-      yield(key, val, first, last)
-      k += 1
+module FatCore
+
+  module Hash
+    # Yield each key-value pair in the Hash together with boolean flags that
+    # indicate whether the item is the first or last yielded.
+    def each_pair_with_flags
+      last_k = size - 1
+      k = 0
+      each_pair do |key, val|
+        first = (k == 0 ? true : false)
+        last  = (k == last_k ? true : false)
+        yield(key, val, first, last)
+        k += 1
+      end
     end
-  end
 
-  # Return all keys in hash that have a value == to the given value or have an
-  # Enumerable value that includes the given value.
-  def keys_with_value(val)
-    result = []
-    each_pair do |k, v|
-      if self[k] == val || (v.respond_to?(:include?) && v.include?(val))
-        result << k
+    # Return all keys in hash that have a value == to the given value or have an
+    # Enumerable value that includes the given value.
+    def keys_with_value(val)
+      result = []
+      each_pair do |k, v|
+        if self[k] == val || (v.respond_to?(:include?) && v.include?(val))
+          result << k
+        end
       end
+      result
     end
-    result
-  end
 
-  # 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
-  def delete_with_value(v)
-    keys_with_value(v).each do |k|
-      delete(k)
+    # 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
+    def delete_with_value(v)
+      keys_with_value(v).each do |k|
+        delete(k)
+      end
+      self
     end
-    self
-  end
 
-  # Change each key of this Hash to its value in key_map
-  def remap_keys(key_map = {})
-    new_hash = {}
-    each_pair do |key, val|
-      if key_map.key?(key)
-        new_hash[key_map[key]] = val
-      else
-        new_hash[key] = val
+    # Change each key of this Hash to its value in key_map
+    def remap_keys(key_map = {})
+      new_hash = {}
+      each_pair do |key, val|
+        if key_map.key?(key)
+          new_hash[key_map[key]] = val
+        else
+          new_hash[key] = val
+        end
       end
+      new_hash
     end
-    new_hash
-  end
 
-  # Change the keys of this Hash to new_keys, an array of keys
-  def replace_keys(new_keys)
-    unless keys.size == new_keys.size
-      raise ArgumentError, 'replace_keys: new keys size differs from key size'
+    # Change the keys of this Hash to new_keys, an array of keys
+    def replace_keys(new_keys)
+      unless keys.size == new_keys.size
+        raise ArgumentError, 'replace_keys: new keys size differs from key size'
+      end
+      to_a.each_with_index.map { |(_k, v), i| [new_keys[i], v] }.to_h
     end
-    to_a.each_with_index.map { |(_k, v), i| [new_keys[i], v] }.to_h
   end
 end
+
+Hash.include FatCore::Hash

data/lib/fat_core/kernel.rb

@@ -1,9 +1,11 @@
+require 'fat_core/numeric'
+
 module Kernel
-  def time_it(message = '', &block)
+  def time_it(name = 'block', &block)
     start = Time.now
     result = yield block
     run_time = Time.now - start
-    puts "Ran #{message} in #{run_time.secs_to_hms}"
+    puts "Ran #{name} in #{run_time.secs_to_hms}"
     result
   end
 end

data/lib/fat_core/nil.rb

@@ -1,17 +1,17 @@
-class NilClass
-  def entitle
-    ''
-  end
+module FatCore
+  module NilClass
+    def entitle
+      ''
+    end
 
-  def tex_quote
-    ''
-  end
+    def tex_quote
+      ''
+    end
 
-  def commas(_places = nil)
-    ''
-  end
-
-  def format_by(_fmt)
-    ''
+    def commas(_places = nil)
+      ''
+    end
   end
 end
+
+NilClass.include FatCore::NilClass

data/lib/fat_core/numeric.rb

@@ -1,105 +1,101 @@
-class Numeric
-  def signum
-    if positive?
-      1
-    elsif negative?
-      -1
-    else
-      0
+module FatCore
+  module Numeric
+    # Return the signum function for this number, i.e., 1 for a positive number,
+    # 0 for zero, and -1 for a negative number.
+    def signum
+      if positive?
+        1
+      elsif negative?
+        -1
+      else
+        0
+      end
     end
-  end
 
-  def commas(places = nil)
-    # By default, use zero places for whole numbers; four places for
-    # numbers containing a fractional part to 4 places.
-    if places.nil?
-      places =
-        if abs.modulo(1).round(4) > 0.0
-          4
-        else
-          0
-        end
+    # Convert this number into a string and insert grouping commas into the
+    # whole number part and round the decimal part to +places+ decimal places,
+    # with the number of places being zero for an integer and 4 for a
+    # non-integer.
+    def commas(places = nil)
+      # By default, use zero places for whole numbers; four places for
+      # numbers containing a fractional part to 4 places.
+      if places.nil?
+        places =
+          if abs.modulo(1).round(4) > 0.0
+            4
+          else
+            0
+          end
+      end
+      group(places, ',')
     end
-    group(places, ',')
-  end
 
-  def group(places = 0, delim = ',')
-    # Return number as a string with embedded commas
-    # for nice printing; round to places places after
-    # the decimal
+    # Convert this number into a string and insert grouping delimiter character,
+    # +delim+ into the whole number part and round the decimal part to +places+
+    # decimal places, with the number of places being zero for an integer and 4
+    # for a non-integer.
+    def group(places = 0, delim = ',')
+      # Return number as a string with embedded commas
+      # for nice printing; round to places places after
+      # the decimal
 
-    # Only convert to string numbers with exponent unless they are
-    # less than 1 (to ensure that really small numbers round to 0.0)
-    return to_s if abs > 1.0 && to_s =~ /e/
+      # Only convert to string numbers with exponent unless they are
+      # less than 1 (to ensure that really small numbers round to 0.0)
+      return to_s if abs > 1.0 && to_s =~ /e/
 
-    str = to_f.round(places).to_s
+      str = to_f.round(places).to_s
 
-    # Break the number into parts
-    str =~ /^(-)?(\d*)((\.)?(\d*))?$/
-    neg = $1 || ''
-    whole = $2
-    frac = $5
+      # Break the number into parts
+      str =~ /^(-)?(\d*)((\.)?(\d*))?$/
+      neg = $1 || ''
+      whole = $2
+      frac = $5
 
-    # Pad out the fractional part with zeroes to the right
-    n_zeroes = [places - frac.length, 0].max
-    frac += '0' * n_zeroes if n_zeroes.positive?
+      # Pad out the fractional part with zeroes to the right
+      n_zeroes = [places - frac.length, 0].max
+      frac += '0' * n_zeroes if n_zeroes.positive?
 
-    # Place the commas in the whole part only
-    whole = whole.reverse
-    whole.gsub!(/([0-9]{3})/, "\\1#{delim}")
-    whole.gsub!(/#{Regexp.escape(delim)}$/, '')
-    whole.reverse!
-    if frac.nil? || places <= 0
-      neg + whole
-    else
-      neg + whole + '.' + frac
+      # Place the commas in the whole part only
+      whole = whole.reverse
+      whole.gsub!(/([0-9]{3})/, "\\1#{delim}")
+      whole.gsub!(/#{Regexp.escape(delim)}$/, '')
+      whole.reverse!
+      if frac.nil? || places <= 0
+        neg + whole
+      else
+        neg + whole + '.' + frac
+      end
     end
-  end
 
-  # Determine if this is a whole number.
-  def whole?
-    floor == self
-  end
-
-  # Return an integer type, but only if the fractional part of self
-  # is zero
-  def int_if_whole
-    whole? ? floor : self
-  end
+    # Return whether this is a whole number.
+    def whole?
+      floor == self
+    end
 
-  def secs_to_hms
-    frac = self % 1
-    mins, secs = divmod(60)
-    hrs, mins = mins.divmod(60)
-    if frac.round(5) > 0.0
-      '%02d:%02d:%02d.%d' % [hrs, mins, secs, frac.round(5) * 100]
-    else
-      '%02d:%02d:%02d' % [hrs, mins, secs]
+    # Return an Integer type, but only if the fractional part of self is zero;
+    # otherwise just return self.
+    def int_if_whole
+      whole? ? floor : self
     end
-  end
 
-  # Format the number according to the given sprintf format.  Besides the
-  # sprintf formats, a format string of '%,2', for example, will return the
-  # number grouped by commas and rounded to 2 places.  If no number of places
-  # is given, the number will be rounded to an integer.
-  def format_by(fmt = nil)
-    return to_s unless fmt
-    if /%,(?<places>\d*)/ =~ fmt.to_s.clean
-      places ||= 0
-      commas(places.to_i)
-    else
-      format fmt, self
+    # Convert a number of seconds into a string of the form HH:MM:SS.dd, that is
+    # to hours, minutes and seconds.
+    def secs_to_hms
+      frac = self % 1
+      mins, secs = divmod(60)
+      hrs, mins = mins.divmod(60)
+      if frac.round(5) > 0.0
+        '%02d:%02d:%02d.%d' % [hrs, mins, secs, frac.round(5) * 100]
+      else
+        '%02d:%02d:%02d' % [hrs, mins, secs]
+      end
     end
-  end
 
-  # Allow erb documents can directly interpolate numbers
-  def tex_quote
-    to_s
+    # Allow erb documents to directly interpolate numbers
+    def tex_quote
+      to_s
+    end
   end
 end
 
-class BigDecimal
-  def inspect
-    to_s
-  end
-end
+Numeric.include FatCore::Numeric