xlsxrb 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87ffb5143d51491cc1a7389a3aa673c40cc02e4e5ee69c554b795754f707c3cd
-  data.tar.gz: 1581c2a99238745d5e6cf65700cd3defbe8b3a3afadb55e74a44b647294407b2
+  metadata.gz: 5dbb3e61f4a1829594ab419865464dbe59f45dbbd9e14abf4593935e74481216
+  data.tar.gz: 1f59b35f34789562610f517a7e6af5de7342c25f97b5c10abce2cf3c8dde7f3c
 SHA512:
-  metadata.gz: 2d994013d341f16ab98f33a190f58fd401247813a9451254eaa46809610e45a2840dc13d9e66b2b5d8c8edf0af6207eab38c9a3d0a2184fa781ff8a80dc63ed2
-  data.tar.gz: 9e92cd503f6a64dcdcf804996e85af09e2a11b4ceebb4586a6d0a688af81ec4cf66f7be0c86fced3acc90f76ca60dd26123aa1440b49740b1bc9522399877974
+  metadata.gz: cf108ff163af536c030873bbb22683546f2f591aba6c304be957e5a39e39a1e25fb678dc08e7fde846e91f9b775fd7383c647d0b0e35b3203602e5c27ec16db5
+  data.tar.gz: 15f68050e2f3a61476e7c30a0b4572adfdae7490f4df396c5e7be6b66ef97f67dac63e2cbbe7c8d6ecd4030e0e9b0e5970fd6a759550f611d97535fef27c499b

data/.devcontainer/Dockerfile

@@ -1,4 +1,4 @@
-FROM ruby:4.0
+FROM ruby:4.0.5
 
 ARG USERNAME=vscode
 ARG USER_UID=1000

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: 82762423fc5694b82888ea89a972847cf19838c2
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems

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: 82762423fc5694b82888ea89a972847cf19838c2
+  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/atomic_reference.rbs

@@ -0,0 +1,16 @@
+module Concurrent
+  class AtomicReference[T]
+    def initialize: (?T value) -> void
+    def get: -> T
+    def value: -> T
+    def set: (T new_value) -> T
+    def value=: (T new_value) -> T
+    def get_and_set: (T new_value) -> T
+    def swap: (T new_value) -> T
+    def compare_and_set: (T old_value, T new_value) -> bool
+    def compare_and_swap: (T old_value, T new_value) -> bool
+    def update: () { (T) -> T } -> T
+    def try_update: () { (T) -> T } -> T?
+    def try_update!: () { (T) -> T } -> T
+  end
+end

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

@@ -0,0 +1,96 @@
+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
+
+  # A thread pool that reuses a fixed number of threads operating off an unbounded queue.
+  class FixedThreadPool
+    include ExecutorService
+
+    attr_reader fallback_policy: Symbol
+
+    attr_reader name: String?
+
+    attr_reader max_length: Integer
+
+    attr_reader min_length: Integer
+
+    attr_reader idletime: Integer
+
+    attr_reader max_queue: Integer
+
+    attr_reader synchronous: bool
+
+    def initialize: (Integer num_threads, ?::Hash[Symbol, untyped] opts) -> void
+
+    def largest_length: () -> Integer
+
+    def scheduled_task_count: () -> Integer
+
+    def completed_task_count: () -> Integer
+
+    def length: () -> Integer
+
+    def queue_length: () -> Integer
+
+    def remaining_capacity: () -> Integer
+
+    def prune_pool: () -> void
+
+    def running?: () -> bool
+
+    def shuttingdown?: () -> bool
+
+    def shutdown?: () -> bool
+
+    def shutdown: () -> bool
+
+    def kill: () -> bool
+
+    def wait_for_termination: (?Numeric? timeout) -> bool
+
+    def auto_terminate?: () -> bool
+
+    def to_s: () -> String
+  end
+
+  # An executor service which runs all operations on the current thread, blocking as necessary.
+  class ImmediateExecutor
+    include ExecutorService
+
+    def initialize: () -> void
+
+    def running?: () -> bool
+
+    def shuttingdown?: () -> bool
+
+    def shutdown?: () -> bool
+
+    def shutdown: () -> bool
+
+    def kill: () -> bool
+
+    def wait_for_termination: (?Numeric? timeout) -> bool
+  end
+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,68 @@
+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 compute: (K key) { (V? old_value) -> V } -> V
+               | (K key) { (V? old_value) -> nil } -> nil
+
+    def compute_if_absent: (K key) { () -> V } -> V
+
+    def compute_if_present: (K key) { (V old_value) -> V? } -> V?
+
+    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
+
+    def delete: (K key) -> V?
+    def delete_pair: (K key, V value) -> bool
+
+    # 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/set.rbs

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

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

@@ -0,0 +1,47 @@
+module Concurrent
+  interface _Observer[T]
+    def update: (Time, T? result, StandardError? exception) -> void
+  end
+
+  interface _Dereferenceable[T]
+    def value: -> T
+    def deref: -> T
+  end
+
+  interface _Observable[T]
+    def add_observer: (_Observer[T]) -> _Observer[T] #  Typed: observer with standard `update` method
+                    | () { (?Time, ?T?, ?StandardError?) -> void } -> ^(?Time, ?T?, ?StandardError?) -> void # Typed: block form
+                    | (untyped observer, Symbol func) -> untyped # Untyped: custom method name
+    def count_observers: -> Integer
+    def delete_observer: (_Observer[T]) -> _Observer[T]
+                       | (^(?Time, ?T?, ?StandardError?) -> void) -> ^(?Time, ?T?, ?StandardError?) -> void
+                       | (untyped observer) -> untyped
+    def delete_observers: -> self
+    def with_observer: (_Observer[T]) -> self
+                     | () { (?Time, ?T?, ?StandardError?) -> void } -> self
+                     | (untyped observer, Symbol func) -> self
+  end
+
+  class TimerTask[T]
+    include _Observable[T]
+    include _Dereferenceable[T]
+
+    def initialize: (
+      ?execution_interval: Float | Integer,
+      ?run_now: bool,
+      ?executor: executor,
+      ?dup_on_deref: bool,
+      ?freeze_on_deref: bool,
+      ?copy_on_deref: (^(T) -> T)?,
+      ?interval_type: :fixed_rate | :fixed_delay
+    ) { (instance) -> T } -> void
+
+    def execute: -> self
+    def execution_interval: -> (Float | Integer)
+    def execution_interval=: (Float | Integer) -> void
+    def shutdown: -> bool
+    def interval_type: -> (:fixed_rate | :fixed_delay)
+    def timeout_interval: -> Float
+    def running?: -> bool
+  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/csv/3.3/.rbs_meta.yaml

@@ -0,0 +1,9 @@
+---
+name: csv
+version: '3.3'
+source:
+  type: git
+  name: ruby/gem_rbs_collection
+  revision: 82762423fc5694b82888ea89a972847cf19838c2
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems