repeatable 1.0.0 → 1.1.0

data/lib/repeatable/expression/intersection.rb

@@ -1,11 +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_intersection, not_intersection = elements.partition { |e| e.is_a?(self.class) }
-        super(other_intersection.flat_map(&:elements) + not_intersection)
+        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,6 +17,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 +28,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,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
+
+      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,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) }
-        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,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,25 +1,34 @@
+# 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 +37,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,4 @@
+# typed: strict
 module Repeatable
   module Expression
   end

data/lib/repeatable/last_date_of_month.rb

@@ -1,5 +1,9 @@
+# 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,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
@@ -50,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,6 +15,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 +25,43 @@ 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(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 = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/repeatable.rb

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

data/rbi/repeatable.rbi

@@ -0,0 +1,310 @@
+# typed: strong
+module Repeatable
+  VERSION = "1.1.0"
+
+  module Conversions
+    extend T::Sig
+
+    sig { params(arg: Object).returns(::Date) }
+    def Date(arg); end
+  end
+
+  module LastDateOfMonth
+    extend T::Sig
+
+    sig { params(date: ::Date).returns(::Date) }
+    def last_date_of_month(date); end
+  end
+
+  class ParseError < StandardError
+  end
+
+  class Parser
+    extend T::Sig
+
+    sig { params(hash: T::Hash[T.any(String, Symbol), T.untyped]).void }
+    def initialize(hash); end
+
+    sig { params(hash: T::Hash[T.any(String, Symbol), T.untyped]).returns(Expression::Base) }
+    def self.call(hash); end
+
+    sig { returns(Expression::Base) }
+    def call; end
+
+    sig { returns(T.untyped) }
+    attr_reader :hash
+
+    sig { params(hash: T.untyped).returns(T.untyped) }
+    def build_expression(hash); end
+
+    sig { params(key: T.untyped, value: T.untyped).returns(T.untyped) }
+    def expression_for(key, value); end
+
+    sig { params(hash: T.untyped).returns(T.untyped) }
+    def symbolize_keys(hash); end
+
+    sig { params(string: T.untyped).returns(T.untyped) }
+    def expression_klass(string); end
+  end
+
+  class Schedule
+    extend T::Sig
+
+    sig { params(arg: Object).void }
+    def initialize(arg); end
+
+    sig { params(start_date: Object, end_date: Object).returns(T::Array[::Date]) }
+    def occurrences(start_date, end_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); end
+
+    sig { params(date: Object).returns(T::Boolean) }
+    def include?(date = Date.today); end
+
+    sig { returns(T::Hash[Symbol, T.any(Types::SymbolHash, T::Array[Types::SymbolHash])]) }
+    def to_h; end
+
+    sig { params(other: Object).returns(T::Boolean) }
+    def ==(other); end
+
+    sig { returns(Expression::Base) }
+    attr_reader :expression
+  end
+
+  module Types
+    SymbolHash = T.type_alias { T::Hash[Symbol, T.untyped] }
+  end
+
+  module Expression
+    class Base
+      abstract!
+
+      extend T::Sig
+      extend T::Helpers
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def self.===(other); end
+
+      sig { abstract.params(date: ::Date).returns(T::Boolean) }
+      def include?(date); end
+
+      sig { returns(T::Hash[Symbol, T.any(Types::SymbolHash, T::Array[Types::SymbolHash])]) }
+      def to_h; end
+
+      sig { params(other: Expression::Base).returns(Expression::Union) }
+      def union(other); end
+
+      sig { params(other: Expression::Base).returns(Expression::Intersection) }
+      def intersection(other); end
+
+      sig { params(other: T.untyped).returns(Expression::Difference) }
+      def difference(other); end
+
+      sig { returns(Symbol) }
+      def hash_key; end
+
+      sig { abstract.returns(T.any(Types::SymbolHash, T::Array[Types::SymbolHash])) }
+      def hash_value; end
+    end
+
+    class Biweekly < Date
+      sig { params(weekday: Integer, start_after: Object).void }
+      def initialize(weekday:, start_after: ::Date.today); end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
+      def include?(date); end
+
+      sig { returns(Integer) }
+      attr_reader :weekday
+
+      sig { returns(::Date) }
+      attr_reader :start_after
+
+      sig { returns(::Date) }
+      attr_reader :_first_occurrence
+
+      sig { returns(::Date) }
+      def find_first_occurrence; end
+    end
+
+    class Date < Base
+      abstract!
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other); end
+
+      sig { returns(Integer) }
+      def hash; end
+
+      sig { returns(Types::SymbolHash) }
+      def attributes; end
+
+      sig { params(value: BasicObject).returns(T.untyped) }
+      def normalize_attribute_value(value); end
+    end
+
+    class DayInMonth < Date
+      include LastDateOfMonth
+
+      sig { params(day: Integer).void }
+      def initialize(day:); end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
+      def include?(date); end
+
+      sig { returns(Integer) }
+      attr_reader :day
+    end
+
+    class Difference < Base
+      sig { params(included: Expression::Base, excluded: Expression::Base).void }
+      def initialize(included:, excluded:); end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
+      def include?(date); end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other); end
+
+      sig { returns(Expression::Base) }
+      attr_reader :included
+
+      sig { returns(Expression::Base) }
+      attr_reader :excluded
+
+      sig { override.returns(Types::SymbolHash) }
+      def hash_value; end
+    end
+
+    class ExactDate < Date
+      sig { params(date: Object).void }
+      def initialize(date:); end
+
+      sig { override.params(other_date: ::Date).returns(T::Boolean) }
+      def include?(other_date); end
+
+      sig { returns(::Date) }
+      attr_reader :date
+    end
+
+    class Intersection < Set
+      sig { params(elements: T.any(Expression::Base, T::Array[Expression::Base])).void }
+      def initialize(*elements); end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
+      def include?(date); end
+    end
+
+    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); end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
+      def include?(date); end
+
+      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); end
+
+      sig { params(date: ::Date).returns(T::Boolean) }
+      def start_month_include?(date); end
+
+      sig { params(date: ::Date).returns(T::Boolean) }
+      def end_month_include?(date); end
+
+      sig { override.returns(T::Hash[Symbol, Integer]) }
+      def hash_value; end
+    end
+
+    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); end
+
+      sig { params(element: T.untyped).returns(Repeatable::Expression::Set) }
+      def <<(element); end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      def ==(other); end
+
+      sig { override.returns(T::Array[Types::SymbolHash]) }
+      def hash_value; end
+    end
+
+    class Union < Set
+      sig { params(elements: T.any(Expression::Base, T::Array[Expression::Base])).void }
+      def initialize(*elements); end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
+      def include?(date); end
+    end
+
+    class Weekday < Date
+      sig { params(weekday: Integer).void }
+      def initialize(weekday:); end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
+      def include?(date); end
+
+      sig { returns(Integer) }
+      attr_reader :weekday
+    end
+
+    class WeekdayInMonth < Date
+      include LastDateOfMonth
+
+      sig { params(weekday: Integer, count: Integer).void }
+      def initialize(weekday:, count:); end
+
+      sig { override.params(date: ::Date).returns(T::Boolean) }
+      def include?(date); end
+
+      sig { returns(Integer) }
+      attr_reader :weekday
+
+      sig { returns(Integer) }
+      attr_reader :count
+
+      sig { params(date: ::Date).returns(T::Boolean) }
+      def day_matches?(date); end
+
+      sig { params(date: ::Date).returns(T::Boolean) }
+      def week_matches?(date); end
+
+      sig { params(date: ::Date).returns(Integer) }
+      def week_from_beginning(date); end
+
+      sig { params(date: ::Date).returns(Integer) }
+      def week_from_end(date); end
+
+      sig { params(zero_indexed_day: Integer).returns(Integer) }
+      def week_in_month(zero_indexed_day); end
+
+      sig { returns(T::Boolean) }
+      def negative_count?; end
+    end
+  end
+end