recurrence 1.2.0 → 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b5dcd970513024fef80a9774f83b32e51aad12a3
+  data.tar.gz: 6c4258d978897be59e86f14c40def4e838f71f3f
+SHA512:
+  metadata.gz: 9ad289eaf1aa4e7e96c9699347229e2b93cff83ac561a64b1638537dfb5fdfa2a24b6e0a2e9747c65a5df1cc02f093996068c20f795a1350b3409d9c7505098c
+  data.tar.gz: c339f2f8e64b880483e162181101c8eedd5bf2dc36beec288138c618c90d8743b82a169e4f68a085f53a61667d5a25a6f73e49df58494b1929142df0ab535b34

data/.rspec

@@ -1 +1 @@
---color --format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+script: bundle exec rspec

data/Gemfile

@@ -1,3 +1,3 @@
-source :rubygems
+source "https://rubygems.org"
 
 gemspec

data/Gemfile.lock

@@ -1,30 +1,44 @@
 PATH
   remote: .
   specs:
-    recurrence (1.2.0)
-      activesupport (>= 2.3.0)
+    recurrence (1.3.0)
+      activesupport
       i18n
 
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
-    activesupport (3.0.9)
-    diff-lcs (1.1.2)
-    i18n (0.6.0)
-    rake (0.9.2)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.4)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
+    activesupport (4.1.0)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    diff-lcs (1.2.5)
+    i18n (0.6.9)
+    json (1.8.1)
+    minitest (5.3.3)
+    rake (10.3.1)
+    rspec (3.0.0.beta2)
+      rspec-core (= 3.0.0.beta2)
+      rspec-expectations (= 3.0.0.beta2)
+      rspec-mocks (= 3.0.0.beta2)
+    rspec-core (3.0.0.beta2)
+      rspec-support (= 3.0.0.beta2)
+    rspec-expectations (3.0.0.beta2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (= 3.0.0.beta2)
+    rspec-mocks (3.0.0.beta2)
+      rspec-support (= 3.0.0.beta2)
+    rspec-support (3.0.0.beta2)
+    thread_safe (0.3.3)
+    tzinfo (1.1.0)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  rake (~> 0.9)
+  rake
   recurrence!
-  rspec (~> 2.6)
+  rspec (= 3.0.0.beta2)

data/License.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2008 Nando Vieira
+Copyright (c) 2008-2014 Nando Vieira
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +17,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,151 @@
+# Recurrence
+
+A simple library to handle recurring events.
+
+## Installation
+
+    gem install recurrence
+
+## Usage
+
+```ruby
+require "rubygems"
+require "recurrence"
+
+# Daily
+r = Recurrence.new(:every => :day)
+r = Recurrence.new(:every => :day, :interval => 9)
+r = Recurrence.new(:every => :day, :repeat => 7)
+r = Recurrence.daily(options = {})
+
+# Weekly
+r = Recurrence.new(:every => :week, :on => 5)
+r = Recurrence.new(:every => :week, :on => :monday)
+r = Recurrence.new(:every => :week, :on => [:monday, :friday])
+r = Recurrence.new(:every => :week, :on => [:monday, :wednesday, :friday])
+r = Recurrence.new(:every => :week, :on => :friday, :interval => 2)
+r = Recurrence.new(:every => :week, :on => :friday, :repeat => 4)
+r = Recurrence.weekly(:on => :thursday)
+
+# Monthly by month day
+r = Recurrence.new(:every => :month, :on => 15)
+r = Recurrence.new(:every => :month, :on => 31)
+r = Recurrence.new(:every => :month, :on => 7, :interval => 2)
+r = Recurrence.new(:every => :month, :on => 7, :interval => :monthly)
+r = Recurrence.new(:every => :month, :on => 7, :interval => :bimonthly)
+r = Recurrence.new(:every => :month, :on => 7, :repeat => 6)
+r = Recurrence.monthly(:on => 31)
+
+# Monthly by week day
+r = Recurrence.new(:every => :month, :on => :first, :weekday => :sunday)
+r = Recurrence.new(:every => :month, :on => :third, :weekday => :monday)
+r = Recurrence.new(:every => :month, :on => :last,  :weekday => :friday)
+r = Recurrence.new(:every => :month, :on => :last,  :weekday => :friday, :interval => 2)
+r = Recurrence.new(:every => :month, :on => :last,  :weekday => :friday, :interval => :quarterly)
+r = Recurrence.new(:every => :month, :on => :last,  :weekday => :friday, :interval => :semesterly)
+r = Recurrence.new(:every => :month, :on => :last,  :weekday => :friday, :repeat => 3)
+
+# Yearly
+r = Recurrence.new(:every => :year, :on => [7, 4]) # => [month, day]
+r = Recurrence.new(:every => :year, :on => [10, 31], :interval => 3)
+r = Recurrence.new(:every => :year, :on => [:jan, 31])
+r = Recurrence.new(:every => :year, :on => [:january, 31])
+r = Recurrence.new(:every => :year, :on => [10, 31], :repeat => 3)
+r = Recurrence.yearly(:on => [:january, 31])
+
+# Limit recurrence
+# :starts defaults to Date.today
+# :until defaults to 2037-12-31
+r = Recurrence.new(:every => :day, :starts => Date.today)
+r = Recurrence.new(:every => :day, :until => '2010-01-31')
+r = Recurrence.new(:every => :day, :starts => Date.today, :until => '2010-01-31')
+
+# Generate a collection of events which always includes a final event with the given through date
+# :through defaults to being unset
+r = Recurrence.new(:every => :day, :through => '2010-01-31')
+r = Recurrence.new(:every => :day, :starts => Date.today, :through => '2010-01-31')
+
+# Remove a date in the series on the given except date(s)
+# :except defaults to being unset
+r = Recurrence.new(:every => :day, :except => '2010-01-31')
+r = Recurrence.new(:every => :day, :except => [Date.today, '2010-01-31'])
+
+# Override the next date handler
+r = Recurrence.new(:every => :month, :on => 1, :handler => Proc.new { |day, month, year| raise("Date not allowed!") if year == 2011 && month == 12 && day == 31 })
+
+# Shift the recurrences to maintain dates around boundaries (Jan 31 -> Feb 28 -> Mar 28)
+r = Recurrence.new(:every => :month, :on => 31, :shift => true)
+
+# Getting an array with all events
+r.events.each {|date| puts date.to_s }  # => Memoized array
+r.events!.each {|date| puts date.to_s } # => reset items cache and re-execute it
+r.events(:starts => '2009-01-01').each {|date| puts date.to_s }
+r.events(:until => '2009-01-10').each {|date| puts date.to_s }
+r.events(:through => '2009-01-10').each {|date| puts date.to_s }
+r.events(:starts => '2009-01-05', :until => '2009-01-10').each {|date| puts date.to_s }
+
+# Iterating events
+r.each { |date| puts date.to_s } # => Use items method
+r.each! { |date| puts date.to_s } # => Use items! method
+
+# Check if a date is included
+r.include?(Date.today) # => true or false
+r.include?('2008-09-21')
+
+# Get next available date
+r.next   # => Keep the original date object
+r.next! # => Change the internal date object to the next available date
+```
+
+## Troubleshooting
+
+If you're having problems because already have a class/module called Recurrence that is conflicting with this gem, you can require the namespace and create a class that inherits from `SimplesIdeias::Recurrence`.
+
+```ruby
+require "recurrence/namespace"
+
+class RecurrentEvent < SimplesIdeias::Recurrence
+end
+
+r = RecurrentEvent.new(:every => :day)
+```
+
+If you're using Rails/Bundler or something like that, remember to override the `:require` option.
+
+```ruby
+# Gemfile
+source "https://rubygems.org"
+
+gem "recurrence", :require => "recurrence/namespace"
+```
+
+## Maintainer
+
+* Nando Vieira (http://nandovieira.com.br)
+
+## Contributors
+
+* https://github.com/fnando/recurrence/graphs/contributors
+
+## License
+
+(The MIT License)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -3,9 +3,3 @@ Bundler::GemHelper.install_tasks
 
 require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new
-
-require "rdoc/task"
-Rake::RDocTask.new do |rd|
- rd.main = "README.rdoc"
- rd.rdoc_files.include("README.rdoc", "lib/**/*.rb", "History.txt", "License.txt")
-end

data/lib/recurrence/event/base.rb

@@ -35,6 +35,7 @@ module SimplesIdeias
 
           @date = next_in_recurrence
 
+          @finished = true if @options[:through] && @date >= @options[:through]
           @finished, @date = true, nil if @date > @options[:until]
           shift_to @date if @date && @options[:shift]
           @date

data/lib/recurrence/event/monthly.rb

@@ -57,7 +57,7 @@ module SimplesIdeias
           # Have a raw month from 0 to 11 interval
           raw_month  = date.month + interval - 1
 
-          next_year  = date.year + raw_month / 12
+          next_year  = date.year + raw_month.div(12)
           next_month = (raw_month % 12) + 1 # change back to ruby interval
 
           @options[:handler].call(@options[:on], next_month, next_year)
@@ -65,7 +65,7 @@ module SimplesIdeias
 
         def advance_to_month_by_weekday(date, interval=@options[:interval])
           raw_month  = date.month + interval - 1
-          next_year  = date.year + raw_month / 12
+          next_year  = date.year + raw_month.div(12)
           next_month = (raw_month % 12) + 1 # change back to ruby interval
           date       = Date.new(next_year, next_month, 1)
 
@@ -79,7 +79,7 @@ module SimplesIdeias
 
           # Go to the previous month if we lost it
           if date.month != month
-            weeks = (date.day - 1) / 7 + 1
+            weeks = (date.day - 1).div(7) + 1
             date -= weeks * 7
           end
 

data/lib/recurrence/namespace.rb

@@ -71,6 +71,7 @@ module SimplesIdeias
     #   Recurrence.daily(:starts => 3.days.from_now)
     #   Recurrence.daily(:until => 10.days.from_now)
     #   Recurrence.daily(:repeat => 5)
+    #   Recurrence.daily(:except => Date.tomorrow)
     #
     def self.daily(options = {})
       options[:every] = :day
@@ -139,24 +140,16 @@ module SimplesIdeias
     #   Recurrence.new(:every => :year, :on => [:jan, 14])
     #
     def initialize(options)
-      raise ArgumentError, ":every option is required" unless options.key?(:every)
-      raise ArgumentError, "invalid :every option"     unless FREQUENCY.include?(options[:every].to_s)
+      validate_initialize_options(options)
+
+      options[:except] = [options[:except]].flatten.map {|d| as_date(d)} if options[:except]
 
       @options = options
       @_options = initialize_dates(options.dup)
       @_options[:interval] ||= 1
       @_options[:handler] ||= Handler::FallBack
 
-      @event = case @_options[:every].to_sym
-        when :day
-          Event::Daily.new(@_options)
-        when :week
-          Event::Weekly.new(@_options)
-        when :month
-          Event::Monthly.new(@_options)
-        when :year
-          Event::Yearly.new(@_options)
-      end
+      @event = initialize_event(@_options[:every])
     end
 
     # Reset the recurrence cache, returning to the first available date.
@@ -221,12 +214,14 @@ module SimplesIdeias
     #     [5] Sat, 20 Nov 2010
     # ]
     #
-    def events(options={})
+    def events(options = {})
       options[:starts] = as_date(options[:starts])
       options[:until]  = as_date(options[:until])
+      options[:through]  = as_date(options[:through])
       options[:repeat] ||= @options[:repeat]
+      options[:except] ||= @options[:except]
 
-      reset! if options[:starts] || options[:until]
+      reset! if options[:starts] || options[:until] || options[:through]
 
       @events ||= Array.new.tap do |list|
         loop do
@@ -236,12 +231,14 @@ module SimplesIdeias
 
           valid_start = options[:starts].nil? || date >= options[:starts]
           valid_until = options[:until].nil?  || date <= options[:until]
-          list << date if valid_start && valid_until
+          valid_except = options[:except].nil? || !options[:except].include?(date)
+          list << date if valid_start && valid_until && valid_except
 
           stop_repeat = options[:repeat] && list.size == options[:repeat]
           stop_until = options[:until] && options[:until] <= date
+          stop_through = options[:through] && options[:through] <= date
 
-          break if stop_until || stop_repeat
+          break if stop_until || stop_repeat || stop_through
         end
       end
     end
@@ -281,8 +278,26 @@ module SimplesIdeias
     end
 
     private
+    def validate_initialize_options(options)
+      raise ArgumentError, ":every option is required" unless options.key?(:every)
+      raise ArgumentError, ":every option is invalid"  unless FREQUENCY.include?(options[:every].to_s)
+    end
+
+    def initialize_event(type)
+      case type.to_sym
+        when :day
+          Event::Daily.new(@_options)
+        when :week
+          Event::Weekly.new(@_options)
+        when :month
+          Event::Monthly.new(@_options)
+        when :year
+          Event::Yearly.new(@_options)
+      end
+    end
+
     def initialize_dates(options) # :nodoc:
-      [:starts, :until].each do |name|
+      [:starts, :until, :through].each do |name|
         options[name] = as_date(options[name])
       end
 

data/lib/recurrence/version.rb

@@ -2,7 +2,7 @@ module SimplesIdeias
   class Recurrence
     module Version
       MAJOR = 1
-      MINOR = 2
+      MINOR = 3
       PATCH = 0
       STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
     end

data/recurrence.gemspec

@@ -1,6 +1,4 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require 'recurrence/version'
+require "./lib/recurrence/version"
 
 Gem::Specification.new do |s|
   s.name        = "recurrence"
@@ -17,8 +15,8 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency "activesupport", ">= 2.3.0"
+  s.add_dependency "activesupport"
   s.add_dependency "i18n"
-  s.add_development_dependency "rspec", "~> 2.6"
-  s.add_development_dependency "rake", "~> 0.9"
+  s.add_development_dependency "rspec", "3.0.0.beta2"
+  s.add_development_dependency "rake"
 end

data/spec/recurrence_spec.rb

@@ -3,64 +3,64 @@ require "spec_helper"
 describe Recurrence do
   let(:enumerator_constant){ RUBY_VERSION > "1.9.0" ? Enumerator : Enumerable::Enumerator }
 
-  it "should require :every option" do
+  it "requires :every option" do
     expect { recurrence({}) }.to raise_error(ArgumentError)
   end
 
-  it "should require valid :every option" do
+  it "requires valid :every option" do
     expect { recurrence(:every => "invalid") }.to raise_error(ArgumentError)
   end
 
-  it "should require :interval to be greater than zero when provided" do
+  it "requires :interval to be greater than zero when provided" do
     expect { recurrence(:every => :day, :interval => 0) }.to raise_error(ArgumentError)
   end
 
-  it "should require :repeat to be greater than zero when provided" do
+  it "requires :repeat to be greater than zero when provided" do
     expect { recurrence(:every => :day, :repeat => 0) }.to raise_error(ArgumentError)
   end
 
-  it "should return an enumerator when Recurrence#each is called without a block" do
-    recurrence(:every => :day).each.should be_instance_of(enumerator_constant)
+  it "returns an enumerator when Recurrence#each is called without a block" do
+    expect(recurrence(:every => :day).each).to be_instance_of(enumerator_constant)
   end
 
-  it "should return an enumerator when Recurrence#each! is called without a block" do
-    recurrence(:every => :day).each!.should be_instance_of(enumerator_constant)
+  it "returns an enumerator when Recurrence#each! is called without a block" do
+    expect(recurrence(:every => :day).each!).to be_instance_of(enumerator_constant)
   end
 
   Recurrence::Event::Monthly::INTERVALS.each do |interval|
-    it "should accept valid :interval symbol for monthly recurrence (#{interval[0]})" do
+    it "accepts valid :interval symbol for monthly recurrence (#{interval[0]})" do
       expect {
         recurrence(:every => :month, :on => 10, :interval => interval[0])
-      }.to_not raise_error(ArgumentError)
+      }.to_not raise_error
     end
   end
 
   Recurrence::Event::Yearly::MONTHS.each do |month_name, month_number|
-    it "should accept month as symbol for yearly recurrence (#{month_name})" do
+    it "accepts month as symbol for yearly recurrence (#{month_name})" do
       expect {
         recurrence(:every => :year, :on => [month_name, 10])
-      }.to_not raise_error(ArgumentError)
+      }.to_not raise_error
     end
   end
 
-  it "should require month to be a valid symbol for yearly recurrence" do
+  it "requires month to be a valid symbol for yearly recurrence" do
     expect {
       recurrence(:every => :year, :on => [:invalid, 10])
     }.to raise_error(ArgumentError)
   end
 
-  it "should require :interval to be a valid symbol for monthly recurrence" do
+  it "requires :interval to be a valid symbol for monthly recurrence" do
     expect {
       recurrence(:every => :month, :on => 10, :interval => :invalid)
     }.to raise_error(ArgumentError)
   end
 
   describe ".default_starts_date" do
-    it "should return Date.today by default" do
-      Recurrence.default_starts_date.should == Date.today
+    it "returns Date.today by default" do
+      expect(Recurrence.default_starts_date).to eq(Date.today)
     end
 
-    it "should require only strings and procs" do
+    it "requires only strings and procs" do
       expect {
         Recurrence.default_starts_date = Date.tomorrow
       }.to raise_error(ArgumentError)
@@ -70,13 +70,13 @@ describe Recurrence do
       before { Recurrence.default_starts_date = "Date.tomorrow" }
       after { Recurrence.default_starts_date = nil }
 
-      it "should return Date.tomorrow" do
-        Recurrence.default_starts_date.should == Date.tomorrow
+      it "returns Date.tomorrow" do
+        expect(Recurrence.default_starts_date).to eq(Date.tomorrow)
       end
 
-      it "should have effect on generated events" do
+      it "has effect on generated events" do
         r = Recurrence.new(:every => :day, :until => 3.days.from_now.to_date)
-        r.events.first.should == Date.tomorrow
+        expect(r.events.first).to eq(Date.tomorrow)
       end
     end
 
@@ -84,93 +84,128 @@ describe Recurrence do
       before { Recurrence.default_starts_date = lambda { Date.tomorrow } }
       after { Recurrence.default_starts_date = nil }
 
-      it "should return Date.tomorrow" do
-        Recurrence.default_starts_date.should == Date.tomorrow
+      it "returns Date.tomorrow" do
+        expect(Recurrence.default_starts_date).to eq(Date.tomorrow)
       end
 
-      it "should have effect on generated events" do
+      it "has effect on generated events" do
         r = Recurrence.new(:every => :day, :until => 3.days.from_now.to_date)
-        r.events.first.should == Date.tomorrow
+        expect(r.events.first).to eq(Date.tomorrow)
       end
     end
   end
 
   context "with daily recurring" do
-    it "should recur until limit date" do
+    it "recurs until limit date" do
       @recurrence = Recurrence.daily
-      @recurrence.events[-1].should == Date.parse("2037-12-31")
+      expect(@recurrence.events[-1]).to eq(Date.parse("2037-12-31"))
     end
 
-    it "should repeat until 1 month from now" do
+    it "repeats until 1 month from now" do
       date = 1.month.from_now
       @recurrence = recurrence(:every => :day, :until => date.to_date)
-      @recurrence.events[-1].should == date.to_date
+      expect(@recurrence.events[-1]).to eq(date.to_date)
     end
 
-    it "should start 2 months ago (#{2.months.ago.to_s(:date)})" do
+    it "recurs through 1 month from now" do
+      date = 1.month.from_now
+      @recurrence = recurrence(:every => :day, :through => date.to_date)
+      expect(@recurrence.events[-1]).to eq(date.to_date)
+    end
+
+    it "starts 2 months ago (#{2.months.ago.to_s(:date)})" do
       date = 2.months.ago
       @recurrence = recurrence(:every => :day, :starts => date.to_date)
-      @recurrence.events[0].should == date.to_date
-      @recurrence.events[1].should == (date + 1.day).to_date
-      @recurrence.events[2].should == (date + 2.day).to_date
+      expect(@recurrence.events[0]).to eq(date.to_date)
+      expect(@recurrence.events[1]).to eq((date + 1.day).to_date)
+      expect(@recurrence.events[2]).to eq((date + 2.day).to_date)
     end
 
-    it "should start at 2008-03-19 and repeat until 2008-04-24" do
+    it "starts at 2008-03-19 and repeat until 2008-04-24" do
       @recurrence = recurrence(:every => :day, :starts => "2008-03-19", :until => "2008-04-24")
-      @recurrence.events[0].to_s.should == "2008-03-19"
-      @recurrence.events[1].to_s.should == "2008-03-20"
-      @recurrence.events[-1].to_s.should == "2008-04-24"
+      expect(@recurrence.events[0].to_s).to eq("2008-03-19")
+      expect(@recurrence.events[1].to_s).to eq("2008-03-20")
+      expect(@recurrence.events[-1].to_s).to eq("2008-04-24")
     end
 
-    it "should use interval" do
+    it "starts at 2008-03-19 and repeat through 2008-04-24" do
+      @recurrence = recurrence(:every => :day, :starts => "2008-03-19", :through => "2008-04-24")
+      expect(@recurrence.events[0].to_s).to eq("2008-03-19")
+      expect(@recurrence.events[1].to_s).to eq("2008-03-20")
+      expect(@recurrence.events[-1].to_s).to eq("2008-04-24")
+    end
+
+    it "uses interval" do
       @recurrence = recurrence(:every => :day, :interval => 2, :starts => "2008-09-21")
-      @recurrence.events[0].to_s.should == "2008-09-21"
-      @recurrence.events[1].to_s.should == "2008-09-23"
-      @recurrence.events[2].to_s.should == "2008-09-25"
+      expect(@recurrence.events[0].to_s).to eq("2008-09-21")
+      expect(@recurrence.events[1].to_s).to eq("2008-09-23")
+      expect(@recurrence.events[2].to_s).to eq("2008-09-25")
     end
 
-    it "should use repeat" do
+    it "uses repeat" do
       @recurrence = recurrence(:every => :day, :starts => "2008-09-21", :repeat => 10)
-      @recurrence.events.size.should == 10
+      expect(@recurrence.events.size).to eq(10)
     end
 
-    it "should have a lacking day if the interval does not match the last day" do
+    it "has a lacking day if the interval does not match the last day" do
       @recurrence = recurrence(
         :every    => :day,
         :starts   => "2008-03-19",
         :until    => "2008-04-25",
         :interval => 2
       )
-      @recurrence.events[-1].to_s.should == "2008-04-24"
+      expect(@recurrence.events[-1].to_s).to eq("2008-04-24")
+    end
+
+    it "doesn't have a lacking day if the interval does not match the last day" do
+      @recurrence = recurrence(
+        :every    => :day,
+        :starts   => "2008-03-19",
+        :through  => "2008-04-25",
+        :interval => 2
+      )
+      expect(@recurrence.events[-1].to_s).to eq("2008-04-26")
+    end
+
+    it "uses except" do
+      @recurrence = Recurrence.daily(:except => Date.tomorrow)
+      expect(@recurrence.events.include?(Date.tomorrow)).to be_falsey
+      expect(@recurrence.events.include?(Date.tomorrow+1.day)).to be_truthy
     end
   end
 
   context "with weekly recurring" do
-    it "should recur until limit date" do
+    it "recurs until limit date" do
       @recurrence = Recurrence.weekly(:on => :thursday)
-      @recurrence.events[-1].should == Date.parse("2037-12-31")
+      expect(@recurrence.events[-1]).to eq(Date.parse("2037-12-31"))
     end
 
-    it "should repeat 6 weeks from now" do
+    it "repeats 6 weeks from now" do
       date = 6.weeks.from_now
       @recurrence = recurrence(:every => :week, :on => date.wday, :until => date.to_date)
-      @recurrence.events[-1].should == date.to_date
+      expect(@recurrence.events[-1]).to eq(date.to_date)
+    end
+
+    it "repeats through 6 weeks from now" do
+      date = 6.weeks.from_now
+      @recurrence = recurrence(:every => :week, :on => date.wday, :through => date.to_date)
+      expect(@recurrence.events[-1]).to eq(date.to_date)
     end
 
-    it "should start 3 months ago (#{3.months.ago.to_s(:date)})" do
+    it "starts 3 months ago (#{3.months.ago.to_s(:date)})" do
       date = 3.months.ago
 
       @recurrence = recurrence(:every => :week, :on => date.wday, :starts => date.to_date)
-      @recurrence.events[0].should == date.to_date
-      @recurrence.events[1].should == (date + 1.week).to_date
-      @recurrence.events[2].should == (date + 2.weeks).to_date
-      @recurrence.events[3].should == (date + 3.weeks).to_date
-      @recurrence.events[4].should == (date + 4.weeks).to_date
-      @recurrence.events[5].should == (date + 5.weeks).to_date
-      @recurrence.events[6].should == (date + 6.weeks).to_date
+      expect(@recurrence.events[0]).to eq(date.to_date)
+      expect(@recurrence.events[1]).to eq((date + 1.week).to_date)
+      expect(@recurrence.events[2]).to eq((date + 2.weeks).to_date)
+      expect(@recurrence.events[3]).to eq((date + 3.weeks).to_date)
+      expect(@recurrence.events[4]).to eq((date + 4.weeks).to_date)
+      expect(@recurrence.events[5]).to eq((date + 5.weeks).to_date)
+      expect(@recurrence.events[6]).to eq((date + 6.weeks).to_date)
     end
 
-    it "should start at 2008-02-29 and repeat until 2008-03-14" do
+    it "starts at 2008-02-29 and repeat until 2008-03-14" do
       starts = Date.parse("2008-02-29")
       ends = Date.parse("2008-03-14")
 
@@ -180,12 +215,27 @@ describe Recurrence do
         :starts => starts,
         :until  => ends.to_date
       )
-      @recurrence.events[0].to_s.should == "2008-02-29"
-      @recurrence.events[1].to_s.should == "2008-03-07"
-      @recurrence.events[-1].to_s.should == ends.to_s
+      expect(@recurrence.events[0].to_s).to eq("2008-02-29")
+      expect(@recurrence.events[1].to_s).to eq("2008-03-07")
+      expect(@recurrence.events[-1].to_s).to eq(ends.to_s)
     end
 
-    it "should use interval" do
+    it "starts at 2008-02-29 and repeat through 2008-03-14" do
+      starts = Date.parse("2008-02-29")
+      ends = Date.parse("2008-03-14")
+
+      @recurrence = recurrence(
+        :every  => :week,
+        :on     => :friday,
+        :starts => starts,
+        :through=> ends.to_date
+      )
+      expect(@recurrence.events[0].to_s).to eq("2008-02-29")
+      expect(@recurrence.events[1].to_s).to eq("2008-03-07")
+      expect(@recurrence.events[-1].to_s).to eq(ends.to_s)
+    end
+
+    it "uses interval" do
       starts = Date.parse("2008-09-21")
       @recurrence = recurrence(
         :every    => :week,
@@ -194,16 +244,16 @@ describe Recurrence do
         :starts   => starts,
         :until    => "2009-01-01"
       )
-      @recurrence.events[0].to_s.should == "2008-09-21"
-      @recurrence.events[1].to_s.should == "2008-10-05"
-      @recurrence.events[2].to_s.should == "2008-10-19"
-      @recurrence.events[3].to_s.should == "2008-11-02"
-      @recurrence.events[4].to_s.should == "2008-11-16"
-      @recurrence.events[5].to_s.should == "2008-11-30"
-      @recurrence.events[6].to_s.should == "2008-12-14"
+      expect(@recurrence.events[0].to_s).to eq("2008-09-21")
+      expect(@recurrence.events[1].to_s).to eq("2008-10-05")
+      expect(@recurrence.events[2].to_s).to eq("2008-10-19")
+      expect(@recurrence.events[3].to_s).to eq("2008-11-02")
+      expect(@recurrence.events[4].to_s).to eq("2008-11-16")
+      expect(@recurrence.events[5].to_s).to eq("2008-11-30")
+      expect(@recurrence.events[6].to_s).to eq("2008-12-14")
     end
 
-    it "should use repeat" do
+    it "uses repeat" do
       starts = Date.parse("2008-09-21")
       @recurrence = recurrence(
         :every    => :week,
@@ -212,10 +262,10 @@ describe Recurrence do
         :until    => "2011-01-01",
         :repeat    => 5
       )
-      @recurrence.events.size.should == 5
+      expect(@recurrence.events.size).to eq(5)
     end
 
-    it "should occur several times per week" do
+    it "occurs several times per week" do
       starts = Date.parse("2008-09-21") #=> sunday
       @recurrence = recurrence(
         :every    => :week,
@@ -224,14 +274,14 @@ describe Recurrence do
         :starts   => starts,
         :until    => "2009-01-01"
       )
-      @recurrence.events[0].to_s.should == "2008-09-21"
-      @recurrence.events[1].to_s.should == "2008-09-27"
-      @recurrence.events[2].to_s.should == "2008-10-05"
-      @recurrence.events[3].to_s.should == "2008-10-11"
-      @recurrence.events[4].to_s.should == "2008-10-19"
-      @recurrence.events[5].to_s.should == "2008-10-25"
-      @recurrence.events[6].to_s.should == "2008-11-02"
-      @recurrence.events[7].to_s.should == "2008-11-08"
+      expect(@recurrence.events[0].to_s).to eq("2008-09-21")
+      expect(@recurrence.events[1].to_s).to eq("2008-09-27")
+      expect(@recurrence.events[2].to_s).to eq("2008-10-05")
+      expect(@recurrence.events[3].to_s).to eq("2008-10-11")
+      expect(@recurrence.events[4].to_s).to eq("2008-10-19")
+      expect(@recurrence.events[5].to_s).to eq("2008-10-25")
+      expect(@recurrence.events[6].to_s).to eq("2008-11-02")
+      expect(@recurrence.events[7].to_s).to eq("2008-11-08")
 
       starts = Date.parse("2008-09-21") #=> sunday
       @recurrence = recurrence(
@@ -240,15 +290,15 @@ describe Recurrence do
         :starts => starts,
         :until  => "2009-01-01"
       )
-      @recurrence.events[0].to_s.should == "2008-09-22"
-      @recurrence.events[1].to_s.should == "2008-09-24"
-      @recurrence.events[2].to_s.should == "2008-09-26"
-      @recurrence.events[3].to_s.should == "2008-09-29"
-      @recurrence.events[4].to_s.should == "2008-10-01"
-      @recurrence.events[5].to_s.should == "2008-10-03"
+      expect(@recurrence.events[0].to_s).to eq("2008-09-22")
+      expect(@recurrence.events[1].to_s).to eq("2008-09-24")
+      expect(@recurrence.events[2].to_s).to eq("2008-09-26")
+      expect(@recurrence.events[3].to_s).to eq("2008-09-29")
+      expect(@recurrence.events[4].to_s).to eq("2008-10-01")
+      expect(@recurrence.events[5].to_s).to eq("2008-10-03")
     end
 
-    it "should run until next available saturday" do
+    it "runs until next available saturday" do
       starts = Date.parse("2008-09-21") # => sunday
       @recurrence = recurrence(
         :every  => :week,
@@ -256,31 +306,44 @@ describe Recurrence do
         :starts => starts,
         :until  => "2009-01-01"
       )
-      @recurrence.events[0].to_s.should == "2008-09-27"
+      expect(@recurrence.events[0].to_s).to eq("2008-09-27")
+    end
+
+    it "uses except" do
+      date = 6.weeks.from_now
+      @recurrence = recurrence(:every => :week, :on => date.wday, :except => 2.weeks.from_now.to_date)
+      expect(@recurrence.events.include?(1.week.from_now.to_date)).to be_truthy
+      expect(@recurrence.events.include?(2.weeks.from_now.to_date)).to be_falsey
     end
   end
 
   context "with monthly recurring" do
     context "using day" do
-      it "should recur until limit date" do
+      it "recurs until limit date" do
         @recurrence = Recurrence.monthly(:on => 31)
-        @recurrence.events[-1].should == Date.parse("2037-12-31")
+        expect(@recurrence.events[-1]).to eq(Date.parse("2037-12-31"))
       end
 
-      it "should repeat until 8 months from now" do
+      it "repeats until 8 months from now" do
         date = 8.months.from_now
         @recurrence = recurrence(:every => :month, :on => date.day, :until => date.to_date)
-        @recurrence.events[-1].should == date.to_date
+        expect(@recurrence.events[-1]).to eq(date.to_date)
+      end
+
+      it "repeats through 8 months from now" do
+        date = 8.months.from_now
+        @recurrence = recurrence(:every => :month, :on => date.day, :through => date.to_date)
+        expect(@recurrence.events[-1]).to eq(date.to_date)
       end
 
-      it "should start 9 months ago" do
+      it "starts 9 months ago" do
         date = 9.months.ago
 
         @recurrence = recurrence(:every => :month, :on => date.day, :starts => date.to_date)
-        @recurrence.events[0].should == date.to_date
+        expect(@recurrence.events[0]).to eq(date.to_date)
       end
 
-      it "should start at 2008-06-07 and repeat until 2008-11-07" do
+      it "starts at 2008-06-07 and repeat until 2008-11-07" do
         starts = Date.parse("2008-06-07")
         ends = Date.parse("2008-11-07")
 
@@ -290,11 +353,25 @@ describe Recurrence do
           :starts => starts,
           :until  => ends
         )
-        @recurrence.events[0].to_s.should == "2008-06-07"
-        @recurrence.events[-1].to_s.should == "2008-11-07"
+        expect(@recurrence.events[0].to_s).to eq("2008-06-07")
+        expect(@recurrence.events[-1].to_s).to eq("2008-11-07")
+      end
+
+      it "starts at 2008-06-07 and repeat through 2008-11-07" do
+        starts = Date.parse("2008-06-07")
+        ends = Date.parse("2008-11-07")
+
+        @recurrence = recurrence(
+          :every  => :month,
+          :on     => starts.day,
+          :starts => starts,
+          :through=> ends
+        )
+        expect(@recurrence.events[0].to_s).to eq("2008-06-07")
+        expect(@recurrence.events[-1].to_s).to eq("2008-11-07")
       end
 
-      it "should run until next available 27th" do
+      it "runs until next available 27th" do
         starts = Date.parse("2008-09-28")
 
         @recurrence = recurrence(
@@ -303,10 +380,22 @@ describe Recurrence do
           :starts => starts,
           :until  => "2009-01-01"
         )
-        @recurrence.events[0].to_s.should == "2008-10-27"
+        expect(@recurrence.events[0].to_s).to eq("2008-10-27")
+      end
+
+      it "runs through final available 27th" do
+        starts = Date.parse("2008-09-28")
+
+        @recurrence = recurrence(
+          :every  => :month,
+          :on     => 27,
+          :starts => starts,
+          :through=> "2009-01-01"
+        )
+        expect(@recurrence.events[-1].to_s).to eq("2009-01-27")
       end
 
-      it "should use interval" do
+      it "uses interval" do
         starts = Date.parse("2008-01-31")
         @recurrence = recurrence(
           :every    => :month,
@@ -315,13 +404,13 @@ describe Recurrence do
           :starts   => starts,
           :until    => "2010-01-01"
         )
-        @recurrence.events[0].to_s.should == "2008-01-31"
-        @recurrence.events[1].to_s.should == "2008-03-31"
-        @recurrence.events[2].to_s.should == "2008-05-31"
-        @recurrence.events[3].to_s.should == "2008-07-31"
-        @recurrence.events[4].to_s.should == "2008-09-30"
-        @recurrence.events[5].to_s.should == "2008-11-30"
-        @recurrence.events[6].to_s.should == "2009-01-31"
+        expect(@recurrence.events[0].to_s).to eq("2008-01-31")
+        expect(@recurrence.events[1].to_s).to eq("2008-03-31")
+        expect(@recurrence.events[2].to_s).to eq("2008-05-31")
+        expect(@recurrence.events[3].to_s).to eq("2008-07-31")
+        expect(@recurrence.events[4].to_s).to eq("2008-09-30")
+        expect(@recurrence.events[5].to_s).to eq("2008-11-30")
+        expect(@recurrence.events[6].to_s).to eq("2009-01-31")
 
         starts = Date.parse("2008-01-31")
         @recurrence = recurrence(
@@ -331,12 +420,12 @@ describe Recurrence do
           :starts   => starts,
           :until    => "2010-01-01"
         )
-        @recurrence.events[0].to_s.should == "2008-04-29"
-        @recurrence.events[1].to_s.should == "2008-07-29"
-        @recurrence.events[2].to_s.should == "2008-10-29"
-        @recurrence.events[3].to_s.should == "2009-01-29"
-        @recurrence.events[4].to_s.should == "2009-04-29"
-        @recurrence.events[5].to_s.should == "2009-07-29"
+        expect(@recurrence.events[0].to_s).to eq("2008-04-29")
+        expect(@recurrence.events[1].to_s).to eq("2008-07-29")
+        expect(@recurrence.events[2].to_s).to eq("2008-10-29")
+        expect(@recurrence.events[3].to_s).to eq("2009-01-29")
+        expect(@recurrence.events[4].to_s).to eq("2009-04-29")
+        expect(@recurrence.events[5].to_s).to eq("2009-07-29")
 
         starts = Date.parse("2008-02-29")
         @recurrence = recurrence(
@@ -346,13 +435,13 @@ describe Recurrence do
           :starts   => starts,
           :until    => "2010-01-01"
         )
-        @recurrence.events[0].to_s.should == "2008-02-29"
-        @recurrence.events[1].to_s.should == "2008-06-30"
-        @recurrence.events[2].to_s.should == "2008-10-31"
-        @recurrence.events[3].to_s.should == "2009-02-28"
+        expect(@recurrence.events[0].to_s).to eq("2008-02-29")
+        expect(@recurrence.events[1].to_s).to eq("2008-06-30")
+        expect(@recurrence.events[2].to_s).to eq("2008-10-31")
+        expect(@recurrence.events[3].to_s).to eq("2009-02-28")
       end
 
-      it "should use repeat" do
+      it "uses repeat" do
         starts = Date.parse("2008-01-31")
         @recurrence = recurrence(
           :every    => :month,
@@ -361,22 +450,28 @@ describe Recurrence do
           :until    => "2010-01-01",
           :repeat    => 5
         )
-        @recurrence.events.size.should == 5
+        expect(@recurrence.events.size).to eq(5)
+      end
+
+      it "uses except" do
+        @recurrence = recurrence(:every => :month, :on => Date.today.day, :except => 8.months.from_now.to_date)
+        expect(@recurrence.events.include?(7.months.from_now.to_date)).to be_truthy
+        expect(@recurrence.events.include?(8.months.from_now.to_date)).to be_falsey
       end
     end
 
     context "using weekday" do
-      it "should recur until limit date" do
+      it "recurs until limit date" do
         @recurrence = Recurrence.daily(:on => 5, :weekday => :thursday)
-        @recurrence.events[-1].should == Date.parse("2037-12-31")
+        expect(@recurrence.events[-1]).to eq(Date.parse("2037-12-31"))
       end
 
-      it "should use weekday shortcut" do
+      it "uses weekday shortcut" do
         @recurrence = Recurrence.daily(:on => 5, :weekday => :thu)
-        @recurrence.events[-1].should == Date.parse("2037-12-31")
+        expect(@recurrence.events[-1]).to eq(Date.parse("2037-12-31"))
       end
 
-      it "should repeat until 8 months from now" do
+      it "repeats until 8 months from now" do
         date = 8.months.from_now
         week = (date.day - 1) / 7 + 1
         @recurrence = recurrence(
@@ -385,10 +480,22 @@ describe Recurrence do
           :weekday => date.wday,
           :until   => date.to_date
         )
-        @recurrence.events[-1].should == date.to_date
+        expect(@recurrence.events[-1]).to eq(date.to_date)
       end
 
-      it "should start 9 months ago" do
+      it "repeats through 8 months from now" do
+        date = 8.months.from_now
+        week = (date.day - 1) / 7 + 1
+        @recurrence = recurrence(
+          :every   => :month,
+          :on      => week,
+          :weekday => date.wday,
+          :through => date.to_date
+        )
+        expect(@recurrence.events[-1]).to eq(date.to_date)
+      end
+
+      it "starts 9 months ago" do
         date = 9.months.ago
         week = (date.day - 1) / 7 + 1
         @recurrence = recurrence(
@@ -397,10 +504,10 @@ describe Recurrence do
           :weekday => date.wday,
           :starts  => date.to_date
         )
-        @recurrence.events[0].should == date.to_date
+        expect(@recurrence.events[0]).to eq(date.to_date)
       end
 
-      it "should start at 2008-06-07 and repeat until 2008-11-01 (first saturday)" do
+      it "starts at 2008-06-07 and repeat until 2008-11-01 (first saturday)" do
         starts = Date.parse("2008-06-07")
         ends = Date.parse("2008-11-01")
 
@@ -411,11 +518,11 @@ describe Recurrence do
           :starts  => starts,
           :until   => ends
         )
-        @recurrence.events[0].to_s.should == "2008-06-07"
-        @recurrence.events[-1].to_s.should == "2008-11-01"
+        expect(@recurrence.events[0].to_s).to eq("2008-06-07")
+        expect(@recurrence.events[-1].to_s).to eq("2008-11-01")
       end
 
-      it "should start at 2008-06-29 and repeat until 2008-11-30 (last sunday)" do
+      it "starts at 2008-06-29 and repeat until 2008-11-30 (last sunday)" do
         starts = Date.parse("2008-06-29")
         ends = Date.parse("2008-11-30")
 
@@ -426,11 +533,11 @@ describe Recurrence do
           :starts  => starts,
           :until   => ends
         )
-        @recurrence.events[0].to_s.should == "2008-06-29"
-        @recurrence.events[-1].to_s.should == "2008-11-30"
+        expect(@recurrence.events[0].to_s).to eq("2008-06-29")
+        expect(@recurrence.events[-1].to_s).to eq("2008-11-30")
       end
 
-      it "should use interval" do
+      it "uses interval" do
         starts = Date.parse("2009-01-01")
         @recurrence = recurrence(
           :every    => :month,
@@ -440,16 +547,16 @@ describe Recurrence do
           :starts   => starts,
           :until    => "2010-02-01"
         )
-        @recurrence.events[0].to_s.should == "2009-01-18"
-        @recurrence.events[1].to_s.should == "2009-03-15"
-        @recurrence.events[2].to_s.should == "2009-05-17"
-        @recurrence.events[3].to_s.should == "2009-07-19"
-        @recurrence.events[4].to_s.should == "2009-09-20"
-        @recurrence.events[5].to_s.should == "2009-11-15"
-        @recurrence.events[6].to_s.should == "2010-01-17"
+        expect(@recurrence.events[0].to_s).to eq("2009-01-18")
+        expect(@recurrence.events[1].to_s).to eq("2009-03-15")
+        expect(@recurrence.events[2].to_s).to eq("2009-05-17")
+        expect(@recurrence.events[3].to_s).to eq("2009-07-19")
+        expect(@recurrence.events[4].to_s).to eq("2009-09-20")
+        expect(@recurrence.events[5].to_s).to eq("2009-11-15")
+        expect(@recurrence.events[6].to_s).to eq("2010-01-17")
       end
 
-      it "should use repeat" do
+      it "uses repeat" do
         starts = Date.parse("2009-01-01")
         @recurrence = recurrence(
           :every    => :month,
@@ -459,7 +566,7 @@ describe Recurrence do
           :until    => "2011-02-01",
           :repeat    => 5
         )
-        @recurrence.events.size.should == 5
+        expect(@recurrence.events.size).to eq(5)
       end
     end
 
@@ -468,82 +575,92 @@ describe Recurrence do
         @starts = Date.parse("2008-09-03")
       end
 
-      it "should use numeric interval" do
+      it "uses numeric interval" do
         @recurrence = recurrence(:every => :month, :on => 21, :interval => 2, :starts => @starts)
-        @recurrence.events[0].to_s.should == "2008-09-21"
-        @recurrence.events[1].to_s.should == "2008-11-21"
-        @recurrence.events[2].to_s.should == "2009-01-21"
-        @recurrence.events[3].to_s.should == "2009-03-21"
+        expect(@recurrence.events[0].to_s).to eq("2008-09-21")
+        expect(@recurrence.events[1].to_s).to eq("2008-11-21")
+        expect(@recurrence.events[2].to_s).to eq("2009-01-21")
+        expect(@recurrence.events[3].to_s).to eq("2009-03-21")
       end
 
-      it "should accept monthly symbol" do
+      it "accepts monthly symbol" do
         @recurrence = recurrence(
           :every    => :month,
           :on       => 10,
           :starts   => @starts,
           :interval => :monthly
         )
-        @recurrence.events[0].to_s.should == "2008-09-10"
-        @recurrence.events[1].to_s.should == "2008-10-10"
+        expect(@recurrence.events[0].to_s).to eq("2008-09-10")
+        expect(@recurrence.events[1].to_s).to eq("2008-10-10")
       end
 
-      it "should accept bimonthly symbol" do
+      it "accepts bimonthly symbol" do
         @recurrence = recurrence(
           :every    => :month,
           :on       => 10,
           :starts   => @starts,
           :interval => :bimonthly
         )
-        @recurrence.events[0].to_s.should == "2008-09-10"
-        @recurrence.events[1].to_s.should == "2008-11-10"
+        expect(@recurrence.events[0].to_s).to eq("2008-09-10")
+        expect(@recurrence.events[1].to_s).to eq("2008-11-10")
       end
 
-      it "should accept quarterly symbol" do
+      it "accepts quarterly symbol" do
         @recurrence = recurrence(
           :every    => :month,
           :on       => 10,
           :starts   => @starts,
           :interval => :quarterly
         )
-        @recurrence.events[0].to_s.should == "2008-09-10"
-        @recurrence.events[1].to_s.should == "2008-12-10"
+        expect(@recurrence.events[0].to_s).to eq("2008-09-10")
+        expect(@recurrence.events[1].to_s).to eq("2008-12-10")
       end
 
-      it "should accept semesterly symbol" do
+      it "accepts semesterly symbol" do
         @recurrence = recurrence(:every => :month, :on => 10, :starts => @starts, :interval => :semesterly)
-        @recurrence.events[0].to_s.should == "2008-09-10"
-        @recurrence.events[1].to_s.should == "2009-03-10"
+        expect(@recurrence.events[0].to_s).to eq("2008-09-10")
+        expect(@recurrence.events[1].to_s).to eq("2009-03-10")
       end
     end
   end
 
   describe "with yearly recurring" do
-    it "should recur until limit date" do
+    it "recurs until limit date" do
       @recurrence = Recurrence.yearly(:on => [12,31])
-      @recurrence.events[-1].should == Date.parse("2037-12-31")
+      expect(@recurrence.events[-1]).to eq(Date.parse("2037-12-31"))
     end
 
-    it "should repeat until 7 years from now" do
+    it "repeats until 7 years from now" do
       date = 7.years.from_now
       @recurrence = recurrence(
         :every => :year,
         :on    => [date.month, date.day],
         :until => date.to_date
       )
-      @recurrence.events[-1].should == date.to_date
+      expect(@recurrence.events[-1]).to eq(date.to_date)
+    end
+
+    it "repeats through 7 years from now" do
+      date = 7.years.from_now
+      @recurrence = recurrence(
+        :every    => :year,
+        :on       => [date.month, date.day],
+        :through  => date.to_date
+      )
+      expect(@recurrence.events[-1]).to eq(date.to_date)
     end
 
-    it "should start 2 years ago" do
+    it "starts 2 years ago" do
       date = 2.years.ago
       @recurrence = recurrence(
         :every  => :year,
         :on     => [date.month, date.day],
         :starts => date.to_date
       )
-      @recurrence.events[0].should == date.to_date
+      expect(@recurrence.events[0]).to eq(date.to_date)
     end
 
-    it "should start at 2003-06-07 and repeat until 2018-06-07" do
+    it "starts at 2003-06-07 and repeat until 2018-06-07" do
       starts = Date.parse("2003-06-07")
       ends = Date.parse("2018-06-07")
 
@@ -553,11 +670,25 @@ describe Recurrence do
         :starts => starts,
         :until  => ends
       )
-      @recurrence.events[0].to_s.should == "2003-06-07"
-      @recurrence.events[-1].to_s.should == "2018-06-07"
+      expect(@recurrence.events[0].to_s).to eq("2003-06-07")
+      expect(@recurrence.events[-1].to_s).to eq("2018-06-07")
     end
 
-    it "should use interval" do
+    it "starts at 2003-06-07 and repeat through 2018-06-07" do
+      starts = Date.parse("2003-06-07")
+      ends = Date.parse("2018-06-07")
+
+      @recurrence = recurrence(
+        :every  => :year,
+        :on     => [starts.month, starts.day],
+        :starts => starts,
+        :through=> ends
+      )
+      expect(@recurrence.events[0].to_s).to eq("2003-06-07")
+      expect(@recurrence.events[-1].to_s).to eq("2018-06-07")
+    end
+
+    it "uses interval" do
       starts = Date.parse("2008-09-21")
 
       @recurrence = recurrence(
@@ -566,13 +697,13 @@ describe Recurrence do
         :interval => 2,
         :starts   => starts
       )
-      @recurrence.events[0].to_s.should == "2008-09-21"
-      @recurrence.events[1].to_s.should == "2010-09-21"
-      @recurrence.events[2].to_s.should == "2012-09-21"
-      @recurrence.events[3].to_s.should == "2014-09-21"
+      expect(@recurrence.events[0].to_s).to eq("2008-09-21")
+      expect(@recurrence.events[1].to_s).to eq("2010-09-21")
+      expect(@recurrence.events[2].to_s).to eq("2012-09-21")
+      expect(@recurrence.events[3].to_s).to eq("2014-09-21")
     end
 
-    it "should use repeat" do
+    it "uses repeat" do
       starts = Date.parse("2008-09-21")
 
       @recurrence = recurrence(
@@ -581,143 +712,184 @@ describe Recurrence do
         :starts   => starts,
         :repeat    => 5
       )
-      @recurrence.events.size.should == 5
+      expect(@recurrence.events.size).to eq(5)
+    end
+
+    it "includes the through date when less than a perfect interval" do
+      starts = Date.parse("2003-06-07")
+      ends = Date.parse("2018-07-12")
+
+      @recurrence = recurrence(
+        :every    => :year,
+        :on       => [starts.month, starts.day],
+        :starts   => starts,
+        :through  => ends
+      )
+      expect(@recurrence.events[-1].to_s).to eq('2019-06-07')
     end
 
-    it "should run until next available date when chosen settings are greater than start date" do
+    it "runs until next available date when chosen settings are greater than start date" do
       starts = Date.parse("2008-09-03")
 
       @recurrence = recurrence(:every => :year, :on => [10, 27], :starts => starts)
-      @recurrence.events[0].to_s.should == "2008-10-27"
+      expect(@recurrence.events[0].to_s).to eq("2008-10-27")
     end
 
-    it "should run until next available date when chosen settings are smaller than start date" do
+    it "runs until next available date when chosen settings are smaller than start date" do
       starts = Date.parse("2008-09-03")
       @recurrence = recurrence(:every => :year, :on => [7, 1], :starts => starts)
-      @recurrence.events[0].to_s.should == "2009-07-01"
+      expect(@recurrence.events[0].to_s).to eq("2009-07-01")
 
       starts = Date.parse("2008-09-03")
       @recurrence = recurrence(:every => :year, :on => [9, 1], :starts => starts)
-      @recurrence.events[0].to_s.should == "2009-09-01"
+      expect(@recurrence.events[0].to_s).to eq("2009-09-01")
+    end
+
+    it "uses except" do
+      @recurrence = Recurrence.yearly(:on => [12,31], :except => "#{Time.now.year+3}-12-31")
+
+      expect(@recurrence.events.include?("#{Time.now.year+2}-12-31".to_date)).to be_truthy
+      expect(@recurrence.events.include?("#{Time.now.year+3}-12-31".to_date)).to be_falsey
+    end
+  end
+
+  context "with except", :focus => true do
+    it "accepts only valid date strings or Dates" do
+      expect { recurrence(:except => :symbol) }.to raise_error(ArgumentError)
+      expect { recurrence(:except => "invalid") }.to raise_error(ArgumentError)
+    end
+
+    it "skips day specified in except" do
+      @recurrence = recurrence(:every => :day, :except => Date.tomorrow)
+      expect(@recurrence.include?(Date.today)).to be_truthy
+      expect(@recurrence.include?(Date.tomorrow)).to be_falsey
+      expect(@recurrence.include?(Date.tomorrow+1.day)).to be_truthy
+    end
+
+    it "skips multiple days specified in except" do
+      @recurrence = recurrence(:every => :day, :except => [Date.tomorrow, "2012-02-29"])
+      expect(@recurrence.include?(Date.today)).to be_truthy
+      expect(@recurrence.include?(Date.tomorrow)).to be_falsey
+      expect(@recurrence.include?("2012-02-29")).to be_falsey
     end
   end
 
   describe "#options" do
-    it "should return passed-in options" do
+    it "returns passed-in options" do
       @recurrence = recurrence(:every => :day)
-      @recurrence.options.should == {:every => :day}
+      expect(@recurrence.options).to eq({:every => :day})
     end
   end
 
   describe "#include?" do
-    it "should include date (day)" do
+    it "includes date (day)" do
       @recurrence = recurrence(:every => :day, :starts => "2008-09-30")
-      @recurrence.include?("2008-09-30").should be_true
-      @recurrence.include?("2008-10-01").should be_true
+      expect(@recurrence.include?("2008-09-30")).to be_truthy
+      expect(@recurrence.include?("2008-10-01")).to be_truthy
     end
 
-    it "should include date (week)" do
+    it "includes date (week)" do
       @recurrence = recurrence(:every => :week, :on => :thursday, :starts => "2008-09-30")
-      @recurrence.include?("2008-09-30").should be_false
-      @recurrence.include?("2008-10-02").should be_true
+      expect(@recurrence.include?("2008-09-30")).to be_falsey
+      expect(@recurrence.include?("2008-10-02")).to be_truthy
 
       @recurrence = recurrence(:every => :week, :on => :monday, :starts => "2008-09-29")
-      @recurrence.include?("2008-09-29").should be_true
-      @recurrence.include?("2008-10-06").should be_true
+      expect(@recurrence.include?("2008-09-29")).to be_truthy
+      expect(@recurrence.include?("2008-10-06")).to be_truthy
     end
 
-    it "should include date (month)" do
+    it "includes date (month)" do
       @recurrence = recurrence(:every => :month, :on => 10, :starts => "2008-09-30")
-      @recurrence.include?("2008-09-30").should be_false
-      @recurrence.include?("2008-10-10").should be_true
+      expect(@recurrence.include?("2008-09-30")).to be_falsey
+      expect(@recurrence.include?("2008-10-10")).to be_truthy
 
       @recurrence = recurrence(:every => :month, :on => 10, :starts => "2008-09-10")
-      @recurrence.include?("2008-09-10").should be_true
-      @recurrence.include?("2008-10-10").should be_true
+      expect(@recurrence.include?("2008-09-10")).to be_truthy
+      expect(@recurrence.include?("2008-10-10")).to be_truthy
     end
 
-    it "should include date (year)" do
+    it "includes date (year)" do
       @recurrence = recurrence(:every => :year, :on => [6,28], :starts => "2008-09-30")
-      @recurrence.include?("2009-09-30").should be_false
-      @recurrence.include?("2009-06-28").should be_true
+      expect(@recurrence.include?("2009-09-30")).to be_falsey
+      expect(@recurrence.include?("2009-06-28")).to be_truthy
 
       @recurrence = recurrence(:every => :year, :on => [6,28], :starts => "2008-06-28")
-      @recurrence.include?("2009-06-28").should be_true
-      @recurrence.include?("2009-06-28").should be_true
+      expect(@recurrence.include?("2009-06-28")).to be_truthy
+      expect(@recurrence.include?("2009-06-28")).to be_truthy
     end
 
-    it "should not include date when is smaller than starting date (day)" do
+    it "doesn't include date when is smaller than starting date (day)" do
       @recurrence = recurrence(:every => :day, :starts => "2008-09-30")
-      @recurrence.include?("2008-09-29").should be_false
+      expect(@recurrence.include?("2008-09-29")).to be_falsey
     end
 
-    it "should not include date when is smaller than starting date (week)" do
+    it "doesn't include date when is smaller than starting date (week)" do
       @recurrence = recurrence(:every => :week, :on => :friday, :starts => "2008-09-30")
-      @recurrence.include?("2008-09-24").should be_false
+      expect(@recurrence.include?("2008-09-24")).to be_falsey
     end
 
-    it "should not include date when is smaller than starting date (month)" do
+    it "doesn't include date when is smaller than starting date (month)" do
       @recurrence = recurrence(:every => :month, :on => 10, :starts => "2008-09-30")
-      @recurrence.include?("2008-09-10").should be_false
+      expect(@recurrence.include?("2008-09-10")).to be_falsey
     end
 
-    it "should not include date when is smaller than starting date (year)" do
+    it "doesn't include date when is smaller than starting date (year)" do
       @recurrence = recurrence(:every => :year, :on => [6,28], :starts => "2008-09-30")
-      @recurrence.include?("2008-06-28").should be_false
+      expect(@recurrence.include?("2008-06-28")).to be_falsey
     end
 
-    it "should not include date when is greater than ending date (day)" do
+    it "doesn't include date when is greater than ending date (day)" do
       @recurrence = recurrence(:every => :day, :until => "2008-09-30")
-      @recurrence.include?("2008-10-01").should be_false
+      expect(@recurrence.include?("2008-10-01")).to be_falsey
     end
 
-    it "should not include date when is greater than ending date (week)" do
+    it "doesn't include date when is greater than ending date (week)" do
       @recurrence = recurrence(:every => :week, :on => :friday, :until => "2008-09-30")
-      @recurrence.include?("2008-10-03").should be_false
+      expect(@recurrence.include?("2008-10-03")).to be_falsey
     end
 
-    it "should not include date when is greater than ending date (year)" do
+    it "doesn't include date when is greater than ending date (year)" do
       @recurrence = recurrence(:every => :year, :on => [6,28], :until => "2008-09-30")
-      @recurrence.include?("2009-06-28").should be_false
+      expect(@recurrence.include?("2009-06-28")).to be_falsey
     end
   end
 
   describe "#next" do
-    it "should return next date" do
+    it "returns next date" do
       @recurrence = recurrence(:every => :day)
 
-      @recurrence.next.to_s.should == Date.today.to_s
-      @recurrence.next.to_s.should == Date.today.to_s
+      expect(@recurrence.next.to_s).to eq(Date.today.to_s)
+      expect(@recurrence.next.to_s).to eq(Date.today.to_s)
     end
 
-    it "should return next! date" do
+    it "returns next! date" do
       @recurrence = recurrence(:every => :day)
 
-      @recurrence.next!.to_s.should == Date.today.to_s
-      @recurrence.next!.to_s.should == 1.day.from_now.to_date.to_s
-      @recurrence.next!.to_s.should == 2.days.from_now.to_date.to_s
-      @recurrence.next!.to_s.should == 3.days.from_now.to_date.to_s
+      expect(@recurrence.next!.to_s).to eq(Date.today.to_s)
+      expect(@recurrence.next!.to_s).to eq(1.day.from_now.to_date.to_s)
+      expect(@recurrence.next!.to_s).to eq(2.days.from_now.to_date.to_s)
+      expect(@recurrence.next!.to_s).to eq(3.days.from_now.to_date.to_s)
     end
   end
 
   describe "#reset!" do
-    it "should reset to the first available date" do
+    it "resets to the first available date" do
       @recurrence = recurrence(:every => :year, :on => [2, 31], :starts => "2008-01-01")
-      @recurrence.next!.to_s.should  == "2008-02-29"
-      @recurrence.next!.to_s.should  == "2009-02-28"
+      expect(@recurrence.next!.to_s).to  eq("2008-02-29")
+      expect(@recurrence.next!.to_s).to  eq("2009-02-28")
       @recurrence.reset!
-      @recurrence.next.to_s.should == "2008-02-29"
+      expect(@recurrence.next.to_s).to eq("2008-02-29")
     end
   end
 
   describe "event initialization" do
-    it "should return the first available date" do
+    it "returns the first available date" do
       @recurrence = recurrence(:every => :year, :on => [2, 31], :starts => "2008-01-01")
-      @recurrence.next!.to_s.should == "2008-02-29"
-      @recurrence.next!.to_s.should == "2009-02-28"
-      @recurrence.next!.to_s.should == "2010-02-28"
-      @recurrence.next!.to_s.should == "2011-02-28"
-      @recurrence.next!.to_s.should == "2012-02-29"
+      expect(@recurrence.next!.to_s).to eq("2008-02-29")
+      expect(@recurrence.next!.to_s).to eq("2009-02-28")
+      expect(@recurrence.next!.to_s).to eq("2010-02-28")
+      expect(@recurrence.next!.to_s).to eq("2011-02-28")
+      expect(@recurrence.next!.to_s).to eq("2012-02-29")
     end
   end
 
@@ -726,44 +898,44 @@ describe Recurrence do
       @recurrence = recurrence(:every => :day, :starts => "2009-01-06", :until => "2009-01-15")
     end
 
-    it "should return starting and ending recurrences" do
-      @recurrence.events[0].to_s.should == "2009-01-06"
-      @recurrence.events[-1].to_s.should == "2009-01-15"
+    it "returns starting and ending recurrences" do
+      expect(@recurrence.events[0].to_s).to eq("2009-01-06")
+      expect(@recurrence.events[-1].to_s).to eq("2009-01-15")
     end
 
-    it "should reset cache" do
-      @recurrence.event.should_receive(:reset!).exactly(3).times
+    it "resets cache" do
+      expect(@recurrence.event).to receive(:reset!).exactly(3).times
       @recurrence.events(:starts => "2009-01-11")
       @recurrence.events(:until => "2009-01-14")
       @recurrence.events(:starts => "2009-01-11", :until => "2009-01-14")
     end
 
-    it "should return only events greater than starting date" do
+    it "returns only events greater than starting date" do
       @events = @recurrence.events(:starts => "2009-01-10")
-      @events[0].to_s.should == "2009-01-10"
+      expect(@events[0].to_s).to eq("2009-01-10")
     end
 
-    it "should return only events smaller than until date" do
+    it "returns only events smaller than until date" do
       @events = @recurrence.events(:until => "2009-01-10")
-      @events[0].to_s.should == "2009-01-06"
-      @events[-1].to_s.should == "2009-01-10"
+      expect(@events[0].to_s).to eq("2009-01-06")
+      expect(@events[-1].to_s).to eq("2009-01-10")
     end
 
-    it "should return only events between starting and until date" do
+    it "returns only events between starting and until date" do
       @events = @recurrence.events(:starts => "2009-01-12", :until => "2009-01-14")
-      @events[0].to_s.should == "2009-01-12"
-      @events[-1].to_s.should == "2009-01-14"
+      expect(@events[0].to_s).to eq("2009-01-12")
+      expect(@events[-1].to_s).to eq("2009-01-14")
     end
 
-    it "should not iterate all dates when using until" do
+    it "doesn't iterate all dates when using until" do
       @events = @recurrence.events(:starts => "2009-01-06", :until => "2009-01-08")
-      @recurrence.instance_variable_get("@events").size.should == 3
-      @events.size.should == 3
-      @events[-1].to_s.should == "2009-01-08"
+      expect(@recurrence.instance_variable_get("@events").size).to eq(3)
+      expect(@events.size).to eq(3)
+      expect(@events[-1].to_s).to eq("2009-01-08")
     end
 
     context "bug fixes" do
-      specify "using name as symbol [http://github.com/fnando/recurrence/issues#issue/3]" do
+      it "uses name as symbol [issue#3]" do
         expect {
           @recurrence = recurrence(:every => :year, :on => [:jan, 31])
         }.to_not raise_error
@@ -777,10 +949,10 @@ describe Recurrence do
 
     it "offsets every other month day" do
       r = recurrence(:every => :month, :on => 1, :starts => "2011-01-01", :handler => shift_handler)
-      r.events[0].should == Date.new(2011, 1, 1)
-      r.events[1].should == Date.new(2011, 2, 2)
-      r.events[2].should == Date.new(2011, 3, 1)
-      r.events[3].should == Date.new(2011, 4, 2)
+      expect(r.events[0]).to eq(Date.new(2011, 1, 1))
+      expect(r.events[1]).to eq(Date.new(2011, 2, 2))
+      expect(r.events[2]).to eq(Date.new(2011, 3, 1))
+      expect(r.events[3]).to eq(Date.new(2011, 4, 2))
     end
 
     it "raises an exception from the handler" do
@@ -791,37 +963,37 @@ describe Recurrence do
   context "with shifting enabled" do
     it "shifts yearly recurrences around February 29" do
       r = recurrence(:every => :year, :starts => "2012-02-29", :on => [2,29], :shift => true)
-      r.events[0].should == Date.new(2012, 2, 29)
-      r.events[1].should == Date.new(2013, 2, 28)
-      r.events[2].should == Date.new(2014, 2, 28)
-      r.events[3].should == Date.new(2015, 2, 28)
-      r.events[4].should == Date.new(2016, 2, 28)
+      expect(r.events[0]).to eq(Date.new(2012, 2, 29))
+      expect(r.events[1]).to eq(Date.new(2013, 2, 28))
+      expect(r.events[2]).to eq(Date.new(2014, 2, 28))
+      expect(r.events[3]).to eq(Date.new(2015, 2, 28))
+      expect(r.events[4]).to eq(Date.new(2016, 2, 28))
     end
 
     it "shifts monthly recurrences around the 31st" do
       r = recurrence(:every => :month, :starts => "2011-01-31", :on => 31, :shift => true)
-      r.events[0].should == Date.new(2011, 1, 31)
-      r.events[1].should == Date.new(2011, 2, 28)
-      r.events[2].should == Date.new(2011, 3, 28)
+      expect(r.events[0]).to eq(Date.new(2011, 1, 31))
+      expect(r.events[1]).to eq(Date.new(2011, 2, 28))
+      expect(r.events[2]).to eq(Date.new(2011, 3, 28))
     end
 
     it "shifts monthly recurrences around the 30th" do
       r = recurrence(:every => :month, :starts => "2011-01-30", :on => 30, :shift => true)
-      r.events[0].should == Date.new(2011, 1, 30)
-      r.events[1].should == Date.new(2011, 2, 28)
-      r.events[2].should == Date.new(2011, 3, 28)
+      expect(r.events[0]).to eq(Date.new(2011, 1, 30))
+      expect(r.events[1]).to eq(Date.new(2011, 2, 28))
+      expect(r.events[2]).to eq(Date.new(2011, 3, 28))
     end
 
     it "shifts monthly recurrences around the 29th" do
       r = recurrence(:every => :month, :starts => "2011-01-29", :on => 29, :shift => true)
-      r.events[0].should == Date.new(2011, 1, 29)
-      r.events[1].should == Date.new(2011, 2, 28)
-      r.events[2].should == Date.new(2011, 3, 28)
+      expect(r.events[0]).to eq(Date.new(2011, 1, 29))
+      expect(r.events[1]).to eq(Date.new(2011, 2, 28))
+      expect(r.events[2]).to eq(Date.new(2011, 3, 28))
 
       r = recurrence(:every => :month, :starts => "2012-01-29", :on => 29, :shift => true)
-      r.events[0].should == Date.new(2012, 1, 29)
-      r.events[1].should == Date.new(2012, 2, 29)
-      r.events[2].should == Date.new(2012, 3, 29)
+      expect(r.events[0]).to eq(Date.new(2012, 1, 29))
+      expect(r.events[1]).to eq(Date.new(2012, 2, 29))
+      expect(r.events[2]).to eq(Date.new(2012, 3, 29))
     end
 
     it "correctly resets to original day for monthly" do