fat_core 1.0.3 → 1.2.0

data/lib/fat_core/enumerable.rb

@@ -2,6 +2,6 @@ module Enumerable
   # Emit item in groups of n
   def groups_of(n)
     k = -1
-    group_by { |item| k += 1; k.div(n) }
+    group_by { k += 1; k.div(n) }
   end
 end

data/lib/fat_core/evaluator.rb

@@ -0,0 +1,43 @@
+module FatCore
+  # The Evaluator class provides a class for evaluating Ruby expressions based
+  # on variable settings provided at runtime. If the same Evaluator object is
+  # used for several successive calls, it can maintain state between calls with
+  # instance variables. The call to Evaluator.new can be given a hash of
+  # instance variable names and values that will be maintained across all calls
+  # to the #evaluate method. In addition, on each evaluate call, a set of
+  # /local/ variables can be supplied to provide variables that exist only for
+  # the duration of that evaluate call. An optional before and after string can
+  # be given to the constructor that will evaluate the given expression before
+  # and, respectively, after each call to #evaluate. This provides a way to
+  # update values of instance variables for use in subsequent calls to
+  # #evaluate.
+  class Evaluator
+   def initialize(vars: {}, before: nil, after: nil)
+     @before = before
+     @after = after
+     set_instance_vars(vars)
+   end
+
+   def set_instance_vars(vars = {})
+     vars.each_pair do |name, val|
+       name = "@#{name}" unless name.to_s.start_with?('@')
+       instance_variable_set(name, val)
+     end
+   end
+
+   def set_local_vars(vars = {}, bnd)
+     vars.each_pair do |name, val|
+       bnd.local_variable_set(name, val)
+     end
+   end
+
+   def evaluate(expr = '', vars: {})
+     bdg = binding
+     set_local_vars(vars, bdg)
+     eval(@before, bdg) if @before
+     result = eval(expr, bdg)
+     eval(@after, bdg) if @after
+     result
+   end
+  end
+end

data/lib/fat_core/hash.rb

@@ -23,7 +23,7 @@ class Hash
   def remap_keys(key_map = {})
     new_hash = {}
     each_pair do |key, val|
-      if key_map.has_key?(key)
+      if key_map.key?(key)
         new_hash[key_map[key]] = val
       else
         new_hash[key] = val

data/lib/fat_core/nil.rb

@@ -10,4 +10,8 @@ class NilClass
   def commas(_places = nil)
     ''
   end
+
+  def format_by(_fmt)
+    ''
+  end
 end

data/lib/fat_core/numeric.rb

@@ -13,11 +13,12 @@ class Numeric
     # By default, use zero places for whole numbers; four places for
     # numbers containing a fractional part to 4 places.
     if places.nil?
-      if self.abs.modulo(1).round(4) > 0.0
-        places = 4
-      else
-        places = 0
-      end
+      places =
+        if abs.modulo(1).round(4) > 0.0
+          4
+        else
+          0
+        end
     end
     group(places, ',')
   end
@@ -29,11 +30,9 @@ class Numeric
 
     # Only convert to string numbers with exponent unless they are
     # less than 1 (to ensure that really small numbers round to 0.0)
-    if self.abs > 1.0 && self.to_s =~ /e/
-      return self.to_s
-    end
+    return to_s if abs > 1.0 && to_s =~ /e/
 
-    str = self.to_f.round(places).to_s
+    str = to_f.round(places).to_s
 
     # Break the number into parts
     str =~ /^(-)?(\d*)((\.)?(\d*))?$/
@@ -43,7 +42,7 @@ class Numeric
 
     # Pad out the fractional part with zeroes to the right
     n_zeroes = [places - frac.length, 0].max
-    frac += "0" * n_zeroes if n_zeroes > 0
+    frac += '0' * n_zeroes if n_zeroes > 0
 
     # Place the commas in the whole part only
     whole = whole.reverse
@@ -51,31 +50,45 @@ class Numeric
     whole.gsub!(/#{Regexp.escape(delim)}$/, '')
     whole.reverse!
     if frac.nil? || places <= 0
-      return neg + whole
+      neg + whole
     else
-      return neg + whole + '.' + frac
+      neg + whole + '.' + frac
     end
   end
 
   # Determine if this is a whole number.
   def whole?
-    self.floor == self
+    floor == self
   end
 
   # Return an integer type, but only if the fractional part of self
   # is zero
   def int_if_whole
-     whole? ? self.floor : self
+    whole? ? floor : self
   end
 
   def secs_to_hms
     frac = self % 1
-    mins, secs = self.divmod(60)
+    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]
+      '%02d:%02d:%02d.%d' % [hrs, mins, secs, frac.round(5) * 100]
+    else
+      '%02d:%02d:%02d' % [hrs, mins, secs]
+    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
-      "%02d:%02d:%02d" % [hrs, mins, secs]
+      format fmt, self
     end
   end
 

data/lib/fat_core/period.rb

@@ -21,7 +21,7 @@ class Period
     when Date
       first = first
     else
-      raise ArgumentError, "use Date or String to initialize Period"
+      raise ArgumentError, 'use Date or String to initialize Period'
     end
 
     case last
@@ -38,7 +38,7 @@ class Period
     when Date
       last = last
     else
-      raise ArgumentError, "use Date or String to initialize Period"
+      raise ArgumentError, 'use Date or String to initialize Period'
     end
 
     @first = first
@@ -54,21 +54,21 @@ class Period
 
   # Need custom setters to ensure first <= last
   def first=(new_first)
-    unless new_first.kind_of?(Date)
+    unless new_first.is_a?(Date)
       raise ArgumentError, "can't set Period#first to non-date"
     end
     unless new_first <= last
-      raise ArgumentError, "cannot make Period#first > Period#last"
+      raise ArgumentError, 'cannot make Period#first > Period#last'
     end
     @first = new_first
   end
 
   def last=(new_last)
-    unless new_last.kind_of?(Date)
-      raise ArgumentError, "can't set Period#last to non-date"
+    unless new_last.is_a?(Date)
+      raise ArgumentError, 'cannot set Period#last to non-date'
     end
     unless new_last >= first
-      raise ArgumentError, "cannot make Period#last < Period#first"
+      raise ArgumentError, 'cannot make Period#last < Period#first'
     end
     @last = new_last
   end
@@ -91,13 +91,13 @@ class Period
     d = first
     while d <= last
       yield d
-      d = d + 1.day
+      d += 1.day
     end
   end
 
   # Case equality checks for inclusion of date in period.
-  def ===(date)
-    self.contains?(date)
+  def ===(other)
+    contains?(other)
   end
 
   # Return the number of days in the period
@@ -146,13 +146,13 @@ class Period
   def self.parse_phrase(phrase)
     phrase = phrase.clean
     if phrase =~ /\Afrom (.*) to (.*)\z/
-      from_phrase = $~[1]
-      to_phrase = $~[2]
+      from_phrase = $1
+      to_phrase = $2
     elsif phrase =~ /\Afrom (.*)\z/
-      from_phrase = $~[1]
+      from_phrase = $1
       to_phrase = nil
     elsif phrase =~ /\Ato (.*)\z/
-      from_phrase = $~[1]
+      from_phrase = $1
     else
       from_phrase = phrase
     end
@@ -232,7 +232,7 @@ class Period
     when :year
       366
     when :irregular
-      raise ArgumentError, "no maximum period for :irregular chunk"
+      raise ArgumentError, 'no maximum period for :irregular chunk'
     else
       chunk_sym_to_days(sym)
     end
@@ -273,16 +273,16 @@ class Period
 
   def to_s
     if first.beginning_of_year? && last.end_of_year? && first.year == last.year
-      "#{first.year}"
+      first.year.to_s
     elsif first.beginning_of_quarter? &&
-        last.end_of_quarter? &&
-        first.year == last.year &&
-        first.quarter == last.quarter
+          last.end_of_quarter? &&
+          first.year == last.year &&
+          first.quarter == last.quarter
       "#{first.year}-#{first.quarter}Q"
     elsif first.beginning_of_month? &&
-        last.end_of_month? &&
-        first.year == last.year &&
-        first.month == last.month
+          last.end_of_month? &&
+          first.year == last.year &&
+          first.month == last.month
       "#{first.year}-%02d" % first.month
     else
       "#{first.iso} to #{last.iso}"
@@ -319,58 +319,54 @@ class Period
     to_range.proper_superset_of?(other.to_range)
   end
 
-  def overlaps?(other)
-    self.to_range.overlaps?(other.to_range)
-  end
-
   def intersection(other)
-    result = self.to_range.intersection(other.to_range)
+    result = to_range.intersection(other.to_range)
     if result.nil?
       nil
     else
       Period.new(result.first, result.last)
     end
   end
-  alias_method :&, :intersection
-  alias_method :narrow_to, :intersection
+  alias & intersection
+  alias narrow_to intersection
 
   def union(other)
-    result = self.to_range.union(other.to_range)
+    result = to_range.union(other.to_range)
     Period.new(result.first, result.last)
   end
-  alias_method :+, :union
+  alias + union
 
   def difference(other)
-    ranges = self.to_range.difference(other.to_range)
-    ranges.each.map{ |r| Period.new(r.first, r.last) }
+    ranges = to_range.difference(other.to_range)
+    ranges.each.map { |r| Period.new(r.first, r.last) }
   end
-  alias_method :-, :difference
+  alias - difference
 
   # returns the chunk sym represented by the period
   def chunk_sym
     if first.beginning_of_year? && last.end_of_year? &&
-        (365..366) === last - first + 1
+       (365..366) === last - first + 1
       :year
     elsif first.beginning_of_half? && last.end_of_half? &&
-        (180..183) === last - first + 1
+          (180..183) === last - first + 1
       :half
     elsif first.beginning_of_quarter? && last.end_of_quarter? &&
-        (90..92) === last - first + 1
+          (90..92) === last - first + 1
       :quarter
     elsif first.beginning_of_bimonth? && last.end_of_bimonth? &&
-        (58..62) === last - first + 1
+          (58..62) === last - first + 1
       :bimonth
     elsif first.beginning_of_month? && last.end_of_month? &&
-        (28..31) === last - first + 1
+          (28..31) === last - first + 1
       :month
     elsif first.beginning_of_semimonth? && last.end_of_semimonth &&
-        (13..16) === last - first + 1
+          (13..16) === last - first + 1
       :semimonth
     elsif first.beginning_of_biweek? && last.end_of_biweek? &&
-        last - first + 1 == 14
+          last - first + 1 == 14
       :biweek
     elsif first.beginning_of_week? && last.end_of_week? &&
-        last - first + 1 == 7
+          last - first + 1 == 7
       :week
     elsif first == last
       :day
@@ -410,32 +406,28 @@ class Period
   end
 
   def contains?(date)
-    if date.respond_to?(:to_date)
-      date = date.to_date
-    end
-    unless (date.is_a? Date)
-      raise ArgumentError, "argument must be a Date"
-    end
-    self.to_range.cover?(date)
+    date = date.to_date if date.respond_to?(:to_date)
+    raise ArgumentError, 'argument must be a Date' unless date.is_a?(Date)
+    to_range.cover?(date)
   end
 
   def overlaps?(other)
-    self.to_range.overlaps?(other.to_range)
+    to_range.overlaps?(other.to_range)
   end
 
   # Return whether any of the Periods that are within self overlap one
   # another
   def has_overlaps_within?(periods)
-    self.to_range.has_overlaps_within?(periods.map{ |p| p.to_range})
+    to_range.has_overlaps_within?(periods.map(&:to_range))
   end
 
   def spanned_by?(periods)
-    to_range.spanned_by?(periods.map { |p| p.to_range })
+    to_range.spanned_by?(periods.map(&:to_range))
   end
 
   def gaps(periods)
-    to_range.gaps(periods.map { |p| p.to_range }).
-      map { |r| Period.new(r.first, r.last)}
+    to_range.gaps(periods.map(&:to_range))
+      .map { |r| Period.new(r.first, r.last) }
   end
 
   # Return an array of Periods wholly-contained within self in chunks of
@@ -444,7 +436,8 @@ class Period
   # respectively, are set true.  The last chunk can be made to extend beyond
   # the end of self to make it a whole chunk if round_up_last is set true,
   # in which case, partial_last is ignored.
-  def chunks(size: :month, partial_first: false, partial_last: false, round_up_last: false)
+  def chunks(size: :month, partial_first: false, partial_last: false,
+             round_up_last: false)
     size = size.to_sym
     result = []
     chunk_start = first.dup
@@ -467,27 +460,27 @@ class Period
         chunk_end = chunk_start.end_of_quarter
       when :bimonth
         unless partial_first
-           chunk_start += 1.day until chunk_start.beginning_of_bimonth?
+          chunk_start += 1.day until chunk_start.beginning_of_bimonth?
         end
         chunk_end = (chunk_start.end_of_month + 1.day).end_of_month
       when :month
         unless partial_first
-           chunk_start += 1.day until chunk_start.beginning_of_month?
+          chunk_start += 1.day until chunk_start.beginning_of_month?
         end
         chunk_end = chunk_start.end_of_month
       when :semimonth
         unless partial_first
-           chunk_start += 1.day until chunk_start.beginning_of_semimonth?
+          chunk_start += 1.day until chunk_start.beginning_of_semimonth?
         end
         chunk_end = chunk_start.end_of_semimonth
       when :biweek
         unless partial_first
-           chunk_start += 1.day until chunk_start.beginning_of_biweek?
+          chunk_start += 1.day until chunk_start.beginning_of_biweek?
         end
         chunk_end = chunk_start.end_of_biweek
       when :week
         unless partial_first
-           chunk_start += 1.day until chunk_start.beginning_of_week?
+          chunk_start += 1.day until chunk_start.beginning_of_week?
         end
         chunk_end = chunk_start.end_of_week
       when :day
@@ -497,14 +490,12 @@ class Period
       end
       if chunk_end <= last
         result << Period.new(chunk_start, chunk_end)
+      elsif round_up_last
+        result << Period.new(chunk_start, chunk_end)
+      elsif partial_last
+        result << Period.new(chunk_start, last)
       else
-        if round_up_last
-          result << Period.new(chunk_start, chunk_end)
-        elsif partial_last
-          result << Period.new(chunk_start, last)
-        else
-          break
-        end
+        break
       end
       chunk_start = result.last.last + 1.day
     end