work_days 0.0.3

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in work_days.gemspec
+gemspec
+
+gem 'pry'
+gem 'rspec'
+gem 'guard-rspec'
+gem 'rb-fsevent'

data/Guardfile

@@ -0,0 +1,46 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Robert Jackson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# WorkDays
+
+Calculate the number of business days in a given period.  Also, add convenience methods to Range, Date, and Time.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'work_days'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install work_days
+
+## Usage
+
+Use your own custom work schedule by creating a class implementing 
+your custom holiday methods and including the WorkDays::CalculationMethods module
+(and optionally the WorkDays::HolidayMethods module for a few of the presets). 
+
+    class SampleSchedule
+      WorkDays::CalculationMethods
+      WorkDays::HolidayMethods
+
+      def observed_holidays
+        [:new_years_day, :christmas_day]
+      end
+    end
+
+Then tell the library to use your new schedule:
+
+    WorkDays.work_schedule = SampleSchedule.new
+
+You can also use a few pre-built schedules (WorkDays::WorkSchedules::Default, WorkDays::WorkSchedules::Bank).
+
+By default a day is considered a work day as long as it is a week day and it isn't a holiday.
+You can configure your own week days by overriding the week_day? method in your work schedule class.
+
+### Methods
+
+These methods can be called either on an instance of your work schedule class or directly
+on the WorkDays module (as long as you set the WorkDays.work_schedule).
+
+* work_day?(date)
+  * Returns true for week days as long as it isn't a holiday.
+* non_work_day?(date)
+  * The opposite of work_day?.
+* work_days_in_range(start_date, end_date)
+  * Returns an array of the work days between the start and end dates.
+* work_days_in_month(date)
+  * Returns an array of the work days for the year and month of the passed in date.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/work_days.rb

@@ -0,0 +1,33 @@
+require 'date'
+
+require_relative 'work_days/version'
+require_relative 'work_days/calculation_methods'
+require_relative 'work_days/holiday_methods'
+require_relative 'work_days/work_schedules/default'
+require_relative 'work_days/work_schedules/bank'
+require_relative 'work_days/ext/date'
+require_relative 'work_days/ext/time'
+require_relative 'work_days/ext/date_time'
+require_relative 'work_days/ext/range'
+
+module WorkDays
+  def self.work_schedule=(schedule)
+    @work_schedule = schedule
+  end
+
+  def self.work_schedule
+    @work_schedule ||= WorkDays::WorkSchedules::Default.new
+  end
+
+  def self.respond_to_missing?(method_name, include_private = false)
+    work_schedule.respond_to?(method_name)
+  end
+
+  def self.method_missing(name, *args, &block)
+    if work_schedule.respond_to?(name)
+      work_schedule.public_send(name, *args, &block)
+    else
+      super
+    end
+  end
+end

data/lib/work_days/calculation_methods.rb

@@ -0,0 +1,103 @@
+module WorkDays::CalculationMethods
+  def holiday?(date)
+    observed_holidays.any? do |sym|
+      next if caller.any?{|c| c =~ /`#{sym.to_s}'\z/}
+      send(sym, date.year) == date
+    end
+  end
+
+  def weekend_day?(date)
+    date.sunday? || date.saturday?
+  end
+
+  def week_day?(date)
+    !weekend_day?(date)
+  end
+
+  def work_day?(date)
+    week_day?(date) && !holiday?(date)
+  end
+
+  def non_work_day?(date)
+    !work_day?(date)
+  end
+
+  def work_days_in_range(start, stop)
+    working_days = []
+
+    (start.to_date..stop.to_date).each do |date|
+      working_days << date if work_day?(date)
+    end
+
+    working_days
+  end
+
+  def work_days_in_month(date)
+    start_date = Date.new(date.year, date.month,  1)
+    end_date   = Date.new(date.year, date.month, -1)
+
+    work_days_in_range(start_date, end_date)
+  end
+
+  def previous_work_day(date)
+    loop do
+      date = date.to_date.prev_day
+      break if work_day?(date)
+    end
+
+    date
+  end
+
+  def next_work_day(date)
+    loop do
+      date = date.to_date.next_day
+      break if work_day?(date)
+    end
+
+    date
+  end
+
+  def work_days_from(number_of_days, date)
+    number_of_days.times do
+      date = next_work_day(date)
+    end
+
+    date
+  end
+
+  def observed_holidays
+    raise NotImplementedError, 'You must override this method.'
+  end
+
+  def monthly_work_days(year=nil)
+    year = format_year(year)
+
+    (1..12).collect{|month| work_days_in_month(Date.new(year, month))}
+  end
+
+  private
+
+  def weekday_if_weekend(date)
+    date -= 1 if date.saturday?
+    date += 1 if date.sunday?
+
+    date
+  end
+
+  def format_year(year=nil)
+    year ||= Date.today.year
+    year.to_i
+  end
+
+  def day_of_week_occurence(year, month, test, count=nil)
+    year    = format_year(year)
+    count ||= 1
+    counter = 0
+
+    1.upto(31).each do |day|
+      date = Date.new(year, month, day)
+      counter += 1 if date.send(test)
+      return date if counter == count
+    end
+  end
+end

data/lib/work_days/ext/date.rb

@@ -0,0 +1,5 @@
+class Date
+  def work_day?
+    WorkDays.work_day?(self)
+  end
+end

data/lib/work_days/ext/date_time.rb

@@ -0,0 +1,5 @@
+class DateTime
+  def work_day?
+    WorkDays.work_day?(self)
+  end
+end

data/lib/work_days/ext/range.rb

@@ -0,0 +1,5 @@
+class Range
+  def work_days
+    WorkDays.work_days_in_range(self.first, self.last)
+  end
+end

data/lib/work_days/ext/time.rb

@@ -0,0 +1,5 @@
+class Time
+  def work_day?
+    WorkDays.work_day?(self)
+  end
+end

data/lib/work_days/holiday_methods.rb

@@ -0,0 +1,87 @@
+require_relative 'calculation_methods'
+
+module WorkDays::HolidayMethods
+  include WorkDays::CalculationMethods
+
+  def new_years_day(year=nil)
+    year = format_year(year)
+    weekday_if_weekend(Date.new(year,1,1))
+  end
+
+  def martin_luther_king_day(year=nil)
+    year = format_year(year)
+
+    return nil if year < 1986
+
+    day_of_week_occurence(year, 1, :monday?, 3)
+  end
+
+  def presidents_day(year=nil)
+    day_of_week_occurence(year, 2, :monday?, 3)
+  end
+
+  def easter_sunday(year=nil)
+    year = format_year(year)
+    y = year
+    a = y % 19
+    b = y / 100
+    c = y % 100
+    d = b / 4
+    e = b % 4
+    f = (b + 8) / 25
+    g = (b - f + 1) / 3
+    h = (19 * a + b - d - g + 15) % 30
+    i = c / 4
+    k = c % 4
+    l = (32 + 2 * e + 2 * i - h - k) % 7
+    m = (a + 11 * h + 22 * l) / 451
+    month = (h + l - 7 * m + 114) / 31
+    day = ((h + l - 7 * m + 114) % 31) + 1
+    Date.new(year, month, day)
+  end
+
+  def memorial_day(year=nil)
+    year = format_year(year)
+
+    31.downto(1).each do |day|
+      date = Date.new(year, 5, day)
+      return date if date.monday?
+    end
+  end
+
+  def independence_day(year=nil)
+    year = format_year(year)
+    weekday_if_weekend(Date.new(year,7,4))
+  end
+
+  def labor_day(year=nil)
+    day_of_week_occurence(year, 9, :monday?)
+  end
+
+  def columbus_day(year=nil)
+    day_of_week_occurence(year, 10, :monday?, 2)
+  end
+
+  def veterans_day(year=nil)
+    year = format_year(year)
+    weekday_if_weekend(Date.new(year,11,11))
+  end
+
+  def thanksgiving_day(year=nil)
+    day_of_week_occurence(year, 11, :thursday?, 4)
+  end
+
+  def black_friday(year=nil)
+    thanksgiving_day(year).next_day
+  end
+
+  def christmas_eve_day(year=nil)
+    previous_work_day(christmas_day(year))
+  end
+
+  def christmas_day(year=nil)
+    year = format_year(year)
+    weekday_if_weekend(Date.new(year,12,25))
+  end
+
+end

data/lib/work_days/version.rb

@@ -0,0 +1,3 @@
+module WorkDays
+  VERSION = "0.0.3"
+end

data/lib/work_days/work_schedules/bank.rb

@@ -0,0 +1,19 @@
+module WorkDays::WorkSchedules
+  class Bank
+    include WorkDays::CalculationMethods
+    include WorkDays::HolidayMethods
+
+    def observed_holidays
+      [ :new_years_day,
+        :martin_luther_king_day,
+        :presidents_day,
+        :memorial_day,
+        :independence_day,
+        :labor_day,
+        :columbus_day,
+        :veterans_day,
+        :thanksgiving_day,
+        :christmas_day ]
+    end
+  end
+end

data/lib/work_days/work_schedules/default.rb

@@ -0,0 +1,17 @@
+module WorkDays::WorkSchedules
+  class Default
+    include WorkDays::CalculationMethods
+    include WorkDays::HolidayMethods
+
+    def observed_holidays
+      [ :new_years_day,
+        :memorial_day,
+        :independence_day,
+        :labor_day,
+        :thanksgiving_day,
+        :black_friday,
+        :christmas_eve_day,
+        :christmas_day ]
+    end
+  end
+end

data/spec/lib/work_days/calculation_methods_spec.rb

@@ -0,0 +1,198 @@
+require_relative '../../spec_helper'
+
+describe WorkDays::CalculationMethods, :type => :holiday_helpers do
+  let(:today)        {Date.today}
+  let(:current_year) {Date.today.year}
+
+  let(:dummy_class) do
+    Class.new do
+      include(WorkDays::CalculationMethods)
+    end
+  end
+
+  subject{dummy_class.new}
+
+  context "#weekend_day?" do
+    let(:date) {double('date', :sunday? => false, :saturday? => false)}
+
+    it "should be true for sundays" do
+      date.should_receive(:sunday?).and_return(true)
+      subject.weekend_day?(date).should be_true
+    end
+
+    it "should be true for saturdays" do
+      date.should_receive(:saturday?).and_return(true)
+      subject.weekend_day?(date).should be_true
+    end
+
+    it "should be false for non-saturdays/non-sundays" do
+      date.should_receive(:sunday?).and_return(false)
+      date.should_receive(:saturday?).and_return(false)
+      subject.weekend_day?(date).should be_false
+    end
+    it "should be true for weekday holidays" do
+      all_holiday_dates.each do |date|
+        date = Date.parse(date)
+        weekend_flag = date.saturday? || date.sunday?
+
+        subject.weekend_day?(date).should == weekend_flag
+      end
+    end
+  end
+
+  context "#week_day?" do
+    it "is true when weekend_day? is false" do
+      subject.should_receive(:weekend_day?).and_return(false)
+      subject.week_day?(today).should be_true
+    end
+
+    it "is false when weekend_day? is true" do
+      subject.should_receive(:weekend_day?).and_return(true)
+      subject.week_day?(today).should be_false
+    end
+  end
+
+  context "#work_day?" do
+    it "should be true for a non-holiday weekday" do
+      subject.should_receive(:week_day?).and_return(true)
+      subject.should_receive(:holiday?).and_return(false)
+
+      subject.work_day?(today).should be_true
+    end
+
+    it "should be false for a holiday" do
+      subject.should_receive(:week_day?).and_return(true)
+      subject.should_receive(:holiday?).and_return(true)
+
+      subject.work_day?(today).should be_false
+    end
+
+    it "should be false for a weekend" do
+      subject.should_receive(:week_day?).and_return(false)
+      subject.should_not_receive(:holiday?)
+
+      subject.work_day?(today).should be_false
+    end
+  end
+
+  context "#non_work_day?" do
+    it "is true when work_day? is false" do
+      subject.should_receive(:work_day?).and_return(false)
+      subject.non_work_day?(today).should be_true
+    end
+
+    it "is false when work_day? is true" do
+      subject.should_receive(:work_day?).and_return(true)
+      subject.non_work_day?(today).should be_false
+    end
+  end
+
+  context "#work_days_in_range" do
+    let(:start_date) {random_date}
+    let(:end_date)   {start_date + rand(45)}
+
+    it "should return an array of the work days between two dates" do
+      valid_work_days = []
+
+      (start_date..end_date).each do |date|
+        work_day = random_boolean
+
+        valid_work_days << date if work_day
+        subject.should_receive(:work_day?).with(date).and_return(work_day)
+      end
+
+      subject.work_days_in_range(start_date, end_date).should eq(valid_work_days)
+    end
+  end
+
+  context "#work_days_in_month" do
+    let(:date)             {random_date}
+    let(:range_start_date) {Date.new(date.year, date.month, 1)}
+    let(:range_end_date)   {Date.new(date.year, date.month, -1)}
+    let(:range_work_days)  {rand(1..31)}
+
+    it "should return the number of days in the month specified" do
+      subject.should_receive(:work_days_in_range).with(range_start_date, range_end_date).and_return(range_work_days)
+      subject.work_days_in_month(date).should eq(range_work_days)
+    end
+  end
+
+  context "#monthly_work_days" do
+    let(:year)          {rand(1900..2500)}
+    let(:monthly_work_days) do
+      Hash[(1..12).collect{|i| [Date.new(year, i, 1), i]}]
+    end
+
+    it "should return an array of the work_days in each month of the given year" do
+      monthly_work_days.each do |start_date, days|
+        subject.should_receive(:work_days_in_month).with(start_date).and_return(days)
+      end
+
+      subject.monthly_work_days(year).should eql(monthly_work_days.values)
+    end
+  end
+
+  context "#next_work_day" do
+    it "should never return the same date" do
+      starting_date = random_date
+      ending_date   = starting_date + 1
+
+      subject.should_receive(:work_day?).and_return(true)
+      subject.next_work_day(starting_date).should eq(ending_date)
+    end
+
+    it "iterates through each day until it finds the first non-holiday/weekend" do
+      first_work_day = random_date
+      starting_date  = first_work_day - 2
+
+      subject.should_receive(:work_day?).and_return(false)
+      subject.should_receive(:work_day?).with(first_work_day).and_return(true)
+
+      subject.next_work_day(starting_date).should eq(first_work_day)
+    end
+  end
+
+  context "#previous_work_day" do
+    it "should never return the same date" do
+      starting_date = random_date
+      ending_date   = starting_date - 1
+
+      subject.should_receive(:work_day?).and_return(true)
+      subject.previous_work_day(starting_date).should eq(ending_date)
+    end
+
+    it "iterates backwards through each day until it finds the first non-holiday/weekend" do
+      first_work_day = random_date
+      starting_date  = first_work_day + 2
+
+      subject.should_receive(:work_day?).and_return(false)
+      subject.should_receive(:work_day?).with(first_work_day).and_return(true)
+
+      subject.previous_work_day(starting_date).should eq(first_work_day)
+    end
+  end
+
+  context "#work_days_from" do
+    it "should accept the number of days and starting date" do
+      should respond_to(:work_days_from)
+    end
+
+    it "should call next_work_day the specified number of times" do
+      start_date      = random_date
+      current_date    = start_date
+      days_from_start = rand(1..100)
+
+      days_from_start.downto(1) do
+        subject.should_receive(:next_work_day).with(current_date).and_return(current_date += 1)
+      end
+
+      subject.work_days_from(days_from_start, start_date).should eq(current_date)
+    end
+  end
+
+  context "#observed_holidays" do
+    it "should raise an exception" do
+      expect{subject.observed_holidays}.to raise_error
+    end
+  end
+end

data/spec/lib/work_days/ext/date_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../../../spec_helper'
+
+describe Date do
+  it_behaves_like "a proxy for WorkDays.work_day?"
+end

data/spec/lib/work_days/ext/datetime_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../../../spec_helper'
+
+describe DateTime do
+  it_behaves_like "a proxy for WorkDays.work_day?"
+end

data/spec/lib/work_days/ext/range_spec.rb

@@ -0,0 +1,12 @@
+require_relative '../../../spec_helper'
+
+describe Range, :type => :holiday_helpers do
+  let(:start_date) { random_date}
+  let(:end_date)   { start_date + rand(35)}
+  let(:range)      { start_date..end_date}
+
+  it "should call WorkDays.work_days_in_range" do
+    WorkDays.should_receive(:work_days_in_range).with(range.first, range.last)
+    range.work_days
+  end
+end

data/spec/lib/work_days/ext/time_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../../../spec_helper'
+
+describe Time do
+  it_behaves_like "a proxy for WorkDays.work_day?"
+end

data/spec/lib/work_days/holiday_methods_spec.rb

@@ -0,0 +1,38 @@
+require_relative '../../spec_helper'
+
+describe WorkDays::HolidayMethods, :type => :holiday_helpers do
+  let(:today)        {Date.today}
+  let(:current_year) {Date.today.year}
+
+  let(:dummy_class) do
+    Class.new do
+      include(WorkDays::HolidayMethods)
+
+      def observed_holidays
+        [:christmas_day]
+      end
+    end
+  end
+
+  holidays.each do |holiday, dates|
+    context "##{holiday.to_s}" do
+      subject {dummy_class.new}
+
+      it "should accept a string as the year input" do
+        subject.public_send(holiday, '2012')
+      end
+
+      it "should default to the current year" do
+        current_year_holiday = subject.public_send(holiday, current_year)
+        subject.public_send(holiday).should eq(current_year_holiday)
+      end
+
+      it "should return the proper date given a year" do
+        dates.each do |date|
+          date = Date.parse(date)
+          subject.public_send(holiday, date.year).should eq(date)
+        end
+      end
+    end
+  end
+end

data/spec/lib/work_days/work_days_spec.rb

@@ -0,0 +1,58 @@
+require_relative '../../spec_helper'
+
+describe WorkDays, :type => :holiday_helpers do
+  subject {WorkDays}
+
+  before do
+    subject.instance_variable_set(:@work_schedule, nil)
+  end
+
+  after do
+    subject.instance_variable_set(:@work_schedule, nil)
+  end
+
+
+  context ".work_schedule=" do
+    it "sets a module instance variable to the passed value" do
+      subject.work_schedule = 'random value'
+      subject.instance_variable_get(:@work_schedule).should eq('random value')
+    end
+  end
+
+  context ".work_schedule" do
+    it "returns the value of the currently set work_schedule" do
+      subject.work_schedule = 'random value'
+      subject.work_schedule.should eq('random value')
+    end
+
+    it "returns new WorkSchedules::Default if the work_schedule wasn't already set" do
+      subject.work_schedule.should be_an_instance_of(WorkDays::WorkSchedules::Default)
+    end
+  end
+
+  context ".method_missing" do
+    before do
+      subject.work_schedule = double('schedule',:random_method => 'non_nil', :foo => 'bar')
+    end
+
+    after do
+      subject.work_schedule = nil
+    end
+
+    it "raises NoMethodError when a method is called that the current WorkSchedule doesn't implement" do
+      expect{ subject.adsfakjlk }.to raise_error(NoMethodError)
+    end
+
+    it "proxies all calls to current work_schedule" do
+      subject.work_schedule.should_receive(:random_method)
+      subject.work_schedule.should_receive(:foo)
+      subject.random_method.should eq('non_nil')
+      subject.foo.should eq('bar')
+    end
+
+    it "indicates that it responds to methods implemented by the current WorkSchedule" do
+      subject.respond_to?(:random_method).should be_true
+      subject.respond_to?(:foo).should be_true
+    end
+  end
+end

data/spec/lib/work_days/work_schedules/bank_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe WorkDays::WorkSchedules::Bank do
+  it_behaves_like "a work schedule"
+end

data/spec/lib/work_days/work_schedules/default_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe WorkDays::WorkSchedules::Default do
+  it_behaves_like "a work schedule"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'pry'
+
+require_relative '../lib/work_days'
+Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/holiday_helpers.rb

@@ -0,0 +1,43 @@
+module WorkDays::SpecHelpers
+  def holidays
+    @holidays ||= {
+      :new_years_day          => %w{1980-01-01 1987-01-01 1993-01-01 2001-01-01 2006-01-02 2015-01-01},
+      :martin_luther_king_day => %w{1986-01-20 1989-01-16 1993-01-18 2001-01-15 2006-01-16 2015-01-19},
+      :presidents_day         => %w{1986-02-17 1989-02-20 1993-02-15 2001-02-19 2006-02-20 2015-02-16},
+      :easter_sunday          => %w{1980-04-06 1987-04-19 1993-04-11 2001-04-15 2002-03-31 2015-04-05},
+      :memorial_day           => %w{1980-05-26 1987-05-25 1993-05-31 2001-05-28 2006-05-29 2015-05-25},
+      :independence_day       => %w{1980-07-04 1987-07-03 1993-07-05 2001-07-04 2002-07-04 2015-07-03},
+      :labor_day              => %w{1980-09-01 1987-09-07 1993-09-06 2001-09-03 2006-09-04 2015-09-07},
+      :columbus_day           => %w{1980-10-13 1987-10-12 1993-10-11 2001-10-08 2006-10-09 2015-10-12},
+      :veterans_day           => %w{1980-11-11 1987-11-11 1993-11-11 2001-11-12 2006-11-10 2015-11-11},
+      :thanksgiving_day       => %w{1980-11-27 1987-11-26 1993-11-25 2001-11-22 2006-11-23 2015-11-26},
+      :black_friday           => %w{1980-11-28 1987-11-27 1993-11-26 2001-11-23 2006-11-24 2015-11-27},
+      :christmas_eve_day      => %w{1982-12-23 1987-12-24 1994-12-23 2001-12-24 2006-12-22 2015-12-24},
+      :christmas_day          => %w{1982-12-24 1987-12-25 1994-12-26 2001-12-25 2006-12-25 2015-12-25},
+    }
+  end
+
+  def all_holiday_dates
+    @all_holiday_dates ||= holidays.values.flatten
+  end
+
+  def default_holiday_dates
+    WorkDays.send(:default_holiday_methods).collect do |holiday|
+      holidays[holiday]
+    end.flatten.compact
+  end
+
+  def random_date
+    Date.new(rand(1900..2500), rand(1..12), rand(1..28))
+  end
+
+  def random_boolean
+    rand(0..1) == 0
+  end
+end
+
+RSpec.configure do |c|
+    c.extend  WorkDays::SpecHelpers, :type => :holiday_helpers
+    c.include WorkDays::SpecHelpers, :type => :holiday_helpers
+end
+

data/spec/support/shared_work_schedule.rb

@@ -0,0 +1,21 @@
+shared_examples "a work schedule" do
+  context "included modules" do
+    it "includes WorkDays::HolidayMethods" do
+      described_class.ancestors.should include(WorkDays::HolidayMethods)
+    end
+
+    it "includes WorkDays::CalculationMethods" do
+      described_class.ancestors.should include(WorkDays::CalculationMethods)
+    end
+  end
+
+  context "#observed_holidays" do
+    it {should respond_to(:observed_holidays)}
+
+    it "returns an enumerable of holiday methods" do
+      subject.observed_holidays.each do |sym|
+        subject.should respond_to(sym)
+      end
+    end
+  end
+end

data/spec/support/work_day_proxy.rb

@@ -0,0 +1,13 @@
+shared_examples "a proxy for WorkDays.work_day?" do
+  context "#work_day?" do
+    it "should respond_to work_day?" do
+      should respond_to(:work_day?)
+    end
+
+    it "should call WorkDays.work_day? passing self" do
+      WorkDays.should_receive(:work_day?).with(subject)
+
+      subject.work_day?
+    end
+  end
+end

data/work_days.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/work_days/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Robert Jackson"]
+  gem.email         = ["robertj@promedicalinc.com"]
+  gem.description   = %q{Calculate the number of business days in a given period.  Also, add convenience methods to Range, Date, DateTime, and Time.}
+  gem.summary       = %q{Simple business day calculations.}
+  gem.homepage      = "https://github.com/rjackson/work_days"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "work_days"
+  gem.require_paths = ["lib"]
+  gem.version       = WorkDays::VERSION
+
+  gem.add_development_dependency 'rspec'
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: work_days
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+  prerelease: 
+platform: ruby
+authors:
+- Robert Jackson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: Calculate the number of business days in a given period.  Also, add convenience
+  methods to Range, Date, DateTime, and Time.
+email:
+- robertj@promedicalinc.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/work_days.rb
+- lib/work_days/calculation_methods.rb
+- lib/work_days/ext/date.rb
+- lib/work_days/ext/date_time.rb
+- lib/work_days/ext/range.rb
+- lib/work_days/ext/time.rb
+- lib/work_days/holiday_methods.rb
+- lib/work_days/version.rb
+- lib/work_days/work_schedules/bank.rb
+- lib/work_days/work_schedules/default.rb
+- spec/lib/work_days/calculation_methods_spec.rb
+- spec/lib/work_days/ext/date_spec.rb
+- spec/lib/work_days/ext/datetime_spec.rb
+- spec/lib/work_days/ext/range_spec.rb
+- spec/lib/work_days/ext/time_spec.rb
+- spec/lib/work_days/holiday_methods_spec.rb
+- spec/lib/work_days/work_days_spec.rb
+- spec/lib/work_days/work_schedules/bank_spec.rb
+- spec/lib/work_days/work_schedules/default_spec.rb
+- spec/spec_helper.rb
+- spec/support/holiday_helpers.rb
+- spec/support/shared_work_schedule.rb
+- spec/support/work_day_proxy.rb
+- work_days.gemspec
+homepage: https://github.com/rjackson/work_days
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple business day calculations.
+test_files:
+- spec/lib/work_days/calculation_methods_spec.rb
+- spec/lib/work_days/ext/date_spec.rb
+- spec/lib/work_days/ext/datetime_spec.rb
+- spec/lib/work_days/ext/range_spec.rb
+- spec/lib/work_days/ext/time_spec.rb
+- spec/lib/work_days/holiday_methods_spec.rb
+- spec/lib/work_days/work_days_spec.rb
+- spec/lib/work_days/work_schedules/bank_spec.rb
+- spec/lib/work_days/work_schedules/default_spec.rb
+- spec/spec_helper.rb
+- spec/support/holiday_helpers.rb
+- spec/support/shared_work_schedule.rb
+- spec/support/work_day_proxy.rb
+has_rdoc: