repeatable 0.2.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 85f2e7cec322abe280bc2d383c2eb3286685e9ce
-  data.tar.gz: b9495fe2fc4044b096d98734ef8521aaff27439e
+SHA256:
+  metadata.gz: 9f6976240c976a027e08e04dc46dff2a7a420894f089ae7fa8c9fded126bafc6
+  data.tar.gz: 4e0e0e4d45d72b543549904a9a6f4b041430b9808075ccb64a81583366a4e414
 SHA512:
-  metadata.gz: eb4e21f11667e4ef609ee9af000a24a83010119cd53fe00c8068272db8fa250b623eeedc77f137dde683edb71d626401bae6cbf0813fba8f43d44e3a0ba93cce
-  data.tar.gz: f6b85f9183fc1e052d5aaefcc6b57f7e52334cbc6685f91e5c930d3be33631af2229b9baa7e717e645d83f83f9b17eedeb9e75a70b42220b58dec677657590cf
+  metadata.gz: 2698038cb582f612642c1b2f9c595e3830ff42556fb89eef56d4bbf5e3c34396d318175699ecb74a2c589aefe861cc5c7e17a6bde0b4950b6939421fedcb1260
+  data.tar.gz: 6a98285ed9058b186651055e5afecae2b2abcb64ca0dbc488b92b76ff6a20da02d4ab1d96f204bd864b210a5d183fdff34db31b82d4b06595e0b7c16f2dc3dcf

data/.git-blame-ignore-revs

@@ -0,0 +1,13 @@
+# These commits should be ignored by git-blame, making it much easier to step through the history
+# of a line without hitting formatting commits (esp. large, update-all-the-files sorts of commits).
+#
+# For git-blame to ignore these revisions, you'll need to tell it about this file.
+#
+# You can either pass it to the command each time:
+#   git blame --ignore-rev-file=.git-blame-ignore-revs -L 12,14 lib/repeatable/conversions.rb
+#
+# Or you can set it as a config value, which will be used by all git-blame commands henceforth:
+#   git config blame.ignoreRevsFile .git-blame-ignore-revs
+
+# Initial style fix after introducing Standard
+80611e9be4fe12e6b9bdb937d37902c12ac3a53b

data/.gitignore

@@ -1,7 +1,6 @@
 /*.gem
 /.bundle/
 /.yardoc
-/Gemfile.lock
 /_yardoc/
 /coverage/
 /doc/

data/.rspec

@@ -1,2 +1 @@
---format documentation
 --color

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see: https://github.com/testdouble/standard
+
+default_ignores: true

data/.travis.yml

@@ -1,8 +1,18 @@
 language: ruby
+env:
+  global:
+    - COVERAGE=true
 rvm:
-  - 2.1.0
-  - 2.2.0
-addons:
-  code_climate:
-    repo_token:
-      secure: fyZ7Ycc23fzfh8bBiqPUhlJGcIcnanZWqVc4nsKDJeE1G5ScW01+ot1g4miDWxo7w80gKRKP/PfoYf6lOQ1B5yJJCV0Z5fjoTW3y+EKksMuGNCFaWh8R73MIPlVtfOazGyI2t3l4zDWoik906wHHNQJFveMZawvZGrVMWF6YxKg=
+  - 2.5
+  - 2.6
+  - 2.7
+  - 3.0
+before_install:
+  - yes | gem update --system --force
+  - gem install bundler
+before_script:
+  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
+  - chmod +x ./cc-test-reporter
+  - ./cc-test-reporter before-build
+after_script:
+  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

data/CHANGELOG.md

@@ -0,0 +1,105 @@
+## CHANGELOG
+
+### Unreleased
+
+[Commits](https://github.com/molawson/repeatable/compare/v1.0.0...main)
+
+### 1.0.0 (2021-03-25)
+
+Breaking Changes:
+
+* Change `Expression::DayInMonth` to take negative numbers instead of special `:last` symbol (or string)
+* Stop including `Conversions` in top level namespace (must now be accessed via `Repeatable::Conversions::Date()` or by calling `include Repeatable::Conversions` in whatever namespace(s) it's needed)
+* Require Ruby 2.5.0 or greater
+
+Changes:
+
+* Flatten nested `Expression::Union` elements during initialization ([@cmoel][])
+* Flatten nested `Expression::Intersection` elements during initialization
+
+Chores:
+
+* Add support for Ruby 2.5, 2.6, 2.7, 3.0
+* Introduce [standard](https://github.com/testdouble/standard) for code formatting
+
+[Commits](https://github.com/molawson/repeatable/compare/v0.6.0...v1.0.0)
+
+
+### 0.6.0 (2017-05-04)
+
+Features:
+
+* Add `Expression::Difference` for set differences between 2 schedules ([@danott][])
+* Allow `Expression::DayInMonth` to take `:last` (or `'last'`) for its `day:` argument ([@PatrickLerner][])
+* Allow `Expression::WeekdayInMonth` to take negative `count` argument for last, second-to-last, etc. of a given weekday ([@danielma][])
+
+Bug Fixes:
+
+* Fix `Expression::RangeInYear` to properly handle using `start_day` and `end_day` when `start_month == end_month` ([@danielma][])
+
+[Commits](https://github.com/molawson/repeatable/compare/v0.5.0...v0.6.0)
+
+### 0.5.0 (2016-01-27)
+
+Features:
+
+* Add `Expression::Biweekly` for "every other week" recurrence
+
+[Commits](https://github.com/molawson/repeatable/compare/v0.4.0...v0.5.0)
+
+### 0.4.0 (2015-06-29)
+
+Features:
+
+* Define equivalence `#==` for `Expression` and `Schedule` objects
+* Define hash equality `#eql?` for `Expression::Date` objects
+* Remove `ActiveSupport` dependency
+
+[Commits](https://github.com/molawson/repeatable/compare/v0.3.0...v0.4.0)
+
+### 0.3.0 (2015-03-11)
+
+Features:
+
+* Ensure `end_date` on or after `start_date` for `Schedule#occurrences` ([@danott][])
+* Consider any invalid argument to `Schedule.new` a `ParseError` ([@danott][])
+
+[Commits](https://github.com/molawson/repeatable/compare/v0.2.1...v0.3.0)
+
+### 0.2.1 (2015-03-09)
+
+Features:
+
+* Add `ParseError` class for better error handling
+* Extract `Parser` class from `Schedule`
+
+Bug Fixes:
+
+* Enable `Schedule` to take a hash with string keys
+
+[Commits](https://github.com/molawson/repeatable/compare/v0.2.0...v0.2.1)
+
+### 0.2.0 (2015-03-03)
+
+Features:
+
+* Add `Schedule#to_h` and `Expression#to_h` methods
+* Enable building a `Schedule` from composed `Expression` objects
+
+Bug Fixes:
+
+* Fix default case equality for `Expression::Base` to work with classes and instances
+
+[Commits](https://github.com/molawson/repeatable/compare/v0.1.0...v0.2.0)
+
+### 0.1.0 (2015-02-23)
+
+Initial Release
+
+[Commits](https://github.com/molawson/repeatable/compare/531d40c...v0.1.0)
+
+
+[@danott]: https://github.com/danott
+[@PatrickLerner]: https://github.com/PatrickLerner
+[@danielma]: https://github.com/danielma
+[@cmoel]: https://github.com/cmoel

data/Gemfile

@@ -1,7 +1,13 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in repeatable.gemspec
 gemspec
 
-gem 'pry'
-gem 'codeclimate-test-reporter', group: :test, require: nil
+gem "pry", "~> 0.13"
+gem "rake", ">= 12.3.3"
+gem "standard", "~> 1.0"
+
+group :test do
+  gem "rspec", "~> 3.0"
+  gem "simplecov", "~> 0.18"
+end

data/Gemfile.lock

@@ -0,0 +1,76 @@
+PATH
+  remote: .
+  specs:
+    repeatable (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    coderay (1.1.3)
+    diff-lcs (1.4.4)
+    docile (1.3.5)
+    method_source (1.0.0)
+    parallel (1.20.1)
+    parser (3.0.0.0)
+      ast (~> 2.4.1)
+    pry (0.14.0)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rainbow (3.0.0)
+    rake (13.0.3)
+    regexp_parser (2.1.1)
+    rexml (3.2.4)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    rubocop (1.11.0)
+      parallel (~> 1.10)
+      parser (>= 3.0.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml
+      rubocop-ast (>= 1.2.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.4.1)
+      parser (>= 2.7.1.5)
+    rubocop-performance (1.10.1)
+      rubocop (>= 0.90.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    simplecov (0.21.2)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+      simplecov_json_formatter (~> 0.1)
+    simplecov-html (0.12.3)
+    simplecov_json_formatter (0.1.2)
+    standard (1.0.4)
+      rubocop (= 1.11.0)
+      rubocop-performance (= 1.10.1)
+    unicode-display_width (2.0.0)
+
+PLATFORMS
+  x86_64-darwin-19
+  x86_64-linux
+
+DEPENDENCIES
+  pry (~> 0.13)
+  rake (>= 12.3.3)
+  repeatable!
+  rspec (~> 3.0)
+  simplecov (~> 0.18)
+  standard (~> 1.0)
+
+BUNDLED WITH
+   2.2.14

data/README.md

@@ -1,8 +1,8 @@
 # Repeatable
 
-[![Build Status](https://img.shields.io/travis/molawson/repeatable.svg)](https://travis-ci.org/molawson/repeatable)
-[![Code Climate](https://img.shields.io/codeclimate/github/molawson/repeatable.svg)](https://codeclimate.com/github/molawson/repeatable)
-[![Code Climate Coverage](https://img.shields.io/codeclimate/coverage/github/molawson/repeatable.svg)](https://codeclimate.com/github/molawson/repeatable)
+[![Build Status](https://travis-ci.org/molawson/repeatable.svg?branch=main)](https://travis-ci.org/molawson/repeatable)
+[![Maintainability](https://api.codeclimate.com/v1/badges/73707efd5eeffd364c0d/maintainability)](https://codeclimate.com/github/molawson/repeatable/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/73707efd5eeffd364c0d/test_coverage)](https://codeclimate.com/github/molawson/repeatable/test_coverage)
 
 Ruby implementation of Martin Fowler's [Recurring Events for Calendars](http://martinfowler.com/apsupp/recurring.pdf) paper.
 
@@ -22,6 +22,10 @@ Or install it yourself as:
 
     $ gem install repeatable
 
+## Requirements
+
+Because this gem relies heavily on required keyword arguments, especially to make dumping and parsing of schedules simpler, this code will only work on **Ruby 2.2** and higher.
+
 ## Usage
 
 ### Building a Schedule
@@ -33,9 +37,9 @@ You can create a schedule in one of two ways.
 Instantiate and compose each of the `Repeatable::Expression` objects manually.
 
 ```ruby
-second_monday = Repeatabe::Expression::WeekdayInMonth.new(weekday: 1, count: 2)
+second_monday = Repeatable::Expression::WeekdayInMonth.new(weekday: 1, count: 2)
 oct_thru_dec = Repeatable::Expression::RangeInYear.new(start_month: 10, end_month: 12)
-intersection = Repeatable::Expresson::Intersection.new(second_monday, oct_thru_dec)
+intersection = Repeatable::Expression::Intersection.new(second_monday, oct_thru_dec)
 
 schedule = Repeatable::Schedule.new(intersection)
 ```
@@ -49,7 +53,8 @@ Or describe the same structure with a `Hash`, and the gem will handle instantiat
 arg = {
   intersection: [
     { weekday_in_month: { weekday: 1, count: 2 } },
-    { range_in_year: { start_month: 10, end_month: 12 } }
+    { range_in_year: { start_month: 10, end_month: 12 } },
+    { exact_date: { date: "2015-08-01" } }
   ]
 }
 
@@ -73,6 +78,10 @@ Repeatable::Expression::Union.new(expressions)
 { intersection: [] }
 Repeatable::Expression::Intersection.new(expressions)
 
+# Date is part of the first set (`included`) but not part of the second set (`excluded`)
+{ difference: { included: expression, excluded: another_expression } }
+Repeatable::Expression::Difference.new(included: expression, excluded: another_expression)
+
 
 # DATES
 
@@ -84,10 +93,22 @@ Repeatable::Expression::Weekday.new(weekday: 0)
 { weekday_in_month: { weekday: 1, count: 3 } }
 Repeatable::Expression::WeekdayInMonth.new(weekday: 1, count: 3)
 
+# The last Thursday of every month
+{ weekday_in_month: { weekday: 4, count: -1 } }
+Repeatable::Expression::WeekdayInMonth.new(weekday: 4, count: -1)
+
+# Every other Monday, starting from December 1, 2015
+{ biweekly: { weekday: 1, start_date: '2015-12-01' } }
+Repeatable::Expression::Biweekly.new(weekday: 1, start_date: Date.new(2015, 12, 1))
+
 # The 13th of every month
 { day_in_month: { day: 13 } }
 Repeatable::Expression::DayInMonth.new(day: 13)
 
+# The last day of every month
+{ day_in_month: { day: -1 } }
+Repeatable::Expression::DayInMonth.new(day: -1)
+
 # All days in October
 { range_in_year: { start_month: 10 } }
 Repeatable::Expression::RangeInYear.new(start_month: 10)
@@ -99,16 +120,38 @@ Repeatable::Expression::RangeInYear.new(start_month: 10, end_month: 12)
 # All days from October 1 through December 20
 { range_in_year: { start_month: 10, end_month: 12, start_day: 1, end_day: 20 } }
 Repeatable::Expression::RangeInYear.new(start_month: 10, end_month: 12, start_day: 1, end_day: 20)
+
+# only December 21, 2012
+{ exact_date: { date: '2012-12-21' } }
+Repeatable::Expression::ExactDate.new(date: Date.new(2012, 12, 21)
 ```
 
+#### Schedule Errors
+
+If something in the argument passed into `Repeatable::Schedule.new` can't be handled by the `Schedule` or `Parser` (e.g. an expression hash key that doesn't match an existing expression class), a `Repeatable::ParseError` will be raised with a (hopefully) helpful error message.
+
 ### Getting information from a Schedule
 
-Ask a schedule one of three questions.
+Ask a schedule to do a number of things.
 
 ```ruby
 schedule.next_occurrence
   # => Date of next occurrence
 
+# By default, it will find the next occurrence after Date.today.
+# You can also specify a start date.
+schedule.next_occurrence(Date.new(2015, 1, 1))
+  # => Date of next occurrence after Jan 1, 2015
+
+# You also have the option of including the start date as a possible result.
+schedule.next_occurrence(Date.new(2015, 1, 1), include_start: true)
+  # => Date of next occurrence on or after Jan 1, 2015
+
+# By default, searches for the next occurrence are limited to the next 36,525 days (about 100 years).
+# That limit can also be specified in number of days.
+schedule.next_occurrence(limit: 365)
+  # => Date of next occurrence within the next 365 days
+
 schedule.occurrences(Date.new(2015, 1, 1), Date.new(2016, 6, 30))
   # => Dates of all occurrences between Jan 1, 2015 and June 30, 2016
 
@@ -117,7 +160,30 @@ schedule.include?(Date.new(2015, 10, 10))
 
 schedule.to_h
   # => Hash representation of the Schedule, which is useful for storage and
-  #    can be used to recreating an identical Schedule object at a later time
+  #    can be used to recreate an identical Schedule object at a later time
+```
+
+#### Equivalence
+
+Both `Repeatable::Schedule` and all `Repeatable::Expression` classes have equivalence `#==` defined according to what's appropriate for each class, so regardless of the order of arguments passed to each, you can tell whether one object is equivalent to the other in terms of whether or not, when asked the same questions, you'd receive the same results from each.
+
+```ruby
+Repeatable::Expression::DayInMonth.new(day: 1) == Repeatable::Expression::DayInMonth.new(day: 1)
+  # => true
+
+first = Repeatable::Expression::DayInMonth.new(day: 1)
+fifteenth = Repeatable::Expression::DayInMonth.new(day: 15)
+first == fifteenth
+  # => false
+
+union = Repeatable::Expression::Union.new(first, fifteenth)
+another_union = Repeatable::Expression::Union.new(fifteenth, first)
+union == another_union
+  # => true (order of Union and Intersection arguments doesn't their affect output)
+
+Repeatable::Schedule.new(union) == Repeatable::Schedule.new(another_union)
+  # => true (their expressions are equivalent, so they'll produce the same results)
+
 ```
 
 ## Development

data/Rakefile

@@ -1,6 +1,8 @@
-require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: :spec
+require "standard/rake"
+
+task default: %i[spec standard]

data/lib/repeatable.rb

@@ -1,26 +1,30 @@
-require 'date'
+require "date"
 
-require 'repeatable/version'
-
-require 'repeatable/conversions'
-include Repeatable::Conversions
+require "repeatable/version"
 
 module Repeatable
 end
 
-require 'repeatable/parse_error'
+require "repeatable/parse_error"
+
+require "repeatable/conversions"
+require "repeatable/last_date_of_month"
 
-require 'repeatable/expression'
-require 'repeatable/expression/base'
+require "repeatable/expression"
+require "repeatable/expression/base"
 
-require 'repeatable/expression/weekday'
-require 'repeatable/expression/weekday_in_month'
-require 'repeatable/expression/day_in_month'
-require 'repeatable/expression/range_in_year'
+require "repeatable/expression/date"
+require "repeatable/expression/exact_date"
+require "repeatable/expression/weekday"
+require "repeatable/expression/biweekly"
+require "repeatable/expression/weekday_in_month"
+require "repeatable/expression/day_in_month"
+require "repeatable/expression/range_in_year"
 
-require 'repeatable/expression/set'
-require 'repeatable/expression/union'
-require 'repeatable/expression/intersection'
+require "repeatable/expression/set"
+require "repeatable/expression/union"
+require "repeatable/expression/intersection"
+require "repeatable/expression/difference"
 
-require 'repeatable/schedule'
-require 'repeatable/parser'
+require "repeatable/schedule"
+require "repeatable/parser"

data/lib/repeatable/expression/base.rb

@@ -23,6 +23,31 @@ module Repeatable
           "Don't use Expression::Base directly. Subclasses must implement `#to_h`"
         )
       end
+
+      def union(other)
+        Union.new(self, other)
+      end
+      alias_method :+, :union
+      alias_method :|, :union
+
+      def intersection(other)
+        Intersection.new(self, other)
+      end
+      alias_method :&, :intersection
+
+      def difference(other)
+        Difference.new(included: self, excluded: other)
+      end
+      alias_method :-, :difference
+
+      private
+
+      def hash_key
+        self.class.name.split("::").last
+          .gsub(/(?<!\b)[A-Z]/) { "_#{Regexp.last_match[0]}" }
+          .downcase
+          .to_sym
+      end
     end
   end
 end

data/lib/repeatable/expression/biweekly.rb

@@ -0,0 +1,28 @@
+module Repeatable
+  module Expression
+    class Biweekly < Date
+      def initialize(weekday:, start_after: ::Date.today)
+        @weekday = weekday
+        @start_after = Conversions::Date(start_after)
+      end
+
+      def include?(date)
+        date >= start_after && (date - first_occurrence) % 14 == 0
+      end
+
+      private
+
+      attr_reader :weekday, :start_after
+
+      def first_occurrence
+        @first_occurrence ||= find_first_occurrence
+      end
+
+      def find_first_occurrence
+        days_away = weekday - start_after.wday
+        days_away += 7 if days_away <= 0
+        start_after + days_away
+      end
+    end
+  end
+end

data/lib/repeatable/expression/date.rb

@@ -0,0 +1,37 @@
+module Repeatable
+  module Expression
+    class Date < Base
+      def to_h
+        Hash[hash_key, attributes]
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && attributes == other.attributes
+      end
+
+      alias_method :eql?, :==
+
+      def hash
+        [attributes.values, self.class.name].hash
+      end
+
+      protected
+
+      def attributes
+        instance_variables.each_with_object({}) do |name, hash|
+          key = name.to_s.gsub(/^@/, "").to_sym
+          hash[key] = normalize_attribute_value(instance_variable_get(name))
+        end
+      end
+
+      def normalize_attribute_value(value)
+        case value
+        when ::Date
+          value.to_s
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/lib/repeatable/expression/day_in_month.rb

@@ -1,16 +1,18 @@
 module Repeatable
   module Expression
-    class DayInMonth < Base
+    class DayInMonth < Date
+      include LastDateOfMonth
+
       def initialize(day:)
         @day = day
       end
 
       def include?(date)
-        date.day == day
-      end
-
-      def to_h
-        { day_in_month: { day: day } }
+        if day < 0
+          date - last_date_of_month(date) - 1 == day
+        else
+          date.day == day
+        end
       end
 
       private

data/lib/repeatable/expression/difference.rb

@@ -0,0 +1,28 @@
+module Repeatable
+  module Expression
+    class Difference < Base
+      def initialize(included:, excluded:)
+        @included = included
+        @excluded = excluded
+      end
+
+      def include?(date)
+        included.include?(date) && !excluded.include?(date)
+      end
+
+      def to_h
+        Hash[hash_key, {included: included.to_h, excluded: excluded.to_h}]
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          included == other.included &&
+          excluded == other.excluded
+      end
+
+      protected
+
+      attr_reader :included, :excluded
+    end
+  end
+end

data/lib/repeatable/expression/exact_date.rb

@@ -0,0 +1,17 @@
+module Repeatable
+  module Expression
+    class ExactDate < Date
+      def initialize(date:)
+        @date = Conversions::Date(date)
+      end
+
+      def include?(other_date)
+        date == other_date
+      end
+
+      private
+
+      attr_reader :date
+    end
+  end
+end

data/lib/repeatable/expression/intersection.rb

@@ -1,6 +1,11 @@
 module Repeatable
   module Expression
     class Intersection < Set
+      def initialize(*elements)
+        other_intersection, not_intersection = elements.partition { |e| e.is_a?(self.class) }
+        super(other_intersection.flat_map(&:elements) + not_intersection)
+      end
+
       def include?(date)
         elements.all? { |e| e.include?(date) }
       end

data/lib/repeatable/expression/range_in_year.rb

@@ -1,6 +1,6 @@
 module Repeatable
   module Expression
-    class RangeInYear < Base
+    class RangeInYear < Date
       def initialize(start_month:, end_month: start_month, start_day: 0, end_day: 0)
         @start_month = start_month
         @end_month = end_month
@@ -9,15 +9,21 @@ module Repeatable
       end
 
       def include?(date)
-        months_include?(date) || start_month_include?(date) || end_month_include?(date)
+        return true if months_include?(date)
+
+        if start_month == end_month
+          start_month_include?(date) && end_month_include?(date)
+        else
+          start_month_include?(date) || end_month_include?(date)
+        end
       end
 
       def to_h
-        args = { start_month: start_month }
+        args = {start_month: start_month}
         args[:end_month] = end_month unless end_month == start_month
         args[:start_day] = start_day unless start_day.zero?
         args[:end_day] = end_day unless end_day.zero?
-        { range_in_year: args }
+        {range_in_year: args}
       end
 
       private

data/lib/repeatable/expression/set.rb

@@ -1,24 +1,26 @@
 module Repeatable
   module Expression
     class Set < Base
+      attr_reader :elements
+
       def initialize(*elements)
-        @elements = elements.flatten
+        @elements = elements.flatten.uniq
       end
 
       def <<(element)
-        elements << element
+        elements << element unless elements.include?(element)
         self
       end
 
       def to_h
-        hash = {}
-        hash[self.class.name.demodulize.underscore.to_sym] = elements.map(&:to_h)
-        hash
+        Hash[hash_key, elements.map(&:to_h)]
       end
 
-      private
-
-      attr_reader :elements
+      def ==(other)
+        other.is_a?(self.class) &&
+          elements.size == other.elements.size &&
+          other.elements.all? { |e| elements.include?(e) }
+      end
     end
   end
 end

data/lib/repeatable/expression/union.rb

@@ -1,6 +1,11 @@
 module Repeatable
   module Expression
     class Union < Set
+      def initialize(*elements)
+        other_unions, not_unions = elements.partition { |e| e.is_a?(self.class) }
+        super(other_unions.flat_map(&:elements) + not_unions)
+      end
+
       def include?(date)
         elements.any? { |e| e.include?(date) }
       end

data/lib/repeatable/expression/weekday.rb

@@ -1,6 +1,6 @@
 module Repeatable
   module Expression
-    class Weekday < Base
+    class Weekday < Date
       def initialize(weekday:)
         @weekday = weekday
       end
@@ -9,10 +9,6 @@ module Repeatable
         date.wday == weekday
       end
 
-      def to_h
-        { weekday: { weekday: weekday } }
-      end
-
       private
 
       attr_reader :weekday

data/lib/repeatable/expression/weekday_in_month.rb

@@ -1,6 +1,8 @@
 module Repeatable
   module Expression
-    class WeekdayInMonth < Base
+    class WeekdayInMonth < Date
+      include LastDateOfMonth
+
       def initialize(weekday:, count:)
         @weekday = weekday
         @count = count
@@ -10,10 +12,6 @@ module Repeatable
         day_matches?(date) && week_matches?(date)
       end
 
-      def to_h
-        { weekday_in_month: { weekday: weekday, count: count } }
-      end
-
       private
 
       attr_reader :weekday, :count
@@ -23,11 +21,27 @@ module Repeatable
       end
 
       def week_matches?(date)
-        week_in_month(date.day) == count
+        if negative_count?
+          week_from_end(date) == count
+        else
+          week_from_beginning(date) == count
+        end
+      end
+
+      def week_from_beginning(date)
+        week_in_month(date.day - 1)
+      end
+
+      def week_from_end(date)
+        -week_in_month(last_date_of_month(date).day - date.day)
+      end
+
+      def week_in_month(zero_indexed_day)
+        (zero_indexed_day / 7) + 1
       end
 
-      def week_in_month(day)
-        ((day - 1) / 7) + 1
+      def negative_count?
+        count < 0
       end
     end
   end

data/lib/repeatable/last_date_of_month.rb

@@ -0,0 +1,7 @@
+module Repeatable
+  module LastDateOfMonth
+    def last_date_of_month(date)
+      ::Date.new(date.next_month.year, date.next_month.month, 1).prev_day
+    end
+  end
+end

data/lib/repeatable/parser.rb

@@ -25,20 +25,35 @@ module Repeatable
     end
 
     def expression_for(key, value)
-      klass = "repeatable/expression/#{key}".classify.safe_constantize
+      klass = expression_klass(key.to_s)
       case klass
       when nil
         fail(ParseError, "Unknown mapping: Can't map key '#{key.inspect}' to an expression class")
       when Repeatable::Expression::Set
         args = value.map { |hash| build_expression(hash) }
         klass.new(*args)
+      when Repeatable::Expression::Difference
+        value = symbolize_keys(value)
+        klass.new(
+          included: build_expression(value[:included]),
+          excluded: build_expression(value[:excluded])
+        )
       else
-        klass.new(symbolize_keys(value))
+        klass.new(**symbolize_keys(value))
       end
     end
 
     def symbolize_keys(hash)
       hash.each_with_object({}) { |(k, v), a| a[k.to_sym] = v }
     end
+
+    def expression_klass(string)
+      camel_cased_string = string
+        .capitalize
+        .gsub(/(?:_)(?<word>[a-z\d]+)/i) { Regexp.last_match[:word].capitalize }
+      Repeatable::Expression.const_get(camel_cased_string)
+    rescue NameError => e
+      raise if e.name && e.name.to_s != camel_cased_string
+    end
   end
 end

data/lib/repeatable/schedule.rb

@@ -1,5 +1,3 @@
-require 'active_support/core_ext/string/inflections'
-
 module Repeatable
   class Schedule
     def initialize(arg)
@@ -9,26 +7,34 @@ module Repeatable
       when Hash
         @expression = Parser.call(arg)
       else
-        fail(ArgumentError, "Can't build a Repeatable::Schedule from #{arg.class}")
+        fail(ParseError, "Can't build a Repeatable::Schedule from #{arg.class}")
       end
     end
 
     def occurrences(start_date, end_date)
-      start_date = Date(start_date)
-      end_date = Date(end_date)
+      start_date = Conversions::Date(start_date)
+      end_date = Conversions::Date(end_date)
+
+      fail(ArgumentError, "end_date must be equal to or after start_date") if end_date < start_date
+
       (start_date..end_date).select { |date| include?(date) }
     end
 
-    def next_occurrence(start_date = Date.today)
-      date = Date(start_date)
-      until include?(date)
+    def next_occurrence(start_date = Date.today, include_start: false, limit: 36525)
+      date = Conversions::Date(start_date)
+
+      return date if include_start && include?(date)
+
+      1.step do |i|
         date = date.next_day
+
+        break date if include?(date)
+        break if i == limit.to_i
       end
-      date
     end
 
     def include?(date = Date.today)
-      date = Date(date)
+      date = Conversions::Date(date)
       expression.include?(date)
     end
 
@@ -36,7 +42,11 @@ module Repeatable
       expression.to_h
     end
 
-    private
+    def ==(other)
+      other.is_a?(self.class) && expression == other.expression
+    end
+
+    protected
 
     attr_reader :expression
   end

data/lib/repeatable/version.rb

@@ -1,3 +1,3 @@
 module Repeatable
-  VERSION = '0.2.1'
+  VERSION = "1.0.0"
 end

data/repeatable.gemspec

@@ -1,24 +1,19 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'repeatable/version'
+require "repeatable/version"
 
 Gem::Specification.new do |spec|
-  spec.name          = 'repeatable'
-  spec.version       = Repeatable::VERSION
-  spec.authors       = ['Mo Lawson']
-  spec.email         = ['mo@molawson.com']
+  spec.name = "repeatable"
+  spec.version = Repeatable::VERSION
+  spec.authors = ["Mo Lawson"]
+  spec.email = ["mo@molawson.com"]
 
-  spec.summary       = 'Describe recurring event schedules and calculate their occurrences'
-  spec.description   = "Ruby implementation of Martin Fowler's 'Recurring Events for Calendars' paper."
-  spec.homepage      = 'https://github.com/molawson/repeatable'
-  spec.license       = 'MIT'
+  spec.summary = "Describe recurring event schedules and calculate their occurrences"
+  spec.description = "Ruby implementation of Martin Fowler's 'Recurring Events for Calendars' paper."
+  spec.homepage = "https://github.com/molawson/repeatable"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
-  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.require_paths = ['lib']
-
-  spec.add_dependency 'activesupport', '>= 3.0'
-
-  spec.add_development_dependency 'bundler', '~> 1.6'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
 end

metadata

@@ -1,71 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: repeatable
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Mo Lawson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-03-09 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
+date: 2021-03-25 00:00:00.000000000 Z
+dependencies: []
 description: Ruby implementation of Martin Fowler's 'Recurring Events for Calendars'
   paper.
 email:
@@ -74,10 +18,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".git-blame-ignore-revs"
 - ".gitignore"
 - ".rspec"
+- ".standard.yml"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -87,13 +35,18 @@ files:
 - lib/repeatable/conversions.rb
 - lib/repeatable/expression.rb
 - lib/repeatable/expression/base.rb
+- lib/repeatable/expression/biweekly.rb
+- lib/repeatable/expression/date.rb
 - lib/repeatable/expression/day_in_month.rb
+- lib/repeatable/expression/difference.rb
+- lib/repeatable/expression/exact_date.rb
 - lib/repeatable/expression/intersection.rb
 - lib/repeatable/expression/range_in_year.rb
 - lib/repeatable/expression/set.rb
 - lib/repeatable/expression/union.rb
 - lib/repeatable/expression/weekday.rb
 - lib/repeatable/expression/weekday_in_month.rb
+- lib/repeatable/last_date_of_month.rb
 - lib/repeatable/parse_error.rb
 - lib/repeatable/parser.rb
 - lib/repeatable/schedule.rb
@@ -103,7 +56,7 @@ homepage: https://github.com/molawson/repeatable
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -111,16 +64,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Describe recurring event schedules and calculate their occurrences
 test_files: []