month 0.1.2 → 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7a5b582cedcab3ae50a07ede99a2036cdf836d6
+  data.tar.gz: 74a2c8bfc2bf430a86cf9b1edadb26d20f047db8
+SHA512:
+  metadata.gz: 2a262762f6b7699fc8031a4d4d304b85751682d7d5efa3e769961c379cf306b6ffeaeb1518067100befe4c3a7998bb1846f005a992a5b1ff22918377fdb55462
+  data.tar.gz: d069fd96c3e81f3e4b19d9e851103db1199d42ca100733b323b0ea680cf948bf985a412356d7f03a150f8b0d3da752e24dffae611525e1dff481ff5d9a19e970

data/README.md

@@ -0,0 +1,130 @@
+month
+=====
+
+
+A little library for working with months.
+
+
+Feature tour
+------------
+
+You can create a new Month object by passing the year and the month number
+as arguments to the constructor:
+
+```ruby
+Month.new(2014, 1)  # January 2014
+```
+
+Alternatively you can use the Month method to cast various date/time
+objects to Month objects:
+
+```ruby
+Month(Date.new(2014, 1, 31))  # January 2014
+
+Month(Time.at(1234567890))  # February 2009
+```
+
+The method will idempotently return Month objects as-is:
+
+```ruby
+Month(Month.new(2014, 1))  # January 2014, same object
+```
+
+Use the Month.parse method to parse a YYYY-MM formatted string:
+
+```ruby
+Month.parse('2014-01')  # January 2014
+```
+
+The #year attribute will return the year of the month:
+
+```ruby
+Month.new(2014, 1).year  # 2014
+```
+
+The #number attribute will return the number of the month:
+
+```ruby
+Month.new(2014, 1).number  # 1
+```
+
+The #name method will return the name of the month as a symbol:
+
+```ruby
+Month.new(2014, 1).name  # :January
+```
+
+Alternatively you can use predicate methods to test for a given month:
+
+```ruby
+Month.new(2014, 1).january?  # true
+
+Month.new(2014, 2).january?  # false
+```
+
+The #to_s method will return a YYYY-MM formatted string representation
+of the month:
+
+```ruby
+Month.new(2014, 1).to_s  # "2014-01"
+```
+
+You can add/subtract an integer number of months:
+
+```ruby
+Month.new(2014, 1) + 1  # February 2014
+
+Month.new(2014, 1) - 1  # December 2013
+```
+
+The #step method iterates between 2 months, similar to Date#step:
+
+```ruby
+Month.new(2014, 1).step(Month.new(2014, 12)) do |month|
+  ...
+end
+```
+
+The #include? method can be used to test if the month includes a date:
+
+```ruby
+Month.new(2014, 1).include?(Date.new(2014, 1, 31))  # true
+```
+
+The #dates method returns a range containing the dates in the month:
+
+```ruby
+Month.new(2014, 1).dates  # Range containing 31 Date objects
+```
+
+The #length method returns the number of days in the month:
+
+```ruby
+Month.new(2014, 1).length  # 31
+```
+
+Month objects can be used in case expressions.
+
+Month objects can be used as hash keys.
+
+Month objects can be used in ranges.
+
+Month objects are comparable.
+
+
+Bonus Extras
+------------
+
+The Month::Methods module provides methods for constructing Month objects
+and Date objects in a manner that closely resembles written english:
+
+```ruby
+include Month::Methods
+
+month = January 2014
+
+date = January 15, 2014
+```
+
+It is not included by default, you can either include it within your
+own modules/classes or globally within your application/script.

data/lib/month.rb

@@ -1,98 +1,160 @@
-# Month represents a specific month in time. With the exception of
-# Month.month_names (which returns a zero-based array), every usage of the
-# month value assumes that 1 equals January and 12 equals December.
-#
-# The Rubyforge project page can be viewed at
-# http://rubyforge.org/projects/month.
+require 'date'
+
+class Month
+  NAMES = {
+    1 => :January,
+    2 => :February,
+    3 => :March,
+    4 => :April,
+    5 => :May,
+    6 => :June,
+    7 => :July,
+    8 => :August,
+    9 => :September,
+    10 => :October,
+    11 => :November,
+    12 => :December
+  }
+
+  def initialize(year, number)
+    unless NAMES.has_key?(number)
+      raise ArgumentError, 'invalid month number'
+    end
+
+    @year, @number = year, number
+  end
+
+  attr_reader :year, :number
+
+  def to_s
+    "#@year-#{@number.to_s.rjust(2, '0')}"
+  end
+
+  def name
+    NAMES.fetch(@number)
+  end
+
+  NAMES.each do |number, name|
+    define_method(:"#{name.downcase}?") do
+      @number == number
+    end
+  end
+
+  def hash
+    [@year, @number].hash
+  end
+
+  def eql?(object)
+    object.class == self.class && object.hash == self.hash
+  end
+
+  def <=>(month)
+    if @year == month.year
+      @number <=> month.number
+    else
+      @year <=> month.year
+    end
+  end
+
+  include Comparable
+
+  def next
+    if @number == 12
+      self.class.new(@year + 1, 1)
+    else
+      self.class.new(@year, @number + 1)
+    end
+  end
+
+  alias_method :succ, :next
+
+  def step(limit)
+    unless block_given?
+      return enum_for(:step, limit)
+    end
+
+    month = self
+
+    until month > limit
+      yield month
+
+      month = month.succ
+    end
+  end
+
+  def +(number)
+    a, b = (@number + number).divmod(12)
+
+    self.class.new(@year + a, b)
+  end
+
+  def -(number)
+    if @number > number
+      self.class.new(@year, @number - number)
+    elsif @number < number
+      a, b = (@number - number).divmod(12)
+
+      self.class.new(@year + a, b)
+    else
+      self.class.new(@year - 1, 12)
+    end
+  end
+
+  def include?(date)
+    @year == date.year && @number == date.month
+  end
+
+  alias_method :===, :include?
+
+  def start_date
+    Date.new(@year, @number, 1)
+  end
+
+  def end_date
+    Date.new(@year, @number, -1)
+  end
+
+  def dates
+    start_date .. end_date
+  end
+
+  def length
+    end_date.mday
+  end
+end
+
+def Month.parse(string)
+  if string =~ /\A(\d{4})-(\d{2})\z/
+    Month.new($1.to_i, $2.to_i)
+  else
+    raise ArgumentError, 'invalid month'
+  end
+end
+
+def Month(object)
+  case object
+  when Month
+    object
+  when Integer
+    Month(Time.at(object))
+  else
+    Month.new(object.year, object.month)
+  end
+end
+
 class Month
-	Version = '0.1.2'
-	
-	# Returns an array of the full names of months (in English). Note that
-	# "January" is the 0th element, and "December" is the 11th element.
-	def Month.month_names
-		[ "January", "February", "March", "April", "May", "June", "July",
-			"August", "September", "October", "November", "December" ]
-	end
-
-	include Comparable
-
-	attr_reader :month, :year
-
-	# A new month can be set to a specific +month+ and +year+, or you can call 
-	# Month.new with no arguments to receive the current month.
-	def initialize( year = nil, month = nil )
-		require 'date'
-		if month.nil? || year.nil?
-			date = Date.today
-			month = date.mon unless month
-			year = date.year unless year
-		end
-		fail "invalid month" if month < 1 || month > 12
-		@month = month
-		@year = year
-	end
-
-	# Returns a new Month that is +amountToAdd+ months later.
-	def +( amountToAdd )
-		( fullYears, remainingMonths ) = amountToAdd.divmod( 12 )
-		resultYear = @year + fullYears
-		resultMonth = @month + remainingMonths
-		if resultMonth > 12
-			resultMonth -= 12
-			resultYear += 1
-		end
-		Month.new( resultYear, resultMonth )
-	end
-	
-	# Returns a new Month that is +amountToSubtract+ months earlier.
-	def -(amountToSubtract)
-		self + (-amountToSubtract)
-	end
-	
-	# Compare this Month to another Month.
-	def <=>(anOther)
-		if @year == anOther.year
-			@month <=> anOther.month
-		else
-			@year <=> anOther.year
-		end
-	end
-
-	# Returns the last Date of the month.
-	def end_date
-		self.next.start_date - 1
-	end
-
-	# Is this Month equal to +anOther+? +anOther+ must be another Month of the
-	# same value.
-	def eql?(anOther)
-		self == anOther
-	end
-	
-	# Calculate a hash value for this Month.
-	def hash
-		"#{@year}#{@month}".to_i
-	end
-
-	# Returns the next Month.
-	def next
-		self + 1
-	end
-	
-	alias_method :succ, :next
-	
-	# Returns the previous Month.
-	def prev
-		self - 1
-	end
-	
-	# Returns the first Date of the month.
-	def start_date
-		Date.new( @year, @month, 1 )
-	end
-	
-	# Returns a string of the format "January 2001".
-	def to_s
-		Month.month_names[@month-1][0..2] + " " + @year.to_s
-	end
+  module Methods
+    NAMES.each do |number, name|
+      define_method(name) do |*args|
+        case args.length
+        when 1
+          Month.new(args.first, number)
+        when 2
+          Date.new(args[1], number, args[0])
+        else
+          raise ArgumentError, 'too many arguments'
+        end
+      end
+    end
+  end
 end

data/month.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'month'
+  s.version = '1.0.0'
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Tim Craft']
+  s.email = ['mail@timcraft.com']
+  s.homepage = 'http://github.com/timcraft/month'
+  s.description = 'A little library for working with months'
+  s.summary = 'See description'
+  s.files = Dir.glob('{lib,spec}/**/*') + %w(README.md month.gemspec)
+  s.add_development_dependency('rake', '~> 10.0')
+  s.add_development_dependency('minitest', '~> 5.0')
+  s.require_path = 'lib'
+end

data/spec/month_spec.rb

@@ -0,0 +1,238 @@
+require 'minitest/autorun'
+
+require_relative '../lib/month'
+
+describe 'Month' do
+  it 'raises an exception when initialized with an invalid number' do
+    proc { Month.new(2014, 0) }.must_raise(ArgumentError)
+    proc { Month.new(2014, 100) }.must_raise(ArgumentError)
+  end
+
+  describe 'year method' do
+    it 'returns the integer year of the month' do
+      Month.new(2014, 1).year.must_equal(2014)
+    end
+  end
+
+  describe 'number method' do
+    it 'returns the integer number of the month' do
+      Month.new(2014, 1).number.must_equal(1)
+    end
+  end
+
+  describe 'to_s method' do
+    it 'returns a string containing the year and zero padded number of the month' do
+      Month.new(2014, 1).to_s.must_equal('2014-01')
+    end
+  end
+
+  describe 'name method' do
+    it 'returns the name of the month' do
+      Month.new(2014, 1).name.must_equal(:January)
+    end
+  end
+
+  describe 'january predicate method' do
+    it 'returns true if the month is january' do
+      Month.new(2014, 1).january?.must_equal(true)
+    end
+
+    it 'returns false otherwise' do
+      Month.new(2014, 2).january?.must_equal(false)
+    end
+  end
+
+  describe 'february predicate method' do
+    it 'returns true if the month is february' do
+      Month.new(2014, 2).february?.must_equal(true)
+    end
+
+    it 'returns false otherwise' do
+      Month.new(2014, 1).february?.must_equal(false)
+    end
+  end
+
+  it 'supports being used as a hash key' do
+    hash, n = Hash.new(0), 10
+
+    n.times { hash[Month.new(2014, 1)] += 1 }
+
+    hash.count.must_equal(1)
+    hash[Month.new(2014, 1)].must_equal(n)
+  end
+
+  it 'supports comparison between month objects' do
+    Month.new(2014, 1).must_be_kind_of(Comparable)
+
+    (Month.new(2014, 1) == Month.new(2014, 1)).must_equal(true)
+    (Month.new(2014, 1) == Month.new(2014, 2)).must_equal(false)
+
+    (Month.new(2014, 1) < Month.new(2014, 2)).must_equal(true)
+    (Month.new(2014, 2) > Month.new(2014, 1)).must_equal(true)
+  end
+
+  it 'supports being used in a range' do
+    range = Month.new(2014, 1) .. Month.new(2014, 4)
+
+    range.map(&:number).must_equal([1, 2, 3, 4])
+  end
+
+  describe 'next method' do
+    it 'returns a month object denoting the next month' do
+      Month.new(2014, 1).next.must_equal(Month.new(2014, 2))
+      Month.new(2014, 12).next.must_equal(Month.new(2015, 1))
+    end
+  end
+
+  describe 'succ method' do
+    it 'returns a month object denoting the next month' do
+      Month.new(2014, 1).succ.must_equal(Month.new(2014, 2))
+      Month.new(2014, 12).succ.must_equal(Month.new(2015, 1))
+    end
+  end
+
+  describe 'step method' do
+    it 'calls the block for every month until the given limit' do
+      months = []
+
+      Month.new(2014, 1).step(Month.new(2014, 3)) { |month| months << month }
+
+      months.must_equal([Month.new(2014, 1), Month.new(2014, 2), Month.new(2014, 3)])
+    end
+
+    it 'returns an enumerator if no block was given' do
+      months = Month.new(2014, 1).step(Month.new(2014, 3))
+
+      months.must_be_instance_of(Enumerator)
+
+      months.next.must_equal(Month.new(2014, 1))
+      months.next.must_equal(Month.new(2014, 2))
+      months.next.must_equal(Month.new(2014, 3))
+    end
+  end
+
+  describe 'addition' do
+    it 'returns a month object denoting the given number of months after self' do
+      (Month.new(2014, 1) + 1).must_equal(Month.new(2014, 2))
+      (Month.new(2014, 1) + 12).must_equal(Month.new(2015, 1))
+      (Month.new(2014, 1) + 18).must_equal(Month.new(2015, 7))
+    end
+  end
+
+  describe 'subtraction' do
+    it 'returns a month object denoting the given number of months before self' do
+      (Month.new(2014, 2) - 1).must_equal(Month.new(2014, 1))
+      (Month.new(2014, 1) - 1).must_equal(Month.new(2013, 12))
+      (Month.new(2014, 1) - 12).must_equal(Month.new(2013, 1))
+      (Month.new(2014, 1) - 18).must_equal(Month.new(2012, 7))
+    end
+  end
+
+  describe 'include predicate method' do
+    it 'returns true if the month includes the given date' do
+      Month.new(2014, 1).include?(Date.new(2014, 1, 1)).must_equal(true)
+    end
+
+    it 'returns false otherwise' do
+      Month.new(2014, 1).include?(Date.new(2014, 2, 1)).must_equal(false)
+    end
+  end
+
+  describe 'case equals method' do
+    it 'returns true if the month includes the given date' do
+      (Month.new(2014, 1) === Date.new(2014, 1, 1)).must_equal(true)
+    end
+
+    it 'returns false otherwise' do
+      (Month.new(2014, 1) === Date.new(2014, 2, 1)).must_equal(false)
+    end
+  end
+
+  describe 'start_date method' do
+    it 'returns a date object denoting the first day of the month' do
+      Month.new(2014, 1).start_date.must_equal(Date.new(2014, 1, 1))
+    end
+  end
+
+  describe 'end_date method' do
+    it 'returns a date object denoting the last day of the month' do
+      Month.new(2014, 1).end_date.must_equal(Date.new(2014, 1, 31))
+    end
+  end
+
+  describe 'dates method' do
+    it 'returns the range of dates in the month' do
+      dates = Month.new(2014, 1).dates
+      dates.must_be_instance_of(Range)
+      dates.count.must_equal(31)
+      dates.all? { |date| Date === date }.must_equal(true)
+      dates.first.must_equal(Date.new(2014, 1, 1))
+      dates.last.must_equal(Date.new(2014, 1, 31))
+    end
+  end
+
+  describe 'length method' do
+    it 'returns the integer number of days in the month' do
+      Month.new(2014, 1).length.must_equal(31)
+      Month.new(2014, 2).length.must_equal(28)
+    end
+  end
+end
+
+describe 'Month parse method' do
+  it 'returns the month corresponding to the given string representation' do
+    Month.parse('2014-01').must_equal(Month.new(2014, 1))
+  end
+
+  it 'raises an exception if the format of the string is not as expected' do
+    proc { Month.parse('January 2014') }.must_raise(ArgumentError)
+  end
+end
+
+describe 'Month method' do
+  it 'returns the month of the given date object' do
+    Month(Date.new(2014, 1, 1)).must_equal(Month.new(2014, 1))
+  end
+
+  it 'returns the month of the given time object' do
+    Month(Time.at(1234567890)).must_equal(Month.new(2009, 2))
+  end
+
+  it 'returns the month of the given datetime object' do
+    Month(DateTime.parse('2001-02-03T04:05:06+07:00')).must_equal(Month.new(2001, 2))
+  end
+
+  it 'returns the month of the given integer unix timestamp' do
+    Month(1234567890).must_equal(Month.new(2009, 2))
+  end
+
+  it 'idempotently returns the given month' do
+    month = Month.new(2014, 1)
+
+    Month(month).object_id.must_equal(month.object_id)
+  end
+end
+
+describe 'A method defined in Month::Methods' do
+  include Month::Methods
+
+  it 'returns a month object denoting that month in the given year' do
+    month = January 2014
+    month.must_equal(Month.new(2014, 1))
+
+    month = February 2014
+    month.must_equal(Month.new(2014, 2))
+  end
+
+  it 'returns a date object when given two arguments' do
+    date = January 31, 2014
+    date.must_equal(Date.new(2014, 1, 31))
+
+    date = February 28, 2014
+    date.must_equal(Date.new(2014, 2, 28))
+  end
+
+  it 'raises an exception if given too many arguments' do
+    proc { January 1, 2, 3 }.must_raise(ArgumentError)
+  end
+end

metadata

@@ -1,63 +1,75 @@
---- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.2
-specification_version: 1
+--- !ruby/object:Gem::Specification
 name: month
-version: !ruby/object:Gem::Version 
-  version: 0.1.2
-date: 2007-11-02 00:00:00 -04:00
-summary: Ruby Month is a utility class for representing months in Ruby. It handles addition, previous and next months, end and start dates, month names (in English), and a few other handy things.
-require_paths: 
-- lib
-email: sera@fhwang.net
-homepage: http://month.rubyforge.org/
-rubyforge_project: month
-description: Ruby Month is a utility class for representing months in Ruby. It handles addition, previous and next months, end and start dates, month names (in English), and a few other handy things.
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tim Craft
 autorequire: 
-default_executable: 
 bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
-platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
-authors: 
-- Francis Hwang
-files: 
-- Manifest.txt
-- README.txt
-- changelog.txt
-- install.rb
-- lib/month.rb
-- rakefile
-- test/ts_month.rb
-test_files: []
-
-rdoc_options: 
-- --main
-- README.txt
-extra_rdoc_files: 
-- Manifest.txt
-- README.txt
-- changelog.txt
+cert_chain: []
+date: 2014-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: A little library for working with months
+email:
+- mail@timcraft.com
 executables: []
-
 extensions: []
-
+extra_rdoc_files: []
+files:
+- README.md
+- lib/month.rb
+- month.gemspec
+- spec/month_spec.rb
+homepage: http://github.com/timcraft/month
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hoe
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.3.0
-    version: 
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: See description
+test_files: []

data/Manifest.txt

@@ -1,7 +0,0 @@
-Manifest.txt
-README.txt
-changelog.txt
-install.rb
-lib/month.rb
-rakefile
-test/ts_month.rb

data/README.txt

@@ -1,7 +0,0 @@
-Ruby Month is a utility class for representing months in Ruby. It handles addition, previous and next months, end and start dates, month names (in English), and a few other handy things.
-
-http://rubyforge.org/projects/month/
-
-INSTALLATION:
-As root, run "./install.rb", which will copy the Ruby files into the right
-subdirectory. You can run "./install.rb --help" for information.

data/changelog.txt

@@ -1,9 +0,0 @@
-= 0.1.2 -- Nov 2 2007
-* added Month#succ.
-
-= 0.1.1 -- Jan 7 2007
-* added install.rb
-* added reference to Rubyforge project page to month.rb RDoc
-
-= 0.1.0 -- Jun 7 2005
-* Initial release.

data/install.rb

@@ -1,164 +0,0 @@
-#! /usr/bin/env ruby
-################################################################################
-#                                                                              #
-#  Name: install.rb                                                            #
-#  Author: Sean E Russell <ser@germane-software.com>                           #
-#  Version: $Id: install.rb,v 1.1 2007/01/08 01:46:57 francis Exp $
-#  Date: *2002-174                                                             #
-#  Description:                                                                #
-#    This is a generic installation script for pure ruby sources.  Features    #
-#          include:                                                            #
-#          * Clean uninstall                                                   #
-#          * Installation into an absolute path                                #
-#          * Installation into a temp path (useful for systems like Portage)   #
-#          * Noop mode, for testing                                            #
-#    To set for a different system, change the SRC directory to point to the   #
-#    package name / source directory for the project.                          #
-#                                                                              #
-################################################################################
-
-# CHANGE THIS
-SRC = 'lib'
-MODULE_NAME = 'month'
-BIN = 'bin'
-# CHANGE NOTHING BELOW THIS LINE
-
-if $0 == __FILE__
-	Dir.chdir ".." if Dir.pwd =~ /bin.?$/
-	
-	require 'getoptlong'
-	require 'rbconfig'
-	require 'ftools'
-	require 'find'
-	
-	opts = GetoptLong.new( [ '--uninstall',	'-u',		GetoptLong::NO_ARGUMENT],
-												[ '--destdir', '-d', GetoptLong::REQUIRED_ARGUMENT ],
-												[ '--target', '-t', GetoptLong::REQUIRED_ARGUMENT ],
-												[ '--help', '-h', GetoptLong::NO_ARGUMENT],
-												[ '--noop', '-n', GetoptLong::NO_ARGUMENT])
-	
-	
-	destdir = File.join Config::CONFIG['sitedir'], 
-		"#{Config::CONFIG['MAJOR']}.#{Config::CONFIG['MINOR']}"
-	bindir = '/usr/local/bin'
-	
-	uninstall = false
-	append = nil
-	opts.each do |opt,arg|
-		case opt
-			when '--destdir'
-				append = arg
-			when '--uninstall'
-				uninstall = true
-			when '--target'
-				destdir = arg
-			when '--help'
-				puts "Installs #{SRC}.\nUsage:\n\t#$0 [[-u] [-n] [-t <dir>|-d <dir>]|-h]"
-				puts "\t-u --uninstall\tUninstalls the package"
-				puts "\t-t --target\tInstalls the software at an absolute location, EG:"
-				puts "\t    #$0 -t /usr/local/lib/ruby"
-				puts "\t  will put the software directly underneath /usr/local/lib/ruby;"
-				puts "\t  IE, /usr/local/lib/ruby/#{SRC}"
-				puts "\t-d --destdir\tInstalls the software at a relative location, EG:"
-				puts "\t    #$0 -d /tmp"
-				puts "\t  will put the software under tmp, using your ruby environment."
-				puts "\t  IE, /tmp/#{destdir}/#{SRC}"
-				puts "\t-n --noop\tDon't actually do anything; just print out what it"
-				puts "\t  would do."
-				exit 0
-			when '--noop'
-				NOOP = true
-		end
-	end
-	
-	destdir = File.join append, destdir if append
-	
-	def get_install_base( file )
-		file_parts = file.split( File::SEPARATOR )
-		file_parts.shift
-		file_parts.join( File::SEPARATOR )
-	end
-	
-	def install destdir, bindir
-		puts "Installing in #{destdir}"
-		begin
-			Find.find(SRC) { |file|
-				next if file =~ /CVS|\.svn/
-				install_base = get_install_base( file )
-				dst = File.join( destdir, install_base )
-				if defined? NOOP
-					puts ">> #{dst}" if file =~ /\.rb$/
-				else
-					File.makedirs( File.dirname(dst) )
-					File.install(file, dst, 0644, true) if file =~ /\.rb$/
-				end
-			}
-		rescue
-			puts $!
-		end
-		puts "Installing binaries in #{ bindir }"
-		begin
-			Dir.entries( BIN ).each { |entry|
-				src = File.join( BIN, entry )
-				next unless FileTest.executable?( src ) && !FileTest.directory?( src )
-				dst = File.join( bindir, entry )
-				if defined? NOOP
-					puts ">> #{ dst }"
-				else
-					File.install( src, dst, 0755, true )
-				end
-			}
-		rescue
-			puts $!
-		end
-	end
-	
-	def uninstall destdir, bindir
-		puts "Uninstalling in #{destdir}"
-		begin
-			puts "Deleting:"
-			dirs = []
-			Find.find( destdir ) do |file|
-				if file =~ /^#{ destdir }#{ File::SEPARATOR }#{ MODULE_NAME }/
-					if defined? NOOP
-						puts "-- #{file}" if File.file? file
-					else
-						File.rm_f file,true if File.file? file
-					end
-					dirs << file if File.directory? file
-				end
-			end
-			dirs.sort { |x,y|
-				y.length <=> x.length 	
-			}.each { |d| 
-				if defined? NOOP
-					puts "-- #{d}"
-				else
-					puts d
-					Dir.delete d
-				end
-			}
-		rescue
-		end
-		puts "Uninstalling binaries in #{ bindir }"
-		begin
-			Dir.entries( BIN ).each { |entry|
-				orig = File.join( BIN, entry )
-				next unless FileTest.executable?( orig ) && !FileTest.directory?( orig )
-				to_uninstall = File.join( bindir, entry )
-				if defined? NOOP
-					puts "-- #{to_uninstall}" if File.file? to_uninstall
-				else
-					File.rm_f to_uninstall,true if File.file? to_uninstall
-				end
-			}
-		rescue
-		end
-	end
-	
-	if uninstall
-		uninstall destdir, bindir
-	else
-		install destdir, bindir
-	end
-end

data/rakefile

@@ -1,44 +0,0 @@
-=begin
-$: << 'lib'
-require 'month'
-
-@@version_str = Month::Version
-
-def release_tag
-	( uber, major, minor ) = @@version_str.split( '.' ).collect! { |str|
-		str.to_i
-	}
-	"rel-#{ uber }-#{ major }-#{ minor }"
-end
-
-def release_dir_name
-	"month-#{ @@version_str }"
-end
-
-task :export_release do
-	Dir.chdir('../releases')
-	ext = "-d:ext:francis@rubyforge.org:/var/cvs/month"
-	`cvs #{ ext } export -r #{ release_tag } -d #{ release_dir_name } month`
-	`tar zcvf month-#{ @@version_str }.tar.gz #{ release_dir_name }`
-end
-
-task :update_docs do
-	Dir.chdir( 'lib' )
-	`rdoc --op ../docs/`
-end
-=end
-
-require 'hoe'
-$:.unshift 'lib'
-require 'month'
-
-Hoe.new("month", Month::Version) do |p|
-	p.rubyforge_name = "month"
-	p.author = 'Francis Hwang'
-	p.description = p.paragraphs_of( 'README.txt', 0 ).first
-	p.summary = p.paragraphs_of( 'README.txt', 0 ).first
-	p.email = 'sera@fhwang.net'
-	p.url = 'http://month.rubyforge.org/'
-	p.changes = p.paragraphs_of( 'changelog.txt', 0 ).first
-end
-

data/test/ts_month.rb

@@ -1,68 +0,0 @@
-$: << 'lib'
-require 'month'
-require 'test/unit'
-
-class TestMonth < Test::Unit::TestCase
-	def setup
-		@jan2000 = Month.new 2000, 1
-		@dec2000 = Month.new 2000, 12
-		@jan2001 = Month.new 2001, 1
-	end
-
-	def test_arithmetic
-		assert_equal( Month.new( 2000, 2 ), @jan2000 + 1 )
-		assert_equal( Month.new( 2001, 1 ), @jan2000 + 12 )
-		assert_equal( Month.new( 1999, 10 ), @jan2000 - 3 )
-		assert_equal( Month.new( 1999, 10 ), @jan2000 + -3 )
-	end
-	
-	def test_checks_month
-		caught = false
-		begin
-			Month.new 1, 2000
-		rescue
-			caught = true
-		end
-		assert caught
-		Month.new 2000, 1
-	end
-
-	def test_compare
-		assert @jan2000 < @jan2001
-	end
-
-	def test_default_init_to_current_month
-		month = Month.new
-		date = Date.today
-		assert_equal( date.mon, month.month )
-		assert_equal( date.year, month.year )
-	end
-	
-	def test_hashable
-		newJan2000 = Month.new( 2000, 1 )
-		assert_equal @jan2000, newJan2000
-		assert_equal @jan2000.hash, newJan2000.hash
-		assert( @jan2000.eql?( newJan2000 ) )
-		normalHash = {}
-		normalHash[@jan2000] = 'q'
-		assert_equal 'q', normalHash[newJan2000]
-	end
-
-	def test_prev_next_succ
-		assert_equal( @dec2000, @jan2001.prev )
-		assert_equal( @jan2001, @dec2000.next )
-		assert_equal( @jan2001, @dec2000.succ )
-		assert_equal( @jan2000, @jan2000.prev.next )
-		assert_equal( @jan2000, @jan2000.prev.succ )
-	end
-
-	def test_start_date_and_end_date
-		assert_equal( Date.new( 2000, 12, 1 ), @dec2000.start_date )
-		assert_equal( Date.new( 2000, 12, 31 ), @dec2000.end_date )
-		assert_equal( Date.new( 1999, 2, 28 ), Month.new( 1999, 2 ).end_date )
-	end
-
-	def test_to_s
-		assert_equal 'Jan 2000', @jan2000.to_s
-	end
-end