workpattern 0.2.0

data/lib/workpattern/week.rb

@@ -0,0 +1,261 @@
+module Workpattern
+  
+  # Represents working and resting times of each day in a week from one date to another.
+  # The two dates could be the same day or they could be several weeks or years apart.
+  #
+  class Week
+    
+    attr_accessor :values, :days, :start, :finish, :week_total, :total
+    
+    # :call-seq: new(start,finish,type) => Week
+    #  
+    #
+    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
+    end
+    
+    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
+    end
+    
+    def refresh
+      set_attributes
+    end
+    
+    def adjust(start,finish)
+      @start=DateTime.new(start.year,start.month,start.day)
+      @finish=DateTime.new(finish.year,finish.month,finish.day)
+      refresh
+    end
+    
+    def workpattern(days,from_time,to_time,type)
+      DAYNAMES[days].each {|day| @values[day].workpattern(from_time,to_time,type)}  
+      refresh
+    end
+    
+    def calc(start,duration, midnight=false)
+      return start,duration if duration==0
+      return add(start,duration) if duration > 0
+      return subtract(start,duration, midnight) if duration <0  
+    end
+    
+    def <=>(obj)
+      if @start < obj.start
+        return -1
+      elsif @start == obj.start
+        return 0
+      else
+        return 1
+      end      
+    end
+    
+    # :call-seq: working?(start) => Boolean
+    # Returns true if the given minute is working and false if it isn't
+    #
+    def working?(start)
+      @values[start.wday].working?(start)
+    end    
+
+    
+    # :call-seq: diff(start,finish) => Duration, Date
+    # Returns the difference in minutes between two times.
+    #
+    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)
+      end
+      return duration, start
+    end
+    
+    private
+    
+    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
+    
+    def total_hours(start,finish)
+      total=0
+      start.upto(finish) {|day|
+        total+=@values[day].total
+        }
+      return total
+    end
+    
+    def add(start,duration)
+      # aim to calculate to the end of the day
+      start,duration = @values[start.wday].calc(start,duration)
+      return start,duration 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
+      end
+      
+      return start,duration 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
+      end
+
+      return start,duration if (duration==0) || (start.jd > @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
+          start=start.next_day
+        else
+          start,duration = @values[start.wday].calc(start,duration)
+        end
+      end    
+      return start, duration 
+      
+    end
+
+    def subtract(start,duration,midnight=false)
+      
+      # Handle subtraction from start of day
+      if midnight
+        start,duration=minute_b4_midnight(start,duration)
+        midnight=false
+      end
+
+      # aim to calculate to the start of the day
+      start,duration, midnight = @values[start.wday].calc(start,duration)
+
+      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  
+
+      # 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))
+
+        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
+      end
+
+      return start,duration if (duration==0) || (start.jd ==@start.jd) 
+
+      #while duration accomodates full weeks
+      while ((duration!=0) && (duration.abs>=@week_total) && ((start.jd-6) >= @start.jd))
+        duration=duration + @week_total
+        start=start-7
+      end
+
+      return start,duration if (duration==0) || (start.jd ==@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
+          start=start.prev_day
+        else
+          start,duration=minute_b4_midnight(start,duration)       
+          start,duration = @values[start.wday].calc(start,duration)
+        end
+      end    
+              
+      return start, duration , midnight
+      
+    end
+    
+    def minute_b4_midnight(start,duration)
+      duration += @values[start.wday].minutes(23,59,23,59)
+      start = start.next_day - MINUTE
+      return start,duration
+    end  
+    
+    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  
+    end
+    
+    def diff_detail(start,finish,finish_on)
+      duration, start=@values[start.wday].diff(start,finish)
+      #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
+    end
+    
+  end
+end

data/lib/workpattern/workpattern.rb

@@ -0,0 +1,236 @@
+
+
+module Workpattern
+  require 'set'
+  
+  # Represents the working and resting periods across a number of whole years.  The #base year
+  # is the first year and the #span is the number of years including that year that is covered.
+  # The #Workpattern is given a unique name so it can be easily identified amongst other Workpatterns.
+  #
+  class Workpattern
+    
+    # Holds collection of <tt>Workpattern</tt> objects  
+    @@workpatterns = Hash.new()
+    attr_accessor :name, :base, :span, :from, :to, :weeks
+    
+    def initialize(name=DEFAULT_NAME,base_year=DEFAULT_BASE_YEAR,span=DEFAULT_SPAN)
+
+      raise(NameError, "Workpattern '#{name}' already exists and can't be created again") if @@workpatterns.key?(name) 
+        
+      if span < 0
+        offset = span.abs - 1
+      else
+        offset = 0
+      end
+      
+      @name = name
+      @base = base_year
+      @span = span
+      @from = DateTime.new(base_year.abs - offset)
+      @to = DateTime.new(@from.year + span.abs - 1,12,31,23,59)
+      @weeks = SortedSet.new
+      @weeks << Week.new(@from,@to,1)
+     
+      
+      @@workpatterns[name]=self
+    end
+    
+    def self.clear
+      @@workpatterns.clear
+    end
+    
+    def self.to_a
+      @@workpatterns.to_a
+    end
+    
+    def self.get(name)
+      return @@workpatterns[name] if @@workpatterns.key?(name) 
+      raise(NameError, "Workpattern '#{name}' doesn't exist so can't be retrieved")
+    end
+    
+    def self.delete(name)
+      if @@workpatterns.delete(name).nil?
+        return false
+      else
+        return true
+      end        
+    end
+    
+    # Sets a work or resting pattern in the _Workpattern_.
+    #
+    # Can also use <tt>resting</tt> and <tt>working</tt> methods leaving off the 
+    # :work_type
+    #
+    # === Parameters
+    #
+    # * <tt>:start</tt> - The first date to apply the pattern.  Defaults
+    #   to the _Workpattern_ <tt>start</tt>.
+    # * <tt>:finish</tt> - The last date to apply the pattern.  Defaults to
+    #   the _Workpattern_ <tt>finish</tt>.
+    # * <tt>:days</tt> - The specific day or days the pattern will apply to. This
+    #   references _Workpattern::DAYNAMES_.  It defailts to <tt>:all</tt> which is 
+    #   everyday. Valid values are <tt>:sun, :mon, :tue, :wed, :thu, :fri, :sat, 
+    #   :weekend, :weekday</tt> and <tt>:all</tt>
+    # * <tt>:start_time</tt> - The first time in the selected days to apply the pattern.
+    #   Must implement #hour and #min to get the Hours and Minutes for the time.  It will default to 
+    #   the first time in the day <tt>00:00</tt>.
+    # * <tt>:finish_time</tt> - The last time in the selected days to apply the pattern.
+    #   Must implement #hour and #min to get the Hours and Minutes for the time.  It will default to
+    #   to the last time in the day <tt>23:59</tt>.
+    # * <tt>:work_type</tt> - type of pattern is either working (1 or <tt>Workpattern::WORK</tt>) or
+    #   resting (0 or <tt>Workpattern::REST</tt>).  Alternatively make use of the <tt>working</tt>
+    #   or <tt>resting</tt> methods that will set this value for you
+    #
+    def workpattern(args={})
+      
+      #
+      upd_start = args[:start] || @from
+      upd_start = dmy_date(upd_start)
+      args[:start] = upd_start
+      
+      upd_finish = args[:finish] || @to
+      upd_finish = dmy_date(upd_finish)
+      args[:finish] = upd_finish
+      
+      #args[:days]  = args[:days] || :all
+      days= args[:days] || :all
+      from_time = args[:from_time] || FIRST_TIME_IN_DAY
+      from_time = hhmn_date(from_time)
+      #args[:from_time] = upd_from_time
+      
+      to_time = args[:to_time] || LAST_TIME_IN_DAY
+      to_time = hhmn_date(to_time)
+      #args[:to_time] = upd_to_time
+      
+      args[:work_type] = args[:work_type] || WORK
+      type= args[:work_type] || WORK
+      
+      while (upd_start <= upd_finish)
+
+        current_wp=find_weekpattern(upd_start)
+        if (current_wp.start == upd_start)
+          if (current_wp.finish > upd_finish)
+            clone_wp=current_wp.duplicate
+            current_wp.adjust(upd_finish+1,current_wp.finish)
+            clone_wp.adjust(upd_start,upd_finish)
+            clone_wp.workpattern(days,from_time,to_time,type)
+            @weeks<< clone_wp
+            upd_start=upd_finish+1
+          else # (current_wp.finish == upd_finish)
+            current_wp.workpattern(days,from_time,to_time,type)
+            upd_start=current_wp.finish + 1 
+          end
+        else
+          clone_wp=current_wp.duplicate
+          current_wp.adjust(current_wp.start,upd_start-1)
+          clone_wp.adjust(upd_start,clone_wp.finish)          
+          if (clone_wp.finish <= upd_finish)
+            clone_wp.workpattern(days,from_time,to_time,type)
+            @weeks<< clone_wp
+            upd_start=clone_wp.finish+1
+          else
+            after_wp=clone_wp.duplicate
+            after_wp.adjust(upd_finish+1,after_wp.finish)
+            @weeks<< after_wp
+            clone_wp.adjust(upd_start,upd_finish)
+            clone_wp.workpattern(days,from_time,to_time,type)
+            @weeks<< clone_wp
+            upd_start=clone_wp.finish+1
+          end
+        end    
+      end
+    end
+    
+    # Identical to the <tt>workpattern</tt> method apart from it always creates
+    # resting patterns so there is no need to set the <tt>:work_type</tt> argument
+    #
+    def resting(args={})
+      args[:work_type]=REST
+      workpattern(args)
+    end
+    
+    # Identical to the <tt>workpattern</tt> method apart from it always creates
+    # working patterns so there is no need to set the <tt>:work_type</tt> argument
+    #
+    def working(args={})
+      args[:work_type]=WORK
+      workpattern(args)
+    end
+    
+    # :call-seq: calc(start,duration) => DateTime
+    # Calculates the resulting date when #duration is added to #start date using the #Workpattern.
+    # Duration is always in whole minutes and can be a negative number, in which case it subtracts 
+    # the minutes from the date.
+    #
+    def calc(start,duration)
+      return start if duration==0 
+      midnight=false
+      
+      while (duration !=0)
+        week=find_weekpattern(start)
+        if (week.start==start) && (duration<0) && (!midnight)
+          start=start.prev_day
+          week=find_weekpattern(start)
+          midnight=true
+        end    
+        
+        start,duration,midnight=week.calc(start,duration,midnight)
+      end 
+      
+      return start
+    end
+
+    # :call-seq: working?(start) => Boolean
+    # Returns true if the given minute is working and false if it isn't
+    #
+    def working?(start)
+      return find_weekpattern(start).working?(start)
+    end    
+    
+    # :call-seq: diff(start,finish) => Duration
+    # Returns number of minutes between two dates
+    #
+    def diff(start,finish)
+    
+      start,finish=finish,start if finish<start
+      duration=0
+      while(start!=finish) do
+        week=find_weekpattern(start)
+        result_duration,start=week.diff(start,finish)
+        duration+=result_duration
+      end
+      return duration
+    end   
+    private
+    
+    # Retrieve the correct pattern for the supplied date
+    #
+    def find_weekpattern(date)
+      # find the pattern that fits the date
+      # TODO: What if there is no pattern?
+      #
+      if date<@from
+        result = Week.new(DateTime.jd(0),@from-MINUTE,1)
+      elsif date>@to
+        result = Week.new(@to+MINUTE,DateTime.new(9999),1)
+      else
+      
+        date = DateTime.new(date.year,date.month,date.day)
+
+        result=@weeks.find {|week| week.start <= date and week.finish >= date}
+      end
+      return result
+    end
+    
+        
+    def dmy_date(date)
+      return DateTime.new(date.year,date.month,date.day)
+    end
+      
+    def hhmn_date(date)
+      return DateTime.new(2000,1,1,date.hour,date.min)
+    end
+    
+  end
+end
+