workpattern 0.5.0 → 0.7.0

data/lib/workpattern/week_pattern.rb

@@ -0,0 +1,142 @@
+module Workpattern
+  class WeekPattern
+    def initialize(work_pattern)
+      @work_pattern = work_pattern
+    end
+
+    def work_pattern
+      @work_pattern
+    end
+
+    def weeks
+      work_pattern.weeks
+    end
+
+    def from
+      work_pattern.from
+    end
+
+    def to
+      work_pattern.to
+    end
+    # Applys a working or resting pattern to the <tt>Workpattern</tt> object.
+    #
+    # The #resting and #working methods are convenience methods that call
+    # this with the appropriate <tt>:work_type</tt> already set.
+    #
+    # @param [Hash] opts the options used to apply a workpattern
+    # @option opts [Date] :start The first date to apply the pattern.  Defaults
+    #     to the <tt>start</tt> attribute.
+    # @option opts [Date] :finish The last date to apply the pattern.  Defaults
+    #     to the <tt>finish</tt> attribute.
+    # @option opts [DAYNAMES] :days The specific day or days the pattern will
+    # apply to.It defaults to <tt>:all</tt>
+    # @option opts [(#hour, #min)] :start_time The first time in the selected
+    # days to apply the pattern. Defaults to <tt>00:00</tt>.
+    # @option opts [(#hour, #min)] :finish_time The last time in the selected
+    # days to apply the pattern. Defaults to <tt>23:59</tt>.
+    # @option opts [(WORK_TYPE || REST_TYPE)] :work_type Either working or resting.
+    # Defaults to working.
+    # @see #working
+    # @see #resting
+    #
+    def workpattern(opts = {})
+      args = all_workpattern_options(opts)
+
+      args = standardise_args(args)
+
+      upd_start = work_pattern.to_utc(args[:start])
+      upd_finish = work_pattern.to_utc(args[:finish])
+
+      while upd_start <= upd_finish
+
+	      current_wp = work_pattern.find_weekpattern(upd_start)
+
+        if current_wp.start == upd_start
+          if current_wp.finish > upd_finish
+            clone_wp = fetch_updatable_week_pattern(current_wp,
+                                                   upd_finish + DAY,
+                                                   current_wp.finish,
+                                                   upd_start,
+                                                   upd_finish)
+            update_and_store_week_pattern(clone_wp, args)
+            upd_start = upd_finish + DAY
+          else # (current_wp.finish == upd_finish)
+            current_wp.workpattern(args[:days], args[:from_time],
+                                   args[:to_time], args[:work_type])
+            upd_start = current_wp.finish + DAY
+          end
+        else
+          clone_wp = fetch_updatable_week_pattern(current_wp, current_wp.start,
+                                                 upd_start - DAY, upd_start)
+          if clone_wp.finish > upd_finish
+            after_wp = fetch_updatable_week_pattern(clone_wp,
+                                                   upd_start,
+                                                   upd_finish,
+                                                   upd_finish + DAY)
+            weeks << after_wp
+          end
+          update_and_store_week_pattern(clone_wp, args)
+          upd_start = clone_wp.finish + DAY
+        end
+      end
+    end
+
+    private
+
+    def all_workpattern_options(opts)
+	    
+      args = { start: from, finish: to, days: :all,
+               from_time: FIRST_TIME_IN_DAY, to_time: LAST_TIME_IN_DAY,
+               work_type: WORK_TYPE }
+
+      args.merge! opts
+    end  
+
+    def standardise_args(args)
+
+      args[:start] = dmy_date(args[:start])
+      args[:finish] = dmy_date(args[:finish])
+
+      args
+    end
+
+    # Clones the supplied Week Pattern then changes the dates on it
+    # The newly cloned Week pattern dates are also changed and it is 
+    # returned by this method
+    #
+    def fetch_updatable_week_pattern(keep_week, keep_start, keep_finish,
+                                    change_start, change_finish = nil)
+      change_week = keep_week.duplicate
+      adjust_date_range(keep_week, keep_start, keep_finish)
+      if change_finish.nil?
+        adjust_date_range(change_week, change_start, change_week.finish)
+      else
+        adjust_date_range(change_week, change_start, change_finish)
+      end
+      change_week
+    end
+
+    def update_and_store_week_pattern(week_pattern, args)
+      week_pattern.workpattern(args[:days], args[:from_time],
+                         args[:to_time], args[:work_type])
+      weeks << week_pattern
+    end
+
+    def adjust_date_range(week_pattern, start_date, finish_date)
+      week_pattern.start = start_date
+      week_pattern.finish = finish_date
+    end
+
+    # Strips off hours, minutes, seconds etc from a supplied <tt>Date</tt> or
+    # <tt>DateTime</tt>
+    #
+    # @param [DateTime] date
+    # @return [DateTime] with zero hours, minutes, seconds and so forth.
+    #
+    def dmy_date(date)
+      Time.gm(date.year, date.month, date.day)
+    end
+
+  end
+end

data/lib/workpattern/workpattern.rb

@@ -10,14 +10,15 @@ module Workpattern
   # referenced by calling applications when
   # using this gem.
   #
-  # @since 0.2.0
-  #
   class Workpattern
-    include Base
 
     # Holds collection of <tt>Workpattern</tt> objects
     @@workpatterns = {}
 
+    def self.workpatterns
+      @@workpatterns
+    end
+
     # @!attribute [r] name
     #   Name given to the <tt>Workpattern</tt>
     # @!attribute [r] base
@@ -33,14 +34,23 @@ module Workpattern
     #
     attr_reader :name, :base, :span, :from, :to, :weeks
 
-    # Class for handling persistence in user's own way
+    # Holds local timezone info
+    @@tz = nil
+
+    # Converts a date like object into utc
     #
-    def self.persistence_class=(klass)
-      @@persist = klass
+    def to_utc(date)
+      date.to_time.utc
+    end
+    # Converts a date like object into local time
+    #
+    def to_local(date)
+      date.to_time.getgm
     end
 
-    def self.persistence?
-      @@persist ||= nil
+    # Retrieves the local timezone
+    def timezone
+      @@tz || @@tz = TZInfo::Timezone.get(Time.now.zone)
     end
 
     # The new <tt>Workpattern</tt> object is created with all working minutes.
@@ -51,8 +61,8 @@ module Workpattern
     # 31st December.
     # @raise [NameError] if the given name already exists
     #
-    def initialize(name = DEFAULT_NAME, base = DEFAULT_BASE_YEAR, span = DEFAULT_SPAN)
-      if @@workpatterns.key?(name)
+    def initialize(name = DEFAULT_WORKPATTERN_NAME, base = DEFAULT_BASE_YEAR, span = DEFAULT_SPAN)
+      if workpatterns.key?(name)
         raise(NameError, "Workpattern '#{name}' already exists and can't be created again")
       end
       offset = span < 0 ? span.abs - 1 : 0
@@ -60,25 +70,35 @@ module Workpattern
       @name = name
       @base = base
       @span = span
-      @from = Time.gm(base.abs - offset)
-      @to = Time.gm(from.year + span.abs - 1, 12, 31, 23, 59)
+      @from = Time.gm(@base.abs - offset)
+      @to = Time.gm(@from.year + @span.abs - 1, 12, 31, 23, 59)
       @weeks = SortedSet.new
-      @weeks << Week.new(from, to, 1)
+      @weeks << Week.new(@from, @to)
 
-      @@workpatterns[name] = self
+      workpatterns[@name] = self
+      @week_pattern = WeekPattern.new(self)
     end
 
+    def week_pattern
+      @week_pattern
+    end
+
+    private def workpatterns
+      @@workpatterns
+    end
+    public
+
     # Deletes all <tt>Workpattern</tt> objects
     #
     def self.clear
-      @@workpatterns.clear
+      workpatterns.clear
     end
 
     # Returns an Array containing all the <tt>Workpattern</tt> objects
     # @return [Array] all <tt>Workpattern</tt> objects
     #
     def self.to_a
-      @@workpatterns.to_a
+      workpatterns.to_a
     end
 
     # Returns the specific named <tt>Workpattern</tt>
@@ -87,7 +107,7 @@ module Workpattern
     # exist
     #
     def self.get(name)
-      return @@workpatterns[name] if @@workpatterns.key?(name)
+      return workpatterns[name] if workpatterns.key?(name)
       raise(NameError, "Workpattern '#{name}' doesn't exist so can't be retrieved")
     end
 
@@ -97,7 +117,7 @@ module Workpattern
     # if it doesn't
     #
     def self.delete(name)
-      @@workpatterns.delete(name).nil? ? false : true
+      workpatterns.delete(name).nil? ? false : true
     end
 
     # Applys a working or resting pattern to the <tt>Workpattern</tt> object.
@@ -116,59 +136,13 @@ module Workpattern
     # days to apply the pattern. Defaults to <tt>00:00</tt>.
     # @option opts [(#hour, #min)] :finish_time The last time in the selected
     # days to apply the pattern. Defaults to <tt>23:59</tt>.
-    # @option opts [(WORK || REST)] :work_type Either working or resting.
+    # @option opts [(WORK_TYPE || REST_TYPE)] :work_type Either working or resting.
     # Defaults to working.
     # @see #working
     # @see #resting
     #
     def workpattern(opts = {})
-      args = { start: from, finish: to, days: :all,
-               from_time: FIRST_TIME_IN_DAY, to_time: LAST_TIME_IN_DAY,
-               work_type: WORK }
-
-      args.merge! opts
-
-      @@persist.store(name: name, workpattern: args) if self.class.persistence?
-
-      args[:start] = dmy_date(args[:start])
-      args[:finish] = dmy_date(args[:finish])
-      args[:from_time] = hhmn_date(args[:from_time])
-      args[:to_time] = hhmn_date(args[:to_time])
-
-      upd_start = to_utc(args[:start])
-      upd_finish = to_utc(args[:finish])
-      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 = clone_and_adjust_current_wp(current_wp,
-                                                   upd_finish + DAY,
-                                                   current_wp.finish,
-                                                   upd_start,
-                                                   upd_finish)
-            set_workpattern_and_store(clone_wp, args)
-            upd_start = upd_finish + DAY
-          else # (current_wp.finish == upd_finish)
-            current_wp.workpattern(args[:days], args[:from_time],
-                                   args[:to_time], args[:work_type])
-            upd_start = current_wp.finish + DAY
-          end
-        else
-          clone_wp = clone_and_adjust_current_wp(current_wp, current_wp.start,
-                                                 upd_start - DAY, upd_start)
-          if clone_wp.finish > upd_finish
-            after_wp = clone_and_adjust_current_wp(clone_wp,
-                                                   upd_start,
-                                                   upd_finish,
-                                                   upd_finish + DAY)
-            weeks << after_wp
-          end
-          set_workpattern_and_store(clone_wp, args)
-          upd_start = clone_wp.finish + DAY
-        end
-      end
+      week_pattern.workpattern(opts)
     end
 
     # Convenience method that calls <tt>#workpattern</tt> with the
@@ -177,7 +151,7 @@ module Workpattern
     # @see #workpattern
     #
     def resting(args = {})
-      args[:work_type] = REST
+      args[:work_type] = REST_TYPE
       workpattern(args)
     end
 
@@ -187,10 +161,67 @@ module Workpattern
     # @see #workpattern
     #
     def working(args = {})
-      args[:work_type] = WORK
+      args[:work_type] = WORK_TYPE
       workpattern(args)
     end
 
+    def to_h
+      { version: 1,
+        name:    @name,
+        base:    @base,
+        span:    @span,
+        weeks:   @weeks.map(&:to_h) }
+    end
+
+    def self.from_h(hash, overwrite: false)
+      unless hash.key?(:version)
+        raise ArgumentError, "from_h: hash is missing a :version key " \
+                             "(if deserialising from JSON, use symbolize_names: true)"
+      end
+      unless hash[:version] == 1
+        raise ArgumentError, "from_h: unsupported version #{hash[:version].inspect} " \
+                             "(supported: 1)"
+      end
+      unless hash[:name].is_a?(String) && !hash[:name].empty?
+        raise ArgumentError, "from_h: :name must be a non-empty String"
+      end
+      unless hash[:base].is_a?(Integer)
+        raise ArgumentError, "from_h: :base must be an Integer"
+      end
+      unless hash[:span].is_a?(Integer) && hash[:span] != 0
+        raise ArgumentError, "from_h: :span must be a non-zero Integer"
+      end
+      unless hash[:weeks].is_a?(Array)
+        raise ArgumentError, "from_h: :weeks must be an Array"
+      end
+
+      name = hash[:name]
+      if workpatterns.key?(name) && !overwrite
+        raise NameError, "Workpattern '#{name}' already exists and can't be created again"
+      end
+
+      wp = allocate
+      wp.instance_variable_set(:@name, name)
+      wp.instance_variable_set(:@base, hash[:base])
+      wp.instance_variable_set(:@span, hash[:span])
+
+      offset    = hash[:span] < 0 ? hash[:span].abs - 1 : 0
+      from_time = Time.gm(hash[:base].abs - offset)
+      to_time   = Time.gm(from_time.year + hash[:span].abs - 1, 12, 31, 23, 59)
+      wp.instance_variable_set(:@from, from_time)
+      wp.instance_variable_set(:@to,   to_time)
+
+      weeks = SortedSet.new
+      hash[:weeks].each { |wh| weeks << Week.from_h(wh) }
+      raise ArgumentError, "from_h: :weeks must not be empty" if weeks.empty?
+      wp.instance_variable_set(:@weeks, weeks)
+      wp.instance_variable_set(:@week_pattern, WeekPattern.new(wp))
+
+      workpatterns.delete(name) if overwrite
+      workpatterns[name] = wp
+      wp
+    end
+
     # Calculates the resulting date when the <tt>duration</tt> in minutes
     # is added to the <tt>start</tt> date.
     # The <tt>duration</tt> is always in whole minutes and subtracts from
@@ -203,20 +234,26 @@ module Workpattern
     #
     def calc(start, duration)
       return start if duration == 0
-      midnight = false
+      a_day = SAME_DAY
 
       utc_start = to_utc(start)
+
       while duration != 0
-        week = find_weekpattern(utc_start)
-        if (week.start == utc_start) && (duration < 0) && !midnight
-          utc_start = utc_start.prev_day
-          week = find_weekpattern(utc_start)
-          midnight = true
-        end
 
-        utc_start, duration, midnight = week.calc(utc_start, duration, midnight)
+        if a_day == PREVIOUS_DAY
+	        utc_start -= DAY
+	        a_day = SAME_DAY
+          utc_start = Time.gm(utc_start.year, utc_start.month, utc_start.day,LAST_TIME_IN_DAY.hour, LAST_TIME_IN_DAY.min)
+	        week = find_weekpattern(utc_start)
+	  
+	        if week.working?(utc_start)
+	          duration += 1
+	        end
+        else
+	        week = find_weekpattern(utc_start)
+        end
+        utc_start, duration, a_day = week.calc(utc_start, duration, a_day)
       end
-
       to_local(utc_start)
     end
 
@@ -239,18 +276,17 @@ module Workpattern
     def diff(start, finish)
       utc_start = to_utc(start)
       utc_finish = to_utc(finish)
-      utc_start, utc_finish = utc_finish, utc_start if finish < start
-      duration = 0
+      utc_start, utc_finish = utc_finish, utc_start if utc_finish < utc_start
+      minutes = 0
+
       while utc_start != utc_finish
         week = find_weekpattern(utc_start)
-        result_duration, utc_start = week.diff(utc_start, utc_finish)
-        duration += result_duration
+        r_minutes, utc_start = week.diff(utc_start, utc_finish)
+        minutes += r_minutes
       end
-      duration
+      minutes
     end
 
-    private
-
     # Retrieve the correct <tt>Week</tt> pattern for the supplied date.
     #
     # If the supplied <tt>date</tt> is outside the span of the
@@ -264,61 +300,17 @@ module Workpattern
     def find_weekpattern(date)
       # find the pattern that fits the date
       #
-      if date < from
-        result = Week.new(Time.at(0), from - MINUTE, 1)
+      if date < @from
+        result = Week.new(Time.at(0), @from - MINUTE, WORK_TYPE)
       elsif date > to
-        result = Week.new(to + MINUTE, Time.new(9999), 1)
+        result = Week.new(@to + MINUTE, Time.new(9999), WORK_TYPE)
       else
 
         date = Time.gm(date.year, date.month, date.day)
 
-        result = weeks.find { |week| week.start <= date && week.finish >= date }
+        result = @weeks.find { |week| week.start <= date && week.finish >= date }
       end
       result
     end
-
-    # Strips off hours, minutes, seconds etc from a supplied <tt>Date</tt> or
-    # <tt>DateTime</tt>
-    #
-    # @param [DateTime] date
-    # @return [DateTime] with zero hours, minutes, seconds and so forth.
-    #
-    def dmy_date(date)
-      Time.gm(date.year, date.month, date.day)
-    end
-
-    # Extract the time into a <tt>Clock</tt> object
-    #
-    # @param [DateTime] date
-    # @return [Clock]
-    def hhmn_date(date)
-      Clock.new(date.hour, date.min)
-    end
-
-    # Handles cloning of Week Pattern including date adjustments
-    #
-    def clone_and_adjust_current_wp(current_wp, current_start, current_finish,
-                                    clone_start, clone_finish = nil)
-      clone_wp = current_wp.duplicate
-      adjust_date_range(current_wp, current_start, current_finish)
-      if clone_finish.nil?
-        adjust_date_range(clone_wp, clone_start, clone_wp.finish)
-      else
-        adjust_date_range(clone_wp, clone_start, clone_finish)
-      end
-      clone_wp
-    end
-
-    def set_workpattern_and_store(new_wp, args)
-      new_wp.workpattern(args[:days], args[:from_time],
-                         args[:to_time], args[:work_type])
-      weeks << new_wp
-    end
-
-    def adjust_date_range(week_pattern, start_date, finish_date)
-      week_pattern.start = start_date
-      week_pattern.finish = finish_date
-    end
-    
   end
 end

data/lib/workpattern.rb

@@ -7,12 +7,14 @@ $LOAD_PATH.unshift(File.dirname(__FILE__)) unless
   $LOAD_PATH.include?(File.dirname(__FILE__)) || $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'rubygems'
+require 'sorted_set' if RUBY_VERSION >= "2.4"
 require 'date'
-require 'workpattern/utility/base.rb'
 require 'workpattern/clock'
-#require 'workpattern/day'
+require 'workpattern/constants'
+require 'workpattern/day'
 require 'workpattern/week'
 require 'workpattern/workpattern'
+require 'workpattern/week_pattern'
 
 #
 # workpattern.rb - date calculation library that takes into account patterns of
@@ -24,67 +26,7 @@ require 'workpattern/workpattern'
 # Documentation: Barrie Callender <barrie@callenb.org>
 #
 module Workpattern
-  # Represents a full working hour
-  # @since 0.2.0
-  WORKING_HOUR = 2**60 - 1
 
-  # Represents a full resting hour
-  # @since 0.2.0
-  RESTING_HOUR = 0
-
-  # The default workpattern name
-  # @since 0.2.0
-  DEFAULT_WORKPATTERN_NAME = 'default'.freeze
-
-  # The default base year
-  # @since 0.2.0
-  DEFAULT_BASE_YEAR = 2000
-
-  # The default span in years
-  # @since 0.2.0
-  DEFAULT_SPAN = 100
-
-  # Minute in terms of seconds
-  #
-  MINUTE = 60
-
-  # Hour interms od seconds
-  #
-  HOUR = MINUTE * 60
-
-  # Day in terms of seconds
-  #
-  DAY = HOUR * 24
-
-  # Earliest or first time in the day
-  # @since 0.0.1
-  FIRST_TIME_IN_DAY = Clock.new(0, 0)
-
-  # Latest or last time in the day
-  # @since 0.0.1
-  LAST_TIME_IN_DAY = Clock.new(23, 59)
-
-  # Specifies a working pattern
-  # @since 0.0.1
-  WORK = 1
-
-  # Specifies a resting pattern
-  # @since 0.0.1
-  REST = 0
-
-  # Represents the days of the week to be used in applying working
-  # and resting patterns.
-  # Values exist for each day of the week as well as for the weekend
-  # (Saturday and Sunday), 
-  # the week (Monday to Friday) and all days in the week.
-  #
-  # @since 0.0.1
-  daynames = { sun: [0], mon: [1], tue: [2], wed: [3],
-               thu: [4], fri: [5], sat: [6], 
-               weekday: [1, 2, 3, 4, 5], 
-               weekend: [0, 6], 
-               all: [0, 1, 2, 3, 4, 5, 6] }
-  DAYNAMES = daynames.freeze
   # Covenience method to obtain a new <tt>Workpattern</tt>
   #
   # A negative <tt>span</tt> counts back from the <tt>base</tt> year
@@ -94,7 +36,6 @@ module Workpattern
   # @param [Integer] number of years ending on 31st December.
   # @return [Workpattern]
   # @raise [NameError] creating a Workpattern with a name that already exists
-  # @since 0.2.0
   #
   def self.new(name = DEFAULT_WORKPATTERN_NAME,
                base = DEFAULT_BASE_YEAR,
@@ -107,8 +48,6 @@ module Workpattern
   #
   # @return [Array] all <tt>Workpattern</tt> objects
   #
-  # @since 0.2.0
-  #
   def self.to_a
     Workpattern.to_a
   end
@@ -118,8 +57,6 @@ module Workpattern
   # @param [String] name The name of the Workpattern to retrieve.
   # @return [Workpattern]
   #
-  # @since 0.2.0
-  #
   def self.get(name)
     Workpattern.get(name)
   end
@@ -128,20 +65,36 @@ module Workpattern
   #
   # @param [String] name The name of the Workpattern to be deleted.
   #
-  # @since 0.2.0
-  #
   def self.delete(name)
     Workpattern.delete(name)
   end
 
   # Convenience method to delete all Workpatterns.
   #
-  # @since 0.2.0
-  #
   def self.clear
     Workpattern.clear
   end
 
+  # Convenience method to deserialise a Workpattern from a plain hash.
+  #
+  # @param [Hash] hash produced by Workpattern#to_h
+  # @param [Boolean] overwrite replace an existing same-named workpattern
+  # @return [Workpattern]
+  # @raise [ArgumentError] if the hash is missing or has an unsupported version
+  # @raise [NameError] if a same-named workpattern already exists and overwrite is false
+  #
+  def self.from_h(hash, overwrite: false)
+    Workpattern.from_h(hash, overwrite: overwrite)
+  end
+
+  # Convenience method to access the registry of all known Workpattern objects.
+  #
+  # @return [Hash]
+  #
+  def self.workpatterns
+    Workpattern.workpatterns
+  end
+
   # Convenience method to create a Clock object.  This can be used for
   # specifying times if you don't want to create a <tt>DateTime</tt> object
   #
@@ -150,9 +103,8 @@ module Workpattern
   # @return [Clock]
   # @see Clock
   #
-  # @since 0.2.0
-  #
   def self.clock(hour, min)
     Clock.new(hour, min)
   end
+
 end