workpattern 0.3.4 → 0.6.0

data/lib/workpattern/version.rb

@@ -1,5 +1,3 @@
 module Workpattern
-  # Version Number for Workpattern gem
-  # @since 0.0.1
-  VERSION = '0.3.4'
-end  
+  VERSION = '0.6.0'
+end

data/lib/workpattern/week.rb

@@ -1,363 +1,281 @@
 module Workpattern
-  
-  # @author Barrie Callender
-  # @!attribute values
-  #   @return [Array] each day of the week
-  # @!attribute days
-  #   @return [Integer] number of days in the week
-  # @!attribute start
-  #   @return [DateTime] first date in the range
-  # @!attribute finish
-  #   @return [DateTime] last date in the range
-  # @!attribute week_total
-  #   @return [Integer] total number of minutes in a week
-  # @!attribute total
-  #   @return [Integer] total number of minutes in the range
-  #  
-  # Represents working and resting periods for each day in a week for a specified date range.
+  # The representation of a week might not be obvious so I am writing about it
+  # here.  It will also help me if I ever need to come back to this in the
+  # future.
   #
-  # @since 0.2.0
+  # Each day is represented by a binary number where a 1 represents a working
+  # minute and a 0 represents a resting minute.
   #
+  # @private
   class Week
-    
-    attr_accessor :values, :days, :start, :finish, :week_total, :total
-
-    # The new <tt>Week</tt> object can be created as either working or resting.
-    #
-    # @param [DateTime] start first date in the range
-    # @param [DateTime] finish last date in the range
-    # @param [Integer] type working (1) or resting (0)
-    # @return [Week] newly initialised Week object    
-    #
-    def initialize(start,finish,type=1)
-      hours_in_days_in_week=[24,24,24,24,24,24,24]
-      @days=hours_in_days_in_week.size
-      @values=Array.new(7) {|index| Day.new(type)}
-      @start=DateTime.new(start.year,start.month,start.day)
-      @finish=DateTime.new(finish.year,finish.month,finish.day)
-        
-      set_attributes
+    attr_accessor :hours_per_day, :start, :finish, :days
+    attr_writer :week_total, :total
+
+    def initialize(start, finish, type = WORK_TYPE, hours_per_day = HOURS_IN_DAY)
+      @hours_per_day = hours_per_day
+      @start = Time.gm(start.year, start.month, start.day)
+      @finish = Time.gm(finish.year, finish.month, finish.day)
+      @days = Array.new(LAST_DAY_OF_WEEK)
+      FIRST_DAY_OF_WEEK.upto(LAST_DAY_OF_WEEK) do |i|
+        @days[i] = Day.new(hours_per_day, type)
+      end
     end
-    
-    # Duplicates the current <tt>Week</tt> object
-    #
-    # @return [Week] a duplicated instance of the current <tt>Week</tt> object
-    #
-    def duplicate()
-      duplicate_week=Week.new(@start,@finish)
-      duplicate_values=Array.new(@values.size)
-      @values.each_index {|index|
-        duplicate_values[index]=@values[index].duplicate
-        }
-      duplicate_week.values=duplicate_values  
-      duplicate_week.days=@days
-      duplicate_week.start=@start
-      duplicate_week.finish=@finish
-      duplicate_week.week_total=@week_total
-      duplicate_week.total=@total
-      duplicate_week.refresh
-      return duplicate_week
+
+    def <=>(other)
+      return -1 if start < other.start
+      return 0 if start == other.start
+      1
     end
-    
-    # Recalculates the attributes that define a <tt>Week</tt> object.
-    # This was made public for <tt>#duplicate</tt> to work
-    #
-    def refresh
-      set_attributes
+
+    def week_total
+      elapsed_days > 6 ? full_week_working_minutes : part_week_total_minutes
     end
-    
-    # Changes the date range.
-    # This method calls <tt>#refresh</tt> to update the attributes.
-    #
-    # @param [DateTime] start is the new starting date for the <tt>Week</tt>
-    # @param [DateTime] finish is the new finish date for the <tt>Week</tt>    
-    #
-    def adjust(start,finish)
-      @start=DateTime.new(start.year,start.month,start.day)
-      @finish=DateTime.new(finish.year,finish.month,finish.day)
-      refresh
+
+    def total
+      elapsed_days < 8 ? week_total : range_total
     end
-    
-    # Sets a range of minutes in a week to be working or resting.  The parameters supplied
-    # to this method determine exactly what should be changed
-    #
-    # @param [Hash(DAYNAMES)] days identifies the days to be included in the range
-    # @param [DateTime] from_time where the time portion is used to specify the first minute to be set
-    # @param [DateTime] to_time where the time portion is used to specify the last minute to be set
-    # @param [Integer] type where a 1 sets it to working and a 0 to resting
-    #
-    def workpattern(days,from_time,to_time,type)
-      DAYNAMES[days].each {|day| @values[day].workpattern(from_time,to_time,type)}  
-      refresh
+
+    def workpattern(days, from_time, to_time, type)
+      DAYNAMES[days].each do |day|
+        if type == WORK_TYPE
+          @days[day].set_working(from_time, to_time)
+        else
+          @days[day].set_resting(from_time, to_time)
+        end
+      end
     end
-    
-    # Calculates a new date by adding or subtracting a duration in minutes.
-    #
-    # @param [DateTime] start original date
-    # @param [Integer] duration minutes to add or subtract
-    # @param [Boolean] midnight flag used for subtraction that indicates the start date is midnight
-    #
-    def calc(start,duration, midnight=false)
-      return start,duration,false if duration==0
-      return add(start,duration) if duration > 0
-      return subtract(@start,duration, midnight) if (@total==0) && (duration <0)
-      return subtract(start,duration, midnight) if duration <0  
+
+    def duplicate
+      duplicate_week = Week.new(@start, @finish)
+      FIRST_DAY_OF_WEEK.upto(LAST_DAY_OF_WEEK) do |i|
+        duplicate_week.days[i] = @days[i].clone
+	      duplicate_week.days[i].hours_per_day = @days[i].hours_per_day
+	      duplicate_week.days[i].pattern = @days[i].pattern
+      end
+      duplicate_week
     end
-    
-    # Comparison Returns an integer (-1, 0, or +1) if week is less than, equal to, or greater than other_week
-    #
-    # @param [Week] other_week object to compare to
-    # @return [Integer] -1,0 or +1 if week is less than, equal to or greater than other_week
-    def <=>(other_week)
-      if @start < other_week.start
-        return -1
-      elsif @start == other_week.start
-        return 0
-      else
-        return 1
-      end      
+
+    def calc(a_date, a_duration, a_day = SAME_DAY) 
+      if a_duration == 0
+        return a_date, a_duration
+      elsif a_duration > 0	
+        return add(a_date, a_duration)
+      else	
+        subtract(a_date, a_duration, a_day)
+      end	
     end
-    
-    # Returns true if the supplied DateTime is working and false if resting
-    #
-    # @param [DateTime] start DateTime to be tested
-    # @return [Boolean] true if the minute is working otherwise false if it is a resting minute
-    #
-    def working?(start)
-      @values[start.wday].working?(start)
-    end    
-
-    # Returns the difference in minutes between two DateTime values.
-    #
-    # @param [DateTime] start starting DateTime
-    # @param [DateTime] finish ending DateTime
-    # @return [Integer, DateTime] number of minutes and start date for rest of calculation.
-    #
-    def diff(start,finish)
-      start,finish=finish,start if ((start <=> finish))==1
-      # calculate to end of day
-      #
-      if (start.jd==finish.jd) # same day
-        duration, start=@values[start.wday].diff(start,finish)
-      elsif (finish.jd<=@finish.jd) #within this week
-        duration, start=diff_detail(start,finish,finish)
-      else # after this week
-        duration, start=diff_detail(start,finish,@finish)
+
+    def working?(time)
+      @days[time.wday].working?(time.hour, time.min)
+    end
+
+    def resting?(time)
+      @days[time.wday].resting?(time.hour, time.min)
+    end
+
+    def diff(start_date, finish_date)
+      if start_date > finish_date
+        start_date, finish_date = finish_date, start_date
+      end
+
+      if jd(start_date) == jd(finish_date)
+        return diff_in_same_day(start_date, finish_date)
+      else
+        return diff_in_same_weekpattern(start_date, finish_date)
       end
-      return duration, start
     end
     
     private
-    
-    # Recalculates all the attributes for a Week object
-    #
-    def set_attributes
-      @total=0
-      @week_total=0
-      days=(@finish-@start).to_i + 1 #/60/60/24+1 
-      if (7-@start.wday) < days and days < 8
-        @total+=total_hours(@start.wday,@finish.wday)
-        @week_total=@total
-      else
-        @total+=total_hours(@start.wday,6)
-        days -= (7-@start.wday)
-        @total+=total_hours(0,@finish.wday)
-        days-=(@finish.wday+1)
-        @week_total=@total if days==0
-        week_total=total_hours(0,6)
-        @total+=week_total * days / 7
-        @week_total=week_total if days != 0
+
+    def elapsed_days
+      (finish - start).to_i / DAY + 1
+    end
+
+    def full_week_working_minutes
+      minutes_in_day_range FIRST_DAY_OF_WEEK, LAST_DAY_OF_WEEK
+    end
+
+    def part_week_total_minutes
+      start.wday <= finish.wday ? no_rollover_minutes : rollover_minutes
+    end
+
+    def no_rollover_minutes
+      minutes_in_day_range(start.wday, finish.wday)
+    end
+
+    def rollover_minutes
+      minutes_to_first_saturday + minutes_to_finish_day
+    end
+
+    def range_total
+      total_days = elapsed_days
+
+      sum = minutes_to_first_saturday
+      total_days -= (7 - start.wday)
+
+      sum += minutes_to_finish_day
+      total_days -= (finish.wday + 1)
+
+      sum += week_total * total_days / 7
+      sum
+    end
+
+    def minutes_to_first_saturday
+      minutes_in_day_range(start.wday, LAST_DAY_OF_WEEK)
+    end
+
+    def minutes_to_finish_day
+      minutes_in_day_range(FIRST_DAY_OF_WEEK, finish.wday)
+    end
+
+    def minutes_in_day_range(first, last)
+      @days[first..last].inject(0) { |sum, day| sum + day.working_minutes }
+    end
+
+    def add(a_date, a_duration)
+
+      r_date, r_duration = add_to_end_of_day(a_date, a_duration)
+
+      r_date, r_duration = add_to_finish_day r_date, r_duration
+      r_date, r_duration = add_full_weeks r_date, r_duration
+      r_date, r_duration = add_remaining_days r_date, r_duration
+      [r_date, r_duration, false]
+    end
+
+    def add_to_end_of_day(a_date, a_duration)
+      r_date, r_duration, r_day = @days[a_date.wday].calc(a_date,a_duration)
+
+      if r_day == NEXT_DAY
+        r_date = start_of_next_day(r_date)
+
       end
+
+      [r_date, r_duration]
     end
-    
-    # Calculates the total number of minutes between two dates
-    #
-    # @param [DateTime] start is the first date in the range
-    # @param [DateTime] finish is the last date in the range
-    # @return [Integer] total number of minutes between supplied dates
-    #
-    def total_hours(start,finish)
-      total=0
-      start.upto(finish) {|day|
-        total+=@values[day].total
-        }
-      return total
+
+    def add_to_finish_day(a_date, a_duration)
+      while ( a_duration != 0) && (a_date.wday != next_day(self.finish).wday) && (jd(a_date) <= jd(self.finish))
+        a_date, a_duration = add_to_end_of_day(a_date,a_duration)
+      end
+
+      [a_date, a_duration]
     end
-    
-    # Adds a duration in minutes to a date.
-    #
-    # The Boolean returned is always false.
-    #
-    # @param [DateTime] start original date
-    # @param [Integer] duration minutes to add
-    # @return [DateTime, Integer, Boolean] the calculated date, remaining minutes and flag used for subtraction
-    #
-    def add(start,duration)
-      # aim to calculate to the end of the day
-      start,duration = @values[start.wday].calc(start,duration)   
-      return start,duration,false if (duration==0) || (start.jd > @finish.jd) 
-      # aim to calculate to the end of the next week day that is the same as @finish
-      while((duration!=0) && (start.wday!=@finish.next_day.wday) && (start.jd <= @finish.jd))
-        if (duration>@values[start.wday].total)
-          duration = duration - @values[start.wday].total
-          start=start.next_day
-        elsif (duration==@values[start.wday].total)
-          start=after_last_work(start)
-          duration = 0
-        else
-          start,duration = @values[start.wday].calc(start,duration)
-        end
+
+    def add_full_weeks(a_date, a_duration)
+
+      while (a_duration != 0) && (a_duration >= self.week_total) && ((jd(a_date) + (6*86400)) <= jd(self.finish))
+        a_duration -= self.week_total
+        a_date += (7*86400)
       end
-      
-      return start,duration,false if (duration==0) || (start.jd > @finish.jd) 
-      
-      # while duration accomodates full weeks
-      while ((duration!=0) && (duration>=@week_total) && ((start.jd+6) <= @finish.jd))
-        duration=duration - @week_total
-        start=start+7
+
+      [a_date, a_duration]
+    end
+
+    def add_remaining_days(a_date, a_duration)
+      while (a_duration != 0) && (jd(a_date) <= jd(self.finish))
+        a_date, a_duration = add_to_end_of_day(a_date,a_duration)
       end
+      [a_date, a_duration]
+    end
 
-      return start,duration,false if (duration==0) || (start.jd > @finish.jd) 
+    def start_of_next_day(date)
+      next_day(date) - (HOUR * date.hour) - (MINUTE * date.min)
+    end
 
-      # while duration accomodates full days
-      while ((duration!=0) && (start.jd<= @finish.jd))
-        if (duration>@values[start.wday].total)
-          duration = duration - @values[start.wday].total
-          start=start.next_day
-        else
-          start,duration = @values[start.wday].calc(start,duration)
-        end
-      end    
-      return start, duration, false 
+    def subtract_to_start_of_day(a_date, a_duration, a_day)
+      
       
+      a_date, a_duration, a_day = handle_midnight(a_date, a_duration, a_day)
+
+      r_date, r_duration, r_day = @days[a_date.wday].calc(a_date, a_duration)
+
+      [r_date, r_duration, r_day]
+
     end
-    
-    # Subtracts a duration in minutes from a date
-    #
-    # @param [DateTime] start original date
-    # @param [Integer] duration minutes to subtract - always a negative
-    # @param [Boolean] midnight flag indicates the start date is midnight when true
-    # @return [DateTime, Integer, Boolean] the calculated date, remaining number of minutes and 
-    #     true if the time is midnight on the date
-    #
-    def subtract(start,duration,midnight=false)
+
+    def handle_midnight(a_date, a_duration, a_day)
       
-      # Handle subtraction from start of day
-      if midnight
-        start,duration=minute_b4_midnight(start,duration)
-        midnight=false
+      if a_day == PREVIOUS_DAY
+        a_date -= DAY
+        a_date = Time.gm(a_date.year, a_date.month, a_date.day,LAST_TIME_IN_DAY.hour, LAST_TIME_IN_DAY.min)
+
+        if @days[a_date.wday].working?(a_date.hour, a_date.min)
+          a_duration += 1
+        end	
       end
 
-      # aim to calculate to the start of the day
-      start,duration, midnight = @values[start.wday].calc(start,duration)
+      [a_date, a_duration, SAME_DAY]
+    end
 
-      if midnight && (start.jd >= @start.jd)
-        start,duration=minute_b4_midnight(start,duration)
-        return subtract(start,duration, false)
-      elsif midnight
-        return start,duration,midnight
-      elsif  (duration==0) || (start.jd ==@start.jd) 
-        return start,duration, midnight
-      end  
+    def subtract(a_date, a_duration, a_day)
+      a_date, a_duration, a_day = handle_midnight(a_date, a_duration, a_day)
+      a_date, a_duration, a_day = subtract_to_start_of_day(a_date, a_duration, a_day)
+      
+      while (a_duration != 0) && (a_date.wday != start.wday) && (jd(a_date) > jd(start))  
+        a_date, a_duration, a_day = handle_midnight(a_date, a_duration, a_day)
+        a_date, a_duration, a_day = subtract_to_start_of_day(a_date, a_duration, a_day)
+      end
 
-      # aim to calculate to the start of the previous week day that is the same as @start
-      while((duration!=0) && (start.wday!=@start.wday) && (start.jd >= @start.jd))
+      while (a_duration != 0) && (a_duration >= week_total) && ((jd(a_date) - (6 * DAY)) >= jd(start))
+        a_duration += week_total
+        a_date -= 7
+      end
 
-        if (duration.abs>=@values[start.wday].total)
-          duration = duration + @values[start.wday].total
-          start=start.prev_day
-        else
-          start,duration=minute_b4_midnight(start,duration)             
-          start,duration = @values[start.wday].calc(start,duration)
-        end
+      while (a_duration != 0) && (jd(a_date) > jd(start))
+        a_date, a_duration, a_day = subtract_to_start_of_day(a_date,a_duration,a_day)
       end
 
-      return start,duration if (duration==0) || (start.jd ==@start.jd) 
+      [a_date, a_duration, a_day]
+    end
+
+    def diff_in_same_weekpattern(start_date, finish_date)
+      minutes = @days[start_date.wday].working_minutes(start_date, LAST_TIME_IN_DAY)
+      run_date = start_of_next_day(start_date)
+      while (run_date.wday != start.wday) && (jd(run_date) < jd(finish)) && (jd(run_date) != jd(finish_date))      
+        minutes += @days[run_date.wday].working_minutes
+	      run_date += DAY
+      end
 
-      #while duration accomodates full weeks
-      while ((duration!=0) && (duration.abs>=@week_total) && ((start.jd-6) >= @start.jd))
-        duration=duration + @week_total
-        start=start-7
+      while ((jd(run_date) + (7 * DAY)) < jd(finish_date))  && ((jd(run_date) + (7 * DAY)) < jd(finish))
+        minutes += week_total
+	      run_date += (7 * DAY)
       end
 
-      return start,duration if (duration==0) || (start.jd ==@start.jd) 
+      while (jd(run_date) < jd(finish_date)) && (jd(run_date) <= jd(finish))
+        minutes += @days[run_date.wday].working_minutes
+	      run_date += DAY
+      end
 
-      #while duration accomodates full days
-      while ((duration!=0) && (start.jd>= @start.jd))    
-        if (duration.abs>=@values[start.wday].total)
-          duration = duration + @values[start.wday].total
-          start=start.prev_day
-        else
-          start,duration=minute_b4_midnight(start,duration)       
-          start,duration = @values[start.wday].calc(start,duration)
+      if run_date != finish_date
+        
+        if (jd(run_date) == jd(finish_date)) && (jd(run_date) <= jd(finish))
+          minutes += @days[run_date.wday].working_minutes(run_date, finish_date - MINUTE)
+	        run_date = finish_date
+        elsif (jd(run_date) <= jd(finish)) 
+          minutes += @days[run_date.wday].working_minutes
+	        run_date += DAY
         end
-      end    
-              
-      return start, duration , midnight
-      
+      end
+
+      [minutes, run_date]
+
     end
-    
-    # Supports calculating from midnight by updating the given duration depending on whether the
-    # last minute in the day is resting or working.  It then sets the time to this minute.
-    #
-    # @param [DateTime] start is the date whose midnight is to be used as the start date
-    # @param [Integer] duration is the number of minutes to subtract
-    # @return [DateTime, Integer] the date with a time of 23:59 and remaining duration
-    #     adjusted according to whether 23:59 is resting or not
-    #
-    def minute_b4_midnight(start,duration)
-      start -= start.hour * HOUR
-      start -= start.min * MINUTE
-      duration += @values[start.wday].minutes(23,59,23,59)
-      start = start.next_day - MINUTE
-      return start,duration
-    end  
-    
-    # Calculates the date and time after the last working minute of the current date
-    #
-    # @param [DateTime] start is the current date
-    # @return [DateTime] the new date
-    #
-    def after_last_work(start)
-      if @values[start.wday].last_hour.nil?
-        return start.next_day
-      else  
-        start = start + HOUR * (@values[start.wday].last_hour - start.hour)
-        start = start + MINUTE * (@values[start.wday].last_min - start.min + 1)
-        return start
-      end  
+
+    def diff_in_same_day(start_date, finish_date)
+      minutes = @days[start_date.wday].working_minutes(start_date, finish_date - MINUTE)
+      [minutes, finish_date]
     end
-    
-    # Calculates the difference between two dates that exist in this Week object.
-    #
-    # @param [DateTime] start first date 
-    # @param [DateTime] finish last date
-    # @param [DateTime] finish_on the range to be used in this Week object.  
-    # @return [DateTime, Integer] new date for rest of calculation and total number of minutes calculated thus far.
-    #
-    def diff_detail(start,finish,finish_on)
-      duration, start=@values[start.wday].diff(start,finish)
-      return duration,start if start > finish_on
-      #rest of week to finish day
-      while (start.wday<finish.wday) do
-        duration+=@values[start.wday].total
-        start=start.next_day
-      end
-      #weeks
-      while (start.jd+7<finish_on.jd) do
-        duration+=@week_total
-        start+=7
-      end
-      #days
-      while (start.jd < finish_on.jd) do
-        duration+=@values[start.wday].total
-        start=start.next_day
-      end
-      #day
-      day_duration, start=@values[start.wday].diff(start,finish)
-      duration+=day_duration
-      return duration, start
+
+    def next_day(time)
+      time + DAY
+    end
+
+    def prev_day(time)
+      time - DAY
+    end
+
+    def jd(time)
+      Time.gm(time.year, time.month, time.day)
     end
-    
   end
 end