repeatable 0.5.0 → 1.1.0

data/lib/repeatable/expression/biweekly.rb

@@ -1,23 +1,31 @@
+# typed: strict
 module Repeatable
   module Expression
     class Biweekly < Date
+      sig { params(weekday: Integer, start_after: Object).void }
       def initialize(weekday:, start_after: ::Date.today)
         @weekday = weekday
-        @start_after = Date(start_after)
+        @start_after = T.let(Conversions::Date(start_after), ::Date)
+        @_first_occurrence = T.let(find_first_occurrence, ::Date)
       end
 
+      sig { override.params(date: ::Date).returns(T::Boolean) }
       def include?(date)
-        date >= start_after && (date - first_occurrence) % 14 == 0
+        date >= start_after && (date - _first_occurrence) % 14 == 0
       end
 
       private
 
-      attr_reader :weekday, :start_after
+      sig { returns(Integer) }
+      attr_reader :weekday
 
-      def first_occurrence
-        @first_occurrence ||= find_first_occurrence
-      end
+      sig { returns(::Date) }
+      attr_reader :start_after
+
+      sig { returns(::Date) }
+      attr_reader :_first_occurrence
 
+      sig { returns(::Date) }
       def find_first_occurrence
         days_away = weekday - start_after.wday
         days_away += 7 if days_away <= 0

data/lib/repeatable/expression/date.rb

@@ -1,30 +1,33 @@
+# typed: strict
 module Repeatable
   module Expression
     class Date < Base
+      abstract!
 
-      def to_h
-        Hash[hash_key, attributes]
-      end
-
+      sig { params(other: Object).returns(T::Boolean) }
       def ==(other)
         other.is_a?(self.class) && attributes == other.attributes
       end
+      alias_method :eql?, :==
 
-      alias eql? ==
-
+      sig { returns(Integer) }
       def hash
         [attributes.values, self.class.name].hash
       end
 
       protected
 
+      sig { returns(Types::SymbolHash) }
       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))
+          key = name.to_s.gsub(/^@/, "")
+          next if key.start_with?("_")
+          hash[key.to_sym] = normalize_attribute_value(instance_variable_get(name))
         end
       end
+      alias_method :hash_value, :attributes
 
+      sig { params(value: BasicObject).returns(T.untyped) }
       def normalize_attribute_value(value)
         case value
         when ::Date

data/lib/repeatable/expression/day_in_month.rb

@@ -1,16 +1,26 @@
+# typed: strict
 module Repeatable
   module Expression
     class DayInMonth < Date
+      include LastDateOfMonth
+
+      sig { params(day: Integer).void }
       def initialize(day:)
         @day = day
       end
 
+      sig { override.params(date: ::Date).returns(T::Boolean) }
       def include?(date)
-        date.day == day
+        if day < 0
+          date - last_date_of_month(date) - 1 == day
+        else
+          date.day == day
+        end
       end
 
       private
 
+      sig { returns(Integer) }
       attr_reader :day
     end
   end

data/lib/repeatable/expression/difference.rb

@@ -0,0 +1,37 @@
+# typed: strict
+module Repeatable
+  module Expression
+    class Difference < Base
+      sig { params(included: Expression::Base, excluded: Expression::Base).void }
+      def initialize(included:, excluded:)
+        @included = included
+        @excluded = excluded
+      end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
+      def include?(date)
+        included.include?(date) && !excluded.include?(date)
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other)
+        other.is_a?(self.class) &&
+          included == other.included &&
+          excluded == other.excluded
+      end
+
+      protected
+
+      sig { returns(Expression::Base) }
+      attr_reader :included
+
+      sig { returns(Expression::Base) }
+      attr_reader :excluded
+
+      sig { override.returns(Types::SymbolHash) }
+      def hash_value
+        {included: included.to_h, excluded: excluded.to_h}
+      end
+    end
+  end
+end

data/lib/repeatable/expression/exact_date.rb

@@ -0,0 +1,21 @@
+# typed: strict
+module Repeatable
+  module Expression
+    class ExactDate < Date
+      sig { params(date: Object).void }
+      def initialize(date:)
+        @date = T.let(Conversions::Date(date), ::Date)
+      end
+
+      sig { override.params(other_date: ::Date).returns(T::Boolean) }
+      def include?(other_date)
+        date == other_date
+      end
+
+      private
+
+      sig { returns(::Date) }
+      attr_reader :date
+    end
+  end
+end

data/lib/repeatable/expression/intersection.rb

@@ -1,6 +1,15 @@
+# typed: strict
 module Repeatable
   module Expression
     class Intersection < Set
+      sig { params(elements: T.any(Expression::Base, T::Array[Expression::Base])).void }
+      def initialize(*elements)
+        other_intersections, not_intersections = elements.partition { |e| e.is_a?(self.class) }
+        other_intersections = T.cast(other_intersections, T::Array[Expression::Intersection])
+        super(other_intersections.flat_map(&:elements).concat(not_intersections))
+      end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
       def include?(date)
         elements.all? { |e| e.include?(date) }
       end

data/lib/repeatable/expression/range_in_year.rb

@@ -1,6 +1,15 @@
+# typed: strict
 module Repeatable
   module Expression
     class RangeInYear < Date
+      sig do
+        params(
+          start_month: Integer,
+          end_month: Integer,
+          start_day: Integer,
+          end_day: Integer
+        ).void
+      end
       def initialize(start_month:, end_month: start_month, start_day: 0, end_day: 0)
         @start_month = start_month
         @end_month = end_month
@@ -8,33 +17,54 @@ module Repeatable
         @end_day = end_day
       end
 
+      sig { override.params(date: ::Date).returns(T::Boolean) }
       def include?(date)
-        months_include?(date) || start_month_include?(date) || end_month_include?(date)
-      end
+        return true if months_include?(date)
 
-      def to_h
-        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 }
+        if start_month == end_month
+          start_month_include?(date) && end_month_include?(date)
+        else
+          start_month_include?(date) || end_month_include?(date)
+        end
       end
 
       private
 
-      attr_reader :start_month, :end_month, :start_day, :end_day
+      sig { returns(Integer) }
+      attr_reader :start_month
+
+      sig { returns(Integer) }
+      attr_reader :end_month
+
+      sig { returns(Integer) }
+      attr_reader :start_day
 
+      sig { returns(Integer) }
+      attr_reader :end_day
+
+      sig { params(date: ::Date).returns(T::Boolean) }
       def months_include?(date)
         date.month > start_month && date.month < end_month
       end
 
+      sig { params(date: ::Date).returns(T::Boolean) }
       def start_month_include?(date)
         date.month == start_month && (start_day == 0 || date.day >= start_day)
       end
 
+      sig { params(date: ::Date).returns(T::Boolean) }
       def end_month_include?(date)
         date.month == end_month && (end_day == 0 || date.day <= end_day)
       end
+
+      sig { override.returns(T::Hash[Symbol, Integer]) }
+      def hash_value
+        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?
+        args
+      end
     end
   end
 end

data/lib/repeatable/expression/set.rb

@@ -1,28 +1,36 @@
+# typed: strict
 module Repeatable
   module Expression
     class Set < Base
+      abstract!
+
+      sig { returns(T::Array[Expression::Base]) }
+      attr_reader :elements
+
+      sig { params(elements: T.any(Expression::Base, T::Array[Expression::Base])).void }
       def initialize(*elements)
-        @elements = elements.flatten.uniq
+        @elements = T.let(elements.flatten.uniq, T::Array[Expression::Base])
       end
 
+      sig { params(element: T.untyped).returns(Repeatable::Expression::Set) }
       def <<(element)
         elements << element unless elements.include?(element)
         self
       end
 
-      def to_h
-        Hash[hash_key, elements.map(&:to_h)]
-      end
-
+      sig { params(other: Object).returns(T::Boolean) }
       def ==(other)
         other.is_a?(self.class) &&
           elements.size == other.elements.size &&
           other.elements.all? { |e| elements.include?(e) }
       end
 
-      protected
+      private
 
-      attr_reader :elements
+      sig { override.returns(T::Array[Types::SymbolHash]) }
+      def hash_value
+        elements.map(&:to_h)
+      end
     end
   end
 end

data/lib/repeatable/expression/union.rb

@@ -1,6 +1,15 @@
+# typed: strict
 module Repeatable
   module Expression
     class Union < Set
+      sig { params(elements: T.any(Expression::Base, T::Array[Expression::Base])).void }
+      def initialize(*elements)
+        other_unions, not_unions = elements.partition { |e| e.is_a?(self.class) }
+        other_unions = T.cast(other_unions, T::Array[Expression::Union])
+        super(other_unions.flat_map(&:elements).concat(not_unions))
+      end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
       def include?(date)
         elements.any? { |e| e.include?(date) }
       end

data/lib/repeatable/expression/weekday.rb

@@ -1,16 +1,20 @@
+# typed: strict
 module Repeatable
   module Expression
     class Weekday < Date
+      sig { params(weekday: Integer).void }
       def initialize(weekday:)
         @weekday = weekday
       end
 
+      sig { override.params(date: ::Date).returns(T::Boolean) }
       def include?(date)
         date.wday == weekday
       end
 
       private
 
+      sig { returns(Integer) }
       attr_reader :weekday
     end
   end

data/lib/repeatable/expression/weekday_in_month.rb

@@ -1,29 +1,60 @@
+# typed: strict
 module Repeatable
   module Expression
     class WeekdayInMonth < Date
+      include LastDateOfMonth
+
+      sig { params(weekday: Integer, count: Integer).void }
       def initialize(weekday:, count:)
         @weekday = weekday
         @count = count
       end
 
+      sig { override.params(date: ::Date).returns(T::Boolean) }
       def include?(date)
         day_matches?(date) && week_matches?(date)
       end
 
       private
 
-      attr_reader :weekday, :count
+      sig { returns(Integer) }
+      attr_reader :weekday
+
+      sig { returns(Integer) }
+      attr_reader :count
 
+      sig { params(date: ::Date).returns(T::Boolean) }
       def day_matches?(date)
         date.wday == weekday
       end
 
+      sig { params(date: ::Date).returns(T::Boolean) }
       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
+
+      sig { params(date: ::Date).returns(Integer) }
+      def week_from_beginning(date)
+        week_in_month(date.day - 1)
+      end
+
+      sig { params(date: ::Date).returns(Integer) }
+      def week_from_end(date)
+        -week_in_month(last_date_of_month(date).day - date.day)
+      end
+
+      sig { params(zero_indexed_day: Integer).returns(Integer) }
+      def week_in_month(zero_indexed_day)
+        (zero_indexed_day / 7) + 1
       end
 
-      def week_in_month(day)
-        ((day - 1) / 7) + 1
+      sig { returns(T::Boolean) }
+      def negative_count?
+        count < 0
       end
     end
   end

data/lib/repeatable/expression.rb

@@ -1,3 +1,4 @@
+# typed: strict
 module Repeatable
   module Expression
   end

data/lib/repeatable/last_date_of_month.rb

@@ -0,0 +1,11 @@
+# typed: strict
+module Repeatable
+  module LastDateOfMonth
+    extend T::Sig
+
+    sig { params(date: ::Date).returns(::Date) }
+    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/parse_error.rb

@@ -1,3 +1,4 @@
+# typed: strict
 module Repeatable
   class ParseError < StandardError
   end

data/lib/repeatable/parser.rb

@@ -1,13 +1,19 @@
+# typed: false
 module Repeatable
   class Parser
+    extend T::Sig
+
+    sig { params(hash: T::Hash[T.any(String, Symbol), T.untyped]).void }
     def initialize(hash)
       @hash = hash
     end
 
+    sig { params(hash: T::Hash[T.any(String, Symbol), T.untyped]).returns(Expression::Base) }
     def self.call(hash)
       new(hash).call
     end
 
+    sig { returns(Expression::Base) }
     def call
       build_expression(hash)
     end
@@ -32,8 +38,14 @@ module Repeatable
       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
 
@@ -44,7 +56,7 @@ module Repeatable
     def expression_klass(string)
       camel_cased_string = string
         .capitalize
-        .gsub(/(?:_)(?<word>[a-z\d]+)/i) { Regexp.last_match[:word].capitalize }
+        .gsub(/(?:_)(?<word>[a-z\d]+)/i) { T.must(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

data/lib/repeatable/schedule.rb

@@ -1,9 +1,13 @@
+# typed: strict
 module Repeatable
   class Schedule
+    extend T::Sig
+
+    sig { params(arg: Object).void }
     def initialize(arg)
       case arg
       when Repeatable::Expression::Base
-        @expression = arg
+        @expression = T.let(arg, Expression::Base)
       when Hash
         @expression = Parser.call(arg)
       else
@@ -11,43 +15,53 @@ module Repeatable
       end
     end
 
+    sig { params(start_date: Object, end_date: Object).returns(T::Array[::Date]) }
     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
+      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
 
+    sig { params(start_date: Object, include_start: T::Boolean, limit: Integer).returns(T.nilable(::Date)) }
     def next_occurrence(start_date = Date.today, include_start: false, limit: 36525)
-      date = Date(start_date)
+      date = Conversions::Date(start_date)
 
       return date if include_start && include?(date)
 
-      1.step do |i|
+      result = T.let(nil, T.nilable(Date))
+      1.step(limit) do |i|
         date = date.next_day
 
-        break date if include?(date)
-        break if i == limit.to_i
+        if include?(date)
+          result = date
+          break
+        end
       end
+      result
     end
 
+    sig { params(date: Object).returns(T::Boolean) }
     def include?(date = Date.today)
-      date = Date(date)
+      date = Conversions::Date(date)
       expression.include?(date)
     end
 
+    sig { returns(T::Hash[Symbol, T.any(Types::SymbolHash, T::Array[Types::SymbolHash])]) }
     def to_h
       expression.to_h
     end
 
+    sig { params(other: Object).returns(T::Boolean) }
     def ==(other)
       other.is_a?(self.class) && expression == other.expression
     end
 
     protected
 
+    sig { returns(Expression::Base) }
     attr_reader :expression
   end
 end

data/lib/repeatable/types.rb

@@ -0,0 +1,6 @@
+# typed: strict
+module Repeatable
+  module Types
+    SymbolHash = T.type_alias { T::Hash[Symbol, T.untyped] }
+  end
+end

data/lib/repeatable/version.rb

@@ -1,3 +1,4 @@
+# typed: strict
 module Repeatable
-  VERSION = '0.5.0'
+  VERSION = "1.1.0"
 end

data/lib/repeatable.rb

@@ -1,28 +1,34 @@
-require 'date'
+# typed: strict
+require "date"
+require "sorbet-runtime"
 
-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/types"
+
+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/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/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"