workpattern 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 692be81b7ee90c4c270d23fb3262b4d277013fba
-  data.tar.gz: 0f1f19a559c02903ffd53ecaf044824b1bdc5e12
+  metadata.gz: 0a052375d1d21fb15b3ec113efeafa9f385613b5
+  data.tar.gz: e5187dbe1b5c5b497553d7d665cb785b02824fdb
 SHA512:
-  metadata.gz: 17e8e271b4de96dddcad27e173358afcd776d3206c07c634fbfa04173320b80c4c74d0cb0f5b5d0bb2f261de14482621c647fc500ca71e57bccf2a686c233f0d
-  data.tar.gz: 24b6b66dff288abb979cff993370e1ee1f9c044e0ff302c0f515ebbcdf57a4e8696dd6e77f565c9b755e3850a9285d64d87bf4db8b75512f01fb81123f374e7b
+  metadata.gz: 296401d1f2ff0d938fd934050373f776d46cfaf199ae24c3951769d65bad804a511c23c032968179a5fb6e979137148a72dba8a471a36cfda45db5a8cde97aae
+  data.tar.gz: 6ae2c003e83b250e1a21efe10ad7e979e2bd93df64887791d14769f12a0ce8a273e985be30fb1633915e947e921e7fecd94de0202706bd2e598938f48d616232

data/CHANGELOG

@@ -1,3 +1,9 @@
+## Workpattern v0.3.6 (Mar 25, 2014)  ##
+
+* total minutes of week is zero when short week starting after Sunday (#17) * Barrie Callender *
+* Subtracting starting from top of the hour and last minute is non working (#18) * Barrie Callender *
+* Refactorings intended to make the code easier to read and easier to change - still more to do * Barrie Callender *
+
 ## Workpattern v0.3.5 (Sep 30, 2013)  ##
 
 * License missing from gemspec (#16) * Barrie Callender *

data/Rakefile

@@ -9,3 +9,12 @@ Rake::TestTask.new do |test|
   test.test_files = Dir["test/test_*.rb"]
   test.verbose = true
 end
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'workpattern' # You know what to do.
+  ARGV.clear
+  IRB.start
+end
+

data/lib/workpattern.rb

@@ -88,7 +88,7 @@ module Workpattern
   # @param [Integer] base Workpattern starts on the 1st January of this year.
   # @param [Integer] span Workpattern spans this number of years ending on 31st December.
   # @return [Workpattern]
-  #
+  # @raise [NameError] when trying to create a Workpattern with a name that already exists
   # @since 0.2.0
   #
   def self.new(name=DEFAULT_WORKPATTERN_NAME, base=DEFAULT_BASE_YEAR, span=DEFAULT_SPAN)

data/lib/workpattern/clock.rb

@@ -29,11 +29,8 @@ module Workpattern
     # @param [Integer] min number of minutes
     #
     def initialize(hour=0,min=0)
-      @hour=hour
-      @min=min
-      total_minutes = minutes
-      @hour=total_minutes.div(60)
-      @min=total_minutes % 60
+      @hour = total_minutes(hour,min).div(60)
+      @min = total_minutes(hour,min) % 60
     end
     
     # Returns the total number of minutes
@@ -41,7 +38,7 @@ module Workpattern
     # @return [Integer] total minutes represented by the Clock object
     #
     def minutes
-      return (@hour*60)+@min
+      return total_minutes(@hour,@min)
     end
     
     # Returns the hour of the clock (0-23)
@@ -74,5 +71,12 @@ module Workpattern
     def to_s      
       hour.to_s.concat(':').concat(min.to_s).concat(' ').concat(minutes.to_s)
     end
+    
+    private
+
+    def total_minutes(hours, mins)
+      return (hours*60) + mins
+    end
+
   end
 end

data/lib/workpattern/day.rb

@@ -34,8 +34,6 @@ module Workpattern
       hour=WORKING_HOUR if type==1
       hour=RESTING_HOUR if type==0
       @values=Array.new(@hours) {|index| hour }
-
-      set_attributes
     end
     
     # Creates a duplicate of the current <tt>Day</tt> instance.
@@ -44,25 +42,26 @@ module Workpattern
     #
     def duplicate
       duplicate_day = Day.new()
-      duplicate_values=Array.new(@values.size)
-      @values.each_index {|index|
-        duplicate_values[index]=@values[index]
+      duplicate_values=Array.new(self.values.size)
+      self.values.each_index {|index|
+        duplicate_values[index]=self.values[index]
         }
       duplicate_day.values=duplicate_values
-      duplicate_day.hours = @hours
-      duplicate_day.first_hour=@first_hour
-      duplicate_day.first_min=@first_min
-      duplicate_day.last_hour=@last_hour
-      duplicate_day.last_min=@last_min
-      duplicate_day.total = @total
+      duplicate_day.hours = self.hours
+      duplicate_day.first_hour=self.first_hour
+      duplicate_day.first_min=self.first_min
+      duplicate_day.last_hour=self.last_hour
+      duplicate_day.last_min=self.last_min
+      duplicate_day.total = self.total
       duplicate_day.refresh
       return duplicate_day
     end
     
     # Recalculates characteristics for this day
+    # no longer required as calculating individually is faster
     #
     def refresh
-      set_attributes
+      
     end
     
     # Sets all minutes in a date range to be working or resting.
@@ -74,19 +73,19 @@ module Workpattern
     def workpattern(start_time,finish_time,type)
     
       if start_time.hour==finish_time.hour
-        @values[start_time.hour]=@values[start_time.hour].wp_workpattern(start_time.min,finish_time.min,type)
+        self.values[start_time.hour]=self.values[start_time.hour].wp_workpattern(start_time.min,finish_time.min,type)
       else
         test_hour=start_time.hour
-        @values[test_hour]=@values[test_hour].wp_workpattern(start_time.min,59,type)
+        self.values[test_hour]=self.values[test_hour].wp_workpattern(start_time.min,59,type)
         
         while ((test_hour+1)<finish_time.hour)
           test_hour+=1
-          @values[test_hour]=@values[test_hour].wp_workpattern(0,59,type)     
+          self.values[test_hour]=self.values[test_hour].wp_workpattern(0,59,type)     
         end
         
-        @values[finish_time.hour]=@values[finish_time.hour].wp_workpattern(0,finish_time.min,type)
+        self.values[finish_time.hour]=self.values[finish_time.hour].wp_workpattern(0,finish_time.min,type)
       end
-      set_attributes
+      
     end
     
     # Calculates the result of adding <tt>duration</tt> to
@@ -166,38 +165,58 @@ module Workpattern
       end
       
       if (start_hour==finish_hour)     
-        retval=@values[start_hour].wp_minutes(start_min,finish_min)
+        retval=self.values[start_hour].wp_minutes(start_min,finish_min)
       else
     
-        retval=@values[start_hour].wp_minutes(start_min,59)
+        retval=self.values[start_hour].wp_minutes(start_min,59)
         while (start_hour+1<finish_hour)        
-          retval+=@values[start_hour+1].wp_total     
+          retval+=self.values[start_hour+1].wp_total     
           start_hour+=1
         end
-        retval+=@values[finish_hour].wp_minutes(0,finish_min)
+        retval+=self.values[finish_hour].wp_minutes(0,finish_min)
       end
         
       return retval
     end
 
-    private
     
-    # Calculates the attributes that describe the day.  Called after changes.
-    #
-    def set_attributes
-      @first_hour=nil
-      @first_min=nil
-      @last_hour=nil
-      @last_min=nil
-      @total=0
-      0.upto(@hours-1) {|index|
-        @first_hour=index if ((@first_hour.nil?) && (@values[index].wp_total!=0))
-        @first_min=@values[index].wp_first if ((@first_min.nil?) && (!@values[index].wp_first.nil?))        
-        @last_hour=index if (@values[index].wp_total!=0)
-        @last_min=@values[index].wp_last if (@values[index].wp_total!=0)
-        @total+=@values[index].wp_total
-      }
+    def first_hour
+      0.upto(self.hours-1) do |index|
+        return index if self.values[index].wp_total!=0
+      end
+      return nil
+    end
+    
+    def first_min
+      0.upto(self.hours-1) do |index|
+       return self.values[index].wp_first if !self.values[index].wp_first.nil?
+      end
+      return nil
+    end
+    
+    def last_hour
+      (self.hours-1).downto(0) do |index|
+        return index if self.values[index].wp_total!=0
+      end
+      return nil
+    end
+
+    def last_min
+      (self.hours-1).downto(0) do |index|
+        return self.values[index].wp_last if self.values[index].wp_total!=0
+      end
+      return nil
     end
+
+    def total
+      total_minutes=0
+      0.upto(self.hours-1) do |index|
+        total_minutes+=self.values[index].wp_total
+      end
+      return total_minutes
+    end
+    private
+    
     
     # Returns the first working minute as a <tt>DateTime</tt> or <tt>oo:oo</tt>
     # when there is no working minutes in the day.  Used by the <tt>#subtract</tt> method
@@ -206,11 +225,11 @@ module Workpattern
     # @return [DateTime] the first working time of the day
     #
     def first_working_minute(time)
-      if @first_hour.nil?
+      if self.first_hour.nil?
         return time - (HOUR*time.hour) - (MINUTE*time.min)
       else  
-        time = time - HOUR * (time.hour - @first_hour)
-        time = time - MINUTE * (time.min - @first_min )
+        time = time - HOUR * (time.hour - self.first_hour)
+        time = time - MINUTE * (time.min - self.first_min )
         return time
       end  
     end
@@ -231,8 +250,8 @@ module Workpattern
         else
           return time.prev_day, duration,true  
         end
-      elsif (time.hour==@first_hour && time.min==@first_min)
-        time=time-(HOUR*@first_hour) - (MINUTE*@first_min)
+      elsif (time.hour==self.first_hour && time.min==self.first_min)
+        time=time-(HOUR*self.first_hour) - (MINUTE*self.first_min)
         return time.prev_day, duration, true  
       elsif (time.min>0)
         available_minutes=minutes(0,0,time.hour,time.min-1) 
@@ -247,17 +266,17 @@ module Workpattern
         duration=0
         time=first_working_minute(time)  
       else
-        minutes_this_hour=@values[time.hour].wp_minutes(0,time.min-1)
+        minutes_this_hour=self.values[time.hour].wp_minutes(0,time.min-1)
         this_hour=time.hour
         until (duration==0)
           if (minutes_this_hour<duration.abs)     
             duration+=minutes_this_hour
             time = time - (MINUTE*time.min) - HOUR
             this_hour-=1
-            minutes_this_hour=@values[this_hour].wp_total
+            minutes_this_hour=self.values[this_hour].wp_total
           else
             next_hour=(time.min==0)
-            time,duration=@values[this_hour].wp_calc(time,duration, next_hour)
+            time,duration=self.values[this_hour].wp_calc(time,duration, next_hour)
           end
         end
       end  
@@ -273,15 +292,15 @@ module Workpattern
     # @return [DateTime,Integer] Calculated time along with any remaining duration
     #
     def add(time,duration)
-      available_minutes=minutes(time.hour,time.min,@hours-1,59)   
+      available_minutes=minutes(time.hour,time.min,self.hours-1,59)   
       if ((duration-available_minutes)>0) # not enough minutes left in the day      
 
         result_date= time.next_day - (HOUR*time.hour) - (MINUTE*time.min)
         duration = duration - available_minutes      
       else
-        total=@values[time.hour].wp_minutes(time.min,59)
+        total=self.values[time.hour].wp_minutes(time.min,59)
         if (total==duration) # this hour satisfies              
-          result_date=time - (MINUTE*time.min) + (MINUTE*@values[time.hour].wp_last) + MINUTE                   
+          result_date=time - (MINUTE*time.min) + (MINUTE*self.values[time.hour].wp_last) + MINUTE                   
           duration = 0
         else  
           result_date = time
@@ -290,9 +309,9 @@ module Workpattern
               duration-=total
               result_date=result_date + HOUR - (MINUTE*result_date.min)
             else
-              result_date,duration=@values[result_date.hour].wp_calc(result_date,duration)     
+              result_date,duration=self.values[result_date.hour].wp_calc(result_date,duration)     
             end
-            total=@values[result_date.hour].wp_total
+            total=self.values[result_date.hour].wp_total
           end
         end
       end    
@@ -317,7 +336,7 @@ module Workpattern
     # @return [Integer] number of remaining working minutes
     #
     def minutes_left_in_hour(start)
-      return @values[start.hour].wp_diff(start.min,60)
+      return self.values[start.hour].wp_diff(start.min,60)
     end
     
   end

data/lib/workpattern/hour.rb

@@ -155,32 +155,28 @@ module Workpattern
     #
     def wp_subtract(time,duration,next_hour)
       if next_hour
-        if wp_working?(59)
-          duration+=1
-          time=time+(MINUTE*59)
-          return wp_calc(time,duration)
-        end  
-        return time, duration if wp_total==0
+        duration += 1 if wp_working?(59)
+        time = time + (MINUTE * 59)
+        return wp_calc(time,duration)
       else  
         start=time.min  
-        available_minutes=0
-        available_minutes = wp_minutes(0,start-1) if start > 0
+        start > 0 ? available_minutes = wp_minutes(0,start-1) : available_minutes=0
       end
       
-      if not_enough_minutes duration,available_minutes
-        result_date = time - (MINUTE*start)
-        result_remainder = duration+available_minutes
-      elsif duration.abs==available_minutes
-        result_date = time - (MINUTE*(start-wp_first))
+      if not_enough_minutes duration, available_minutes
+        result_date = time - (MINUTE * start)
+        result_remainder = duration + available_minutes
+      elsif duration.abs == available_minutes
+        result_date = time - (MINUTE * (start - wp_first))
         result_remainder = 0
       else     
         step = start + duration
-        duration+=wp_minutes(step,start-1)
-        until (duration==0)
-          step-=1
-          duration+=wp_minutes(step,step)
+        duration += wp_minutes(step, start - 1)
+        until (duration == 0)
+          step -= 1
+          duration += wp_minutes(step,step)
         end
-        result_date = time - (MINUTE * (start-step))
+        result_date = time - (MINUTE * (start - step))
         result_remainder = 0
       end  
       return result_date, result_remainder  
@@ -188,7 +184,8 @@ module Workpattern
     end
 
     private
- 
+    
+    
     def not_enough_minutes(duration,available_minutes)
       return true if (duration.abs-available_minutes)>0
       return false

data/lib/workpattern/version.rb

@@ -1,5 +1,5 @@
 module Workpattern
   # Version Number for Workpattern gem
   # @since 0.0.1
-  VERSION = '0.3.5'
+  VERSION = '0.3.6'
 end  

data/lib/workpattern/week.rb

@@ -44,17 +44,17 @@ module Workpattern
     # @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=Week.new(self.start,self.finish)
+      duplicate_values=Array.new(self.values.size)
+      self.values.each_index {|index|
+        duplicate_values[index]=self.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.days=self.days
+      duplicate_week.start=self.start
+      duplicate_week.finish=self.finish
+      duplicate_week.week_total=self.week_total
+      duplicate_week.total=self.total
       duplicate_week.refresh
       return duplicate_week
     end
@@ -72,9 +72,9 @@ module Workpattern
     # @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)
+    def adjust(start_date,finish_date)
+      self.start=DateTime.new(start_date.year,start_date.month,start_date.day)
+      self.finish=DateTime.new(finish_date.year,finish_date.month,finish_date.day)
       refresh
     end
     
@@ -87,7 +87,7 @@ module Workpattern
     # @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)}  
+      DAYNAMES[days].each {|day| self.values[day].workpattern(from_time,to_time,type)}  
       refresh
     end
     
@@ -97,11 +97,11 @@ module Workpattern
     # @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 calc(start_date,duration, midnight=false)
+      return start_date,duration,false if duration==0
+      return add(start_date,duration) if duration > 0
+      return subtract(self.start,duration, midnight) if (self.total==0) && (duration <0)
+      return subtract(start_date,duration, midnight) if duration <0  
     end
     
     # Comparison Returns an integer (-1, 0, or +1) if week is less than, equal to, or greater than other_week
@@ -109,9 +109,9 @@ module Workpattern
     # @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
+      if self.start < other_week.start
         return -1
-      elsif @start == other_week.start
+      elsif self.start == other_week.start
         return 0
       else
         return 1
@@ -123,8 +123,8 @@ module Workpattern
     # @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)
+    def working?(start_date)
+      self.values[start_date.wday].working?(start_date)
     end    
 
     # Returns the difference in minutes between two DateTime values.
@@ -133,41 +133,50 @@ module Workpattern
     # @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
+    def diff(start_date,finish_date)
+      start_date,finish_date=finish_date,start_date if ((start_date <=> finish_date))==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)
+      if (start_date.jd==finish_date.jd) # same day
+        duration, start_date=self.values[start_date.wday].diff(start_date,finish_date)
+      elsif (finish_date.jd<=self.finish.jd) #within this week
+        duration, start_date=diff_detail(start_date,finish_date,finish_date)
       else # after this week
-        duration, start=diff_detail(start,finish,@finish)
+        duration, start_date=diff_detail(start_date,finish_date,self.finish)
       end
-      return duration, start
+      return duration, start_date
     end
-    
+   
+    def week_total
+      span_in_days > 6 ? self.values.inject(0) {|sum,x| sum + x.total } : day_indexes.inject(0) {|sum,x| sum + self.values[x].total}
+    end 
+
+    def total
+      total_days = span_in_days
+      return week_total if total_days < 8
+      sum = total_hours(self.start.wday,6)
+      total_days -= (7-self.start.wday)
+      sum += total_hours(0,self.finish.wday)
+      total_days-=(self.finish.wday+1)
+      sum += week_total * total_days / 7
+      return sum
+    end
+
     private
+
+    def day_indexes
+      self.start.wday > self.finish.wday ? self.start.wday.upto(6).to_a.concat(0.upto(self.finish.wday).to_a) : self.start.wday.upto(self.finish.wday).to_a
+    end
+
     
+    def span_in_days
+      (self.finish-self.start).to_i + 1
+    end
+
     # 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
-      end
+
     end
     
     # Calculates the total number of minutes between two dates
@@ -179,7 +188,7 @@ module Workpattern
     def total_hours(start,finish)
       total=0
       start.upto(finish) {|day|
-        total+=@values[day].total
+        total+=self.values[day].total
         }
       return total
     end
@@ -194,38 +203,38 @@ module Workpattern
     #
     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) 
+      start,duration = self.values[start.wday].calc(start,duration)   
+      return start,duration,false if (duration==0) || (start.jd > self.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
+      while((duration!=0) && (start.wday!=self.finish.next_day.wday) && (start.jd <= self.finish.jd))
+        if (duration>self.values[start.wday].total)
+          duration = duration - self.values[start.wday].total
           start=start.next_day
-        elsif (duration==@values[start.wday].total)
+        elsif (duration==self.values[start.wday].total)
           start=after_last_work(start)
           duration = 0
         else
-          start,duration = @values[start.wday].calc(start,duration)
+          start,duration = self.values[start.wday].calc(start,duration)
         end
       end
       
-      return start,duration,false if (duration==0) || (start.jd > @finish.jd) 
+      return start,duration,false if (duration==0) || (start.jd > self.finish.jd) 
       
       # while duration accomodates full weeks
-      while ((duration!=0) && (duration>=@week_total) && ((start.jd+6) <= @finish.jd))
-        duration=duration - @week_total
+      while ((duration!=0) && (duration>=self.week_total) && ((start.jd+6) <= self.finish.jd))
+        duration=duration - self.week_total
         start=start+7
       end
 
-      return start,duration,false if (duration==0) || (start.jd > @finish.jd) 
+      return start,duration,false if (duration==0) || (start.jd > self.finish.jd) 
 
       # while duration accomodates full days
-      while ((duration!=0) && (start.jd<= @finish.jd))
-        if (duration>@values[start.wday].total)
-          duration = duration - @values[start.wday].total
+      while ((duration!=0) && (start.jd<= self.finish.jd))
+        if (duration>self.values[start.wday].total)
+          duration = duration - self.values[start.wday].total
           start=start.next_day
         else
-          start,duration = @values[start.wday].calc(start,duration)
+          start,duration = self.values[start.wday].calc(start,duration)
         end
       end    
       return start, duration, false 
@@ -249,47 +258,47 @@ module Workpattern
       end
 
       # aim to calculate to the start of the day
-      start,duration, midnight = @values[start.wday].calc(start,duration)
+      start,duration, midnight = self.values[start.wday].calc(start,duration)
 
-      if midnight && (start.jd >= @start.jd)
+      if midnight && (start.jd >= self.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) 
+      elsif  (duration==0) || (start.jd ==self.start.jd) 
         return start,duration, midnight
       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((duration!=0) && (start.wday!=self.start.wday) && (start.jd >= self.start.jd))
 
-        if (duration.abs>=@values[start.wday].total)
-          duration = duration + @values[start.wday].total
+        if (duration.abs>=self.values[start.wday].total)
+          duration = duration + self.values[start.wday].total
           start=start.prev_day
         else
           start,duration=minute_b4_midnight(start,duration)             
-          start,duration = @values[start.wday].calc(start,duration)
+          start,duration = self.values[start.wday].calc(start,duration)
         end
       end
 
-      return start,duration if (duration==0) || (start.jd ==@start.jd) 
+      return start,duration if (duration==0) || (start.jd ==self.start.jd) 
 
       #while duration accomodates full weeks
-      while ((duration!=0) && (duration.abs>=@week_total) && ((start.jd-6) >= @start.jd))
-        duration=duration + @week_total
+      while ((duration!=0) && (duration.abs>=self.week_total) && ((start.jd-6) >= self.start.jd))
+        duration=duration + self.week_total
         start=start-7
       end
 
-      return start,duration if (duration==0) || (start.jd ==@start.jd) 
+      return start,duration if (duration==0) || (start.jd ==self.start.jd) 
 
       #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
+      while ((duration!=0) && (start.jd>= self.start.jd))    
+        if (duration.abs>=self.values[start.wday].total)
+          duration = duration + self.values[start.wday].total
           start=start.prev_day
         else
           start,duration=minute_b4_midnight(start,duration)       
-          start,duration = @values[start.wday].calc(start,duration)
+          start,duration = self.values[start.wday].calc(start,duration)
         end
       end    
               
@@ -308,7 +317,7 @@ module Workpattern
     def minute_b4_midnight(start,duration)
       start -= start.hour * HOUR
       start -= start.min * MINUTE
-      duration += @values[start.wday].minutes(23,59,23,59)
+      duration += self.values[start.wday].minutes(23,59,23,59)
       start = start.next_day - MINUTE
       return start,duration
     end  
@@ -318,13 +327,13 @@ module Workpattern
     # @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
+    def after_last_work(start_date)
+      if self.values[start_date.wday].last_hour.nil?
+        return start_date.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
+        start_date = start_date + HOUR * (self.values[start_date.wday].last_hour - start_date.hour)
+        start_date = start_date + MINUTE * (self.values[start_date.wday].last_min - start_date.min + 1)
+        return start_date
       end  
     end
     
@@ -335,29 +344,42 @@ module Workpattern
     # @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
+    def diff_detail(start_date,finish_date,finish_on_date)
+      
+      duration, start_date=diff_in_day(start_date, finish_date)
+      return duration,start_date if start_date > finish_on_date
+      
       #rest of week to finish day
-      while (start.wday<finish.wday) do
-        duration+=@values[start.wday].total
-        start=start.next_day
+      while (start_date.wday<finish_date.wday) do
+        duration+=day_total(start_date)
+        start_date=start_date.next_day
       end
+
       #weeks
-      while (start.jd+7<finish_on.jd) do
-        duration+=@week_total
-        start+=7
+      while (start_date.jd+7<finish_on_date.jd) do
+        duration+=self.week_total
+        start_date+=7
       end
+
       #days
-      while (start.jd < finish_on.jd) do
-        duration+=@values[start.wday].total
-        start=start.next_day
+      while (start_date.jd < finish_on_date.jd) do
+        duration+=day_total(start_date)
+        start_date=start_date.next_day
       end
-      #day
-      day_duration, start=@values[start.wday].diff(start,finish)
+
+      #day      
+      day_duration, start_date=diff_in_day(start_date, finish_date)
       duration+=day_duration
-      return duration, start
+      return duration, start_date
     end
     
+    def diff_in_day(start_date,finish_date)
+      return self.values[start_date.wday].diff(start_date,finish_date)
+    end
+
+    def day_total(start_date)
+      return self.values[start_date.wday].total
+    end
+
   end
 end