fat_core 0.0.1

data/lib/fat_core/enumerable.rb

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

data/lib/fat_core/hash.rb

@@ -0,0 +1,33 @@
+class Hash
+  # 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
+
+  # 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
+  end
+
+  def remap_keys(key_map = {})
+    new_hash = {}
+    each_pair do |key, val|
+      if key_map.has_key?(key)
+        new_hash[key_map[key]] = val
+      else
+        new_hash[key] = val
+      end
+    end
+    new_hash
+  end
+end

data/lib/fat_core/kernel.rb

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

data/lib/fat_core/latex_eruby.rb

@@ -0,0 +1,11 @@
+require 'erubis'
+require 'erubis/enhancer'
+require 'erubis/helper'
+
+class LaTeXEruby < Erubis::Eruby
+  include Erubis::EscapeEnhancer
+
+  def escaped_expr(code)
+    code.nil? ? '' : "(#{code}).tex_quote"
+  end
+end

data/lib/fat_core/nil.rb

@@ -0,0 +1,9 @@
+class NilClass
+  def entitle
+    nil
+  end
+
+  def tex_quote
+    ''
+  end
+end

data/lib/fat_core/numeric.rb

@@ -0,0 +1,87 @@
+class Numeric
+  def signum
+    if self > 0
+      1
+    elsif self < 0
+      -1
+    else
+      0
+    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?
+      if self.modulo(1).round(4) > 0.0
+        places = 4
+      else
+        places = 0
+      end
+    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
+
+    # 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
+
+    str = self.to_f.round(places).to_s
+
+    # 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 > 0
+
+    # 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
+      return neg + whole
+    else
+      return neg + whole + '.' + frac
+    end
+  end
+
+  # Return an integer type, but only if the fractional part of self
+  # is zero
+  def int_if_whole
+    self.floor == self ? self.floor : self
+  end
+
+  def secs_to_hms
+    frac = self % 1
+    mins, secs = self.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
+
+  # Allow erb documents can directly interpolate numbers
+  def tex_quote
+    to_s
+  end
+end
+
+class BigDecimal
+  def inspect
+    to_s
+  end
+end

data/lib/fat_core/period.rb

@@ -0,0 +1,410 @@
+# -*- coding: utf-8 -*-
+class Period
+  include Enumerable
+  include Comparable
+
+  attr_accessor :first, :last
+
+  def initialize(first, last)
+    case first
+    when String
+      begin
+        first = Date.parse(first)
+      rescue ArgumentError => ex
+        if ex.message =~ /invalid date/
+          raise ArgumentError, "you gave an invalid date '#{first}'"
+        else
+          raise
+        end
+      end
+    when Date
+      first = first
+    else
+      raise ArgumentError, "use Date or String to initialize Period"
+    end
+
+    case last
+    when String
+      begin
+        last = Date.parse(last)
+      rescue ArgumentError => ex
+        if ex.message =~ /invalid date/
+          raise ArgumentError, "you gave an invalid date '#{last}'"
+        else
+          raise
+        end
+      end
+    when Date
+      last = last
+    else
+      raise ArgumentError, "use Date or String to initialize Period"
+    end
+
+    @first = first
+    @last = last
+    if @first > @last
+      raise ArgumentError, "Period's first date is later than its last date"
+    end
+  end
+
+  # Possibly useful class method to take an array of periods and join all the
+  # contiguous ones, then return an array of the disjoint periods not
+  # contiguous to one another.  An array of periods with no gaps should return
+  # an array of only one period spanning all the given periods.
+
+  # Return an array of periods that represent the concatenation of all
+  # adjacent periods in the given periods.
+  # def self.meld_periods(*periods)
+  #   melded_periods = []
+  #   while (this_period = periods.pop)
+  #     melded_periods.each do |mp|
+  #       if mp.overlaps?(this_period)
+  #         melded_periods.delete(mp)
+  #         melded_periods << mp.union(this_period)
+  #         break
+  #       elsif mp.contiguous?(this_period)
+  #         melded_periods.delete(mp)
+  #         melded_periods << mp.join(this_period)
+  #         break
+  #       end
+  #     end
+  #   end
+  #   melded_periods
+  # end
+
+  # TO_DATE = Period.new(Date::BOT, Date.current)
+  # FOREVER = Period.new(Date::BOT, Date::EOT)
+
+  def each
+    d = first
+    while d <= last
+      yield d
+      d = d + 1.day
+    end
+  end
+
+  def self.chunk_syms
+    [:day, :week, :biweek, :semimonth, :month, :bimonth,
+     :quarter, :year, :irregular]
+  end
+
+  def self.chunk_sym_to_days(sym)
+    case sym
+    when :day
+      1
+    when :week
+      7
+    when :biweek
+      14
+    when :semimonth
+      15
+    when :month
+      30
+    when :bimonth
+      60
+    when :quarter
+      90
+    when :year
+      365
+    when :irregular
+      30
+    else
+      raise ArgumentError, "unknown chunk sym '#{sym}'"
+    end
+  end
+
+  # The largest number of days possible in each chunk
+  def self.chunk_sym_to_max_days(sym)
+    case sym
+    when :semimonth
+      16
+    when :month
+      31
+    when :bimonth
+      62
+    when :quarter
+      92
+    when :year
+      366
+    else
+      chunk_sym_to_days(sym)
+    end
+  end
+
+  # This is only used for inferring statement frequency based on the number
+  # of days between statements, so it will not consider all possible chunks,
+  # only :year, :quarter, :month, and :week.  And distinguishing between
+  # :semimonth and :biweek is impossible anyway.  Since statement dates can
+  # bounce around quite a bit in my experience, this is really fuzzy.  For
+  # example, one of my banks does monthly statements "around" the 10th of
+  # the month, but the 10th can get pushed off by holidays, weekends, etc.,
+  # so a "quarter" here is much broader than the calendar definition.  Ditto
+  # for the others, but since statements are most likely monthly, we default
+  # to :month.
+  def self.days_to_chunk_sym(days)
+    case days
+    when 356..376
+      :year
+    when 86..96
+      :quarter
+    when 26..33
+      :month
+    when 7
+      :week
+    when 1
+      :day
+    else
+      :irregular
+    end
+  end
+
+  def size
+    to_range.size
+  end
+
+  def length
+    size
+  end
+
+  def to_range
+    (first..last)
+  end
+
+  def ==(other)
+    first == other.first && last == other.last
+  end
+
+  def <=>(other)
+    [first, size] <=> [other.first, other.size]
+  end
+
+  def to_s
+    if first.beginning_of_year? && last.end_of_year? && first.year == last.year
+      "#{first.year}"
+    elsif first.beginning_of_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
+      "#{first.year}-%02d" % first.month
+    else
+      "#{first.iso} to #{last.iso}"
+    end
+  end
+
+  # Allow erb documents can directly interpolate ranges
+  def tex_quote
+    "#{first.iso}--#{last.iso}"
+  end
+
+  # Days in period
+  def size
+    (last - first + 1).to_i
+  end
+
+  def length
+    size
+  end
+
+  def subset_of?(other)
+    to_range.subset_of?(other.to_range)
+  end
+
+  def proper_subset_of?(other)
+    to_range.proper_subset_of?(other.to_range)
+  end
+
+  def superset_of?(other)
+    to_range.superset_of?(other.to_range)
+  end
+
+  def proper_superset_of?(other)
+    to_range.proper_superset_of?(other.to_range)
+  end
+
+  def overlaps?(other)
+    self.to_range.overlaps?(other.to_range)
+  end
+
+  def intersection(other)
+    self.to_range.intersection(other.to_range)
+  end
+  alias_method :&, :intersection
+
+  def union(other)
+    self.to_range.union(other.to_range)
+  end
+  alias_method :+, :union
+
+  def difference(other)
+    self.to_range.difference(other.to_range)
+  end
+  alias_method :-, :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
+      :year
+    elsif first.beginning_of_quarter? && last.end_of_quarter? &&
+        (90..92) === last - first + 1
+      :quarter
+    elsif first.beginning_of_bimonth? && last.end_of_bimonth? &&
+        (58..62) === last - first + 1
+      :bimonth
+    elsif first.beginning_of_month? && last.end_of_month? &&
+        (28..31) === last - first + 1
+      :month
+    elsif first.beginning_of_semimonth? && last.end_of_semimonth &&
+        (13..16) === last - first + 1
+      :semimonth
+    elsif first.beginning_of_biweek? && last.end_of_biweek? &&
+        last - first + 1 == 14
+      :biweek
+    elsif first.beginning_of_week? && last.end_of_week? &&
+        last - first + 1 == 7
+      :week
+    elsif first == last
+      :day
+    else
+      :irregular
+    end
+  end
+
+  # Name for a period not necessarily ending on calendar boundaries.  For
+  # example, in reporting reconciliation, we want the period from Feb 11,
+  # 2014, to March 10, 2014, be called the 'Month ending March 10, 2014,'
+  # event though the period is not a calendar month.  Using the stricter
+  # Period#chunk_sym, would not allow such looseness.
+  def chunk_name
+    case Period.days_to_chunk_sym(length)
+    when :year
+      'Year'
+    when :quarter
+      'Quarter'
+    when :bimonth
+      'Bi-month'
+    when :month
+      'Month'
+    when :semimonth
+      'Semi-month'
+    when :biweek
+      'Bi-week'
+    when :week
+      'Week'
+    when :day
+      'Day'
+    else
+      'Period'
+    end
+  end
+
+  def contains?(date)
+    self.to_range.cover?(date)
+  end
+
+  def overlaps?(other)
+    self.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})
+  end
+
+  def spanned_by?(periods)
+    to_range.spanned_by?(periods.map { |p| p.to_range })
+  end
+
+  def gaps(periods)
+    to_range.gaps(periods.map { |p| p.to_range }).
+      map { |r| Period.new(r.first, r.last)}
+  end
+
+  # Return an array of Periods wholly-contained within self in chunks of
+  # size, defaulting to monthly chunks.  Partial chunks at the beginning and
+  # end of self are not included unless partial_first or partial_last,
+  # 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)
+    size = size.to_sym
+    result = []
+    chunk_start = first.dup
+    while chunk_start <= last
+      case size
+      when :year
+        unless partial_first
+          until chunk_start.beginning_of_year?
+            chunk_start += 1.day
+          end
+        end
+        chunk_end = chunk_start.end_of_year
+      when :quarter
+        unless partial_first
+          until chunk_start.beginning_of_quarter?
+            chunk_start += 1.day
+          end
+        end
+        chunk_end = chunk_start.end_of_quarter
+      when :bimonth
+        unless partial_first
+          until chunk_start.beginning_of_bimonth?
+            chunk_start += 1.day
+          end
+        end
+        chunk_end = (chunk_start.end_of_month + 1.day).end_of_month
+      when :month
+        unless partial_first
+          until chunk_start.beginning_of_month?
+            chunk_start += 1.day
+          end
+        end
+        chunk_end = chunk_start.end_of_month
+      when :semimonth
+        unless partial_first
+          until chunk_start.beginning_of_semimonth?
+            chunk_start += 1.day
+          end
+        end
+        chunk_end = chunk_start.end_of_semimonth
+      when :biweek
+        unless partial_first
+          until chunk_start.beginning_of_biweek?
+            chunk_start += 1.day
+          end
+        end
+        chunk_end = chunk_start.end_of_biweek
+      when :week
+        unless partial_first
+          until chunk_start.beginning_of_week?
+            chunk_start += 1.day
+          end
+        end
+        chunk_end = chunk_start.end_of_week
+      when :day
+        chunk_end = chunk_start
+      else
+        chunk_end = last
+      end
+      if chunk_end <= last
+        result << Period.new(chunk_start, chunk_end)
+      else
+        if round_up_last
+          result << Period.new(chunk_start, chunk_end)
+        elsif partial_last
+          result << Period.new(chunk_start, last)
+        else
+          break
+        end
+      end
+      chunk_start = result.last.last + 1.day
+    end
+    result
+  end
+end