workpattern 0.4.0 → 0.5.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YmYzOTdhYWIzZTYwZjZmODY3NzBmYmQ5ZWY3MTI0MDcyNWUzNThhYw==
-  data.tar.gz: !binary |-
-    MjZmZTg4OTViNzJjY2I0NGI1OTNlZjQ2NzYwZGNmZTg1ZDE4Y2JjZA==
+SHA1:
+  metadata.gz: 8e19f40a13975d2a07d505bce513b1d48dc25ca6
+  data.tar.gz: 8a974a014e365222029c333b8fee0835e91bd125
 SHA512:
-  metadata.gz: !binary |-
-    ZTIzNDljMTg5NTJmMzgyMGEwZTE2ZmM3OTUzNjVhNzRjYzIzMDAxYTE3ZWY1
-    YTJkYTRkZWQ5YjVmZTQ3N2E4YWVhZGNiZTFmNmQ2YzI1Yjc5MjY5MzU1YWRk
-    NTNmMDFjODY5ZTNkZDliZjBiYzY5ZDljMzkwYWY1NzA3ZjYyNDk=
-  data.tar.gz: !binary |-
-    OWY5ZmM4Yzc0MmViNmY5YmZmMTE2YzFhMTVmMTA5Y2M5MzRmMmE0ZWM0YWVh
-    MzY3YWFkNjNlYTBkN2JjZjdmYjM3MTRhMDA4NTQ2YjQ1NGZkYmU3ZmQzMDE2
-    NjZlZDI5MzVjZjExNTY4YjVlZjMyMTA4ZjQxMDg0YmY2ZjE1NDI=
+  metadata.gz: 8bc16dcdae0b21a90952c15fde3bdcc51a7ad0dea8d28afa9e26f3afb78e76b16738690227a668e01878eb56009460f9b82f698f72ed5198d6a6156cfc375818
+  data.tar.gz: 757f7bc54c5247c09ca12533ed349a1aef37d47056ac4e12d98820a4ea7a94958f6d5c4256fb935278c4152159a100f10aa7a4cba54c4468ab89ea4625e73b69

data/.gitignore

@@ -14,4 +14,7 @@ rdoc
 spec/reports
 test/tmp
 test/version_tmp
-tmp
+tmp
+\#*
+.#*
+*.swp

data/.travis.yml

@@ -2,7 +2,13 @@ language: ruby
 rvm:
   - 1.9.3
   - jruby-19mode # JRuby in 1.9 mode
-  - 2.0.0
   - 2.1.0
+  - 2.1.9
+  - 2.2.0
+  - 2.2.5
+  - 2.3.0
+  - 2.3.1
   - jruby-head
-  - ruby-head
+before_install:
+  - gem install bundler
+  - gem update bundler

data/CHANGELOG

@@ -1,3 +1,22 @@
+## Workpattern v0.5.0 ( Oct 19, 2016) ##
+
+* Workpattern now handles Timezones.  It changes the date into UTC, does the calculation and then changes it back * Barrie Callender
+* Removed Day class and associated tests as it is no longer used * Barrie Callender
+* Reviewed the README and removed a lot of cruft and also updated it a little to demonstrate features * Barrie Callender
+* Hid documentation unless it was part of the public api * Barrie Callender
+* Used Rubocop to help me be more consistent.  I ignored some of the offences to do with long lines/methods and classes * Barrie Callender
+* Code makes use of Time objects where it use to use DateTime.  Time comes with a Timezone * Barrie Callender
+* Rewrote/refactored methods in the Week class - which needs refactoring into new classes * Barrie Callender
+* Removed rubyforge_project from workpattern.gemspec * Barrie Callender
+* Added homepage & required_ruby_version to workpattern.gemspec * Barrie Callender
+* Added versions to test in Travis CI to include 1.9.3, 2.0.0, 2.1.0, 2.1.9, 2.2.0, 2.2.5, 2.3.0 & 2.3.1 * Barrie Callender
+* Dealt with Travis CI issue with version of bundler * Barrie Callender
+* Removed config directory & contents * Barrie Callender
+* Changed Description * barrie Callender
+* Specified minitest ~> 5.4.3 due to an issue I no longer recall * Barrie Callender
+* Hid all the documentation apart from public api * Barrie Callender
+* improved the README.md (IMHO) * Barrie Callender
+
 ## Workpattern v0.4.0 ( May 23, 2014)  ##
 
 * Updated Week class to use bits and removed Day and Hour class as a consequence * Barrie Callender *

data/README.md

@@ -1,102 +1,103 @@
 # Workpattern [![Build Status](https://secure.travis-ci.org/callenb/workpattern.png)](https://secure.travis-ci.org/callenb/workpattern.png)
 
-## What?
+Calculates dates and durations whilst taking into account working and non-working times.  It creates calendars similar to what you can find in project scheduling software like Microsoft project and Primavera P6.
 
-Simple addition and subtraction of minutes on dates taking account of real-life working and resting periods.
+Please use [Github Issues] to report bugs.  If you have a question about the library, please use the `workpattern` tag on [Stack Overflow].  This tag is monitored by contributors.
 
-## So What?
+[Github Issues]: http://github.com/callenb/workpattern/issues
+[Stack Overflow]: http://stackoverflow.com/questions/tagged/workpattern
 
-The core Ruby classes that represent date and time allow calculations by adding a duration such as days or 
-minutes to a date and returning the new `Date` or `DateTime` as the result.  Although there 
-are 60 seconds in every minute and 60 minutes in every hour, there aren't always 24 hours in every day, and 
-if there was, we still wouldn't be working during all of them.  We would be doing other things like eating,
-sleeping, travelling and having a bit of leisure time.  Workpattern refers to this time as Resting time.
-It refers to the time when we're busy doing stuff as Working time.
+## Getting Started
 
-When it comes to scheduling work, whether part of a project, teachers in a classroom or even bed availability
-in a hospital, the working day can have anything from 0 hours to the full 24 hours.  Most office based work
-is something like 7.5 or 8 hours a day except weekends, public holidays and vacations when no work takes 
-place.
+Workpattern is a library with no monkey-patching and is tested against Ruby `>= 1.9.2`.
 
-The `Workpattern` library was born to allow date related calculations to take  into account real life 
-working and resting times.  It gets told about working and resting periods and can then perform calculations
-on a given date.  It can add and subtract a number of minutes, calculate the working minutes between two dates 
-and say whether a specific minute is working or resting.
+You can install it using:
+```sh
+gem install workpattern
+```
 
-This gem has the potential to serve as the engine for scheduling algorithms that are the core of products such as Microsoft Project and Oracle Primavera P6 as well as other applications that need to know when they can perform work and when they can’t.
+Or you can add it to your Gemfile with:
 
-## Install
+```sh
+gem "workpattern"
+```
 
-  `sudo gem install workpattern`
+Then run the bundle command to install it.
 
-## Getting Started
+## Use
 
-The first step is to create a `Workpattern` to hold all the working and resting times.  I'll start in 2011 and let it run for 10 years.
+## Configure and Calculate
+
+First create a `Workpattern` to hold all the working and resting times.
 
 ``` ruby
-mywp=Workpattern.new('My Workpattern',2011,10)
+mywp=Workpattern.new 'My Workpattern',2011,10 
 ```
+That line created a `Workpattern` called `My Workpattern` starting on 1-Jan-2011 and continuing for `10` years until `2020`.
 
-My `Workpattern` will be created as a 24 hour a day full working time.  Now it has to be told about the resting periods.  First the weekends.
+`mywp` is created with a 24 hour a day working time.  Next step is to tell it to ignore weekends by making every Saturday and Sunday non-working.
 
 ``` ruby
-mywp.resting(:days => :weekend)
+mywp.resting :days => :weekend 
 ```
 
-then the days in the week have specific working and resting times using the *Workpattern.clock* method, although anything that responds to `#hour` and `#min` methods will do ...
+The `Workpattern.clock` method can be used to specify the non-working times for each weekday.  Any class that responds to `#hour` and `#min` methods such as `Time` or `DateTime` can be used instead of `Workpattern.clock`.
 
 ``` ruby
-mywp.resting(:days =>:weekday, :from_time=>Workpattern.clock(0,0),:to_time=>Workpattern.clock(8,59))
-mywp.resting(:days =>:weekday, :from_time=>Workpattern.clock(12,0),:to_time=>Workpattern.clock(12,59))
-mywp.resting(:days =>:weekday, :from_time=>Workpattern.clock(18,0),:to_time=>Workpattern.clock(23,59))
+mywp.resting :days =>:weekday, :from_time=>Workpattern.clock(0,0),:to_time=>Workpattern.clock(8,59) 
+mywp.resting :days =>:weekday, :from_time=>Workpattern.clock(12,0),:to_time=>Workpattern.clock(12,59) 
+mywp.resting :days =>:weekday, :from_time=>Workpattern.clock(18,0),:to_time=>Workpattern.clock(23,59) 
 ```
+As well as `:weekend` and `:weekday` it is possible to use `:mon`, `:tue`, `:wed`, `:thu`, `:fri`, `:sat`, `:sun` or `all`.
 
-Now we have the working and resting periods setup we can just add 32 hours as minutes (1920) to our date.
+With `mywp` setup, the `#calc` method is used to add 32 hours which must be supplied as the number of whole minutes (1920) to a date.
 
 ``` ruby
-mydate=DateTime.civil(2011,9,1,9,0)
-result_date = mywp.calc(mydate,1920) # => 6/9/11@18:00
+my_date=Time.gm 2011,9,1,9,0 
+result_date = mywp.calc my_date,1920  # => 6/9/11@18:00
 ```
 
-## Development
+The result takes into account the non-working or resting times.
+
+Subtracting a date is just as easy by using a negative number of minutes in `#calc`.
 
-* Source hosted on [GitHub](http://github.com/callenb/workpattern).
-* Direct questions and discussions to the [mailing list](http://groups.google.com/group/workpattern).
-* Report issues on [GitHub Issues](http://github.com/callenb/workpattern/issues).
-* Pull requests are very welcome, however I have never participated in Open Source so will be a bit slow as I am learning. Please be patient with me.  Please include spec and/or feature coverage for every patch,  and create a topic branch for every separate change you make.
-* Advice, such as pointing out how I should really code in Ruby will be gratefully received.
+Finding the duration between two dates is also easy using the `#diff` method.
 
-## Things To Do
+``` ruby
+diff_result = mywp.diff my_date, result_date  # => 1920
+```
 
-In its current form this library is being made available to see if there is any interest in using 
-it. At the moment it can perform the following:
+Vacations can be added to the `Workpattern` using the `#resting` method:
 
-* define the working and resting minutes for any 24 hour day
-* given a date it can return the resulting date after adding or subtracting a number of minutes
-* calculate the number of working minutes between two dates
-* report whether a specific minute in time is working or resting
+``` ruby
+mywp.resting :days => :all, :start => DateTime.civil(2011,5,1), :finish => DateTime.civil(2011,5,7)
+```
+Find out if a specific date and time is working or not.
 
-This is what I consider to be the basics, but there are a number of functional and non-functial areas I 
-would like to address in a future version.
+``` ruby
+mydate = DateTime.civil 2011,5,2,9,10
+mywp.resting? mydate  # => true
+mywp.working? mydate  # => false
+```
 
-## Functional
+### Manage
 
-* Merge two Workpatterns together to create a new one allowing either resting or working to take precedence
-* Given a date, find the next working or resting minute either before or after it.
-* Handle both 23 and 25 hour days that occur when the clocks change.
-* Extract patterns from the workpattern so they can be persisted in a database.
-* Decide how to handle different Timezones apart from UTC.
+``` ruby
+# Fetch a specific Workpattern
+Workpattern.get "My Workpattern"
 
-## Non-Functional
+# Delete a specific Workpattern
+Workpattern.delete "My Workpattern"
 
-* Improve the documentation and introduce real world use as an example
-* Improve my ability to write Ruby code
+# Delete all Workpatterns
+Workpattern.clear
+```
 
 ## License
 
 (The MIT License)
 
-Copyright (c) 2012 
+Copyright (c) 2012 - 2016
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/workpattern.rb

@@ -3,107 +3,117 @@
 #
 # email: barrie@callenb.org
 #++
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+$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 'date'
 require 'workpattern/utility/base.rb'
 require 'workpattern/clock'
+#require 'workpattern/day'
 require 'workpattern/week'
 require 'workpattern/workpattern'
 
 #
 # workpattern.rb - date calculation library that takes into account patterns of
-# working and resting time and is aimed at supporting scheduling applications such 
-# as critical path analysis.
+# working and resting time and is aimed at supporting scheduling applications
+# such as critical path analysis.
 #
 # Author:        Barrie Callender 2011
 #
 # Documentation: Barrie Callender <barrie@callenb.org>
 #
 module Workpattern
-  
   # Represents a full working hour
   # @since 0.2.0
-  WORKING_HOUR = 2**60-1
-  
+  WORKING_HOUR = 2**60 - 1
+
   # Represents a full resting hour
-  # @since 0.2.0  
+  # @since 0.2.0
   RESTING_HOUR = 0
-  
+
   # The default workpattern name
-  # @since 0.2.0  
-  DEFAULT_WORKPATTERN_NAME = 'default'
-  
+  # @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
-  
-  # Hour in terms of days
-  # @since 0.2.0
-  HOUR = Rational(1,24)
-  
-  # Minute in terms of days
-  # @since 0.2.0
-  MINUTE = Rational(1,1440)
-  
+
+  # 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)
-  
+  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)
-  
+  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), 
+
+  # 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]}
-              
-  # Covenience method to obtain a new <tt>Workpattern</tt> 
+  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
   #
   # @param [String] name Every workpattern has a unique name.
   # @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.
+  # @param [Integer] number of years ending on 31st December.
   # @return [Workpattern]
-  # @raise [NameError] when trying to create a Workpattern with a name that already exists
+  # @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, span=DEFAULT_SPAN)
-    return Workpattern.new(name, base,span)
+  def self.new(name = DEFAULT_WORKPATTERN_NAME,
+               base = DEFAULT_BASE_YEAR,
+               span = DEFAULT_SPAN)
+    Workpattern.new(name, base, span)
   end
-  
-  # Covenience method to obtain an Array of all the known <tt>Workpattern</tt> objects
+
+  # Covenience method to obtain an Array of all the known <tt>Workpattern</tt>
+  # objects
   #
   # @return [Array] all <tt>Workpattern</tt> objects
   #
   # @since 0.2.0
   #
-  def self.to_a()
-    return Workpattern.to_a
+  def self.to_a
+    Workpattern.to_a
   end
 
-  # Covenience method to obtain an existing <tt>Workpattern</tt> 
+  # Covenience method to obtain an existing <tt>Workpattern</tt>
   #
   # @param [String] name The name of the Workpattern to retrieve.
   # @return [Workpattern]
@@ -111,9 +121,9 @@ module Workpattern
   # @since 0.2.0
   #
   def self.get(name)
-    return Workpattern.get(name)
+    Workpattern.get(name)
   end
-  
+
   # Convenience method to delete the named <tt>Workpattern</tt>
   #
   # @param [String] name The name of the Workpattern to be deleted.
@@ -123,18 +133,18 @@ module Workpattern
   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 create a Clock object.  This can be used for specifying times 
-  # if you don't want to create a <tt>DateTime</tt> object
-  # 
+
+  # 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
+  #
   # @param [Integer] hour the number of hours.
   # @param [Integer] min the number of minutes
   # @return [Clock]
@@ -142,7 +152,7 @@ module Workpattern
   #
   # @since 0.2.0
   #
-  def self.clock(hour,min)
-    return Clock.new(hour,min)
+  def self.clock(hour, min)
+    Clock.new(hour, min)
   end
 end

data/lib/workpattern/clock.rb

@@ -7,7 +7,7 @@ module Workpattern
   #   myClock.hour #=> 3
   #   myClock.min  #=> 32
   #   myClock.time #=> Time.new(1963,6,10,3,32)
-  #   myClock.to_s #=> 3:32 212 
+  #   myClock.to_s #=> 3:32 212
   #
   #   aClock=Clock.new(27,80)
   #   aClock.minutes #=> 1700
@@ -19,64 +19,61 @@ module Workpattern
   # @since 0.2.0
   #
   class Clock
-    
-    # Initialises an instance of <tt>Clock</tt> using the hours and minutes supplied
-    # or 0 if they are absent.  Although there are 24 hours in a day
+    # Initialises an instance of <tt>Clock</tt> using the hours and minutes
+    # supplied or 0 if they are absent.  Although there are 24 hours in a day
     # (0-23) and 60 minutes in an hour (0-59), <tt>Clock</tt> calculates
     # the full hours and remaining minutes of whatever is supplied.
     #
     # @param [Integer] hour number of hours
     # @param [Integer] min number of minutes
     #
-    def initialize(hour=0,min=0)
-      @hour = total_minutes(hour,min).div(60)
-      @min = total_minutes(hour,min) % 60
+    def initialize(hour = 0, min = 0)
+      @hour = total_minutes(hour, min).div(60)
+      @min = total_minutes(hour, min) % 60
     end
-    
+
     # Returns the total number of minutes
     #
     # @return [Integer] total minutes represented by the Clock object
     #
     def minutes
-      return total_minutes(@hour,@min)
+      total_minutes(@hour, @min)
     end
-    
+
     # Returns the hour of the clock (0-23)
     #
     # @return [Integer] hour of Clock from 0 to 23.
     #
     def hour
-      return @hour % 24
+      @hour % 24
     end
-    
+
     # Returns the minute of the clock (0-59)
     #
     # @return [Integer] minute of Clock from 0 to 59
     #
     def min
-      return @min % 60
+      @min % 60
     end
-    
+
     # Returns a <tt>Time</tt> object with the correct
     # <tt>hour</tt> and <tt>min</tt> values.  The date
     # is 10th June 1963.
     #
     # @return [DateTime] The time using the date of 10th June 1963 (My Birthday)
     def time
-      return DateTime.new(1963,6,10,hour,min)
+      DateTime.new(1963, 6, 10, hour, min)
     end
-    
 
     # @return [String] representation of <tt>Clock</tt> value as 'hh:mn minutes'
-    def to_s      
+    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
+      (hours * 60) + mins
     end
-
   end
 end