fat_core 0.0.1

data/lib/fat_core/range.rb

@@ -0,0 +1,192 @@
+class Range
+  # Return a range that concatenates this range with other; return nil
+  # if the ranges are not contiguous.
+  def join(other)
+    if left_contiguous?(other)
+      Range.new(min, other.max)
+    elsif right_contiguous?(other)
+      Range.new(other.min, max)
+    else
+      nil
+    end
+  end
+
+  # Is self on the left of and contiguous to other?
+  def left_contiguous?(other)
+    if max.respond_to?(:succ)
+      max.succ == other.min
+    else
+      max == other.min
+    end
+  end
+
+  # Is self on the right of and contiguous to other?
+  def right_contiguous?(other)
+    if other.max.respond_to?(:succ)
+      other.max.succ == min
+    else
+      other.max == min
+    end
+  end
+
+  def contiguous?(other)
+    left_contiguous?(other) || right_contiguous?(other)
+  end
+
+  def subset_of?(other)
+    min >= other.min && max <= other.max
+  end
+
+  def proper_subset_of?(other)
+    min > other.min && max < other.max
+  end
+
+  def superset_of?(other)
+    min <= other.min && max >= other.max
+  end
+
+  def proper_superset_of?(other)
+    min < other.min && max > other.max
+  end
+
+  def overlaps?(other)
+    cover?(other.min) || cover?(other.max)
+  end
+
+  def intersection(other)
+    return nil unless self.overlaps?(other)
+    ([self.min, other.min].max..[self.max, other.max].min)
+  end
+  alias_method :&, :intersection
+
+  def union(other)
+    return nil unless self.overlaps?(other)
+    ([self.min, other.min].min..[self.max, other.max].max)
+  end
+  alias_method :+, :union
+
+  # The difference method, -, removes the overlapping part of the other
+  # argument from self.  Because in the case where self is a superset of the
+  # other range, this will result in the difference being two non-contiguous
+  # ranges, this returns an array of ranges.  If there is no overlap or if
+  # self is a subset of the other range, return an empty array
+  def difference(other)
+    unless max.respond_to?(:succ) && min.respond_to?(:pred) &&
+        other.max.respond_to?(:succ) && other.min.respond_to?(:pred)
+      raise "Range difference operation requires objects have pred and succ methods"
+    end
+    # return [] unless self.overlaps?(other)
+    if proper_superset_of?(other)
+      [(min..other.min.pred),
+       (other.max.succ..max)]
+    elsif subset_of?(other)
+      []
+    elsif overlaps?(other) && other.min <= min
+      [(other.max.succ .. max)]
+    elsif overlaps?(other) && other.max >= max
+      [(min .. other.min.pred)]
+    else
+      []
+    end
+  end
+  alias_method :-, :difference
+
+  # Return whether any of the ranges that are within self overlap one
+  # another
+  def has_overlaps_within?(ranges)
+    result = false
+    unless ranges.empty?
+      ranges.each do |r1|
+        next unless overlaps?(r1)
+        result =
+          ranges.any? do |r2|
+          r1.object_id != r2.object_id && overlaps?(r2) &&
+            r1.overlaps?(r2)
+        end
+        return true if result
+      end
+    end
+    result
+  end
+
+  # Return true if the given ranges collectively cover this range
+  # without overlaps.
+  def spanned_by?(ranges)
+    joined_range = nil
+    ranges.sort_by {|r| r.min}.each do |r|
+      unless joined_range
+        joined_range = r
+        next
+      end
+      joined_range = joined_range.join(r)
+      break if joined_range.nil?
+    end
+    if !joined_range.nil?
+      joined_range.min <= min && joined_range.max >= max
+    else
+      false
+    end
+  end
+
+  # If this range is not spanned by the ranges collectively, return an array
+  # of ranges representing the gaps in coverage.  Otherwise return an empty
+  # array.
+  def gaps(ranges)
+    if ranges.empty?
+      [self.clone]
+    elsif spanned_by?(ranges)
+      []
+    else
+      ranges = ranges.sort_by {|r| r.min}
+      gaps = []
+      cur_point = min
+      ranges.each do |rr|
+        if rr.min > cur_point
+          start_point = cur_point
+          end_point = rr.min.pred
+          gaps << (start_point..end_point)
+        end
+        cur_point = rr.max.succ
+      end
+      if cur_point < max
+        gaps << (cur_point..max)
+      end
+      gaps
+    end
+  end
+
+  # Similar to gaps, but within this range return the /overlaps/ among the
+  # given ranges.  If there are no overlaps, return an empty array. Don't
+  # consider overlaps in the ranges that occur outside of self.
+  def overlaps(ranges)
+    if ranges.empty? || spanned_by?(ranges)
+      []
+    else
+      ranges = ranges.sort_by {|r| r.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
+        cur_point = rr.max
+      end
+      overlaps
+    end
+  end
+
+  # Allow erb documents can directly interpolate ranges
+  def tex_quote
+    to_s
+  end
+end

data/lib/fat_core/string.rb

@@ -0,0 +1,184 @@
+class String
+  # See if self contains colon- or space-separated words that include
+  # the colon- or space-separated words of other.  Return the matched
+  # portion of self.  Other cannot be a regex embedded in a string.
+  def fuzzy_match(other)
+    # Remove periods, commas, and apostrophes
+    other = other.gsub(/[.,']/, '')
+    target = self.gsub(/[.,']/, '')
+    matched_text = nil
+    matchers = other.split(/[: ]+/)
+    regexp_string = matchers.map {|m| ".*?#{Regexp.escape(m)}.*?"}.join('[: ]')
+    regexp_string.sub!(/^\.\*\?/, '')
+    regexp_string.sub!(/\.\*\?$/, '')
+    regexp = /#{regexp_string}/i
+    if match = regexp.match(target)
+      matched_text = match[0]
+    else
+      matched_text = nil
+    end
+    matched_text
+  end
+
+  # Here are instance methods for the class that includes Matchable
+  # This tries to convert the receiver object into a string, then
+  # matches against the given matcher, either via regex or a fuzzy
+  # string matcher.
+  def matches_with(str)
+    if str.nil?
+      nil
+    elsif str =~ /^\s*\//
+      re = str.to_regexp
+      if self.to_s =~ re
+        $&
+      else
+        nil
+      end
+    else
+      self.to_s.fuzzy_match(str)
+    end
+  end
+
+  # Convert a string of the form '/.../Iixm' to a regular expression. However,
+  # make the regular expression case-insensitive by default and extend the
+  # modifier syntax to allow '/I' to indicate case-sensitive.
+  def to_regexp
+    if self =~ /^\s*\/([^\/]*)\/([Iixm]*)\s*$/
+      body = $1
+      opts = $2
+      flags = Regexp::IGNORECASE
+      unless opts.blank?
+        flags = 0 if opts.include?('I')
+        flags |= Regexp::IGNORECASE if opts.include?('i')
+        flags |= Regexp::EXTENDED if opts.include?('x')
+        flags |= Regexp::MULTILINE if opts.include?('m')
+      end
+      flags = nil if flags == 0
+      Regexp.new(body, flags)
+    else
+      Regexp.new(self)
+    end
+  end
+
+  # Convert to symbol "Hello World" -> :hello_world
+  def as_sym
+    strip.squeeze(' ').gsub(/\s+/, '_').downcase.to_sym
+  end
+
+  def as_string
+    self
+  end
+
+  def wrap(width=70, hang=0)
+    offset = 0
+    trip = 1
+    result = ''
+    while (s = slice(offset, width))
+      offset += width
+      if trip == 1
+        width -= hang
+      else
+        s = (' ' * hang) + s
+      end
+      result << s + "\n"
+      trip += 1
+    end
+    # Remove the final newline before exiting
+    result.strip
+  end
+
+  def tex_quote
+    r = self.dup
+    r = r.gsub(/[{]/, 'XzXzXobXzXzX')
+    r = r.gsub(/[}]/, 'XzXzXcbXzXzX')
+    r = r.gsub(/\\/, '\textbackslash{}')
+    r = r.gsub(/\^/, '\textasciicircum{}')
+    r = r.gsub(/~/, '\textasciitilde{}')
+    r = r.gsub(/\|/, '\textbar{}')
+    r = r.gsub(/\</, '\textless{}')
+    r = r.gsub(/\>/, '\textgreater{}')
+    r = r.gsub(/([_$&%#])/) { |m| '\\' + m }
+    r = r.gsub('XzXzXobXzXzX', '\\{')
+    r = r.gsub('XzXzXcbXzXzX', '\\}')
+  end
+
+  def self.random(size = 8)
+    "abcdefghijklmnopqrstuvwxyz".split('').shuffle[0..size].join('')
+  end
+
+  # Convert a string with an all-digit date to an iso string
+  # E.g., "20090923" -> "2009-09-23"
+  def digdate2iso
+    self.sub(/(\d\d\d\d)(\d\d)(\d\d)/, '\1-\2-\3')
+  end
+
+  def entitle!
+    little_words = %w[ a an the and or in on under of from as by to ]
+    newwords = []
+    words = split(/\s+/)
+    first_word = true
+    num_words = words.length
+    words.each_with_index do |w, k|
+      last_word = (k + 1 == num_words)
+      if w =~ %r[c/o]i
+        # Care of
+        newwords.push("c/o")
+      elsif w =~ %r[^p\.?o\.?$]i
+        # Post office
+        newwords.push("P.O.")
+      elsif w =~ %r[^[0-9]+(st|nd|rd|th)$]i
+        # Ordinals
+        newwords.push(w.downcase)
+      elsif w =~ %r[^(cr|dr|st|rd|ave|pk|cir)$]i
+        # Common abbrs to capitalize
+        newwords.push(w.capitalize)
+      elsif w =~ %r[^(us|ne|se|rr)$]i
+        # Common 2-letter abbrs to upcase
+        newwords.push(w.upcase)
+      elsif w =~ %r[^[0-9].*$]i
+        # Other runs starting with numbers,
+        # like 3-A
+        newwords.push(w.upcase)
+      elsif w =~ %r[^[^aeiouy]*$]i
+        # All consonants, probably abbr
+        newwords.push(w.upcase)
+      elsif w =~ %r[^(\w+)-(\w+)$]i
+        # Hypenated double word
+        newwords.push($1.capitalize + '-' + $2.capitalize)
+      elsif little_words.include?(w.downcase)
+        # Only capitalize at beginning or end
+        newwords.push((first_word or last_word) ? w.capitalize : w.downcase)
+      else
+        # All else
+        newwords.push(w.capitalize)
+      end
+      first_word = false
+    end
+    self[0..-1] = newwords.join(' ')
+  end
+
+  def entitle
+    self.dup.entitle!
+  end
+
+  # Thanks to Eugene at stackoverflow for the following.
+  # http://stackoverflow.com/questions/8806643/
+  #   colorized-output-breaks-linewrapping-with-readline
+  # These color strings without confusing readline about the length of
+  # the prompt string in the shell. (Unlike the rainbow routines)
+  def console_red;          colorize(self, "\001\e[1m\e[31m\002");  end
+  def console_dark_red;     colorize(self, "\001\e[31m\002");       end
+  def console_green;        colorize(self, "\001\e[1m\e[32m\002");  end
+  def console_dark_green;   colorize(self, "\001\e[32m\002");       end
+  def console_yellow;       colorize(self, "\001\e[1m\e[33m\002");  end
+  def console_dark_yellow;  colorize(self, "\001\e[33m\002");       end
+  def console_blue;         colorize(self, "\001\e[1m\e[34m\002");  end
+  def console_dark_blue;    colorize(self, "\001\e[34m\002");       end
+  def console_purple;       colorize(self, "\001\e[1m\e[35m\002");  end
+
+  def console_def;          colorize(self, "\001\e[1m\002");  end
+  def console_bold;         colorize(self, "\001\e[1m\002");  end
+  def console_blink;        colorize(self, "\001\e[5m\002");  end
+
+  def colorize(text, color_code)  "#{color_code}#{text}\001\e[0m\002" end
+end

data/lib/fat_core/symbol.rb

@@ -0,0 +1,17 @@
+  class Symbol
+    # Convert to capitalized string: :hello_world -> "Hello World"
+    def entitle
+      to_s.gsub('_', ' ').split(' ')
+        .join(' ')
+        .entitle
+    end
+    alias :to_string :entitle
+
+    def as_sym
+      self
+    end
+
+    def tex_quote
+      to_s.tex_quote
+    end
+  end

data/lib/fat_core/version.rb

@@ -0,0 +1,3 @@
+module FatCore
+  VERSION = "0.0.1"
+end

data/spec/lib/date_spec.rb

@@ -0,0 +1,320 @@
+require 'spec_helper'
+
+describe Date do
+  before :each do
+    # Pretend it is this date. Not at beg or end of year, quarter,
+    # month, or week.  It is a Wednesday
+    Date.stub(:current).and_return(Date.parse('2012-07-18'))
+    Date.stub(:today).and_return(Date.parse('2012-07-18'))
+    @test_today = Date.parse('2012-07-18')
+  end
+
+  describe "class methods" do
+
+    describe "parse_spec" do
+
+      it "should choke if spec type is neither :from or :to" do
+        expect {
+          Date.parse_spec('2011-07-15', :form)
+        }.to raise_error
+      end
+
+      it "should parse plain iso dates correctly" do
+        Date.parse_spec('2011-07-15').should eq Date.parse('2011-07-15')
+        Date.parse_spec('2011-08-05').should eq Date.parse('2011-08-05')
+      end
+
+      it "should parse week numbers such as 'W23' or '23W' correctly" do
+        Date.parse_spec('W1').should eq Date.parse('2012-01-02')
+        Date.parse_spec('W23').should eq Date.parse('2012-06-04')
+        Date.parse_spec('W23', :to).should eq Date.parse('2012-06-10')
+        Date.parse_spec('23W').should eq Date.parse('2012-06-04')
+        Date.parse_spec('23W', :to).should eq Date.parse('2012-06-10')
+        expect {
+          Date.parse_spec('W83', :to)
+        }.to raise_error
+      end
+
+      it "should parse year-week numbers such as 'YYYY-W23' or 'YYYY-23W' correctly" do
+        Date.parse_spec('2003-W1').should eq Date.parse('2002-12-30')
+        Date.parse_spec('2003-W1', :to).should eq Date.parse('2003-01-05')
+        Date.parse_spec('2003-W23').should eq Date.parse('2003-06-02')
+        Date.parse_spec('2003-W23', :to).should eq Date.parse('2003-06-08')
+        Date.parse_spec('2003-23W').should eq Date.parse('2003-06-02')
+        Date.parse_spec('2003-23W', :to).should eq Date.parse('2003-06-08')
+        expect {
+          Date.parse_spec('2003-W83', :to)
+        }.to raise_error
+      end
+
+      it "should parse year-quarter specs such as YYYY-NQ or YYYY-QN" do
+        Date.parse_spec('2011-4Q', :from).should eq Date.parse('2011-10-01')
+        Date.parse_spec('2011-4Q', :to).should eq Date.parse('2011-12-31')
+        Date.parse_spec('2011-Q4', :from).should eq Date.parse('2011-10-01')
+        Date.parse_spec('2011-Q4', :to).should eq Date.parse('2011-12-31')
+        expect { Date.parse_spec('2011-5Q') }.to raise_error
+      end
+
+      it "should parse quarter-only specs such as NQ or QN" do
+        Date.parse_spec('4Q', :from).should eq Date.parse('2012-10-01')
+        Date.parse_spec('4Q', :to).should eq Date.parse('2012-12-31')
+        Date.parse_spec('Q4', :from).should eq Date.parse('2012-10-01')
+        Date.parse_spec('Q4', :to).should eq Date.parse('2012-12-31')
+        expect { Date.parse_spec('5Q') }.to raise_error
+      end
+
+      it "should parse year-month specs such as YYYY-MM" do
+        Date.parse_spec('2010-5', :from).should eq Date.parse('2010-05-01')
+        Date.parse_spec('2010-5', :to).should eq Date.parse('2010-05-31')
+        expect { Date.parse_spec('2010-13') }.to raise_error
+      end
+
+      it "should parse month-only specs such as MM" do
+        Date.parse_spec('10', :from).should eq Date.parse('2012-10-01')
+        Date.parse_spec('10', :to).should eq Date.parse('2012-10-31')
+        expect { Date.parse_spec('99') }.to raise_error
+        expect { Date.parse_spec('011') }.to raise_error
+      end
+
+      it "should parse year-only specs such as YYYY" do
+        Date.parse_spec('2010', :from).should eq Date.parse('2010-01-01')
+        Date.parse_spec('2010', :to).should eq Date.parse('2010-12-31')
+        expect { Date.parse_spec('99999') }.to raise_error
+      end
+
+      it "should parse relative day names: today, yesterday" do
+        Date.parse_spec('today').should eq Date.current
+        Date.parse_spec('this_day').should eq Date.current
+        Date.parse_spec('yesterday').should eq Date.current - 1.day
+        Date.parse_spec('last_day').should eq Date.current - 1.day
+      end
+
+      it "should parse relative weeks: this_week, last_week" do
+        Date.parse_spec('this_week').should eq Date.parse('2012-07-16')
+        Date.parse_spec('this_week', :to).should eq Date.parse('2012-07-22')
+        Date.parse_spec('last_week').should eq Date.parse('2012-07-09')
+        Date.parse_spec('last_week', :to).should eq Date.parse('2012-07-15')
+      end
+
+      it "should parse relative biweeks: this_biweek, last_biweek" do
+        Date.parse_spec('this_biweek').should eq Date.parse('2012-07-16')
+        Date.parse_spec('this_biweek', :to).should eq Date.parse('2012-07-29')
+        Date.parse_spec('last_biweek').should eq Date.parse('2012-07-02')
+        Date.parse_spec('last_biweek', :to).should eq Date.parse('2012-07-15')
+      end
+
+      it "should parse relative months: this_semimonth, last_semimonth" do
+        Date.parse_spec('this_semimonth').should eq Date.parse('2012-07-16')
+        Date.parse_spec('this_semimonth', :to).should eq Date.parse('2012-07-31')
+        Date.parse_spec('last_semimonth').should eq Date.parse('2012-07-01')
+        Date.parse_spec('last_semimonth', :to).should eq Date.parse('2012-07-15')
+      end
+
+      it "should parse relative months: this_month, last_month" do
+        Date.parse_spec('this_month').should eq Date.parse('2012-07-01')
+        Date.parse_spec('this_month', :to).should eq Date.parse('2012-07-31')
+        Date.parse_spec('last_month').should eq Date.parse('2012-06-01')
+        Date.parse_spec('last_month', :to).should eq Date.parse('2012-06-30')
+      end
+
+      it "should parse relative bimonths: this_bimonth, last_bimonth" do
+        Date.parse_spec('this_bimonth').should eq Date.parse('2012-07-01')
+        Date.parse_spec('this_bimonth', :to).should eq Date.parse('2012-08-31')
+        Date.parse_spec('last_bimonth').should eq Date.parse('2012-05-01')
+        Date.parse_spec('last_bimonth', :to).should eq Date.parse('2012-06-30')
+      end
+
+      it "should parse relative quarters: this_quarter, last_quarter" do
+        Date.parse_spec('this_quarter').should eq Date.parse('2012-07-01')
+        Date.parse_spec('this_quarter', :to).should eq Date.parse('2012-09-30')
+        Date.parse_spec('last_quarter').should eq Date.parse('2012-04-01')
+        Date.parse_spec('last_quarter', :to).should eq Date.parse('2012-06-30')
+      end
+
+      it "should parse relative years: this_year, last_year" do
+        Date.parse_spec('this_year').should eq Date.parse('2012-01-01')
+        Date.parse_spec('this_year', :to).should eq Date.parse('2012-12-31')
+        Date.parse_spec('last_year').should eq Date.parse('2011-01-01')
+        Date.parse_spec('last_year', :to).should eq Date.parse('2011-12-31')
+      end
+
+      it "should parse forever and never" do
+        Date.parse_spec('forever').should eq Date::BOT
+        Date.parse_spec('forever', :to).should eq Date::EOT
+        Date.parse_spec('never').should be_nil
+      end
+    end
+
+    it "should be able to parse an American-style date" do
+      Date.parse_american('2/12/2011').iso.should eq('2011-02-12')
+      Date.parse_american('2 / 12/ 2011').iso.should eq('2011-02-12')
+      Date.parse_american('2 / 1 / 2011').iso.should eq('2011-02-01')
+      Date.parse_american('  2 / 1 / 2011  ').iso.should eq('2011-02-01')
+      Date.parse_american('  2 / 1 / 15  ').iso.should eq('2015-02-01')
+    end
+  end
+
+  describe "instance methods" do
+
+    it "should know if its a weekend of a weekday" do
+      expect(Date.parse('2014-05-17')).to be_weekend
+      expect(Date.parse('2014-05-17')).to_not be_weekday
+      expect(Date.parse('2014-05-18')).to be_weekend
+      expect(Date.parse('2014-05-18')).to_not be_weekday
+
+      expect(Date.parse('2014-05-22')).to be_weekday
+      expect(Date.parse('2014-05-22')).to_not be_weekend
+    end
+
+    it "should know its pred and succ (for Range)" do
+      Date.today.pred.should eq (Date.today - 1)
+      Date.today.succ.should eq (Date.today + 1)
+    end
+
+    it "should be able to print itself as an American-style date" do
+      Date.parse('2011-02-12').american.should eq('2/12/2011')
+    end
+
+    it "should be able to print itself in iso form" do
+      Date.today.iso.should == '2012-07-18'
+    end
+
+    it "should be able to print itself in org form" do
+      Date.today.org.should eq('[2012-07-18 Wed]')
+      (Date.today + 1.day).org.should eq('[2012-07-19 Thu]')
+    end
+
+    it "should be able to print itself in eng form" do
+      Date.today.eng.should eq('July 18, 2012')
+      (Date.today + 1.day).eng.should eq('July 19, 2012')
+    end
+
+    it "should be able to state its quarter" do
+      Date.today.quarter.should eq(3)
+      Date.parse('2012-02-29').quarter.should eq(1)
+      Date.parse('2012-01-01').quarter.should eq(1)
+      Date.parse('2012-03-31').quarter.should eq(1)
+      Date.parse('2012-04-01').quarter.should eq(2)
+      Date.parse('2012-05-15').quarter.should eq(2)
+      Date.parse('2012-06-30').quarter.should eq(2)
+      Date.parse('2012-07-01').quarter.should eq(3)
+      Date.parse('2012-08-15').quarter.should eq(3)
+      Date.parse('2012-09-30').quarter.should eq(3)
+      Date.parse('2012-10-01').quarter.should eq(4)
+      Date.parse('2012-11-15').quarter.should eq(4)
+      Date.parse('2012-12-31').quarter.should eq(4)
+    end
+
+    it "should know about years" do
+      Date.parse('2013-01-01').should be_beginning_of_year
+      Date.parse('2013-12-31').should be_end_of_year
+      Date.parse('2013-04-01').should_not be_beginning_of_year
+      Date.parse('2013-12-30').should_not be_end_of_year
+    end
+
+    it "should know about quarters" do
+      Date.parse('2013-01-01').should be_beginning_of_quarter
+      Date.parse('2013-12-31').should be_end_of_quarter
+      Date.parse('2013-04-01').should be_beginning_of_quarter
+      Date.parse('2013-06-30').should be_end_of_quarter
+      Date.parse('2013-05-01').should_not be_beginning_of_quarter
+      Date.parse('2013-07-31').should_not be_end_of_quarter
+    end
+
+    it "should know about bimonths" do
+      Date.parse('2013-11-04').beginning_of_bimonth.should eq Date.parse('2013-11-01')
+      Date.parse('2013-11-04').end_of_bimonth.should eq Date.parse('2013-12-31')
+      Date.parse('2013-03-01').should be_beginning_of_bimonth
+      Date.parse('2013-04-30').should be_end_of_bimonth
+      Date.parse('2013-01-01').should be_beginning_of_bimonth
+      Date.parse('2013-12-31').should be_end_of_bimonth
+      Date.parse('2013-05-01').should be_beginning_of_bimonth
+      Date.parse('2013-06-30').should be_end_of_bimonth
+      Date.parse('2013-06-01').should_not be_beginning_of_bimonth
+      Date.parse('2013-07-31').should_not be_end_of_bimonth
+    end
+
+    it "should know about months" do
+      Date.parse('2013-01-01').should be_beginning_of_month
+      Date.parse('2013-12-31').should be_end_of_month
+      Date.parse('2013-05-01').should be_beginning_of_month
+      Date.parse('2013-07-31').should be_end_of_month
+      Date.parse('2013-05-02').should_not be_beginning_of_month
+      Date.parse('2013-07-30').should_not be_end_of_month
+    end
+
+    it "should know about semimonths" do
+      Date.parse('2013-11-24').beginning_of_semimonth.should eq Date.parse('2013-11-16')
+      Date.parse('2013-11-04').beginning_of_semimonth.should eq Date.parse('2013-11-01')
+      Date.parse('2013-11-04').end_of_semimonth.should eq Date.parse('2013-11-15')
+      Date.parse('2013-11-24').end_of_semimonth.should eq Date.parse('2013-11-30')
+      Date.parse('2013-03-01').should be_beginning_of_semimonth
+      Date.parse('2013-03-16').should be_beginning_of_semimonth
+      Date.parse('2013-04-15').should be_end_of_semimonth
+      Date.parse('2013-04-30').should be_end_of_semimonth
+    end
+
+    it "should know about biweeks" do
+      Date.parse('2013-11-07').beginning_of_biweek.should eq Date.parse('2013-11-04')
+      Date.parse('2013-11-07').end_of_biweek.should eq Date.parse('2013-11-17')
+      Date.parse('2013-03-11').should be_beginning_of_biweek
+      Date.parse('2013-03-24').should be_end_of_biweek
+    end
+
+    it "should know about weeks" do
+      Date.parse('2013-11-04').should be_beginning_of_week
+      Date.parse('2013-11-10').should be_end_of_week
+      Date.parse('2013-12-02').should be_beginning_of_week
+      Date.parse('2013-12-08').should be_end_of_week
+      Date.parse('2013-10-13').should_not be_beginning_of_week
+      Date.parse('2013-10-19').should_not be_end_of_week
+    end
+
+    it "should know the beginning of chunks" do
+      Date.parse('2013-11-04').beginning_of_chunk(:year).should eq Date.parse('2013-01-01')
+      Date.parse('2013-11-04').beginning_of_chunk(:quarter).should eq Date.parse('2013-10-01')
+      Date.parse('2013-12-04').beginning_of_chunk(:bimonth).should eq Date.parse('2013-11-01')
+      Date.parse('2013-11-04').beginning_of_chunk(:month).should eq Date.parse('2013-11-01')
+      Date.parse('2013-11-04').beginning_of_chunk(:semimonth).should eq Date.parse('2013-11-01')
+      Date.parse('2013-11-24').beginning_of_chunk(:semimonth).should eq Date.parse('2013-11-16')
+      Date.parse('2013-11-08').beginning_of_chunk(:biweek).should eq Date.parse('2013-11-04')
+      Date.parse('2013-11-08').beginning_of_chunk(:week).should eq Date.parse('2013-11-04')
+      expect {
+        Date.parse('2013-11-04').beginning_of_chunk(:wek)
+      }.to raise_error
+    end
+
+    it "should know the end of chunks" do
+      Date.parse('2013-07-04').end_of_chunk(:year).should eq Date.parse('2013-12-31')
+      Date.parse('2013-07-04').end_of_chunk(:quarter).should eq Date.parse('2013-09-30')
+      Date.parse('2013-12-04').end_of_chunk(:bimonth).should eq Date.parse('2013-12-31')
+      Date.parse('2013-07-04').end_of_chunk(:month).should eq Date.parse('2013-07-31')
+      Date.parse('2013-11-04').end_of_chunk(:semimonth).should eq Date.parse('2013-11-15')
+      Date.parse('2013-11-24').end_of_chunk(:semimonth).should eq Date.parse('2013-11-30')
+      Date.parse('2013-11-08').end_of_chunk(:biweek).should eq Date.parse('2013-11-17')
+      Date.parse('2013-07-04').end_of_chunk(:week).should eq Date.parse('2013-07-07')
+      expect {
+        Date.parse('2013-11-04').end_of_chunk(:wek)
+      }.to raise_error
+    end
+
+    it "should know how to expand to chunk periods" do
+      Date.parse('2013-07-04').expand_to_period(:year).
+        should eq Period.new(Date.parse('2013-01-01'), Date.parse('2013-12-31'))
+      Date.parse('2013-07-04').expand_to_period(:quarter).
+        should eq Period.new(Date.parse('2013-07-01'), Date.parse('2013-09-30'))
+      Date.parse('2013-07-04').expand_to_period(:bimonth).
+        should eq Period.new(Date.parse('2013-07-01'), Date.parse('2013-08-31'))
+      Date.parse('2013-07-04').expand_to_period(:month).
+        should eq Period.new(Date.parse('2013-07-01'), Date.parse('2013-07-31'))
+      Date.parse('2013-07-04').expand_to_period(:semimonth).
+        should eq Period.new(Date.parse('2013-07-01'), Date.parse('2013-07-15'))
+      Date.parse('2013-07-04').expand_to_period(:biweek).
+        should eq Period.new(Date.parse('2013-07-01'), Date.parse('2013-07-14'))
+      Date.parse('2013-07-04').expand_to_period(:week).
+        should eq Period.new(Date.parse('2013-07-01'), Date.parse('2013-07-07'))
+      Date.parse('2013-07-04').expand_to_period(:day).
+        should eq Period.new(Date.parse('2013-07-04'), Date.parse('2013-07-04'))
+    end
+  end
+end