repeatable 1.0.0 → 1.2.0

data/lib/repeatable/expression/biweekly.rb

@@ -1,23 +1,32 @@
+# 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 = Conversions::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,29 +1,34 @@
+# typed: strict
+
 module Repeatable
   module Expression
     class Date < Base
-      def to_h
-        Hash[hash_key, attributes]
-      end
+      abstract!
 
+      sig { params(other: Object).returns(T::Boolean) }
       def ==(other)
         other.is_a?(self.class) && attributes == other.attributes
       end
-
       alias_method :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,12 +1,16 @@
+# 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)
         if day < 0
           date - last_date_of_month(date) - 1 == day
@@ -17,6 +21,7 @@ module Repeatable
 
       private
 
+      sig { returns(Integer) }
       attr_reader :day
     end
   end

data/lib/repeatable/expression/difference.rb

@@ -1,19 +1,20 @@
+# 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
 
-      def to_h
-        Hash[hash_key, {included: included.to_h, excluded: excluded.to_h}]
-      end
-
+      sig { params(other: Object).returns(T::Boolean) }
       def ==(other)
         other.is_a?(self.class) &&
           included == other.included &&
@@ -22,7 +23,16 @@ module Repeatable
 
       protected
 
-      attr_reader :included, :excluded
+      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

@@ -1,16 +1,21 @@
+# typed: strict
+
 module Repeatable
   module Expression
     class ExactDate < Date
+      sig { params(date: Object).void }
       def initialize(date:)
-        @date = Conversions::Date(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

data/lib/repeatable/expression/intersection.rb

@@ -1,11 +1,17 @@
+# 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_intersection, not_intersection = elements.partition { |e| e.is_a?(self.class) }
-        super(other_intersection.flat_map(&:elements) + not_intersection)
+        elements = Array(elements).flatten
+        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,16 @@
+# 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,6 +18,7 @@ module Repeatable
         @end_day = end_day
       end
 
+      sig { override.params(date: ::Date).returns(T::Boolean) }
       def include?(date)
         return true if months_include?(date)
 
@@ -18,29 +29,43 @@ module Repeatable
         end
       end
 
-      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}
-      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,26 +1,37 @@
+# typed: strict
+
 module Repeatable
   module Expression
     class Set < Base
+      abstract!
+
+      sig { returns(T::Array[Expression::Base]) }
       attr_reader :elements
 
-      def initialize(*elements)
-        @elements = elements.flatten.uniq
+      sig { params(elements: T::Array[Expression::Base]).void }
+      def initialize(elements)
+        @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
+
+      private
+
+      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,11 +1,17 @@
+# typed: strict
+
 module Repeatable
   module Expression
     class Union < Set
+      sig { params(elements: T.any(Expression::Base, T::Array[Expression::Base])).void }
       def initialize(*elements)
+        elements = Array(elements).flatten
         other_unions, not_unions = elements.partition { |e| e.is_a?(self.class) }
-        super(other_unions.flat_map(&:elements) + not_unions)
+        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,21 @@
+# 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,25 +1,35 @@
+# 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)
         if negative_count?
           week_from_end(date) == count
@@ -28,18 +38,22 @@ module Repeatable
         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
 
+      sig { returns(T::Boolean) }
       def negative_count?
         count < 0
       end

data/lib/repeatable/expression.rb

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

data/lib/repeatable/last_date_of_month.rb

@@ -1,5 +1,10 @@
+# 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

data/lib/repeatable/parse_error.rb

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

data/lib/repeatable/parser.rb

@@ -1,13 +1,20 @@
+# 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
@@ -50,7 +57,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,14 @@
+# 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,6 +16,7 @@ module Repeatable
       end
     end
 
+    sig { params(start_date: Object, end_date: Object).returns(T::Array[::Date]) }
     def occurrences(start_date, end_date)
       start_date = Conversions::Date(start_date)
       end_date = Conversions::Date(end_date)
@@ -20,34 +26,48 @@ module Repeatable
       (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 = 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 = 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(_keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.any(Types::SymbolHash, T::Array[Types::SymbolHash])]) }
+    def deconstruct_keys(_keys)
+      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,7 @@
+# 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,5 @@
+# typed: strict
+
 module Repeatable
-  VERSION = "1.0.0"
+  VERSION = "1.2.0"
 end

data/lib/repeatable.rb

@@ -1,4 +1,7 @@
+# typed: strict
+
 require "date"
+require "sorbet-runtime"
 
 require "repeatable/version"
 
@@ -7,6 +10,8 @@ end
 
 require "repeatable/parse_error"
 
+require "repeatable/types"
+
 require "repeatable/conversions"
 require "repeatable/last_date_of_month"