rubysky 0.1.0

data/.gem_rbs_collection/ast/2.4/ast.rbs

@@ -0,0 +1,73 @@
+module AST
+  interface _ToAst
+    def to_ast: () -> Node
+  end
+
+  interface _ToSym
+    def to_sym: () -> Symbol
+  end
+
+  class Node
+    public
+
+    attr_reader children: Array[untyped]
+    attr_reader hash: String
+    attr_reader type: Symbol
+
+    alias + concat
+
+    alias << append
+
+    def ==: (untyped other) -> bool
+
+    def append: (untyped element) -> self
+
+    alias clone dup
+
+    def concat: (_ToA[untyped] array) -> self
+
+    def dup: () -> self
+
+    def eql?: (untyped other) -> bool
+
+    def inspect: (?Integer indent) -> String
+
+    alias to_a children
+
+    def to_ast: () -> self
+
+    alias to_s to_sexp
+
+    def to_sexp: (?Integer indent) -> String
+
+    def to_sexp_array: () -> Array[untyped]
+
+    def updated: (?_ToSym? `type`, ?_ToA[untyped]? children, ?Hash[Symbol, untyped]? properties) -> self
+
+    private
+
+    def initialize: (_ToSym `type`, ?_ToA[untyped]? children, ?Hash[Symbol, untyped] properties) -> void
+
+    alias original_dup dup
+  end
+
+  class Processor
+    include Mixin
+
+    module Mixin
+      public
+
+      def handler_missing: (Node node) -> Node?
+
+      def process: (_ToAst? node) -> Node?
+
+      def process_all: (Array[_ToAst] nodes) -> Array[Node]
+    end
+  end
+
+  module Sexp
+    public
+
+    def s: (_ToSym `type`, *untyped children) -> Node
+  end
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/.rbs_meta.yaml

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

data/.gem_rbs_collection/concurrent-ruby/1.1/array.rbs

@@ -0,0 +1,4 @@
+module Concurrent
+  class Array[T] < ::Array[T]
+  end
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/executor.rbs

@@ -0,0 +1,26 @@
+module Concurrent
+  module ExecutorService
+    interface _Task
+      def call: () -> void
+    end
+
+    def post: [A] (*A args) { (*A args) -> void } -> bool
+
+    def <<: (_Task task) -> bool
+
+    def can_overflow?: () -> bool
+
+    def serialized?: () -> bool
+  end
+
+  type executor = ExecutorService | :io | :fast | :immediate
+
+  def self.executor: (executor executor_identifier) -> ExecutorService
+
+  def self.global_io_executor: () -> ExecutorService
+  def self.global_fast_executor: () -> ExecutorService
+  def self.global_immediate_executor: () -> ExecutorService
+
+  def self.new_io_executor: (?Hash[Symbol, untyped] opts) -> ExecutorService
+  def self.new_fast_executor: (?Hash[Symbol, untyped] opts) -> ExecutorService
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/hash.rbs

@@ -0,0 +1,4 @@
+module Concurrent
+  class Hash[K, V] < ::Hash[K, V]
+  end
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/map.rbs

@@ -0,0 +1,58 @@
+module Concurrent
+  class Map[unchecked out K, unchecked out V]
+    def initialize: (?Hash[Symbol, untyped] options) ?{ (self, untyped) -> V } -> void
+
+    def []: (untyped key) -> V?
+    def []=: (K key, V value) -> V
+
+    alias get []
+    alias put []=
+
+    def fetch: (untyped key) -> V
+             | [D] (untyped key, D default_value) -> (V | D)
+             | [T, D] (T key) { (T key) -> D } -> (V | D)
+
+    def fetch_or_store: (untyped key) -> V
+                      | (K key, V default_value) -> V
+                      | (K key) { (K key) -> V } -> V
+    
+    def put_if_absent: (K key, V value) -> V?
+
+    def value?: (untyped value) -> bool
+
+    def keys: () -> Array[K]
+
+    def values: () -> Array[V]
+
+    def each_key: () { (K key) -> void } -> self
+
+    def each_value: () { (V value) -> void } -> self
+
+    def each_pair: () { (K key, V value) -> void } -> self
+
+    alias each each_pair
+
+    def key: (untyped value) -> K?
+
+    def empty?: () -> bool
+
+    def size: () -> Integer
+
+    def marshal_dump: () -> Hash[K, V]
+    def marshal_load: (Hash[K, V] hash) -> self
+
+    # undef :freeze
+
+    def inspect: () -> String
+
+    private
+
+    def raise_fetch_no_key: () -> bot
+
+    def initialize_copy: (instance other) -> void
+
+    def populate_from: (Hash[K, V] hash) -> self
+
+    def validate_options_hash!: (Hash[Symbol, untyped] options) -> void
+  end
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/promises.rbs

@@ -0,0 +1,249 @@
+module Concurrent
+  module Promises
+    module FactoryMethods
+      def any_event: (*(Event | Future[top, top]) futures_and_or_events) -> Event
+      def any_event_on: (executor default_executor, *(Event | Future[top, top]) futures_and_or_events) -> Event
+
+      def any_fulfilled_future: (*Event events) -> Future[nil, bot]
+        | [T, E] (*Future[T, E] futures) -> Future[T, E]
+        | [T, E] (*(Event | Future[T, E]) futures_and_or_events) -> Future[T | nil, E]
+      def any_fulfilled_future_on: (executor default_executor, *Event events) -> Future[nil, bot]
+        | [T, E] (executor default_executor, *Future[T, E] futures) -> Future[T, E]
+        | [T, E] (executor default_executor, *(Event | Future[T, E]) futures_and_or_events) -> Future[T | nil, E]
+
+      def any_resolved_future: (*Event events) -> Future[nil, bot]
+        | [T, E] (*Future[T, E] futures) -> Future[T, E]
+        | [T, E] (*(Event | Future[T, E]) futures_and_or_events) -> Future[T | nil, E]
+      alias any any_resolved_future
+      def any_resolved_future_on: (executor default_executor, *Event events) -> Future[nil, bot]
+        | [T, E] (executor default_executor, *Future[T, E] futures) -> Future[T, E]
+        | [T, E] (executor default_executor, *(Event | Future[T, E]) futures_and_or_events) -> Future[T | nil, E]
+
+      def default_executor: () -> executor
+
+      def delay: () -> Event
+        | [A, T] (*A args) { (*A args) -> T } -> Future[T, Exception]
+      def delay_on: (executor default_executor) -> Event
+        | [A, T] (executor default_executor, *A args) { (*A args) -> T } -> Future[T, Exception]
+
+      def fulfilled_future: [T] (T value, ?executor default_executor) -> Future[T, bot]
+
+      def future: [A, T] (*A args) { (*A args) -> T } -> Future[T, Exception]
+      def future_on: [A, T] (executor default_executor, *A args) { (*A args) -> T } -> Future[T, Exception]
+
+      def make_future: (nil, ?executor default_executor) -> Event
+        | [X < AbstractEventFuture] (X event_or_future, ?executor default_executor) -> X
+        | [E < Exception] (E reason, ?executor default_executor) -> Future[bot, E]
+        | [T] (T value, ?executor default_executor) -> Future[T, bot]
+
+      def rejected_future: [E] (E reason, ?executor default_executor) -> Future[bot, E]
+
+      def resolvable_event: () -> ResolvableEvent
+      def resolvable_event_on: (executor default_executor) -> ResolvableEvent
+
+      def resolvable_future: () -> ResolvableFuture[untyped, untyped]
+      def resolvable_future_on: (executor default_executor) -> ResolvableFuture[untyped, untyped]
+
+      def resolved_event: (?executor default_executor) -> Event
+
+      def resolved_future: [T] (true fulfilled, T value, top reason, ?executor default_executor) -> Future[T, bot]
+        | [E] (false fulfilled, top value, E reason, ?executor default_executor) -> Future[bot, E]
+        | [T, E] (boolish fulfilled, T? value, E? reason, ?executor default_executor) -> Future[T, E]
+
+      def schedule: (Numeric | Time intended_time) -> Event
+        | [A, T] (Numeric | Time intended_time, *A args) { (*A args) -> T } -> Future[T, Exception]
+      def schedule_on: (executor default_executor, Numeric | Time intended_time) -> Event
+        | [A, T] (executor default_executor, Numeric | Time intended_time, *A args) { (*A args) -> T } -> Future[T, Exception]
+
+      def zip_events: (*(Event | Future[top, top]) futures_and_or_events) -> Event
+      def zip_events_on: (executor default_executor, *(Event | Future[top, top]) futures_and_or_events) -> Event
+
+      def zip_futures: (*Event events) -> Future[::Array[nil], bot]
+        | [T, E] (*Future[T, E] futures) -> Future[::Array[T], ::Array[E]]
+        | [T, E] (*(Event | Future[T, E]) futures_and_or_events) -> Future[::Array[T | nil], ::Array[E | nil]]
+      alias zip zip_futures
+      def zip_futures_on: (executor default_executor, *Event events) -> Future[Array[nil], bot]
+        | [T, E] (executor default_executor, *Future[T, E] futures) -> Future[Array[T], Array[E]]
+        | [T, E] (executor default_executor, *(Event | Future[T, E]) futures_and_or_events) -> Future[Array[T | nil], Array[E]]
+    end
+
+    extend FactoryMethods
+
+    class AbstractEventFuture
+      def chain: [A, U] (*A args) { (*untyped) -> U } -> Future[U, Exception]
+      def chain_on: [A, U] (executor executor, *A args) { (*untyped) -> U } -> Future[U, Exception]
+
+      def chain_resolvable: (Resolvable resolvable) -> self
+      alias tangle chain_resolvable
+
+      def default_executor: () -> executor
+
+      def internal_state: () -> Object
+
+      def on_resolution: [A] (*A args) { (*untyped) -> void } -> self
+      def on_resolution!: [A] (*A args) { (*untyped) -> void } -> self
+      def on_resolution_using: [A] (executor executor, *A args) { (*untyped) -> void } -> self
+
+      def resolved?: () -> bool
+
+      def pending?: () -> bool
+
+      def state: () -> Symbol
+
+      def touch: () -> self
+
+      def wait: (?nil) -> self
+        | (Numeric timeout) -> bool
+    end
+
+    class Event < AbstractEventFuture
+      def any: (Event | Future[top, top] event_or_future) -> Event
+      alias | any
+
+      def delay: () -> Event
+
+      def schedule: (Numeric | Time intended_time) -> Event
+
+      def to_event: () -> self
+
+      def to_future: () -> Future[nil, bot]
+
+      def with_default_executor: (executor executor) -> Event
+
+      def zip: (Event event) -> Event
+        | [T, E] (Future[T, E] future) -> Future[T, E]
+      alias & zip
+
+
+      ## Following methods are actually defined in the base class and have specific types for Event
+
+      def chain: [A, U] (*A args) { (*A args) -> U } -> Future[U, Exception]
+      def chain_on: [A, U] (executor executor, *A args) { (*A args) -> U } -> Future[U, Exception]
+
+      def on_resolution: [A] (*A args) { (*A args) -> void } -> self
+      def on_resolution!: [A] (*A args) { (*A args) -> void } -> self
+      def on_resolution_using: [A] (executor executor, *A args) { (*A args) -> void } -> self
+
+      def state: () -> (:pending | :resolved)
+    end
+
+    class Future[out T, out E] < AbstractEventFuture
+      def any: (Event event) -> Future[T | nil, E]
+        | [T2, E2] (Future[T2, E2] future) -> Future[T | T2, E | E2]
+      alias | any
+
+      def delay: () -> Future[T, E]
+
+      def exception: () -> Exception  # TODO: Return type can be narrowed to E when E <: Exception
+
+      def flat_event: () -> Event
+
+      def flat_future: (?Integer level) -> untyped  # TODO: Valid only if T <: Future[top, top]
+      alias flat flat_future
+
+      def fulfilled?: () -> bool
+
+      def on_fulfillment: [A] (*A args) { (T value, *A args) -> void } -> self
+      def on_fulfillment!: [A] (*A args) { (T value, *A args) -> void } -> self
+      def on_fulfillment_using: [A] (executor executor, *A args) { (T value, A args) -> void } -> self
+
+      def on_rejection: [A] (*A args) { (E reason, *A args) -> void } -> self
+      def on_rejection!: [A] (*A args) { (E reason, *A args) -> void } -> self
+      def on_rejection_using: [A] (executor executor, *A args) { (E reason, A args) -> void } -> self
+
+      def reason: (?Numeric timeout) -> (E | nil)
+        | [R] (Numeric timeout, R timeout_value) -> (E | R | nil)
+
+      def rejected?: () -> bool
+
+      def rescue: [A, U] (*A args) { (E reason, *A args) -> U } -> Future[U, Exception]
+      def rescue_on: [A, U] (executor executor, *A args) { (E reason, *A args) -> U } -> Future[U, Exception]
+
+      def result: (?nil) -> ([true, T, nil] | [false, nil, E])
+        | (Numeric timeout) -> ([true, T, nil] | [false, nil, E] | nil)
+
+      def run: (?^(untyped) -> Future[untyped, untyped]? run_test) -> Future[untyped, untyped]  # TODO: Any specific type?
+
+      def schedule: (Numeric | Time intended_time) -> Future[T, E]
+
+      def then: [A, U] (*A args) { (T value, *A args) -> U } -> Future[U, E | Exception]
+      def then_on: [A, U] (executor executor, *A args) { (T value, *A args) -> U } -> Future[U, E | Exception]
+
+      def to_event: () -> Event
+
+      def to_future: () -> self
+
+      def value: (?Numeric timeout) -> (T | nil)
+        | [R] (Numeric timeout, R timeout_value) -> (T | R | nil)
+      def value!: (?nil) -> T
+        | (Numeric timeout) -> (T | nil)
+        | [R] (Numeric timeout, R timeout_value) -> (T | R | nil)
+
+      def wait!: (?nil) -> self
+        | (Numeric timeout) -> bool
+
+      def with_default_executor: (executor executor) -> Future[T, E]
+
+      def zip: (Event event) -> Future[T, E]
+        | [T2, E2] (Future[T2, E2] future) -> Future[[T, T2], [E, E2]]
+      alias & zip
+
+
+      ## Following methods are actually defined in the base class and have specific types for Future
+
+      def chain: [A, U] (*A args) { (bool fulfilled, T? value, E? reason, *A args) -> U } -> Future[U, Exception]
+      def chain_on: [A, U] (executor executor, *A args) { (bool fulfilled, T? value, E? reason, *A args) -> U } -> Future[U, Exception]
+
+      def on_resolution: [A] (*A args) { (bool fulfilled, T? value, E? reason, *A args) -> void } -> self
+      def on_resolution!: [A] (*A args) { (bool fulfilled, T? value, E? reason, *A args) -> void } -> self
+      def on_resolution_using: [A] (executor executor, *A args) { (bool fulfilled, T? value, E? reason, *A args) -> void } -> self
+
+      def state: () -> (:pending | :fulfilled | :rejected)
+    end
+
+    module Resolvable
+    end
+
+    class ResolvableEvent < Event
+      include Resolvable
+
+      def resolve: (?true raise_on_reassign, ?boolish reserved) -> self
+        | (boolish raise_on_reassign, ?boolish reserved) -> (self | false)
+
+      def wait: (Numeric timeout, boolish resolve_on_timeout) -> bool
+        | ...
+
+      def with_hidden_resolvable: () -> Event
+    end
+
+    class ResolvableFuture[T, E] < Future[T, E]  # Note: ResolvableFuture is invariant on T and E
+      include Resolvable
+
+      def evalute_to: [A] (*A args) { (*A args) -> T } -> self  # TODO: Unsound unless E :> Exception
+      def evalute_to!: [A] (*A args) { (*A args) -> T } -> self  # TODO: ditto
+
+      def fulfill:  (T value, ?true raise_on_reassign, ?boolish reserved) -> self
+        | (T value, boolish raise_on_reassign, ?boolish reserved) -> (self | false)
+
+      def reason: [R] (Numeric timeout, R timeout_value, [boolish, T?, E?] resolve_on_timeout) -> (E | R | nil)
+        | ...
+
+      def reject: (E reason, ?true raise_on_reassign, ?boolish reserved) -> self
+        | (E reason, boolish raise_on_reassign, ?boolish reserved) -> (self | false)
+
+      def resolve: (?boolish fulfilled, ?T? value, ?E? reason, ?true raise_on_reassign, ?boolish reserved) -> self
+        | (boolish fulfilled, T? value, E? reason, boolish raise_on_reassign, ?boolish reserved) -> (self | false)
+
+      def result: (Numeric timeout, [boolish, T?, E?] resolve_on_timeout) -> ([true, T, nil] | [false, nil, E] | nil)
+        | ...
+
+      def value: [R] (Numeric timeout, R timeout_value, [boolish, T?, E?] resolve_on_timeout) -> (T | R | nil)
+        | ...
+
+      def value!: [R] (Numeric timeout, R timeout_value, [boolish, T?, E?] resolve_on_timeout) -> (T | R | nil)
+        | ...
+
+      def with_hidden_resolvable: () -> Future[T, E]
+    end
+  end
+end

data/.gem_rbs_collection/concurrent-ruby/1.1/utility/processor_counter.rbs

@@ -0,0 +1,5 @@
+module Concurrent
+  def self.physical_processor_count: () -> Integer
+
+  def self.processor_count: () -> Integer
+end

data/.gem_rbs_collection/connection_pool/2.4/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: connection_pool
+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

data/.gem_rbs_collection/connection_pool/2.4/connection_pool.rbs

@@ -0,0 +1,34 @@
+class ConnectionPool[T]
+  class Error < ::RuntimeError
+  end
+
+  class PoolShuttingDownError < ::ConnectionPool::Error
+  end
+
+  class TimeoutError < ::Timeout::Error
+  end
+
+  class Wrapper[T]
+    def initialize: (pool: ConnectionPool[T]) -> void
+                  | (?size: Integer, ?timeout: Numeric, ?auto_reload_after_fork: bool) { () -> T } -> void
+    def wrapped_pool: () -> ConnectionPool[T]
+    def with: [A] () { (T) -> A } -> A
+    def pool_shutdown: () { (T) -> void } -> void
+    def pool_size: () -> Integer
+    def pool_available: () -> Integer
+  end
+
+  def initialize: (?size: Integer, ?timeout: Numeric, ?auto_reload_after_fork: bool) { () -> T } -> void
+  def with: [A] (?timeout: Numeric) { (T) -> A } -> A
+  def checkout: (?timeout: Numeric) -> T
+  def checkin: (?force: bool) -> void
+  def shutdown: () { (T) -> void } -> void
+  def reload: () { (T) -> void } -> void
+
+  attr_reader size: Integer
+  attr_reader auto_reload_after_fork: bool
+
+  def available: () -> Integer
+
+  alias then with
+end

data/.gem_rbs_collection/connection_pool/2.4/manifest.yaml

@@ -0,0 +1,2 @@
+rdependencies:
+  - name: timeout

data/.gem_rbs_collection/diff-lcs/1.5/.rbs_meta.yaml

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

data/.gem_rbs_collection/diff-lcs/1.5/diff-lcs.rbs

@@ -0,0 +1,11 @@
+module Diff
+end
+
+module Diff::LCS
+  def self.LCS: (Array[String], Array[String]) -> Array[String]
+              | (String, String) -> Array[String]
+  def self.diff: (Array[String], Array[String]) -> Array[String]
+              | (String, String) -> Array[String]
+
+  def self.patch!: (Array[String], Array[String]) -> String
+end

data/.gem_rbs_collection/i18n/1.10/.rbs_meta.yaml

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