working-time 0.3.4

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Carl Hicks
+
+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.rdoc

@@ -0,0 +1,17 @@
+= working-time
+
+Description goes here.
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Carl Hicks. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "working-time"
+    gem.summary = %Q{Calculate work hours for a given date range}
+    gem.description = %Q{Need to figure out how many working hours are in a date range?  Need to calculate around holidays, on-call schedules, etc?  Use this gem!}
+    gem.email = "carl.hicks@gmail.com"
+    gem.homepage = "http://github.com/chicks/working-time"
+    gem.authors = ["Carl Hicks"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "working-time #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.4

data/lib/working-time.rb

@@ -0,0 +1,12 @@
+module WorkingTime
+  # 8am to 6pm
+  WORKING_HOURS = (8..18).to_a
+
+  # Monday to Friday
+  WORKING_DAYS  = (1..5).to_a
+
+  require 'date'
+  require 'working_time/date'
+  require 'working_time/interval'
+end
+

data/lib/working_time/date.rb

@@ -0,0 +1,175 @@
+module WorkingTime
+
+  class Hour 
+    attr :value
+    def initialize(num)
+      @value = num
+    end
+    def to_i
+      @value
+    end
+  end
+
+  class Date < Date
+    def + (n)
+      case n
+      when Numeric; 
+        new_date = self.class.new!(@ajd + n, @of, @sg)
+        if new_date.is_work_day?
+          return new_date
+        else
+          until new_date.is_work_day?
+            #puts "incrementing days! #{new_date}"
+            n += 1
+            new_date = self.class.new!(@ajd + n, @of, @sg)
+          end
+          return new_date
+        end
+      end
+      raise TypeError, 'expected numeric'
+    end
+
+    def is_work_day?
+      # check the day of week
+      WORKING_DAYS.include? self.cwday
+    end
+
+  end
+
+  class Time < Time
+
+  #  def to_time() getlocal end
+
+    def to_date
+      jd = Date.civil_to_jd(year, mon, mday, Date::ITALY)
+      Date.new!(Date.jd_to_ajd(jd, 0, 0), 0, Date::ITALY)
+    end
+
+    def to_datetime
+      jd = WorkingTime::DateTime.civil_to_jd(year, mon, mday, DateTime::ITALY)
+      fr = WorkingTime::DateTime.time_to_day_fraction(hour, min, [sec, 59].min) +
+     usec.to_r/86400000000
+      of = utc_offset.to_r/86400
+      WorkingTime::DateTime.new!(WorkingTime::DateTime.jd_to_ajd(jd, fr, of), of, DateTime::ITALY)
+    end
+
+    private :to_date, :to_datetime
+
+  end
+
+  # Lets just modify the basic DateTime class
+  class DateTime < DateTime 
+
+    def self.now  (sg=ITALY) WorkingTime::Time.now.__send__(:to_datetime).new_start(sg) end
+
+    # Returns the number of hours left in the day. 
+    def hours_left
+      remaining = WorkingTime::Interval.new(self, close_of_business)
+      return remaining.duration
+    end
+
+    def mins_left
+      hours_left * 60
+    end
+
+    def secs_left
+      hours_left * 3600
+    end
+
+    def open_of_business
+      self.class.new(self.year, self.mon, self.day, WORKING_HOURS[0], 0, 0, @of, @sg)
+    end
+
+    def close_of_business
+      self.class.new(self.year, self.mon, self.day, WORKING_HOURS[-1], 0, 0, @of, @sg)
+    end
+
+    def close_of_week
+      date = Date.new(self.year, self.mon, self.day)
+      date = date.next until date.cwday == WORKING_DAYS[-1]
+      self.class.new(date.year, date.mon, date.day, WORKING_HOURS[-1], 0, 0, @of, @sg)
+    end
+
+    def close_of_next_week
+      date = Date.commercial(year, cweek + 1, cwday)
+      date = date.next until date.cwday == WORKING_DAYS[-1]
+      self.class.new(date.year, date.mon, date.day, WORKING_HOURS[-1], 0, 0, @of, @sg)
+    end
+
+    def is_working_time?
+      # check the day of week
+      if WORKING_DAYS.include? cwday
+        #check the hour
+        if WORKING_HOURS.include? hour
+          return true
+        else
+          return false
+        end
+      else
+        return false
+      end
+    end
+
+    # override addition
+    def + (n)
+      case n
+      when Numeric; return self.class.new!(@ajd + n, @of, @sg)
+      when WorkingTime::Hour
+
+        cur_hour = self.hour
+        hours_remaining = n.to_i
+
+        min  = self.min
+        sec  = self.sec
+
+        date = Date.new(self.year,self.mon,self.day)
+
+        # if our initial value is before the start of the work day, set the cur_hour to the start of the workday
+        if cur_hour < WORKING_HOURS[0]
+          cur_hour = WORKING_HOURS[0]
+        # if our initial value is after the end of the current work day, set the cur_hour to the start of the NEXT workday
+        elsif cur_hour > WORKING_HOURS[-1]
+          cur_hour = WORKING_HOURS[0]
+          date = date.next
+        end
+
+        #puts "Incrementing #{self}"
+        # Add hours to the current hour, incrementing the day until we run out of hours
+        while hours_remaining > 0
+          until cur_hour == WORKING_HOURS[-1] || hours_remaining < 1
+            hours_remaining -= 1
+            cur_hour        += 1
+            #puts "Cur: #{cur_hour} / Rem: #{hours_remaining}"
+          end
+          if hours_remaining > 0
+            hours_remaining -= 1
+            cur_hour = WORKING_HOURS[0]
+            # go to the next day
+            date = date.next
+            #puts "Rolling Date: #{date} #{cur_hour}"
+          end
+        end
+        return self.class.new(date.year, date.mon, date.day, cur_hour, min, sec, @of, @sg)
+      end
+      raise TypeError, 'expected numeric or hour'
+    end
+
+    def to_gm_time
+      to_time(new_offset, :gm)
+    end
+
+    def to_local_time
+      to_time(new_offset(DateTime.now.offset-offset), :local)
+    end
+
+    private
+      def to_time(dest, method)
+        #Convert a fraction of a day to a number of microseconds
+        usec = (dest.sec_fraction * 60 * 60 * 24 * (10**6)).to_i
+        Time.send(method, dest.year, dest.month, dest.day, dest.hour, dest.min, dest.sec, usec)
+      end
+
+
+  end
+
+end

data/lib/working_time/interval.rb

@@ -0,0 +1,97 @@
+#! /usr/bin/env ruby
+
+module WorkingTime
+
+class Interval
+
+  attr :start, true
+  attr :stop, true
+  attr :duration, true
+  attr :log, true
+
+  def initialize(start, stop) 
+    @start = start
+    @stop  = stop
+    @duration = hours_between
+  end
+
+  # Calculates the number of seconds in a work day between two times in the same day
+  def seconds_between(start, stop)
+ 
+    # we need this to be a float   
+    duration = 0.0
+  
+    # we just return if the start comes after the stop
+    return duration if start > stop
+
+    # If it's a weekday, examine it.
+    if WORKING_DAYS.include? start.wday
+
+      # If it's inside working hours, calculate
+      if WORKING_HOURS.include? start.hour
+
+        # Figure out how many seconds between now and then
+        hours, mins, secs, ignore_fractions = Date::day_fraction_to_time(stop - start)
+        duration = hours * 60 * 60 + mins * 60 + secs
+
+      end
+
+    end
+
+    return duration
+  end
+
+  def hours_between
+  
+    #LOG.puts "Calculating: #{@start} to #{@stop}" if DEBUG
+
+    # Our placeholder in seconds   
+    duration = 0.0
+
+    start_date = Date.new(@start.year, @start.mon, @start.day)
+    stop_date  = Date.new(@stop.year, @stop.mon, @stop.day)
+
+    if start_date == stop_date
+
+      # If we closed it in the same day, we need to do a simple calculation
+      result = seconds_between(@start,@stop)
+      duration += result
+      #LOG.puts "Same day: #{@start} to #{@stop} (#{result / 3600})" if DEBUG
+
+    else 
+
+      # Loop over each day
+      start_date.upto(stop_date) do |date|
+        
+        #LOG.puts "Looking at: #{date}"
+        start_work_time = DateTime.new(date.year, date.mon, date.day, WORKING_HOURS[0])
+        stop_work_time  = DateTime.new(date.year, date.mon, date.day, WORKING_HOURS[-1])
+
+        # If we are looking at the first day, we only want to count from the create time, to the end of the working day
+        if date == start_date
+          result = seconds_between(@start,stop_work_time)
+          duration += result
+          #LOG.puts "Start date: #{@start} to #{stop_work_time} (#{result / 3600})" if DEBUG
+        # If we are looking at the end date we only want to count from the beginning of the day to the close time
+        elsif date == stop_date
+          result = seconds_between(start_work_time,@stop)
+          duration += result
+          #LOG.puts "Stop date: #{start_work_time} to #{@stop} (#{result / 3600})" if DEBUG
+        # Otherwise we assume this date falls between start and end
+        else
+          result = seconds_between(start_work_time,stop_work_time)
+          duration += result
+          #LOG.puts "In-between date: #{start_work_time} to #{stop_work_time} (#{result / 3600 })" if DEBUG 
+        end
+
+      end
+
+    end
+
+    #LOG.puts ""
+    return duration / 3600
+  end
+ 
+end
+
+end

data/test/helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'working-time'
+
+class Test::Unit::TestCase
+end

data/test/test_working-time.rb

@@ -0,0 +1,102 @@
+require 'helper'
+
+class TestWorkingTime < Test::Unit::TestCase
+  def test_same_day_hours_left
+    remaining = WorkingTime::DateTime.parse("2009-07-23T12:00:00+00:00").hours_left
+    assert_equal(6, remaining)
+  end 
+
+  def test_multi_day_add_hours
+    start = WorkingTime::DateTime.parse("2009-07-23T12:00:00+00:00")
+    stop  = WorkingTime::DateTime.parse("2009-07-24T11:00:00+00:00")
+    start = start + WorkingTime::Hour.new(10)
+    assert_equal(stop.to_s,start.to_s)
+  end
+
+  def test_multi_month_add_hours
+    start = WorkingTime::DateTime.parse("2009-07-23T12:00:00+00:00")
+    stop  = WorkingTime::DateTime.parse("2009-08-31T15:00:00+00:00")
+    start = start + WorkingTime::Hour.new(300)
+    assert_equal(stop.to_s,start.to_s)
+  end
+
+  def test_start_of_business
+    today = WorkingTime::DateTime.parse("2009-07-23T12:12:15-07:00").open_of_business
+    start = WorkingTime::DateTime.parse("2009-07-23T08:00:00-07:00")
+    assert_equal(start.to_s,today.to_s)
+  end
+
+  def test_datetime_now_class
+    assert_equal("WorkingTime::DateTime", WorkingTime::DateTime.now.class.to_s)
+  end
+
+  def test_after_hours_add
+    start = WorkingTime::DateTime.parse("2009-07-23T23:00:00+00:00")
+    stop  = WorkingTime::DateTime.parse("2009-07-24T18:00:00+00:00")
+    start = start + WorkingTime::Hour.new(10)
+    assert_equal(stop.to_s,start.to_s)
+  end
+
+  def test_after_hours_completion
+    start = WorkingTime::DateTime.parse("2009-07-23T23:00:00+00:00")
+    stop  = WorkingTime::DateTime.parse("2009-07-27T08:00:00+00:00")
+    start = start + WorkingTime::Hour.new(11)
+    assert_equal(stop.to_s,start.to_s)
+  end
+
+  def test_multi_day_rollover
+    start = WorkingTime::DateTime.parse("2009-09-23T13:14:00+00:00")
+    stop  = WorkingTime::DateTime.parse("2009-09-24T10:14:00+00:00")
+    start = start + WorkingTime::Hour.new(8)
+    assert_equal(stop.to_s,start.to_s)
+  end
+
+  def test_close_of_week
+    start = WorkingTime::DateTime.parse("2009-09-23T13:14:00+00:00")
+    stop  = WorkingTime::DateTime.parse("2009-09-25T18:00:00+00:00")
+    start = start.close_of_week
+    assert_equal(stop.to_s,start.to_s)
+  end
+
+  def test_close_of_next_week
+    start = WorkingTime::DateTime.parse("2009-09-23T13:14:00+00:00")
+    stop  = WorkingTime::DateTime.parse("2009-10-02T18:00:00+00:00")
+    start = start.close_of_next_week
+    assert_equal(stop.to_s,start.to_s)
+  end
+end
+
+class TestWorkingTimeInterval < Test::Unit::TestCase
+
+  def test_same_day_close
+    start = DateTime.parse("2009-07-29T18:30:00+00:00")
+    stop  = DateTime.parse("2009-07-29T22:00:00+00:00")
+
+    interval = WorkingTime::Interval.new(start,stop)
+    assert_equal(3.5, interval.duration)
+  end
+
+  def test_multi_day_close_no_weekend
+    start = DateTime.parse("2009-07-23T12:00:00+00:00")
+    stop  = DateTime.parse("2009-07-24T12:00:00+00:00")
+
+    interval = WorkingTime::Interval.new(start,stop)
+    assert_equal(10.0, interval.duration)
+  end
+
+  def test_multi_day_close_weekend
+    start = DateTime.parse("2009-07-23T12:00:00+00:00")
+    stop  = DateTime.parse("2009-07-27T12:00:00+00:00")
+
+    interval = WorkingTime::Interval.new(start,stop)
+    assert_equal(20.0, interval.duration)
+  end
+
+  def test_multi_day_after_hours
+    start = DateTime.parse("2009-07-28T18:59:00+00:00")
+    stop  = DateTime.parse("2009-07-29T16:00:00+00:00")
+
+    interval = WorkingTime::Interval.new(start,stop)
+    assert_equal(8.0, interval.duration)
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: working-time
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 4
+  version: 0.3.4
+platform: ruby
+authors: 
+- Carl Hicks
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-27 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Need to figure out how many working hours are in a date range?  Need to calculate around holidays, on-call schedules, etc?  Use this gem!
+email: carl.hicks@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/working-time.rb
+- lib/working_time/date.rb
+- lib/working_time/interval.rb
+- test/helper.rb
+- test/test_working-time.rb
+has_rdoc: true
+homepage: http://github.com/chicks/working-time
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Calculate work hours for a given date range
+test_files: 
+- test/helper.rb
+- test/test_working-time.rb