availability 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8eaf871af31feb52dcf53dcf209011faa140849a
-  data.tar.gz: ea9daa4546d229bdd17b454d2ef51bac5e33bd1c
+  metadata.gz: 3be1734eee2d550422776a8d399236e4e9fdd2ca
+  data.tar.gz: 4c98f924c2a0a12daafb846886a8be06a4a85358
 SHA512:
-  metadata.gz: cac1e269b14a79478b15db2c34c11cb2166762c3c50b4a6dec66953e574d3500461f0fb5353ab14a6a6717c1197f258b0ba5cff07f3fd3da9d36ce9ab75e03fe
-  data.tar.gz: b9cfe1fc23f4b068a9244d65ef5f2c7543bbd17732429a856b8eeaa3e83008438a70cac2dc0b36cf21750b3af4ef9acc81c9edda7b098c7a7441037e841c3afc
+  metadata.gz: 0d334f811b0745a5774ca32a5e0357694abf6b72973d67c59668b93c06b44bd8b640ae5dedeae529d164265273bb4307dc94418a59d405cd6b2cd523a18fbf13
+  data.tar.gz: 71ff6a5d558627ce59c4bfafdb6e81102ea60c7e8dda203ed30b9d52513559670b2f224dc7163202ffbc604b65cac33b75a9a3e1ecdcd58cf9dbd5bad5159629

data/README.md

@@ -20,9 +20,9 @@ There are a few convenience factory methods beyond the main factory methods:
   - `Availability.every_two_{days,weeks,months,years}` and `Availability.every_other_{day,week,month,year}` will create the appropriate availability with an interval of 2
   - There are other `every_*` factory methods for intervals of 3, 4, and 5 (e.g. `every_three_months`)
 
-## Primary API
+## Basic Usage
 
-### [#occurs_at?/1][OCCURS_AT]
+### [#includes?/1][INCLUDES]
 This method takes a date or time and responds with a boolean indicating whether or not it is covered by the receiver.
 
 ### [#corresponds_to?/1][CORRESPONDS_TO]
@@ -40,14 +40,55 @@ This returns a single time object for the next occurrence on or after the given
 ## Examples
 
 ```ruby
-# Every Monday from 9:00 AM to 10:00 AM starting on May 2, 2016
-Availability.every_other_week(start_time: Time.new(2016, 5, 2, 9), duration: 1.hour)
+# Every other Monday from 9:00 AM to 10:00 AM starting on May 2, 2016
+every_other_monday = Availability.every_other_week(start_time: Time.new(2016, 5, 2, 9), duration: 1.hour)
+every_other_monday.includes? Time.new(2016, 5, 30, 9)  # => true
+every_other_monday.includes? Time.new(2016, 5, 30, 10) # => false, because it lasts only an hour
+every_other_monday.includes? Time.new(2016, 5, 23, 9)  # => false, because it's not a covered Monday
+every_other_monday.includes? Time.new(2016, 5, 18, 9)  # => false, because it's not a Monday
 
 # A business week starting on May 2, 2016 going from 1:30 PM until 2:00 PM every day
-Availability.daily(start_time: Time.new(2016, 5, 2, 13, 30), stops_by: Time.new(2016, 5, 6), duration: 30.minutes)
+biz_week = Availability.daily(start_time: Time.new(2016, 5, 2, 13, 30), stops_by: Time.new(2016, 5, 6), duration: 30.minutes)
+
+biz_week.includes? Time.new(2016, 5, 3, 13, 30) #=> true
+biz_week.includes? Time.new(2016, 5, 3, 14, 30) #=> false
+biz_week.includes? Time.new(2016, 5, 6, 13, 30) #=> true
 
 # A semi-monthly availability occurring all day, without an end
-Availability.every_other_month(start_time: Time.new(2016, 1, 1), duration: 1.day)
+every_other_month = Availability.every_other_month(start_time: Time.new(2016, 1, 1), duration: 1.day)
+
+every_other_month.includes? Time.new(2016, 3, 1) #=> true
+every_other_month.includes? Time.new(4037, 7, 1) #=> true
+```
+
+Exclusion rules can be added to an availability to further restrict it. For instance, if you wanted to create an availability for business days that spanned more than a single week you might do something like the following (note that exclusion rules need only to respond to `violated_by?(time)`).
+```ruby
+class BusinessDayRule
+  def initialize
+    @not_on_sunday = Availability::Exclusion.on_day_of_week(0)
+    @not_on_saturday = Availability::Exclusion.on_day_of_week(6)
+    @after_work_hours = Availability::Exclusion.after_time(Time.parse('18:00'))
+    @before_work_hours = Availability::Exclusion.before_time(Time.parse('08:00'))
+  end
+
+  def violated_by?(time)
+    @not_on_saturday.violated_by?(time) ||
+      @not_on_sunday.violated_by?(time) ||
+      @after_work_hours.violated_by?(time) ||
+      @before_work_hours.violated_by?(time)
+  end
+end
+
+business_days = Availability.daily(
+  start_time: Time.new(2016, 1, 1, 8),
+  duration: 1.hour,
+  exclusions: [Availability::Exclusion.new(BusinessDayRule.new)]
+)
+
+business_days.includes? Time.new(2016, 5, 2, 8)  #=> true
+business_days.includes? Time.new(2016, 5, 2, 10) #=> true
+business_days.includes? Time.new(2016, 5, 2, 7)  #=> false
+business_days.includes? Time.new(2016, 5, 2, 18) #=> false
 ```
 
 ## TODO
@@ -89,8 +130,8 @@ see <http://unlicense.org/> or the accompanying [UNLICENSE]{UNLICENSE} file.
 [YARD-GS]:          http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:              http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
 [DOCS]:             http://www.rubydoc.info/gems/availability
-[OCCURS_AT]:        http://www.rubydoc.info/gems/availability/Availability/AbstractAvailability#occurs_at%3F-instance_method
+[INCLUDES]:         http://www.rubydoc.info/gems/availability/Availability/AbstractAvailability#includes%3F-instance_method
 [CORRESPONDS_TO]:   http://www.rubydoc.info/gems/availability/Availability/AbstractAvailability#corresponds_to%3F-instance_method
 [LAST_OCCURRENCE]:  http://www.rubydoc.info/gems/availability/Availability/AbstractAvailability#last_occurrence-instance_method
-[NEXT_N_OCCURS]:    http://www.rubydoc.info/gems/availability/Availability/AbstractAvailability#next_n_occurrences%3F-instance_method
-[NEXT_OCCUR]:       http://www.rubydoc.info/gems/availability/Availability/AbstractAvailability#next_occurrence%3F-instance_method
+[NEXT_N_OCCURS]:    http://www.rubydoc.info/gems/availability/Availability/AbstractAvailability#next_n_occurrences-instance_method
+[NEXT_OCCUR]:       http://www.rubydoc.info/gems/availability/Availability/AbstractAvailability#next_occurrence-instance_method

data/availability.gemspec

@@ -26,4 +26,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"
   spec.add_development_dependency "rspec-its"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-byebug"
 end

data/examples/scheduler_spec.rb

@@ -71,19 +71,8 @@ RSpec.describe Scheduler do
     end
 
     describe '#allow?' do
-      context 'enforces parameter values' do
-        it { expect{bobs_schedule.allow?}.to raise_error ArgumentError }
-        it { expect{bobs_schedule.allow? availability_request: nil}.to raise_error ArgumentError }
-        it { expect{bobs_schedule.allow? start_time: nil }.to raise_error ArgumentError }
-        it { expect{bobs_schedule.allow? start_time: Date.today }.to raise_error ArgumentError }
-        it { expect{bobs_schedule.allow? end_time: nil }.to raise_error ArgumentError }
-        it { expect{bobs_schedule.allow? end_time: Date.today }.to raise_error ArgumentError }
-        it { expect{bobs_schedule.allow? availability_request: one_hour_slot_per_week(start_time: T(0))}.not_to raise_error }
-        it { expect{bobs_schedule.allow? start_time: Date.today, end_time: Date.tomorrow}.not_to raise_error }
-      end
-
       context 'with Availability objects' do
-        it 'allows an event requests that start in the first week and go through the end of the availability' do
+        it 'allows an event request that starts in the first week and goes through the end of the availability' do
           bob_availabilities.each do |a|
             expect(bobs_schedule.allow? availability_request: a).to be_truthy, "at #{a.start_time}"
           end

data/lib/availability.rb

@@ -4,6 +4,7 @@ require_relative "availability/version"
 require_relative 'availability/createable'
 require_relative 'availability/exclusion'
 require_relative 'availability/abstract_availability'
+require_relative 'availability/hourly'
 require_relative 'availability/daily'
 require_relative 'availability/weekly'
 require_relative 'availability/monthly'

data/lib/availability/abstract_availability.rb

@@ -51,13 +51,14 @@ module Availability
     # @return [Boolean] true or false
     #
     def corresponds_to?(availability)
-      return false unless occurs_at?(availability.start_time) && occurs_at?(availability.start_time + availability.duration)
+      return false unless includes?(availability.start_time) \
+        && includes?(availability.start_time + availability.duration - 1.second)
       if !!stops_by
         that_last = availability.last_occurrence
-        !that_last.nil? &&
-          occurs_at?(that_last) &&
-          occurs_at?(that_last + availability.duration) &&
-          that_last.to_date <= self.last_occurrence.to_date
+        !that_last.nil? \
+          && includes?(that_last) \
+          && includes?(that_last + availability.duration - 1.second) \
+          && that_last.to_date <= self.last_occurrence.to_date
       else
         true
       end
@@ -66,12 +67,15 @@ module Availability
     #
     # Whether or not the given time is covered by the receiver
     #
-    # @param [Time] time the Date, Time, or DateTime to test for coverage
+    # @param [Time] time the Time to test for coverage
     #
     # @return [Boolean] true or false
     #
-    def occurs_at?(time)
-      residue_for(time) == @residue && time_overlaps?(time, start_time, start_time + duration)
+    def includes?(time)
+      next_occurrence = next_occurrence(time) || last_occurrence
+      residue_for(time) == @residue \
+        && !next_occurrence.nil? \
+        && time_overlaps?(time, next_occurrence, next_occurrence + duration)
     end
 
     # @!endgroup
@@ -105,7 +109,7 @@ module Availability
       residue = @residue - residue_for(from_date)
       date = move_by from_date, residue.modulo(interval)
       time = Time.new(date.year, date.month, date.day, start_time.hour, start_time.min, start_time.sec)
-      if exclusions.any? {|rule| rule.violated_by? time}
+      if (exx = exclusions.detect {|rule| rule.violated_by? time})
         if stops_by && time > stops_by
           nil
         else
@@ -173,10 +177,10 @@ module Availability
     # @!group Helpers
 
     def time_overlaps?(time, start_time, end_time)
-      that_start = time.seconds_since_midnight.to_i
-      this_start = start_time.seconds_since_midnight.to_i
-      this_end   = end_time.seconds_since_midnight.to_i
-      (this_start..this_end).include?(that_start)
+      that_start = time.to_i
+      this_start = start_time.to_i
+      this_end   = end_time.to_i
+      (this_start...this_end).include?(that_start)
     end
 
     # @!endgroup

data/lib/availability/exclusion.rb

@@ -1,12 +1,17 @@
 module Availability
   class Exclusion
-    private_class_method :new # :nodoc:
+    attr_reader :rule
 
     def self.after_day(date)
       raise ArgumentError, "invalid date" if date.nil?
       new Rule::AfterDate.new(date.to_date)
     end
 
+    def self.after_date_and_time(time)
+      raise ArgumentError, "invalid time" if time.nil?
+      new Rule::AfterDateAndTime.new(time.to_time)
+    end
+
     def self.after_time(time)
       raise ArgumentError, "invalid time" if time.nil?
       new Rule::AfterTime.new(time.to_time)
@@ -22,11 +27,23 @@ module Availability
       new Rule::BeforeDate.new(date.to_date)
     end
 
+    def self.before_date_and_time(time)
+      raise ArgumentError, "invalid time" if time.nil?
+      new Rule::BeforeDateAndTime.new(time.to_time)
+    end
+
     def self.before_time(time)
       raise ArgumentError, "invalid time" if time.nil?
       new Rule::BeforeTime.new(time.to_time)
     end
 
+    def self.on_day_of_week(day_of_week) # 0=Sunday, 6=Saturday
+      unless day_of_week.is_a?(Fixnum) && (0..6).include?(day_of_week)
+        raise ArgumentError, "invalid day of week"
+      end
+      new Rule::OnDayOfWeek.new(day_of_week)
+    end
+
     def initialize(rule)
       @rule = rule
     end
@@ -47,6 +64,17 @@ module Availability
         end
       end
 
+      class AfterDateAndTime
+        def initialize(time)
+          @after_date = AfterDate.new time.to_date
+          @after_time = AfterTime.new time
+        end
+
+        def violated_by?(time)
+          @after_date.violated_by?(time) || @after_time.violated_by?(time)
+        end
+      end
+
       class AfterTime
         def initialize(date_or_time)
           @compare_to = date_or_time.to_time
@@ -67,6 +95,17 @@ module Availability
         end
       end
 
+      class BeforeDateAndTime
+        def initialize(time)
+          @before_date = BeforeDate.new time.to_date
+          @before_time = BeforeTime.new time
+        end
+
+        def violated_by?(time)
+          @before_date.violated_by?(time) || @before_time.violated_by?(time)
+        end
+      end
+
       class BeforeTime
         def initialize(date_or_time)
           @compare_to = date_or_time.to_time
@@ -86,6 +125,16 @@ module Availability
           time.to_date == @date
         end
       end
+
+      class OnDayOfWeek
+        def initialize(day_of_week)
+          @day_of_week = day_of_week
+        end
+
+        def violated_by?(time)
+          time.wday == @day_of_week
+        end
+      end
     end
   end
 end

data/lib/availability/factory_methods.rb

@@ -10,7 +10,7 @@ module Availability
       Once.create **args
     end
 
-    %w{day week month year}.each do |suffix|
+    %w{hour day week month year}.each do |suffix|
       frequency = suffix == 'day' ? :daily : :"#{suffix}ly"
       cls = Availability::subclass_for(frequency)
 

data/lib/availability/hourly.rb

@@ -0,0 +1,29 @@
+require_relative 'abstract_availability'
+require_relative 'daily'
+
+module Availability
+  class Hourly < Daily
+    extend Createable
+
+    def interval_difference(this, that)
+      first, second = [this, that].sort
+      (second.to_i - first.to_i) / 1.hour
+    end
+
+    def move_by(time, amount)
+      time + amount.hours
+    end
+
+    def includes?(time)
+      return true if super
+      return false if residue_for(time) != residue
+      hours_on_same_day = next_n_occurrences(24, time).select {|t| t.wday == time.wday && t <= time }
+      hours_on_same_day.none? {|hour| exclusions.any?{|excl| excl.violated_by? hour}} &&
+        hours_on_same_day.any?{|hour| time_overlaps? time, hour, hour + duration}
+    end
+
+    def residue_for(time)
+      interval_difference(time, beginning.to_time).modulo(@interval)
+    end
+  end
+end

data/lib/availability/once.rb

@@ -22,6 +22,10 @@ module Availability
       start_time
     end
 
+    def next_occurrence(time)
+      start_time
+    end
+
     def residue_for(time)
       0
     end

data/lib/availability/version.rb

@@ -1,3 +1,3 @@
 module Availability
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: availability
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Jason Rogers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-03 00:00:00.000000000 Z
+date: 2016-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -80,6 +80,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Use modular arithmetic and residue classes to calculate schedule availability
   for dates (times handled separately).
 email:
@@ -113,6 +141,7 @@ files:
 - lib/availability/daily.rb
 - lib/availability/exclusion.rb
 - lib/availability/factory_methods.rb
+- lib/availability/hourly.rb
 - lib/availability/monthly.rb
 - lib/availability/once.rb
 - lib/availability/version.rb