rubysky 0.1.0

data/.gem_rbs_collection/activesupport/7.0/activesupport.rbs

@@ -0,0 +1,583 @@
+module ActiveSupport
+  interface _IncludeP
+    def include?: (untyped value) -> bool
+  end
+end
+
+module ActiveSupport
+  module Callbacks
+    module ClassMethods
+      # Manual definition to make block optional
+      def set_callback: (untyped name, *untyped filter_list) ?{ () -> untyped } -> untyped
+                      | ...
+
+      # Manual definition to make block optional
+      def skip_callback: (untyped name, *untyped filter_list) ?{ () -> untyped } -> untyped
+                       | ...
+    end
+  end
+
+  module Configurable
+    extend Concern
+
+    class Configuration < InheritableOptions
+      def compile_methods!: () -> void
+
+      # Compiles reader methods so we don't have to go through method_missing.
+      def self.compile_methods!: (Array[Symbol | String] keys) -> void
+    end
+
+    module ClassMethods
+      def config: () -> InheritableOptions
+
+      def configure: () { (InheritableOptions config) -> void } -> void
+
+      private
+
+      # TODO: Fix to use `interned` in names params after releasing ruby/rbs#1499
+      def config_accessor: (*(String | Symbol) names, ?instance_accessor: bool instance_accessor, ?instance_writer: bool instance_writer, ?instance_reader: bool instance_reader) ?{ () -> untyped } -> void
+    end
+
+    def config: () -> InheritableOptions
+  end
+
+  class Deprecation
+    class DeprecatedConstantProxy
+      # Manual definition to make block optional
+      def self.new: (*untyped args, **untyped kwargs) ?{ () -> untyped } -> untyped
+                  | ...
+    end
+  end
+
+  class HashWithIndifferentAccess[T, U] < Hash[T, U]
+    # Manual definition to make block optional
+    def fetch_values: (*untyped indices) ?{ () -> untyped } -> untyped
+                    | ...
+
+    # Manual definition to make block optional
+    def merge: (untyped hash) ?{ () -> untyped } -> untyped
+             | ...
+
+    # Manual definition to make block optional
+    def select: (*untyped args) ?{ () -> untyped } -> untyped
+              | ...
+
+    # Manual definition to make block optional
+    def reject: (*untyped args) ?{ () -> untyped } -> untyped
+              | ...
+
+    # Manual definition to make block optional
+    def transform_values: (*untyped args) ?{ () -> untyped } -> untyped
+                        | ...
+
+    # Manual definition to make block optional
+    def transform_keys: (*untyped args) ?{ () -> untyped } -> untyped
+                      | ...
+
+    # Manual definition to make block optional
+    def transform_keys!: () ?{ (untyped) -> untyped } -> untyped
+                       | ...
+  end
+
+  module Testing
+    module TimeHelpers
+      # Manual definition to make block optional
+      def travel: (untyped duration) ?{ () -> untyped } -> untyped
+                | ...
+
+      # Manual definition to make block optional
+      def travel_to: (untyped date_or_time) ?{ () -> untyped } -> untyped
+                   | ...
+
+      # Manual definition to make block optional
+      def freeze_time: () ?{ () -> untyped } -> untyped
+                     | ...
+    end
+  end
+
+  class TimeWithZone
+    include DateAndTime::Calculations
+
+    # Returns a <tt>Time</tt> instance that represents the time in +time_zone+.
+    def time: () -> ::Time
+
+    # Returns a <tt>Time</tt> instance of the simultaneous time in the UTC timezone.
+    def utc: () -> ::Time
+
+    # Returns a <tt>Time</tt> instance of the simultaneous time in the system timezone.
+    def localtime: (?::String utc_offset) -> ::Time
+                 | (?::Integer utc_offset) -> ::Time
+
+    # Returns true if the current time is within Daylight Savings Time for the
+    # specified time zone.
+    #
+    #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
+    #   Time.zone.parse("2012-5-30").dst?           # => true
+    #   Time.zone.parse("2012-11-30").dst?          # => false
+    def dst?: () -> bool
+
+    # Returns true if the current time zone is set to UTC.
+    #
+    #   Time.zone = 'UTC'                           # => 'UTC'
+    #   Time.zone.now.utc?                          # => true
+    #   Time.zone = 'Eastern Time (US & Canada)'    # => 'Eastern Time (US & Canada)'
+    #   Time.zone.now.utc?                          # => false
+    def utc?: () -> bool
+
+    # Returns the offset from current time to UTC time in seconds.
+    def utc_offset: () -> ::Integer
+
+    # Returns the time zone abbreviation.
+    #
+    #   Time.zone = 'Eastern Time (US & Canada)'   # => "Eastern Time (US & Canada)"
+    #   Time.zone.now.zone # => "EST"
+    def zone: () -> ::String
+
+    # Returns a string of the object's date and time in the format used by
+    # HTTP requests.
+    #
+    #   Time.zone.now.httpdate  # => "Tue, 01 Jan 2013 04:39:43 GMT"
+    def httpdate: () -> ::String
+
+    # Returns a string of the object's date and time in the RFC 2822 standard
+    # format.
+    #
+    #   Time.zone.now.rfc2822  # => "Tue, 01 Jan 2013 04:51:39 +0000"
+    def rfc2822: () -> ::String
+
+    # Replaces <tt>%Z</tt> directive with +zone before passing to Time#strftime,
+    # so that zone information is correct.
+    def strftime: (::String arg0) -> ::String
+
+    # Returns Array of parts of Time in sequence of
+    # [seconds, minutes, hours, day, month, year, weekday, yearday, dst?, zone].
+    #
+    #   now = Time.zone.now     # => Tue, 18 Aug 2015 02:29:27 UTC +00:00
+    #   now.to_a                # => [27, 29, 2, 18, 8, 2015, 2, 230, false, "UTC"]
+    def to_a: () -> [ ::Integer, ::Integer, ::Integer, ::Integer, ::Integer, ::Integer, ::Integer, ::Integer, bool, ::String ]
+
+    # Returns the object's date and time as a floating point number of seconds
+    # since the Epoch (January 1, 1970 00:00 UTC).
+    #
+    #   Time.zone.now.to_f # => 1417709320.285418
+    def to_f: () -> ::Float
+
+    # Returns the object's date and time as an integer number of seconds
+    # since the Epoch (January 1, 1970 00:00 UTC).
+    #
+    #   Time.zone.now.to_i # => 1417709320
+    def to_i: () -> ::Integer
+
+    # Returns the object's date and time as a rational number of seconds
+    # since the Epoch (January 1, 1970 00:00 UTC).
+    #
+    #   Time.zone.now.to_r # => (708854548642709/500000)
+    def to_r: () -> ::Rational
+
+    # Returns an instance of DateTime with the timezone's UTC offset
+    #
+    #   Time.zone.now.to_datetime                         # => Tue, 18 Aug 2015 02:32:20 +0000
+    #   Time.current.in_time_zone('Hawaii').to_datetime   # => Mon, 17 Aug 2015 16:32:20 -1000
+    def to_datetime: () -> ::DateTime
+
+    # Returns an instance of +Time+, either with the same UTC offset
+    # as +self+ or in the local system timezone depending on the setting
+    # of +ActiveSupport.to_time_preserves_timezone+.
+    def to_time: () -> ::Time
+
+    # class_eval
+    def year: () -> Integer
+    def mon: () -> Integer
+    def month: () -> Integer
+    def day: () -> Integer
+    def mday: () -> Integer
+    def wday: () -> Integer
+    def yday: () -> Integer
+    def hour: () -> Integer
+    def min: () -> Integer
+    def sec: () -> Integer
+    def usec: () -> Integer
+    def nsec: () -> Integer
+    def to_date: () -> Date
+
+    # method_missing
+    def asctime: () -> String
+    alias at_beginning_of_day beginning_of_day
+    alias at_beginning_of_hour beginning_of_hour
+    alias at_beginning_of_minute beginning_of_minute
+    alias at_end_of_day end_of_day
+    alias at_end_of_hour end_of_hour
+    alias at_end_of_minute end_of_minute
+    alias at_midday middle_of_day
+    alias at_middle_of_day middle_of_day
+    alias at_midnight beginning_of_day
+    alias at_noon middle_of_day
+    def beginning_of_day: () -> self
+    def beginning_of_hour: () -> self
+    def beginning_of_minute: () -> self
+    def ceil: (?int ndigits) -> self
+    def compare_with_coercion: (untyped other) -> (-1 | 0 | 1 | nil)
+    def compare_without_coercion: (untyped other) -> (-1 | 0 | 1 | nil)
+    def ctime: () -> String
+    def end_of_day: () -> self
+    def end_of_hour: () -> self
+    def end_of_minute: () -> self
+    def eql_with_coercion: (untyped other) -> bool
+    def eql_without_coercion: (untyped other) -> bool
+    def floor: (?int ndigits) -> self
+    def friday?: () -> bool
+    alias midday middle_of_day
+    def middle_of_day: () -> self
+    alias midnight beginning_of_day
+    def minus_with_coercion: (Time | self arg0) -> Float
+                           | (Numeric arg0) -> self
+    def minus_with_duration: (Time | self arg0) -> Float
+                           | (Numeric arg0) -> self
+    def minus_without_coercion: (Time | self arg0) -> Float
+                           | (Numeric arg0) -> self
+    def minus_without_duration: (Time | self arg0) -> Float
+                           | (Numeric arg0) -> self
+    def monday?: () -> bool
+    def next_day: () -> self
+    def next_month: () -> self
+    def next_year: () -> self
+    alias noon middle_of_day
+    def plus_without_duration: (Time | self arg0) -> Float
+                             | (Numeric arg0) -> self
+    def prev_day: () -> self
+    def prev_month: () -> self
+    def prev_year: () -> self
+    def round: (?int ndigits) -> self
+    def saturday?: () -> bool
+    def seconds_since_midnight: () -> Float
+    def seconds_until_end_of_day: () -> Integer
+    def sec_fraction: () -> (Integer | Rational)
+    def subsec: () -> (Integer | Rational)
+    def sunday?: () -> bool
+    def thursday?: () -> bool
+    def to_default_s: () -> String
+    def tuesday?: () -> bool
+    def tv_nsec: () -> Integer
+    def tv_usec: () -> Integer
+    def wednesday?: () -> bool
+  end
+
+  module SecurityUtils
+    def self?.fixed_length_secure_compare: (String a, String b) -> bool
+
+    def self?.secure_compare: (String a, String b) -> bool
+  end
+
+  class OrderedOptions < Hash[Symbol, untyped]
+    alias _get []
+
+    # TODO: Fix to use `interned` in key params after releasing ruby/rbs#1499
+    def []=: ((String | Symbol) key, untyped value) -> untyped
+
+    # TODO: Fix to use `interned` in key params after releasing ruby/rbs#1499
+    def []: ((String | Symbol) key) -> untyped
+
+    def method_missing: (Symbol name, *untyped args) -> untyped
+
+    def respond_to_missing?: (Symbol name, ?bool include_private) -> true
+
+    def extractable_options?: () -> true
+  end
+
+  class InheritableOptions < OrderedOptions
+    # TODO: Fix to use `interned` in parent params after releasing ruby/rbs#1499
+    def initialize: (?Hash[(String | Symbol), untyped]? parent) -> void
+
+    def inheritable_copy: () -> instance
+  end
+end
+
+class Hash[unchecked out K, unchecked out V]
+  # Manual definition to make block optional
+  def deep_merge: (untyped other_hash) ?{ () -> untyped } -> untyped
+                | ...
+
+  # Manual definition to make block optional
+  def deep_merge!: (untyped other_hash) ?{ () -> untyped } -> untyped
+                 | ...
+
+  def stringify_keys: () -> Hash[String, V]
+
+  def stringify_keys!: () -> self
+
+  def symbolize_keys: () -> Hash[Symbol, V]
+  alias to_options symbolize_keys
+
+  def symbolize_keys!: () -> self
+  alias to_options! symbolize_keys!
+
+  def deep_stringify_keys: () -> Hash[String, untyped]
+
+  def deep_stringify_keys!: () -> self
+
+  def deep_symbolize_keys: () -> Hash[Symbol, untyped]
+
+  def deep_symbolize_keys!: () -> self
+end
+
+class Module
+  # Manual definition to make block optional
+  def mattr_reader: (*untyped syms, ?default: untyped? default, ?instance_accessor: bool instance_accessor, ?instance_reader: bool instance_reader) ?{ () -> untyped } -> untyped
+                  | ...
+
+  # Manual definition to make block optional
+  def mattr_writer: (*untyped syms, ?default: untyped? default, ?instance_accessor: bool instance_accessor, ?instance_writer: bool instance_writer) ?{ () -> untyped } -> untyped
+                  | ...
+
+  # Manual definition to make block optional
+  def mattr_accessor: (*untyped syms, ?default: untyped? default, ?instance_accessor: bool instance_accessor, ?instance_writer: bool instance_writer, ?instance_reader: bool instance_reader) ?{ () -> untyped } -> untyped
+                    | ...
+
+  # TODO: Fix to use `interned` in attrs params after releasing ruby/rbs#1499
+  def attr_internal_reader: (*(Symbol | String) attrs) -> void
+
+  # TODO: Fix to use `interned` in attrs params after releasing ruby/rbs#1499
+  def attr_internal_writer: (*(Symbol | String) attrs) -> void
+
+  # TODO: Fix to use `interned` in attrs params after releasing ruby/rbs#1499
+  def attr_internal_accessor: (*(Symbol | String) attrs) -> void
+
+  alias attr_internal attr_internal_accessor
+
+  attr_accessor self.attr_internal_naming_format: String
+
+  private
+
+  # TODO: Fix to use `interned` in attr params after releasing ruby/rbs#1499
+  def attr_internal_ivar_name: ((Symbol | String) attr) -> String
+
+  type access_type = :reader | :writer
+  # TODO: Fix to use `interned` in attr params after releasing ruby/rbs#1499
+  def attr_internal_define: ((Symbol | String) attr_name, access_type `type`) -> void
+end
+
+class Integer
+  prepend ActiveSupport::NumericWithFormat
+end
+
+class Float
+  prepend ActiveSupport::NumericWithFormat
+end
+
+class BigDecimal
+  prepend ActiveSupport::NumericWithFormat
+end
+
+module ActiveSupport
+  module Tryable : BasicObject
+    def try: [T] () { (self) -> T } -> T # When yield self
+           | [T] () { () -> T } -> T # When instance_eval
+           | (Object::name method_name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
+
+    def try!: [T] () { (self) -> T } -> T # When yield self
+            | [T] () { () -> T } -> T # When instance_eval
+            | (Object::name method_name, *untyped args) ?{ (*untyped) -> untyped } -> untyped
+  end
+end
+
+class NilClass
+    def try: () { (untyped) -> untyped } -> nil
+           | () { () -> untyped } -> nil
+           | (Object::name method_name, *untyped args) ?{ (*untyped) -> untyped } -> nil
+
+    def try!: () { (untyped) -> untyped } -> nil
+            | () { () -> untyped } -> nil
+            | (Object::name method_name, *untyped args) ?{ (*untyped) -> untyped } -> nil
+
+end
+
+class Array[unchecked out Elem]
+  # Manual definition to make block optional
+  def in_groups: (untyped number, ?untyped? fill_with) ?{ (untyped) -> untyped } -> untyped
+end
+
+# active_support/core_ext/object/blank.rb
+class Object
+  def blank?: () -> bool
+  def present?: () -> bool
+  def presence: () -> self?
+end
+
+# active_support/core_ext/object/inclusion.rb
+class Object
+  def in?: (ActiveSupport::_IncludeP another_object) -> bool
+  def presence_in: (ActiveSupport::_IncludeP another_object) -> (self | nil)
+end
+
+class NilClass
+  def blank?: () -> true
+end
+
+class FalseClass
+  def blank?: () -> true
+end
+
+class TrueClass
+  def blank?: () -> false
+end
+
+class Array[unchecked out Elem]
+  alias blank? empty?
+end
+
+class Hash[unchecked out K, unchecked out V]
+  alias blank? empty?
+end
+
+class String
+  BLANK_RE: Regexp
+  ENCODED_BLANKS: Concurrent::Map[Encoding, Regexp]
+  def blank?: () -> bool
+end
+
+class Numeric
+  def blank?: () -> false
+end
+
+class Time
+  def blank?: () -> false
+end
+
+# active_support/core_ext/string/inflections.rb
+class String
+  def camelize: (?Symbol first_letter) -> String
+  alias camelcase camelize
+  def underscore: () -> String
+  def dasherize: () -> String
+  def pluralize: (?Integer | Symbol? count, ?Symbol locale) -> String
+  def singularize: (?Symbol locale) -> String
+  def constantize: () -> untyped
+  def safe_constantize: () -> untyped
+  def titleize: (?keep_id_suffix: boolish) -> String
+  alias titlecase titleize
+  def demodulize: () -> String
+  def deconstantize: () -> String
+  def parameterize: (?separator: String, ?preserve_case: boolish, ?locale: Symbol) -> String
+  def tableize: () -> String
+  def classify: () -> String
+  def humanize: (?capitalize: boolish, ?keep_id_suffix: boolish) -> String
+  def upcase_first: () -> String
+  def foreign_key: (?boolish separate_class_name_and_id_with_underscore) -> String
+end
+
+class Array[unchecked out Elem]
+  # Wraps its argument in an array unless it is already an array (or array-like).
+  #
+  # Specifically:
+  #
+  # * If the argument is +nil+ an empty array is returned.
+  # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
+  # * Otherwise, returns an array with the argument as its single element.
+  #
+  #     Array.wrap(nil)       # => []
+  #     Array.wrap([1, 2, 3]) # => [1, 2, 3]
+  #     Array.wrap(0)         # => [0]
+  #
+  # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
+  #
+  # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
+  #   moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
+  #   an array with the argument as its single element right away.
+  # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
+  #   raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
+  # * It does not call +to_a+ on the argument, if the argument does not respond to +to_ary+
+  #   it returns an array with the argument as its single element.
+  #
+  # The last point is easily explained with some enumerables:
+  #
+  #   Array(foo: :bar)      # => [[:foo, :bar]]
+  #   Array.wrap(foo: :bar) # => [{:foo=>:bar}]
+  #
+  # There's also a related idiom that uses the splat operator:
+  #
+  #   [*object]
+  #
+  # which returns <tt>[]</tt> for +nil+, but calls to <tt>Array(object)</tt> otherwise.
+  #
+  # The differences with <tt>Kernel#Array</tt> explained above
+  # apply to the rest of <tt>object</tt>s.
+  def self.wrap: (nil) -> Array[untyped]
+               | [T] (_ToAry[T] array_like) -> Array[T]
+               | [T] (T ele) -> Array[T]
+end
+
+module ActiveSupport
+  # Rescuable module adds support for easier exception handling.
+  module Rescuable
+    extend Concern
+
+    module ClassMethods
+      # Rescue exceptions raised in controller actions.
+      #
+      # <tt>rescue_from</tt> receives a series of exception classes or class
+      # names, and a trailing <tt>:with</tt> option with the name of a method
+      # or a Proc object to be called to handle them. Alternatively a block can
+      # be given.
+      #
+      # Handlers that take one argument will be called with the exception, so
+      # that the exception can be inspected when dealing with it.
+      #
+      # Handlers are inherited. They are searched from right to left, from
+      # bottom to top, and up the hierarchy. The handler of the first class for
+      # which <tt>exception.is_a?(klass)</tt> holds true is the one invoked, if
+      # any.
+      #
+      #   class ApplicationController < ActionController::Base
+      #     rescue_from User::NotAuthorized, with: :deny_access # self defined exception
+      #     rescue_from ActiveRecord::RecordInvalid, with: :show_errors
+      #
+      #     rescue_from 'MyAppError::Base' do |exception|
+      #       render xml: exception, status: 500
+      #     end
+      #
+      #     private
+      #       def deny_access
+      #         ...
+      #       end
+      #
+      #       def show_errors(exception)
+      #         exception.record.new_record? ? ...
+      #       end
+      #   end
+      #
+      # Exceptions raised inside exception handlers are not propagated up.
+      def rescue_from: (*Class) { (Exception) [self: instance] -> void } -> void
+                     | (*Class, with: Symbol | ^(Exception) [self: instance] -> void) -> void
+
+      # Matches an exception to a handler based on the exception class.
+      #
+      # If no handler matches the exception, check for a handler matching the
+      # (optional) exception.cause. If no handler matches the exception or its
+      # cause, this returns +nil+, so you can deal with unhandled exceptions.
+      # Be sure to re-raise unhandled exceptions if this is what you expect.
+      #
+      #     begin
+      #       (trim non-ascii characters)
+      #     rescue => exception
+      #       rescue_with_handler(exception) || raise
+      #     end
+      #
+      # Returns the exception if it was handled and +nil+ if it was not.
+      def rescue_with_handler: (untyped exception, ?visited_exceptions: untyped visited_exceptions, ?object: untyped object) -> untyped
+
+      def handler_for_rescue: (untyped exception, ?object: untyped object) -> untyped
+
+      private
+
+      def find_rescue_handler: (untyped exception) -> untyped
+
+      def constantize_rescue_handler_class: (untyped class_or_name) -> untyped
+    end
+
+    # Delegates to the class method, but uses the instance as the subject for
+    # rescue_from handlers (method calls, instance_exec blocks).
+    def rescue_with_handler: (untyped exception) -> untyped
+
+    def handler_for_rescue: (untyped exception) -> untyped
+  end
+end

data/.gem_rbs_collection/activesupport/7.0/manifest.yaml

@@ -0,0 +1,16 @@
+# manifest.yaml describes dependencies which do not appear in the gemspec.
+# If this gem includes such dependencies, comment-out the following lines and
+# declare the dependencies.
+# If all dependencies appear in the gemspec, you should remove this file.
+#
+dependencies:
+  - name: date
+  - name: logger
+  - name: minitest
+  - name: monitor
+  - name: mutex_m
+  - name: openssl
+  - name: singleton
+  - name: time
+  - name: securerandom
+  - name: erb

data/.gem_rbs_collection/activesupport/7.0/patch.rbs

@@ -0,0 +1,55 @@
+module ActiveSupport
+  class TestCase < ::Minitest::Test
+    # It is necessary to satisfy alias target.
+    # TODO: Define this method to correct place.
+    def name: () -> untyped
+    def assert_raises: (*untyped) -> untyped
+    def refute_empty: (*untyped) -> untyped
+    def refute_equal: (*untyped) -> untyped
+    def refute_in_delta: (*untyped) -> untyped
+    def refute_in_epsilon: (*untyped) -> untyped
+    def refute_includes: (*untyped) -> untyped
+    def refute_instance_of: (*untyped) -> untyped
+    def refute_kind_of: (*untyped) -> untyped
+    def refute_match: (*untyped) -> untyped
+    def refute_nil: (*untyped) -> untyped
+    def refute_operator: (*untyped) -> untyped
+    def refute_predicate: (*untyped) -> untyped
+    def refute_respond_to: (*untyped) -> untyped
+    def refute_same: (*untyped) -> untyped
+  end
+end
+
+# Remove the fake type of LibXML
+# if the real types are available.
+module LibXML
+  module XML
+    module SaxParser
+      module Callbacks
+      end
+    end
+  end
+end
+
+# Remove the fake type of Nokogiri
+# if the real types are available.
+module Nokogiri
+  module XML
+    module SAX
+      class Document
+      end
+    end
+  end
+end
+
+# Remove the fake type of DRb
+# if the real types are available.
+module DRb
+  module DRbUndumped
+  end
+end
+
+module Rails
+  class Railtie
+  end
+end

data/.gem_rbs_collection/ast/2.4/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: ast
+version: '2.4'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 0a6ea105a0afc7eaee4494585a7775f47eea6145
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems