repeatable 1.0.0 → 1.2.0

data/rbi/repeatable.rbi

@@ -0,0 +1,316 @@
+# typed: strong
+module Repeatable
+  VERSION = "1.2.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(_keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.any(Types::SymbolHash, T::Array[Types::SymbolHash])]) }
+    def deconstruct_keys(_keys); 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(_keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.any(Types::SymbolHash, T::Array[Types::SymbolHash])]) }
+      def deconstruct_keys(_keys); 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::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

data/repeatable.gemspec

@@ -12,8 +12,11 @@ Gem::Specification.new do |spec|
   spec.description = "Ruby implementation of Martin Fowler's 'Recurring Events for Calendars' paper."
   spec.homepage = "https://github.com/molawson/repeatable"
   spec.license = "MIT"
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
   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 "sorbet-runtime"
 end

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/rainbow.rbi

@@ -0,0 +1,269 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module Rainbow
+  # @shim: https://github.com/sickill/rainbow/blob/master/lib/rainbow.rb#L10-L12
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig { params(ground: Symbol, values: T.any([Integer], [Integer, Integer, Integer])).returns(Color) }
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Rainbow::Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).void }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Rainbow::Color::Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+
+    class RGB < Rainbow::Color::Indexed
+      sig { returns(Integer) }
+      attr_reader :r, :g, :b
+
+      sig { params(ground: Symbol, values: Integer).void }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+
+      sig { params(value: Numeric).returns(Integer) }
+      def self.to_ansi_domain(value); end
+    end
+
+    class X11Named < Rainbow::Color::RGB
+      include Rainbow::X11ColorNames
+
+      sig { params(ground: Symbol, name: Symbol).void }
+      def initialize(ground, name); end
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def self.uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).void }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end

data/sorbet/rbi/gems/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-generated=true