"a"*1_000_000_000:
+#
+# require 'benchmark'
+#
+# puts Benchmark.measure { "a"*1_000_000_000 }
+#
+# On my machine (OSX 10.8.3 on i5 1.7 GHz) this generates:
+#
+# 0.350000 0.400000 0.750000 ( 0.835234)
+#
+# This report shows the user CPU time, system CPU time, the sum of
+# the user and system CPU times, and the elapsed real time. The unit
+# of time is seconds.
+#
+# * Do some experiments sequentially using the #bm method:
+#
+# require 'benchmark'
+#
+# n = 5000000
+# Benchmark.bm do |x|
+# x.report { for i in 1..n; a = "1"; end }
+# x.report { n.times do ; a = "1"; end }
+# x.report { 1.upto(n) do ; a = "1"; end }
+# end
+#
+# The result:
+#
+# user system total real
+# 1.010000 0.000000 1.010000 ( 1.014479)
+# 1.000000 0.000000 1.000000 ( 0.998261)
+# 0.980000 0.000000 0.980000 ( 0.981335)
+#
+# * Continuing the previous example, put a label in each report:
+#
+# require 'benchmark'
+#
+# n = 5000000
+# Benchmark.bm(7) do |x|
+# x.report("for:") { for i in 1..n; a = "1"; end }
+# x.report("times:") { n.times do ; a = "1"; end }
+# x.report("upto:") { 1.upto(n) do ; a = "1"; end }
+# end
+#
+# The result:
+#
+# user system total real
+# for: 1.010000 0.000000 1.010000 ( 1.015688)
+# times: 1.000000 0.000000 1.000000 ( 1.003611)
+# upto: 1.030000 0.000000 1.030000 ( 1.028098)
+#
+# * The times for some benchmarks depend on the order in which items
+# are run. These differences are due to the cost of memory
+# allocation and garbage collection. To avoid these discrepancies,
+# the #bmbm method is provided. For example, to compare ways to
+# sort an array of floats:
+#
+# require 'benchmark'
+#
+# array = (1..1000000).map { rand }
+#
+# Benchmark.bmbm do |x|
+# x.report("sort!") { array.dup.sort! }
+# x.report("sort") { array.dup.sort }
+# end
+#
+# The result:
+#
+# Rehearsal -----------------------------------------
+# sort! 1.490000 0.010000 1.500000 ( 1.490520)
+# sort 1.460000 0.000000 1.460000 ( 1.463025)
+# -------------------------------- total: 2.960000sec
+#
+# user system total real
+# sort! 1.460000 0.000000 1.460000 ( 1.460465)
+# sort 1.450000 0.010000 1.460000 ( 1.448327)
+#
+# * Report statistics of sequential experiments with unique labels,
+# using the #benchmark method:
+#
+# require 'benchmark'
+# include Benchmark # we need the CAPTION and FORMAT constants
+#
+# n = 5000000
+# Benchmark.benchmark(CAPTION, 7, FORMAT, ">total:", ">avg:") do |x|
+# tf = x.report("for:") { for i in 1..n; a = "1"; end }
+# tt = x.report("times:") { n.times do ; a = "1"; end }
+# tu = x.report("upto:") { 1.upto(n) do ; a = "1"; end }
+# [tf+tt+tu, (tf+tt+tu)/3]
+# end
+#
+# The result:
+#
+# user system total real
+# for: 0.950000 0.000000 0.950000 ( 0.952039)
+# times: 0.980000 0.000000 0.980000 ( 0.984938)
+# upto: 0.950000 0.000000 0.950000 ( 0.946787)
+# >total: 2.880000 0.000000 2.880000 ( 2.883764)
+# >avg: 0.960000 0.000000 0.960000 ( 0.961255)
+module Benchmark
+ private
+
+ # Invokes the block with a Benchmark::Report object, which
+ # may be used to collect and report on the results of individual
+ # benchmark tests. Reserves +label_width+ leading spaces for
+ # labels on each line. Prints +caption+ at the top of the
+ # report, and uses +format+ to format each line.
+ # (Note: +caption+ must contain a terminating newline character,
+ # see the default Benchmark::Tms::CAPTION for an example.)
+ #
+ # Returns an array of Benchmark::Tms objects.
+ #
+ # If the block returns an array of
+ # Benchmark::Tms objects, these will be used to format
+ # additional lines of output. If +labels+ parameter are
+ # given, these are used to label these extra lines.
+ #
+ # _Note_: Other methods provide a simpler interface to this one, and are
+ # suitable for nearly all benchmarking requirements. See the examples in
+ # Benchmark, and the #bm and #bmbm methods.
+ #
+ # Example:
+ #
+ # require 'benchmark'
+ # include Benchmark # we need the CAPTION and FORMAT constants
+ #
+ # n = 5000000
+ # Benchmark.benchmark(CAPTION, 7, FORMAT, ">total:", ">avg:") do |x|
+ # tf = x.report("for:") { for i in 1..n; a = "1"; end }
+ # tt = x.report("times:") { n.times do ; a = "1"; end }
+ # tu = x.report("upto:") { 1.upto(n) do ; a = "1"; end }
+ # [tf+tt+tu, (tf+tt+tu)/3]
+ # end
+ #
+ # Generates:
+ #
+ # user system total real
+ # for: 0.970000 0.000000 0.970000 ( 0.970493)
+ # times: 0.990000 0.000000 0.990000 ( 0.989542)
+ # upto: 0.970000 0.000000 0.970000 ( 0.972854)
+ # >total: 2.930000 0.000000 2.930000 ( 2.932889)
+ # >avg: 0.976667 0.000000 0.976667 ( 0.977630)
+ #
+ # source://benchmark//benchmark.rb#170
+ def benchmark(caption = T.unsafe(nil), label_width = T.unsafe(nil), format = T.unsafe(nil), *labels); end
+
+ # A simple interface to the #benchmark method, #bm generates sequential
+ # reports with labels. +label_width+ and +labels+ parameters have the same
+ # meaning as for #benchmark.
+ #
+ # require 'benchmark'
+ #
+ # n = 5000000
+ # Benchmark.bm(7) do |x|
+ # x.report("for:") { for i in 1..n; a = "1"; end }
+ # x.report("times:") { n.times do ; a = "1"; end }
+ # x.report("upto:") { 1.upto(n) do ; a = "1"; end }
+ # end
+ #
+ # Generates:
+ #
+ # user system total real
+ # for: 0.960000 0.000000 0.960000 ( 0.957966)
+ # times: 0.960000 0.000000 0.960000 ( 0.960423)
+ # upto: 0.950000 0.000000 0.950000 ( 0.954864)
+ #
+ # source://benchmark//benchmark.rb#215
+ def bm(label_width = T.unsafe(nil), *labels, &blk); end
+
+ # Sometimes benchmark results are skewed because code executed
+ # earlier encounters different garbage collection overheads than
+ # that run later. #bmbm attempts to minimize this effect by running
+ # the tests twice, the first time as a rehearsal in order to get the
+ # runtime environment stable, the second time for
+ # real. GC.start is executed before the start of each of
+ # the real timings; the cost of this is not included in the
+ # timings. In reality, though, there's only so much that #bmbm can
+ # do, and the results are not guaranteed to be isolated from garbage
+ # collection and other effects.
+ #
+ # Because #bmbm takes two passes through the tests, it can
+ # calculate the required label width.
+ #
+ # require 'benchmark'
+ #
+ # array = (1..1000000).map { rand }
+ #
+ # Benchmark.bmbm do |x|
+ # x.report("sort!") { array.dup.sort! }
+ # x.report("sort") { array.dup.sort }
+ # end
+ #
+ # Generates:
+ #
+ # Rehearsal -----------------------------------------
+ # sort! 1.440000 0.010000 1.450000 ( 1.446833)
+ # sort 1.440000 0.000000 1.440000 ( 1.448257)
+ # -------------------------------- total: 2.890000sec
+ #
+ # user system total real
+ # sort! 1.460000 0.000000 1.460000 ( 1.458065)
+ # sort 1.450000 0.000000 1.450000 ( 1.455963)
+ #
+ # #bmbm yields a Benchmark::Job object and returns an array of
+ # Benchmark::Tms objects.
+ #
+ # source://benchmark//benchmark.rb#257
+ def bmbm(width = T.unsafe(nil)); end
+
+ # Returns the time used to execute the given block as a
+ # Benchmark::Tms object. Takes +label+ option.
+ #
+ # require 'benchmark'
+ #
+ # n = 1000000
+ #
+ # time = Benchmark.measure do
+ # n.times { a = "1" }
+ # end
+ # puts time
+ #
+ # Generates:
+ #
+ # 0.220000 0.000000 0.220000 ( 0.227313)
+ #
+ # source://benchmark//benchmark.rb#302
+ def measure(label = T.unsafe(nil)); end
+
+ # Returns the elapsed real time used to execute the given block.
+ # The unit of time is seconds.
+ #
+ # Benchmark.realtime { "a" * 1_000_000_000 }
+ # #=> 0.5098029999935534
+ #
+ # source://benchmark//benchmark.rb#321
+ def realtime; end
+
+ class << self
+ # Invokes the block with a Benchmark::Report object, which
+ # may be used to collect and report on the results of individual
+ # benchmark tests. Reserves +label_width+ leading spaces for
+ # labels on each line. Prints +caption+ at the top of the
+ # report, and uses +format+ to format each line.
+ # (Note: +caption+ must contain a terminating newline character,
+ # see the default Benchmark::Tms::CAPTION for an example.)
+ #
+ # Returns an array of Benchmark::Tms objects.
+ #
+ # If the block returns an array of
+ # Benchmark::Tms objects, these will be used to format
+ # additional lines of output. If +labels+ parameter are
+ # given, these are used to label these extra lines.
+ #
+ # _Note_: Other methods provide a simpler interface to this one, and are
+ # suitable for nearly all benchmarking requirements. See the examples in
+ # Benchmark, and the #bm and #bmbm methods.
+ #
+ # Example:
+ #
+ # require 'benchmark'
+ # include Benchmark # we need the CAPTION and FORMAT constants
+ #
+ # n = 5000000
+ # Benchmark.benchmark(CAPTION, 7, FORMAT, ">total:", ">avg:") do |x|
+ # tf = x.report("for:") { for i in 1..n; a = "1"; end }
+ # tt = x.report("times:") { n.times do ; a = "1"; end }
+ # tu = x.report("upto:") { 1.upto(n) do ; a = "1"; end }
+ # [tf+tt+tu, (tf+tt+tu)/3]
+ # end
+ #
+ # Generates:
+ #
+ # user system total real
+ # for: 0.970000 0.000000 0.970000 ( 0.970493)
+ # times: 0.990000 0.000000 0.990000 ( 0.989542)
+ # upto: 0.970000 0.000000 0.970000 ( 0.972854)
+ # >total: 2.930000 0.000000 2.930000 ( 2.932889)
+ # >avg: 0.976667 0.000000 0.976667 ( 0.977630)
+ #
+ # source://benchmark//benchmark.rb#170
+ def benchmark(caption = T.unsafe(nil), label_width = T.unsafe(nil), format = T.unsafe(nil), *labels); end
+
+ # A simple interface to the #benchmark method, #bm generates sequential
+ # reports with labels. +label_width+ and +labels+ parameters have the same
+ # meaning as for #benchmark.
+ #
+ # require 'benchmark'
+ #
+ # n = 5000000
+ # Benchmark.bm(7) do |x|
+ # x.report("for:") { for i in 1..n; a = "1"; end }
+ # x.report("times:") { n.times do ; a = "1"; end }
+ # x.report("upto:") { 1.upto(n) do ; a = "1"; end }
+ # end
+ #
+ # Generates:
+ #
+ # user system total real
+ # for: 0.960000 0.000000 0.960000 ( 0.957966)
+ # times: 0.960000 0.000000 0.960000 ( 0.960423)
+ # upto: 0.950000 0.000000 0.950000 ( 0.954864)
+ #
+ # source://benchmark//benchmark.rb#215
+ def bm(label_width = T.unsafe(nil), *labels, &blk); end
+
+ # Sometimes benchmark results are skewed because code executed
+ # earlier encounters different garbage collection overheads than
+ # that run later. #bmbm attempts to minimize this effect by running
+ # the tests twice, the first time as a rehearsal in order to get the
+ # runtime environment stable, the second time for
+ # real. GC.start is executed before the start of each of
+ # the real timings; the cost of this is not included in the
+ # timings. In reality, though, there's only so much that #bmbm can
+ # do, and the results are not guaranteed to be isolated from garbage
+ # collection and other effects.
+ #
+ # Because #bmbm takes two passes through the tests, it can
+ # calculate the required label width.
+ #
+ # require 'benchmark'
+ #
+ # array = (1..1000000).map { rand }
+ #
+ # Benchmark.bmbm do |x|
+ # x.report("sort!") { array.dup.sort! }
+ # x.report("sort") { array.dup.sort }
+ # end
+ #
+ # Generates:
+ #
+ # Rehearsal -----------------------------------------
+ # sort! 1.440000 0.010000 1.450000 ( 1.446833)
+ # sort 1.440000 0.000000 1.440000 ( 1.448257)
+ # -------------------------------- total: 2.890000sec
+ #
+ # user system total real
+ # sort! 1.460000 0.000000 1.460000 ( 1.458065)
+ # sort 1.450000 0.000000 1.450000 ( 1.455963)
+ #
+ # #bmbm yields a Benchmark::Job object and returns an array of
+ # Benchmark::Tms objects.
+ #
+ # source://benchmark//benchmark.rb#257
+ def bmbm(width = T.unsafe(nil)); end
+
+ # Returns the time used to execute the given block as a
+ # Benchmark::Tms object. Takes +label+ option.
+ #
+ # require 'benchmark'
+ #
+ # n = 1000000
+ #
+ # time = Benchmark.measure do
+ # n.times { a = "1" }
+ # end
+ # puts time
+ #
+ # Generates:
+ #
+ # 0.220000 0.000000 0.220000 ( 0.227313)
+ #
+ # source://benchmark//benchmark.rb#302
+ def measure(label = T.unsafe(nil)); end
+
+ # Returns the elapsed real time used to execute the given block.
+ # The unit of time is seconds.
+ #
+ # Benchmark.realtime { "a" * 1_000_000_000 }
+ # #=> 0.5098029999935534
+ #
+ # source://benchmark//benchmark.rb#321
+ def realtime; end
+ end
+end
+
+# A Job is a sequence of labelled blocks to be processed by the
+# Benchmark.bmbm method. It is of little direct interest to the user.
+class Benchmark::Job
+ # Returns an initialized Job instance.
+ # Usually, one doesn't call this method directly, as new
+ # Job objects are created by the #bmbm method.
+ # +width+ is a initial value for the label offset used in formatting;
+ # the #bmbm method passes its +width+ argument to this constructor.
+ #
+ # @return [Job] a new instance of Job
+ #
+ # source://benchmark//benchmark.rb#341
+ def initialize(width); end
+
+ # Registers the given label and block pair in the job list.
+ #
+ # @raise [ArgumentError]
+ #
+ # source://benchmark//benchmark.rb#349
+ def item(label = T.unsafe(nil), &blk); end
+
+ # An array of 2-element arrays, consisting of label and block pairs.
+ #
+ # source://benchmark//benchmark.rb#361
+ def list; end
+
+ # Registers the given label and block pair in the job list.
+ #
+ # @raise [ArgumentError]
+ #
+ # source://benchmark//benchmark.rb#349
+ def report(label = T.unsafe(nil), &blk); end
+
+ # Length of the widest label in the #list.
+ #
+ # source://benchmark//benchmark.rb#364
+ def width; end
+end
+
+# This class is used by the Benchmark.benchmark and Benchmark.bm methods.
+# It is of little direct interest to the user.
+class Benchmark::Report
+ # Returns an initialized Report instance.
+ # Usually, one doesn't call this method directly, as new
+ # Report objects are created by the #benchmark and #bm methods.
+ # +width+ and +format+ are the label offset and
+ # format string used by Tms#format.
+ #
+ # @return [Report] a new instance of Report
+ #
+ # source://benchmark//benchmark.rb#379
+ def initialize(width = T.unsafe(nil), format = T.unsafe(nil)); end
+
+ # An array of Benchmark::Tms objects representing each item.
+ #
+ # source://benchmark//benchmark.rb#398
+ def format; end
+
+ # Prints the +label+ and measured time for the block,
+ # formatted by +format+. See Tms#format for the
+ # formatting rules.
+ #
+ # source://benchmark//benchmark.rb#388
+ def item(label = T.unsafe(nil), *format, &blk); end
+
+ # An array of Benchmark::Tms objects representing each item.
+ #
+ # source://benchmark//benchmark.rb#398
+ def list; end
+
+ # Prints the +label+ and measured time for the block,
+ # formatted by +format+. See Tms#format for the
+ # formatting rules.
+ #
+ # source://benchmark//benchmark.rb#388
+ def report(label = T.unsafe(nil), *format, &blk); end
+
+ # An array of Benchmark::Tms objects representing each item.
+ #
+ # source://benchmark//benchmark.rb#398
+ def width; end
+end
+
+# A data object, representing the times associated with a benchmark
+# measurement.
+class Benchmark::Tms
+ # Returns an initialized Tms object which has
+ # +utime+ as the user CPU time, +stime+ as the system CPU time,
+ # +cutime+ as the children's user CPU time, +cstime+ as the children's
+ # system CPU time, +real+ as the elapsed real time and +label+ as the label.
+ #
+ # @return [Tms] a new instance of Tms
+ #
+ # source://benchmark//benchmark.rb#442
+ def initialize(utime = T.unsafe(nil), stime = T.unsafe(nil), cutime = T.unsafe(nil), cstime = T.unsafe(nil), real = T.unsafe(nil), label = T.unsafe(nil)); end
+
+ # Returns a new Tms object obtained by memberwise multiplication
+ # of the individual times for this Tms object by +x+.
+ #
+ # source://benchmark//benchmark.rb#490
+ def *(x); end
+
+ # Returns a new Tms object obtained by memberwise summation
+ # of the individual times for this Tms object with those of the +other+
+ # Tms object.
+ # This method and #/() are useful for taking statistics.
+ #
+ # source://benchmark//benchmark.rb#477
+ def +(other); end
+
+ # Returns a new Tms object obtained by memberwise subtraction
+ # of the individual times for the +other+ Tms object from those of this
+ # Tms object.
+ #
+ # source://benchmark//benchmark.rb#484
+ def -(other); end
+
+ # Returns a new Tms object obtained by memberwise division
+ # of the individual times for this Tms object by +x+.
+ # This method and #+() are useful for taking statistics.
+ #
+ # source://benchmark//benchmark.rb#497
+ def /(x); end
+
+ # Returns a new Tms object whose times are the sum of the times for this
+ # Tms object, plus the time required to execute the code block (+blk+).
+ #
+ # source://benchmark//benchmark.rb#451
+ def add(&blk); end
+
+ # An in-place version of #add.
+ # Changes the times of this Tms object by making it the sum of the times
+ # for this Tms object, plus the time required to execute
+ # the code block (+blk+).
+ #
+ # source://benchmark//benchmark.rb#461
+ def add!(&blk); end
+
+ # System CPU time of children
+ #
+ # source://benchmark//benchmark.rb#425
+ def cstime; end
+
+ # User CPU time of children
+ #
+ # source://benchmark//benchmark.rb#422
+ def cutime; end
+
+ # Returns the contents of this Tms object as
+ # a formatted string, according to a +format+ string
+ # like that passed to Kernel.format. In addition, #format
+ # accepts the following extensions:
+ #
+ # %u:: Replaced by the user CPU time, as reported by Tms#utime.
+ # %y:: Replaced by the system CPU time, as reported by #stime (Mnemonic: y of "s*y*stem")
+ # %U:: Replaced by the children's user CPU time, as reported by Tms#cutime
+ # %Y:: Replaced by the children's system CPU time, as reported by Tms#cstime
+ # %t:: Replaced by the total CPU time, as reported by Tms#total
+ # %r:: Replaced by the elapsed real time, as reported by Tms#real
+ # %n:: Replaced by the label string, as reported by Tms#label (Mnemonic: n of "*n*ame")
+ #
+ # If +format+ is not given, FORMAT is used as default value, detailing the
+ # user, system and real elapsed time.
+ #
+ # source://benchmark//benchmark.rb#516
+ def format(format = T.unsafe(nil), *args); end
+
+ # Label
+ #
+ # source://benchmark//benchmark.rb#434
+ def label; end
+
+ # Elapsed real time
+ #
+ # source://benchmark//benchmark.rb#428
+ def real; end
+
+ # System CPU time
+ #
+ # source://benchmark//benchmark.rb#419
+ def stime; end
+
+ # Returns a new 6-element array, consisting of the
+ # label, user CPU time, system CPU time, children's
+ # user CPU time, children's system CPU time and elapsed
+ # real time.
+ #
+ # source://benchmark//benchmark.rb#541
+ def to_a; end
+
+ # Returns a hash containing the same data as `to_a`.
+ #
+ # source://benchmark//benchmark.rb#548
+ def to_h; end
+
+ # Same as #format.
+ #
+ # source://benchmark//benchmark.rb#531
+ def to_s; end
+
+ # Total time, that is +utime+ + +stime+ + +cutime+ + +cstime+
+ #
+ # source://benchmark//benchmark.rb#431
+ def total; end
+
+ # User CPU time
+ #
+ # source://benchmark//benchmark.rb#416
+ def utime; end
+
+ protected
+
+ # Returns a new Tms object obtained by memberwise operation +op+
+ # of the individual times for this Tms object with those of the other
+ # Tms object (+x+).
+ #
+ # +op+ can be a mathematical operation such as +, -,
+ # *, /
+ #
+ # source://benchmark//benchmark.rb#569
+ def memberwise(op, x); end
+end
+
+# source://benchmark//benchmark.rb#124
+Benchmark::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/bigdecimal@3.1.8.rbi b/sorbet/rbi/gems/bigdecimal@3.1.8.rbi
new file mode 100644
index 000000000..5c82e1f3d
--- /dev/null
+++ b/sorbet/rbi/gems/bigdecimal@3.1.8.rbi
@@ -0,0 +1,75 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `bigdecimal` gem.
+# Please instead update this file by running `bin/tapioca gem bigdecimal`.
+
+# source://bigdecimal//lib/bigdecimal/util.rb#78
+class BigDecimal < ::Numeric
+ # call-seq:
+ # a.to_d -> bigdecimal
+ #
+ # Returns self.
+ #
+ # require 'bigdecimal/util'
+ #
+ # d = BigDecimal("3.14")
+ # d.to_d # => 0.314e1
+ #
+ # source://bigdecimal//lib/bigdecimal/util.rb#110
+ def to_d; end
+
+ # call-seq:
+ # a.to_digits -> string
+ #
+ # Converts a BigDecimal to a String of the form "nnnnnn.mmm".
+ # This method is deprecated; use BigDecimal#to_s("F") instead.
+ #
+ # require 'bigdecimal/util'
+ #
+ # d = BigDecimal("3.14")
+ # d.to_digits # => "3.14"
+ #
+ # source://bigdecimal//lib/bigdecimal/util.rb#90
+ def to_digits; end
+end
+
+# source://bigdecimal//lib/bigdecimal/util.rb#138
+class Complex < ::Numeric
+ # call-seq:
+ # cmp.to_d -> bigdecimal
+ # cmp.to_d(precision) -> bigdecimal
+ #
+ # Returns the value as a BigDecimal.
+ #
+ # The +precision+ parameter is required for a rational complex number.
+ # This parameter is used to determine the number of significant digits
+ # for the result.
+ #
+ # require 'bigdecimal'
+ # require 'bigdecimal/util'
+ #
+ # Complex(0.1234567, 0).to_d(4) # => 0.1235e0
+ # Complex(Rational(22, 7), 0).to_d(3) # => 0.314e1
+ #
+ # See also Kernel.BigDecimal.
+ #
+ # source://bigdecimal//lib/bigdecimal/util.rb#157
+ def to_d(*args); end
+end
+
+# source://bigdecimal//lib/bigdecimal/util.rb#171
+class NilClass
+ # call-seq:
+ # nil.to_d -> bigdecimal
+ #
+ # Returns nil represented as a BigDecimal.
+ #
+ # require 'bigdecimal'
+ # require 'bigdecimal/util'
+ #
+ # nil.to_d # => 0.0
+ #
+ # source://bigdecimal//lib/bigdecimal/util.rb#182
+ def to_d; end
+end
diff --git a/sorbet/rbi/gems/byebug@11.1.3.rbi b/sorbet/rbi/gems/byebug@11.1.3.rbi
new file mode 100644
index 000000000..b2aace929
--- /dev/null
+++ b/sorbet/rbi/gems/byebug@11.1.3.rbi
@@ -0,0 +1,3606 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `byebug` gem.
+# Please instead update this file by running `bin/tapioca gem byebug`.
+
+# Reopen main module to define the library version
+#
+# source://byebug//lib/byebug/helpers/reflection.rb#3
+module Byebug
+ include ::Byebug::Helpers::ReflectionHelper
+ extend ::Byebug::Helpers::ReflectionHelper
+ extend ::Byebug
+
+ # Debugger's display expressions
+ #
+ # source://byebug//lib/byebug/core.rb#31
+ def displays; end
+
+ # Debugger's display expressions
+ #
+ # source://byebug//lib/byebug/core.rb#31
+ def displays=(_arg0); end
+
+ # Configuration file used for startup commands. Default value is .byebugrc
+ #
+ # source://byebug//lib/byebug/core.rb#25
+ def init_file; end
+
+ # Configuration file used for startup commands. Default value is .byebugrc
+ #
+ # source://byebug//lib/byebug/core.rb#25
+ def init_file=(_arg0); end
+
+ # Running mode of the debugger. Can be either:
+ #
+ # * :attached => Attached to a running program through the `byebug` method.
+ # * :standalone => Started through `byebug` script.
+ # * :off => Ignoring any `byebug` method calls.
+ #
+ # source://byebug//lib/byebug/core.rb#41
+ def mode; end
+
+ # Running mode of the debugger. Can be either:
+ #
+ # * :attached => Attached to a running program through the `byebug` method.
+ # * :standalone => Started through `byebug` script.
+ # * :off => Ignoring any `byebug` method calls.
+ #
+ # source://byebug//lib/byebug/core.rb#41
+ def mode=(_arg0); end
+
+ # Runs normal byebug initialization scripts.
+ #
+ # Reads and executes the commands from init file (if any) in the current
+ # working directory. This is only done if the current directory is different
+ # from your home directory. Thus, you can have more than one init file, one
+ # generic in your home directory, and another, specific to the program you
+ # are debugging, in the directory where you invoke byebug.
+ #
+ # source://byebug//lib/byebug/core.rb#52
+ def run_init_script; end
+
+ private
+
+ def add_catchpoint(_arg0); end
+ def breakpoints; end
+ def catchpoints; end
+ def contexts; end
+ def current_context; end
+ def debug_load(*_arg0); end
+ def lock; end
+ def post_mortem=(_arg0); end
+ def post_mortem?; end
+ def raised_exception; end
+
+ # List of folders to load rc files from
+ #
+ # @note Files will be loaded in the order specified here.
+ #
+ # source://byebug//lib/byebug/core.rb#102
+ def rc_dirs; end
+
+ # Runs a initialization script file
+ #
+ # source://byebug//lib/byebug/core.rb#91
+ def run_rc_file(rc_file); end
+
+ def start; end
+ def started?; end
+ def stop; end
+ def stoppable?; end
+ def thread_context(_arg0); end
+ def tracing=(_arg0); end
+ def tracing?; end
+ def unlock; end
+ def verbose=(_arg0); end
+ def verbose?; end
+
+ class << self
+ # The actual port that the control server is started at
+ #
+ # source://byebug//lib/byebug/remote.rb#25
+ def actual_control_port; end
+
+ # The actual port that the server is started at
+ #
+ # source://byebug//lib/byebug/remote.rb#20
+ def actual_port; end
+
+ def add_catchpoint(_arg0); end
+
+ # Starts byebug, and stops at the first line of user's code.
+ #
+ # source://byebug//lib/byebug/attacher.rb#10
+ def attach; end
+
+ def breakpoints; end
+ def catchpoints; end
+ def contexts; end
+ def current_context; end
+ def debug_load(*_arg0); end
+
+ # Saves information about the unhandled exception and gives a byebug
+ # prompt back to the user before program termination.
+ #
+ # source://byebug//lib/byebug/core.rb#76
+ def handle_post_mortem; end
+
+ # Interrupts the current thread
+ #
+ # source://byebug//lib/byebug/remote.rb#32
+ def interrupt; end
+
+ # source://byebug//lib/byebug/core.rb#61
+ def load_settings; end
+
+ def lock; end
+
+ # source://byebug//lib/byebug/remote.rb#59
+ def parse_host_and_port(host_port_spec); end
+
+ def post_mortem=(_arg0); end
+ def post_mortem?; end
+ def raised_exception; end
+
+ # source://byebug//lib/byebug/attacher.rb#21
+ def spawn(host = T.unsafe(nil), port = T.unsafe(nil)); end
+
+ def start; end
+
+ # Connects to the remote byebug
+ #
+ # source://byebug//lib/byebug/remote.rb#55
+ def start_client(host = T.unsafe(nil), port = T.unsafe(nil)); end
+
+ # Starts the remote server control thread
+ #
+ # source://byebug//lib/byebug/remote.rb#48
+ def start_control(host = T.unsafe(nil), port = T.unsafe(nil)); end
+
+ # Starts the remote server main thread
+ #
+ # source://byebug//lib/byebug/remote.rb#39
+ def start_server(host = T.unsafe(nil), port = T.unsafe(nil)); end
+
+ def started?; end
+ def stop; end
+ def stoppable?; end
+ def thread_context(_arg0); end
+ def tracing=(_arg0); end
+ def tracing?; end
+ def unlock; end
+ def verbose=(_arg0); end
+ def verbose?; end
+
+ # If in remote mode, wait for the remote connection
+ #
+ # source://byebug//lib/byebug/remote.rb#17
+ def wait_connection; end
+
+ # If in remote mode, wait for the remote connection
+ #
+ # source://byebug//lib/byebug/remote.rb#17
+ def wait_connection=(_arg0); end
+
+ private
+
+ # source://byebug//lib/byebug/remote.rb#66
+ def client; end
+
+ # source://byebug//lib/byebug/remote.rb#76
+ def control; end
+
+ # source://byebug//lib/byebug/remote.rb#70
+ def server; end
+ end
+end
+
+# Setting for automatically invoking IRB on every stop.
+#
+# source://byebug//lib/byebug/settings/autoirb.rb#10
+class Byebug::AutoirbSetting < ::Byebug::Setting
+ # @return [AutoirbSetting] a new instance of AutoirbSetting
+ #
+ # source://byebug//lib/byebug/settings/autoirb.rb#13
+ def initialize; end
+
+ # source://byebug//lib/byebug/settings/autoirb.rb#17
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/autoirb.rb#25
+ def value; end
+
+ # source://byebug//lib/byebug/settings/autoirb.rb#21
+ def value=(val); end
+end
+
+# source://byebug//lib/byebug/settings/autoirb.rb#11
+Byebug::AutoirbSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+# Setting for automatically listing source code on every stop.
+#
+# source://byebug//lib/byebug/settings/autolist.rb#10
+class Byebug::AutolistSetting < ::Byebug::Setting
+ # @return [AutolistSetting] a new instance of AutolistSetting
+ #
+ # source://byebug//lib/byebug/settings/autolist.rb#13
+ def initialize; end
+
+ # source://byebug//lib/byebug/settings/autolist.rb#17
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/autolist.rb#25
+ def value; end
+
+ # source://byebug//lib/byebug/settings/autolist.rb#21
+ def value=(val); end
+end
+
+# source://byebug//lib/byebug/settings/autolist.rb#11
+Byebug::AutolistSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+# Setting for automatically invoking Pry on every stop.
+#
+# source://byebug//lib/byebug/settings/autopry.rb#10
+class Byebug::AutoprySetting < ::Byebug::Setting
+ # @return [AutoprySetting] a new instance of AutoprySetting
+ #
+ # source://byebug//lib/byebug/settings/autopry.rb#13
+ def initialize; end
+
+ # source://byebug//lib/byebug/settings/autopry.rb#17
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/autopry.rb#25
+ def value; end
+
+ # source://byebug//lib/byebug/settings/autopry.rb#21
+ def value=(val); end
+end
+
+# source://byebug//lib/byebug/settings/autopry.rb#11
+Byebug::AutoprySetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+# Setting for automatically saving previously entered commands to history
+# when exiting the debugger.
+#
+# source://byebug//lib/byebug/settings/autosave.rb#10
+class Byebug::AutosaveSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/autosave.rb#13
+ def banner; end
+end
+
+# source://byebug//lib/byebug/settings/autosave.rb#11
+Byebug::AutosaveSetting::DEFAULT = T.let(T.unsafe(nil), TrueClass)
+
+# Command to display short paths in file names.
+#
+# For example, when displaying source code information.
+#
+# source://byebug//lib/byebug/settings/basename.rb#11
+class Byebug::BasenameSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/basename.rb#12
+ def banner; end
+end
+
+# Implements breakpoint functionality
+#
+# source://byebug//lib/byebug/commands/break.rb#13
+class Byebug::BreakCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+ include ::Byebug::Helpers::FileHelper
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/break.rb#40
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/break.rb#83
+ def add_line_breakpoint(file, line); end
+
+ # source://byebug//lib/byebug/commands/break.rb#54
+ def line_breakpoint(location); end
+
+ # source://byebug//lib/byebug/commands/break.rb#65
+ def method_breakpoint(location); end
+
+ # source://byebug//lib/byebug/commands/break.rb#74
+ def target_object(str); end
+
+ # source://byebug//lib/byebug/commands/break.rb#104
+ def valid_breakpoints_for(path, line); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/break.rb#24
+ def description; end
+
+ # source://byebug//lib/byebug/commands/break.rb#20
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/break.rb#36
+ def short_description; end
+ end
+end
+
+# Implements breakpoints
+#
+# source://byebug//lib/byebug/breakpoint.rb#7
+class Byebug::Breakpoint
+ def initialize(_arg0, _arg1, _arg2); end
+
+ def enabled=(_arg0); end
+ def enabled?; end
+ def expr; end
+ def expr=(_arg0); end
+ def hit_condition; end
+ def hit_condition=(_arg0); end
+ def hit_count; end
+ def hit_value; end
+ def hit_value=(_arg0); end
+ def id; end
+
+ # Prints all information associated to the breakpoint
+ #
+ # source://byebug//lib/byebug/breakpoint.rb#105
+ def inspect; end
+
+ def pos; end
+ def source; end
+
+ class << self
+ # Adds a new breakpoint
+ #
+ # @param file [String]
+ # @param line [Fixnum]
+ # @param expr [String]
+ #
+ # source://byebug//lib/byebug/breakpoint.rb#29
+ def add(file, line, expr = T.unsafe(nil)); end
+
+ # First breakpoint, in order of creation
+ #
+ # source://byebug//lib/byebug/breakpoint.rb#11
+ def first; end
+
+ # Last breakpoint, in order of creation
+ #
+ # source://byebug//lib/byebug/breakpoint.rb#18
+ def last; end
+
+ # True if there's no breakpoints
+ #
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/breakpoint.rb#98
+ def none?; end
+
+ # Returns true if a breakpoint could be set in line number +lineno+ in file
+ # name +filename.
+ #
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/breakpoint.rb#91
+ def potential_line?(filename, lineno); end
+
+ # Returns an array of line numbers in file named +filename+ where
+ # breakpoints could be set. The list will contain an entry for each
+ # distinct line event call so it is possible (and possibly useful) for a
+ # line number appear more than once.
+ #
+ # @param filename [String] File name to inspect for possible breakpoints
+ #
+ # source://byebug//lib/byebug/breakpoint.rb#52
+ def potential_lines(filename); end
+
+ # Removes a breakpoint
+ #
+ # @param id [integer] breakpoint number
+ #
+ # source://byebug//lib/byebug/breakpoint.rb#40
+ def remove(id); end
+
+ private
+
+ # source://byebug//lib/byebug/breakpoint.rb#63
+ def potential_lines_with_trace_points(iseq, lines); end
+
+ # source://byebug//lib/byebug/breakpoint.rb#74
+ def potential_lines_without_trace_points(iseq, lines); end
+ end
+end
+
+# Setting to customize the verbosity level for stack frames.
+#
+# source://byebug//lib/byebug/settings/callstyle.rb#9
+class Byebug::CallstyleSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/callstyle.rb#12
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/callstyle.rb#16
+ def to_s; end
+end
+
+# source://byebug//lib/byebug/settings/callstyle.rb#10
+Byebug::CallstyleSetting::DEFAULT = T.let(T.unsafe(nil), String)
+
+# Implements exception catching.
+#
+# Enables the user to catch unhandled assertion when they happen.
+#
+# source://byebug//lib/byebug/commands/catch.rb#12
+class Byebug::CatchCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+
+ # source://byebug//lib/byebug/commands/catch.rb#38
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/catch.rb#57
+ def add(exception); end
+
+ # source://byebug//lib/byebug/commands/catch.rb#64
+ def clear; end
+
+ # source://byebug//lib/byebug/commands/catch.rb#68
+ def info; end
+
+ # source://byebug//lib/byebug/commands/catch.rb#50
+ def remove(exception); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/catch.rb#21
+ def description; end
+
+ # source://byebug//lib/byebug/commands/catch.rb#17
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/catch.rb#34
+ def short_description; end
+ end
+end
+
+# Parent class of all byebug commands.
+#
+# Subclass it and name the subclass ending with the word Command to implement
+# your own custom command.
+#
+# class MyCustomCommand < Command
+# def self.regexp
+# /custom_regexp/
+# end
+#
+# def self.description
+# "Custom long desc"
+# end
+#
+# def.short_description
+# "Custom short desc"
+# end
+#
+# def execute
+# # My command's implementation
+# end
+# end
+#
+# @example Define a custom command
+#
+# source://byebug//lib/byebug/command.rb#33
+class Byebug::Command
+ extend ::Forwardable
+ extend ::Byebug::Helpers::StringHelper
+
+ # @return [Command] a new instance of Command
+ #
+ # source://byebug//lib/byebug/command.rb#38
+ def initialize(processor, input = T.unsafe(nil)); end
+
+ # source://byebug//lib/byebug/command.rb#51
+ def arguments; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def confirm(*args, **_arg1, &block); end
+
+ # source://byebug//lib/byebug/command.rb#43
+ def context; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def errmsg(*args, **_arg1, &block); end
+
+ # source://byebug//lib/byebug/command.rb#47
+ def frame; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def help(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def match(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def pr(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def prc(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def print(*args, **_arg1, &block); end
+
+ # Returns the value of attribute processor.
+ #
+ # source://byebug//lib/byebug/command.rb#36
+ def processor; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def prv(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def puts(*args, **_arg1, &block); end
+
+ class << self
+ # Special methods to allow command filtering in processors
+ #
+ # source://byebug//lib/byebug/command.rb#69
+ def allow_in_control; end
+
+ # Special methods to allow command filtering in processors
+ #
+ # source://byebug//lib/byebug/command.rb#69
+ def allow_in_control=(_arg0); end
+
+ # Special methods to allow command filtering in processors
+ #
+ # source://byebug//lib/byebug/command.rb#69
+ def allow_in_post_mortem; end
+
+ # Special methods to allow command filtering in processors
+ #
+ # source://byebug//lib/byebug/command.rb#69
+ def allow_in_post_mortem=(_arg0); end
+
+ # source://byebug//lib/byebug/command.rb#73
+ def always_run; end
+
+ # Sets the attribute always_run
+ #
+ # @param value the value to set the attribute always_run to.
+ #
+ # source://byebug//lib/byebug/command.rb#71
+ def always_run=(_arg0); end
+
+ # source://byebug//lib/byebug/command.rb#88
+ def columnize(width); end
+
+ # Default help text for a command.
+ #
+ # source://byebug//lib/byebug/command.rb#99
+ def help; end
+
+ # Command's regexp match against an input
+ #
+ # source://byebug//lib/byebug/command.rb#106
+ def match(input); end
+
+ # Name of the command, as executed by the user.
+ #
+ # source://byebug//lib/byebug/command.rb#80
+ def to_s; end
+ end
+end
+
+# Holds an array of subcommands for a command
+#
+# source://byebug//lib/byebug/command_list.rb#9
+class Byebug::CommandList
+ include ::Enumerable
+
+ # @return [CommandList] a new instance of CommandList
+ #
+ # source://byebug//lib/byebug/command_list.rb#12
+ def initialize(commands); end
+
+ # source://byebug//lib/byebug/command_list.rb#20
+ def each; end
+
+ # source://byebug//lib/byebug/command_list.rb#16
+ def match(input); end
+
+ # source://byebug//lib/byebug/command_list.rb#24
+ def to_s; end
+
+ private
+
+ # source://byebug//lib/byebug/command_list.rb#30
+ def width; end
+end
+
+# Custom exception exception to signal "command not found" errors
+#
+# source://byebug//lib/byebug/errors.rb#7
+class Byebug::CommandNotFound < ::NoMethodError
+ # @return [CommandNotFound] a new instance of CommandNotFound
+ #
+ # source://byebug//lib/byebug/errors.rb#8
+ def initialize(input, parent = T.unsafe(nil)); end
+
+ private
+
+ # source://byebug//lib/byebug/errors.rb#25
+ def build_cmd(*args); end
+
+ # source://byebug//lib/byebug/errors.rb#21
+ def help; end
+
+ # source://byebug//lib/byebug/errors.rb#17
+ def name; end
+end
+
+# Processes commands in regular mode.
+#
+# You can override this class to create your own command processor that, for
+# example, whitelists only certain commands to be executed.
+#
+# @see PostMortemProcessor for a example
+#
+# source://byebug//lib/byebug/processors/command_processor.rb#17
+class Byebug::CommandProcessor
+ include ::Byebug::Helpers::EvalHelper
+ extend ::Forwardable
+
+ # @return [CommandProcessor] a new instance of CommandProcessor
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#23
+ def initialize(context, interface = T.unsafe(nil)); end
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#64
+ def at_breakpoint(brkpt); end
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#70
+ def at_catchpoint(exception); end
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#80
+ def at_end; end
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#54
+ def at_line; end
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#74
+ def at_return(return_value); end
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#58
+ def at_tracing; end
+
+ # Available commands
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#50
+ def command_list; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def commands(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def confirm(*args, **_arg1, &block); end
+
+ # Returns the value of attribute context.
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#21
+ def context; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def errmsg(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def frame(*args, **_arg1, &block); end
+
+ # Returns the value of attribute interface.
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#21
+ def interface; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def pr(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def prc(*args, **_arg1, &block); end
+
+ # Returns the value of attribute prev_line.
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#20
+ def prev_line; end
+
+ # Sets the attribute prev_line
+ #
+ # @param value the value to set the attribute prev_line to.
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#20
+ def prev_line=(_arg0); end
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#31
+ def printer; end
+
+ # Let the execution continue
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#87
+ def proceed!; end
+
+ # Handle byebug commands.
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#94
+ def process_commands; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def prv(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def puts(*args, **_arg1, &block); end
+
+ protected
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#119
+ def after_repl; end
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#111
+ def before_repl; end
+
+ # Prompt shown before reading a command.
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#107
+ def prompt; end
+
+ # Main byebug's REPL
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#126
+ def repl; end
+
+ private
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#139
+ def auto_cmds_for(run_level); end
+
+ # Run permanent commands.
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#146
+ def run_auto_cmds(run_level); end
+
+ # Executes the received input
+ #
+ # Instantiates a command matching the input and runs it. If a matching
+ # command is not found, it evaluates the unknown input.
+ #
+ # source://byebug//lib/byebug/processors/command_processor.rb#158
+ def run_cmd(input); end
+
+ # source://byebug//lib/byebug/processors/command_processor.rb#167
+ def safely; end
+end
+
+# Implements conditions on breakpoints.
+#
+# Adds the ability to stop on breakpoints only under certain conditions.
+#
+# source://byebug//lib/byebug/commands/condition.rb#12
+class Byebug::ConditionCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/condition.rb#38
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/condition.rb#21
+ def description; end
+
+ # source://byebug//lib/byebug/commands/condition.rb#17
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/condition.rb#34
+ def short_description; end
+ end
+end
+
+# Mantains context information for the debugger and it's the main
+# communication point between the library and the C-extension through the
+# at_breakpoint, at_catchpoint, at_tracing, at_line and at_return callbacks
+#
+# source://byebug//lib/byebug/context.rb#14
+class Byebug::Context
+ include ::Byebug::Helpers::FileHelper
+ extend ::Byebug::Helpers::PathHelper
+ extend ::Forwardable
+
+ # Breakpoint handler
+ #
+ # source://byebug//lib/byebug/context.rb#113
+ def at_breakpoint(breakpoint); end
+
+ # Catchpoint handler
+ #
+ # source://byebug//lib/byebug/context.rb#120
+ def at_catchpoint(exception); end
+
+ # End of class definition handler
+ #
+ # source://byebug//lib/byebug/context.rb#136
+ def at_end; end
+
+ # Line handler
+ #
+ # source://byebug//lib/byebug/context.rb#94
+ def at_line; end
+
+ # Return handler
+ #
+ # source://byebug//lib/byebug/context.rb#127
+ def at_return(return_value); end
+
+ # Tracing handler
+ #
+ # source://byebug//lib/byebug/context.rb#104
+ def at_tracing; end
+
+ def backtrace; end
+ def dead?; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def file(*args, **_arg1, &block); end
+
+ # Reader for the current frame
+ #
+ # source://byebug//lib/byebug/context.rb#46
+ def frame; end
+
+ # Writer for the current frame
+ #
+ # source://byebug//lib/byebug/context.rb#53
+ def frame=(pos); end
+
+ def frame_binding(*_arg0); end
+ def frame_class(*_arg0); end
+ def frame_file(*_arg0); end
+ def frame_line(*_arg0); end
+ def frame_method(*_arg0); end
+ def frame_self(*_arg0); end
+
+ # Current file, line and source code information
+ #
+ # source://byebug//lib/byebug/context.rb#70
+ def full_location; end
+
+ def ignored?; end
+
+ # source://byebug//lib/byebug/context.rb#87
+ def interrupt; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def line(*args, **_arg1, &block); end
+
+ # Current file & line information
+ #
+ # source://byebug//lib/byebug/context.rb#63
+ def location; end
+
+ def resume; end
+
+ # Context's stack size
+ #
+ # source://byebug//lib/byebug/context.rb#79
+ def stack_size; end
+
+ def step_into(*_arg0); end
+ def step_out(*_arg0); end
+ def step_over(*_arg0); end
+ def stop_reason; end
+ def suspend; end
+ def suspended?; end
+ def switch; end
+ def thnum; end
+ def thread; end
+ def tracing; end
+ def tracing=(_arg0); end
+
+ private
+
+ # Tells whether a file is ignored by the debugger.
+ #
+ # @param path [String] filename to be checked.
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/context.rb#153
+ def ignored_file?(path); end
+
+ # source://byebug//lib/byebug/context.rb#144
+ def processor; end
+
+ class << self
+ # List of files byebug will ignore while debugging
+ #
+ # source://byebug//lib/byebug/context.rb#25
+ def ignored_files; end
+
+ # Sets the attribute ignored_files
+ #
+ # @param value the value to set the attribute ignored_files to.
+ #
+ # source://byebug//lib/byebug/context.rb#20
+ def ignored_files=(_arg0); end
+
+ # source://byebug//lib/byebug/context.rb#32
+ def interface; end
+
+ # Sets the attribute interface
+ #
+ # @param value the value to set the attribute interface to.
+ #
+ # source://byebug//lib/byebug/context.rb#30
+ def interface=(_arg0); end
+
+ # source://byebug//lib/byebug/context.rb#38
+ def processor; end
+
+ # Sets the attribute processor
+ #
+ # @param value the value to set the attribute processor to.
+ #
+ # source://byebug//lib/byebug/context.rb#36
+ def processor=(_arg0); end
+ end
+end
+
+# Implements the continue command.
+#
+# Allows the user to continue execution until the next stopping point, a
+# specific line number or until program termination.
+#
+# source://byebug//lib/byebug/commands/continue.rb#13
+class Byebug::ContinueCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/continue.rb#37
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/continue.rb#64
+ def modifier; end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/commands/continue.rb#60
+ def unconditionally?; end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/commands/continue.rb#56
+ def until_line?; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/continue.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/continue.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/continue.rb#33
+ def short_description; end
+ end
+end
+
+# Processes commands when there's not program running
+#
+# source://byebug//lib/byebug/processors/control_processor.rb#9
+class Byebug::ControlProcessor < ::Byebug::CommandProcessor
+ # Available commands
+ #
+ # source://byebug//lib/byebug/processors/control_processor.rb#13
+ def commands; end
+
+ # Prompt shown before reading a command.
+ #
+ # source://byebug//lib/byebug/processors/control_processor.rb#20
+ def prompt; end
+end
+
+# Spawns a subdebugger and evaluates the given expression
+#
+# source://byebug//lib/byebug/commands/debug.rb#10
+class Byebug::DebugCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+
+ # source://byebug//lib/byebug/commands/debug.rb#32
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/debug.rb#17
+ def description; end
+
+ # source://byebug//lib/byebug/commands/debug.rb#13
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/debug.rb#28
+ def short_description; end
+ end
+end
+
+class Byebug::DebugThread < ::Thread
+ class << self
+ def inherited; end
+ end
+end
+
+# Implements breakpoint deletion.
+#
+# source://byebug//lib/byebug/commands/delete.rb#10
+class Byebug::DeleteCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/delete.rb#35
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/delete.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/delete.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/delete.rb#31
+ def short_description; end
+ end
+end
+
+# Disabling custom display expressions or breakpoints.
+#
+# source://byebug//lib/byebug/commands/disable/breakpoints.rb#9
+class Byebug::DisableCommand < ::Byebug::Command
+ include ::Byebug::Subcommands
+ extend ::Byebug::Helpers::ReflectionHelper
+ extend ::Byebug::Subcommands::ClassMethods
+
+ class << self
+ # source://byebug//lib/byebug/commands/disable.rb#21
+ def description; end
+
+ # source://byebug//lib/byebug/commands/disable.rb#17
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/disable.rb#29
+ def short_description; end
+ end
+end
+
+# Disables all or specific breakpoints
+#
+# source://byebug//lib/byebug/commands/disable/breakpoints.rb#13
+class Byebug::DisableCommand::BreakpointsCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+ include ::Byebug::Helpers::ToggleHelper
+
+ # source://byebug//lib/byebug/commands/disable/breakpoints.rb#37
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/disable/breakpoints.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/disable/breakpoints.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/disable/breakpoints.rb#33
+ def short_description; end
+ end
+end
+
+# Enables all or specific displays
+#
+# source://byebug//lib/byebug/commands/disable/display.rb#13
+class Byebug::DisableCommand::DisplayCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+ include ::Byebug::Helpers::ToggleHelper
+
+ # source://byebug//lib/byebug/commands/disable/display.rb#38
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/disable/display.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/disable/display.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/disable/display.rb#34
+ def short_description; end
+ end
+end
+
+# Custom expressions to be displayed every time the debugger stops.
+#
+# source://byebug//lib/byebug/commands/display.rb#10
+class Byebug::DisplayCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+
+ # source://byebug//lib/byebug/commands/display.rb#35
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/display.rb#44
+ def display_expression(exp); end
+
+ # source://byebug//lib/byebug/commands/display.rb#60
+ def eval_expr(expression); end
+
+ # source://byebug//lib/byebug/commands/display.rb#50
+ def print_display_expressions; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/display.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/display.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/display.rb#31
+ def short_description; end
+ end
+end
+
+# Move the current frame down in the backtrace.
+#
+# source://byebug//lib/byebug/commands/down.rb#12
+class Byebug::DownCommand < ::Byebug::Command
+ include ::Byebug::Helpers::FrameHelper
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/down.rb#36
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/down.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/down.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/down.rb#32
+ def short_description; end
+ end
+end
+
+# Edit a file from byebug's prompt.
+#
+# source://byebug//lib/byebug/commands/edit.rb#9
+class Byebug::EditCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/edit.rb#33
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/edit.rb#65
+ def edit_error(type, file); end
+
+ # source://byebug//lib/byebug/commands/edit.rb#61
+ def editor; end
+
+ # source://byebug//lib/byebug/commands/edit.rb#45
+ def location(matched); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/edit.rb#17
+ def description; end
+
+ # source://byebug//lib/byebug/commands/edit.rb#13
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/edit.rb#29
+ def short_description; end
+ end
+end
+
+# Enabling custom display expressions or breakpoints.
+#
+# source://byebug//lib/byebug/commands/enable/breakpoints.rb#9
+class Byebug::EnableCommand < ::Byebug::Command
+ include ::Byebug::Subcommands
+ extend ::Byebug::Helpers::ReflectionHelper
+ extend ::Byebug::Subcommands::ClassMethods
+
+ class << self
+ # source://byebug//lib/byebug/commands/enable.rb#21
+ def description; end
+
+ # source://byebug//lib/byebug/commands/enable.rb#17
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/enable.rb#29
+ def short_description; end
+ end
+end
+
+# Enables all or specific breakpoints
+#
+# source://byebug//lib/byebug/commands/enable/breakpoints.rb#13
+class Byebug::EnableCommand::BreakpointsCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+ include ::Byebug::Helpers::ToggleHelper
+
+ # source://byebug//lib/byebug/commands/enable/breakpoints.rb#37
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/enable/breakpoints.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/enable/breakpoints.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/enable/breakpoints.rb#33
+ def short_description; end
+ end
+end
+
+# Enables all or specific displays
+#
+# source://byebug//lib/byebug/commands/enable/display.rb#13
+class Byebug::EnableCommand::DisplayCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+ include ::Byebug::Helpers::ToggleHelper
+
+ # source://byebug//lib/byebug/commands/enable/display.rb#38
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/enable/display.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/enable/display.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/enable/display.rb#34
+ def short_description; end
+ end
+end
+
+# Implements the finish functionality.
+#
+# Allows the user to continue execution until certain frames are finished.
+#
+# source://byebug//lib/byebug/commands/finish.rb#12
+class Byebug::FinishCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/finish.rb#37
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/finish.rb#53
+ def max_frames; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/finish.rb#21
+ def description; end
+
+ # source://byebug//lib/byebug/commands/finish.rb#17
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/finish.rb#33
+ def short_description; end
+ end
+end
+
+# Represents a frame in the stack trace
+#
+# source://byebug//lib/byebug/frame.rb#9
+class Byebug::Frame
+ include ::Byebug::Helpers::FileHelper
+
+ # @return [Frame] a new instance of Frame
+ #
+ # source://byebug//lib/byebug/frame.rb#14
+ def initialize(context, pos); end
+
+ # source://byebug//lib/byebug/frame.rb#31
+ def _binding; end
+
+ # source://byebug//lib/byebug/frame.rb#35
+ def _class; end
+
+ # source://byebug//lib/byebug/frame.rb#39
+ def _method; end
+
+ # source://byebug//lib/byebug/frame.rb#27
+ def _self; end
+
+ # Gets current method arguments for the frame.
+ #
+ # source://byebug//lib/byebug/frame.rb#62
+ def args; end
+
+ # Checks whether the frame is a c-frame
+ #
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/frame.rb#141
+ def c_frame?; end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/frame.rb#43
+ def current?; end
+
+ # Builds a string containing all available args in the frame number, in a
+ # verbose or non verbose way according to the value of the +callstyle+
+ # setting
+ #
+ # source://byebug//lib/byebug/frame.rb#89
+ def deco_args; end
+
+ # source://byebug//lib/byebug/frame.rb#76
+ def deco_block; end
+
+ # Builds a formatted string containing information about current method call
+ #
+ # source://byebug//lib/byebug/frame.rb#106
+ def deco_call; end
+
+ # Returns the current class in the frame or an empty string if the current
+ # +callstyle+ setting is 'short'
+ #
+ # source://byebug//lib/byebug/frame.rb#72
+ def deco_class; end
+
+ # Formatted filename in frame
+ #
+ # source://byebug//lib/byebug/frame.rb#113
+ def deco_file; end
+
+ # source://byebug//lib/byebug/frame.rb#80
+ def deco_method; end
+
+ # Properly formatted frame number of frame
+ #
+ # source://byebug//lib/byebug/frame.rb#120
+ def deco_pos; end
+
+ # source://byebug//lib/byebug/frame.rb#19
+ def file; end
+
+ # source://byebug//lib/byebug/frame.rb#23
+ def line; end
+
+ # Gets local variables for the frame.
+ #
+ # source://byebug//lib/byebug/frame.rb#50
+ def locals; end
+
+ # Formatted mark for the frame.
+ #
+ # --> marks the current frame
+ # ͱ-- marks c-frames
+ # marks regular frames
+ #
+ # source://byebug//lib/byebug/frame.rb#131
+ def mark; end
+
+ # Returns the value of attribute pos.
+ #
+ # source://byebug//lib/byebug/frame.rb#12
+ def pos; end
+
+ # source://byebug//lib/byebug/frame.rb#145
+ def to_hash; end
+
+ private
+
+ # source://byebug//lib/byebug/frame.rb#158
+ def c_args; end
+
+ # source://byebug//lib/byebug/frame.rb#178
+ def prefix_and_default(arg_type); end
+
+ # source://byebug//lib/byebug/frame.rb#164
+ def ruby_args; end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/frame.rb#174
+ def use_short_style?(arg); end
+end
+
+# Move to specific frames in the backtrace.
+#
+# source://byebug//lib/byebug/commands/frame.rb#12
+class Byebug::FrameCommand < ::Byebug::Command
+ include ::Byebug::Helpers::FrameHelper
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/frame.rb#46
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/frame.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/frame.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/frame.rb#42
+ def short_description; end
+ end
+end
+
+# Setting to display full paths in backtraces.
+#
+# source://byebug//lib/byebug/settings/fullpath.rb#9
+class Byebug::FullpathSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/fullpath.rb#12
+ def banner; end
+end
+
+# source://byebug//lib/byebug/settings/fullpath.rb#10
+Byebug::FullpathSetting::DEFAULT = T.let(T.unsafe(nil), TrueClass)
+
+# Ask for help from byebug's prompt.
+#
+# source://byebug//lib/byebug/commands/help.rb#10
+class Byebug::HelpCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/help.rb#34
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/help.rb#54
+ def command; end
+
+ # @raise [CommandNotFound]
+ #
+ # source://byebug//lib/byebug/commands/help.rb#48
+ def help_for(input, cmd); end
+
+ # source://byebug//lib/byebug/commands/help.rb#44
+ def help_for_all; end
+
+ # source://byebug//lib/byebug/commands/help.rb#58
+ def subcommand; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/help.rb#18
+ def description; end
+
+ # source://byebug//lib/byebug/commands/help.rb#14
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/help.rb#30
+ def short_description; end
+ end
+end
+
+# source://byebug//lib/byebug/helpers/reflection.rb#4
+module Byebug::Helpers; end
+
+# Utilities for interaction with executables
+#
+# source://byebug//lib/byebug/helpers/bin.rb#8
+module Byebug::Helpers::BinHelper
+ # source://byebug//lib/byebug/helpers/bin.rb#38
+ def executable_file_extensions; end
+
+ # source://byebug//lib/byebug/helpers/bin.rb#24
+ def find_executable(path, cmd); end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/helpers/bin.rb#42
+ def real_executable?(file); end
+
+ # source://byebug//lib/byebug/helpers/bin.rb#34
+ def search_paths; end
+
+ # Cross-platform way of finding an executable in the $PATH.
+ # Adapted from: https://gist.github.com/steakknife/88b6c3837a5e90a08296
+ #
+ # source://byebug//lib/byebug/helpers/bin.rb#13
+ def which(cmd); end
+end
+
+# Utilities to assist evaluation of code strings
+#
+# source://byebug//lib/byebug/helpers/eval.rb#8
+module Byebug::Helpers::EvalHelper
+ # Evaluates a string containing Ruby code in a specific binding,
+ # handling the errors at an error level.
+ #
+ # source://byebug//lib/byebug/helpers/eval.rb#46
+ def error_eval(str, binding = T.unsafe(nil)); end
+
+ # Evaluates an +expression+ that might use or defer execution to threads
+ # other than the current one.
+ #
+ # "frozen" so that nothing gets run. So we need to unlock threads prior
+ # to evaluation or we will run into a deadlock.
+ #
+ # @note This is necessary because when in byebug's prompt, every thread is
+ # @param expression [String] Expression to evaluate
+ #
+ # source://byebug//lib/byebug/helpers/eval.rb#30
+ def multiple_thread_eval(expression); end
+
+ # Evaluates an +expression+ in a separate thread.
+ #
+ # @param expression [String] Expression to evaluate
+ #
+ # source://byebug//lib/byebug/helpers/eval.rb#14
+ def separate_thread_eval(expression); end
+
+ # Evaluates a string containing Ruby code in a specific binding,
+ # returning nil in an error happens.
+ #
+ # source://byebug//lib/byebug/helpers/eval.rb#38
+ def silent_eval(str, binding = T.unsafe(nil)); end
+
+ # Evaluates a string containing Ruby code in a specific binding,
+ # handling the errors at a warning level.
+ #
+ # source://byebug//lib/byebug/helpers/eval.rb#54
+ def warning_eval(str, binding = T.unsafe(nil)); end
+
+ private
+
+ # Run block temporarily ignoring all TracePoint events.
+ #
+ # Used to evaluate stuff within Byebug's prompt. Otherwise, any code
+ # creating new threads won't be properly evaluated because new threads
+ # will get blocked by byebug's main thread.
+ #
+ # source://byebug//lib/byebug/helpers/eval.rb#91
+ def allowing_other_threads; end
+
+ # source://byebug//lib/byebug/helpers/eval.rb#72
+ def error_msg(exception); end
+
+ # Runs the given block in a new thread, waits for it to finish and
+ # returns the new thread's result.
+ #
+ # source://byebug//lib/byebug/helpers/eval.rb#105
+ def in_new_thread; end
+
+ # source://byebug//lib/byebug/helpers/eval.rb#66
+ def msg(exception); end
+
+ # source://byebug//lib/byebug/helpers/eval.rb#60
+ def safe_eval(str, binding); end
+
+ # source://byebug//lib/byebug/helpers/eval.rb#113
+ def safe_inspect(var); end
+
+ # source://byebug//lib/byebug/helpers/eval.rb#119
+ def safe_to_s(var); end
+
+ # source://byebug//lib/byebug/helpers/eval.rb#80
+ def warning_msg(exception); end
+end
+
+# Utilities for interaction with files
+#
+# source://byebug//lib/byebug/helpers/file.rb#8
+module Byebug::Helpers::FileHelper
+ # Reads line number +lineno+ from file named +filename+
+ #
+ # source://byebug//lib/byebug/helpers/file.rb#19
+ def get_line(filename, lineno); end
+
+ # Reads lines of source file +filename+ into an array
+ #
+ # source://byebug//lib/byebug/helpers/file.rb#12
+ def get_lines(filename); end
+
+ # Returns the number of lines in file +filename+ in a portable,
+ # one-line-at-a-time way.
+ #
+ # source://byebug//lib/byebug/helpers/file.rb#30
+ def n_lines(filename); end
+
+ # Regularize file name.
+ #
+ # source://byebug//lib/byebug/helpers/file.rb#37
+ def normalize(filename); end
+
+ # A short version of a long path
+ #
+ # source://byebug//lib/byebug/helpers/file.rb#48
+ def shortpath(fullpath); end
+
+ # True for special files like -e, false otherwise
+ #
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/helpers/file.rb#58
+ def virtual_file?(name); end
+end
+
+# Utilities to assist frame navigation
+#
+# source://byebug//lib/byebug/helpers/frame.rb#8
+module Byebug::Helpers::FrameHelper
+ # source://byebug//lib/byebug/helpers/frame.rb#16
+ def jump_frames(steps); end
+
+ # source://byebug//lib/byebug/helpers/frame.rb#9
+ def switch_to_frame(frame); end
+
+ private
+
+ # source://byebug//lib/byebug/helpers/frame.rb#22
+ def adjust_frame(new_frame); end
+
+ # @param step [Integer] A positive or negative integer
+ # @return [Integer] +1 if step is positive / -1 if negative
+ #
+ # source://byebug//lib/byebug/helpers/frame.rb#60
+ def direction(step); end
+
+ # source://byebug//lib/byebug/helpers/frame.rb#51
+ def frame_err(msg); end
+
+ # Convert a possibly negative index to a positive index from the start
+ # of the callstack. -1 is the last position in the stack and so on.
+ #
+ # @param i [Integer] Integer to be converted in a proper positive index.
+ #
+ # source://byebug//lib/byebug/helpers/frame.rb#70
+ def index_from_start(index); end
+
+ # source://byebug//lib/byebug/helpers/frame.rb#30
+ def navigate_to_frame(jump_no); end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/helpers/frame.rb#47
+ def out_of_bounds?(pos); end
+end
+
+# Utilities to assist command parsing
+#
+# source://byebug//lib/byebug/helpers/parse.rb#8
+module Byebug::Helpers::ParseHelper
+ # Parses +str+ of command +cmd+ as an integer between +min+ and +max+.
+ #
+ # If either +min+ or +max+ is nil, that value has no bound.
+ #
+ # purpose.
+ #
+ # @todo Remove the `cmd` parameter. It has nothing to do with the method's
+ #
+ # source://byebug//lib/byebug/helpers/parse.rb#17
+ def get_int(str, cmd, min = T.unsafe(nil), max = T.unsafe(nil)); end
+
+ # @return +str+ as an integer or 1 if +str+ is empty.
+ #
+ # source://byebug//lib/byebug/helpers/parse.rb#51
+ def parse_steps(str, cmd); end
+
+ # @return [Boolean] true if code is syntactically correct for Ruby, false otherwise
+ #
+ # source://byebug//lib/byebug/helpers/parse.rb#35
+ def syntax_valid?(code); end
+
+ private
+
+ # Temporarily disable output to $stderr
+ #
+ # source://byebug//lib/byebug/helpers/parse.rb#65
+ def without_stderr; end
+end
+
+# Utilities for managing gem paths
+#
+# source://byebug//lib/byebug/helpers/path.rb#8
+module Byebug::Helpers::PathHelper
+ # source://byebug//lib/byebug/helpers/path.rb#29
+ def all_files; end
+
+ # source://byebug//lib/byebug/helpers/path.rb#9
+ def bin_file; end
+
+ # source://byebug//lib/byebug/helpers/path.rb#25
+ def gem_files; end
+
+ # source://byebug//lib/byebug/helpers/path.rb#17
+ def lib_files; end
+
+ # source://byebug//lib/byebug/helpers/path.rb#13
+ def root_path; end
+
+ # source://byebug//lib/byebug/helpers/path.rb#21
+ def test_files; end
+
+ private
+
+ # source://byebug//lib/byebug/helpers/path.rb#35
+ def glob_for(dir); end
+end
+
+# Reflection utilitie
+#
+# source://byebug//lib/byebug/helpers/reflection.rb#8
+module Byebug::Helpers::ReflectionHelper
+ # List of "command" classes in the including module
+ #
+ # source://byebug//lib/byebug/helpers/reflection.rb#12
+ def commands; end
+end
+
+# Utilities for interaction with strings
+#
+# source://byebug//lib/byebug/helpers/string.rb#8
+module Byebug::Helpers::StringHelper
+ # Converts +str+ from an_underscored-or-dasherized_string to
+ # ACamelizedString.
+ #
+ # source://byebug//lib/byebug/helpers/string.rb#13
+ def camelize(str); end
+
+ # Removes a number of leading whitespace for each input line.
+ #
+ # source://byebug//lib/byebug/helpers/string.rb#28
+ def deindent(str, leading_spaces: T.unsafe(nil)); end
+
+ # Improves indentation and spacing in +str+ for readability in Byebug's
+ # command prompt.
+ #
+ # source://byebug//lib/byebug/helpers/string.rb#21
+ def prettify(str); end
+end
+
+# Utilities for thread subcommands
+#
+# source://byebug//lib/byebug/helpers/thread.rb#8
+module Byebug::Helpers::ThreadHelper
+ # source://byebug//lib/byebug/helpers/thread.rb#30
+ def context_from_thread(thnum); end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/helpers/thread.rb#26
+ def current_thread?(ctx); end
+
+ # source://byebug//lib/byebug/helpers/thread.rb#9
+ def display_context(ctx); end
+
+ # source://byebug//lib/byebug/helpers/thread.rb#13
+ def thread_arguments(ctx); end
+
+ private
+
+ # source://byebug//lib/byebug/helpers/thread.rb#62
+ def debug_flag(ctx); end
+
+ # @todo Check whether it is Byebug.current_context or context
+ #
+ # source://byebug//lib/byebug/helpers/thread.rb#47
+ def location(ctx); end
+
+ # source://byebug//lib/byebug/helpers/thread.rb#56
+ def status_flag(ctx); end
+end
+
+# Utilities to assist breakpoint/display enabling/disabling.
+#
+# source://byebug//lib/byebug/helpers/toggle.rb#10
+module Byebug::Helpers::ToggleHelper
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/helpers/toggle.rb#13
+ def enable_disable_breakpoints(is_enable, args); end
+
+ # source://byebug//lib/byebug/helpers/toggle.rb#26
+ def enable_disable_display(is_enable, args); end
+
+ private
+
+ # source://byebug//lib/byebug/helpers/toggle.rb#57
+ def n_displays; end
+
+ # source://byebug//lib/byebug/helpers/toggle.rb#41
+ def select_breakpoints(is_enable, args); end
+end
+
+# Utilities for variable subcommands
+#
+# source://byebug//lib/byebug/helpers/var.rb#10
+module Byebug::Helpers::VarHelper
+ include ::Byebug::Helpers::EvalHelper
+
+ # source://byebug//lib/byebug/helpers/var.rb#42
+ def var_args; end
+
+ # source://byebug//lib/byebug/helpers/var.rb#21
+ def var_global; end
+
+ # source://byebug//lib/byebug/helpers/var.rb#29
+ def var_instance(str); end
+
+ # source://byebug//lib/byebug/helpers/var.rb#13
+ def var_list(ary, binding = T.unsafe(nil)); end
+
+ # source://byebug//lib/byebug/helpers/var.rb#35
+ def var_local; end
+end
+
+# Setting to customize the file where byebug's history is saved.
+#
+# source://byebug//lib/byebug/settings/histfile.rb#9
+class Byebug::HistfileSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/histfile.rb#12
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/histfile.rb#16
+ def to_s; end
+end
+
+# source://byebug//lib/byebug/settings/histfile.rb#10
+Byebug::HistfileSetting::DEFAULT = T.let(T.unsafe(nil), String)
+
+# Handles byebug's history of commands.
+#
+# source://byebug//lib/byebug/history.rb#19
+class Byebug::History
+ # @return [History] a new instance of History
+ #
+ # source://byebug//lib/byebug/history.rb#22
+ def initialize; end
+
+ # Array holding the list of commands in history
+ #
+ # source://byebug//lib/byebug/history.rb#29
+ def buffer; end
+
+ # Discards history.
+ #
+ # source://byebug//lib/byebug/history.rb#58
+ def clear; end
+
+ # Max number of commands to be displayed when no size has been specified.
+ #
+ # Never more than Setting[:histsize].
+ #
+ # source://byebug//lib/byebug/history.rb#105
+ def default_max_size; end
+
+ # Whether a specific command should not be stored in history.
+ #
+ # For now, empty lines and consecutive duplicates.
+ #
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/history.rb#123
+ def ignore?(buf); end
+
+ # Array of ids of the last +number+ commands.
+ #
+ # source://byebug//lib/byebug/history.rb#96
+ def last_ids(number); end
+
+ # Removes a command from Readline's history.
+ #
+ # source://byebug//lib/byebug/history.rb#75
+ def pop; end
+
+ # Adds a new command to Readline's history.
+ #
+ # source://byebug//lib/byebug/history.rb#65
+ def push(cmd); end
+
+ # Restores history from disk.
+ #
+ # source://byebug//lib/byebug/history.rb#36
+ def restore; end
+
+ # Saves history to disk.
+ #
+ # source://byebug//lib/byebug/history.rb#45
+ def save; end
+
+ # Returns the value of attribute size.
+ #
+ # source://byebug//lib/byebug/history.rb#20
+ def size; end
+
+ # Sets the attribute size
+ #
+ # @param value the value to set the attribute size to.
+ #
+ # source://byebug//lib/byebug/history.rb#20
+ def size=(_arg0); end
+
+ # Max number of commands to be displayed when a size has been specified.
+ #
+ # The only bound here is not showing more items than available.
+ #
+ # source://byebug//lib/byebug/history.rb#114
+ def specific_max_size(number); end
+
+ # Prints the requested numbers of history entries.
+ #
+ # source://byebug//lib/byebug/history.rb#83
+ def to_s(n_cmds); end
+end
+
+# Show history of byebug commands.
+#
+# source://byebug//lib/byebug/commands/history.rb#10
+class Byebug::HistoryCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/history.rb#31
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/history.rb#19
+ def description; end
+
+ # source://byebug//lib/byebug/commands/history.rb#15
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/history.rb#27
+ def short_description; end
+ end
+end
+
+# Setting to customize the number of byebug commands to be saved in history.
+#
+# source://byebug//lib/byebug/settings/histsize.rb#9
+class Byebug::HistsizeSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/histsize.rb#12
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/histsize.rb#16
+ def to_s; end
+end
+
+# source://byebug//lib/byebug/settings/histsize.rb#10
+Byebug::HistsizeSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+# Shows info about different aspects of the debugger.
+#
+# source://byebug//lib/byebug/commands/info/breakpoints.rb#7
+class Byebug::InfoCommand < ::Byebug::Command
+ include ::Byebug::Subcommands
+ extend ::Byebug::Helpers::ReflectionHelper
+ extend ::Byebug::Subcommands::ClassMethods
+
+ class << self
+ # source://byebug//lib/byebug/commands/info.rb#25
+ def description; end
+
+ # source://byebug//lib/byebug/commands/info.rb#21
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/info.rb#33
+ def short_description; end
+ end
+end
+
+# Information about current breakpoints
+#
+# source://byebug//lib/byebug/commands/info/breakpoints.rb#11
+class Byebug::InfoCommand::BreakpointsCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/info/breakpoints.rb#30
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/info/breakpoints.rb#47
+ def info_breakpoint(brkpt); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/info/breakpoints.rb#18
+ def description; end
+
+ # source://byebug//lib/byebug/commands/info/breakpoints.rb#14
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/info/breakpoints.rb#26
+ def short_description; end
+ end
+end
+
+# Information about display expressions
+#
+# source://byebug//lib/byebug/commands/info/display.rb#11
+class Byebug::InfoCommand::DisplayCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/info/display.rb#30
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/info/display.rb#18
+ def description; end
+
+ # source://byebug//lib/byebug/commands/info/display.rb#14
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/info/display.rb#26
+ def short_description; end
+ end
+end
+
+# Information about a particular source file
+#
+# source://byebug//lib/byebug/commands/info/file.rb#13
+class Byebug::InfoCommand::FileCommand < ::Byebug::Command
+ include ::Byebug::Helpers::FileHelper
+ include ::Byebug::Helpers::StringHelper
+
+ # source://byebug//lib/byebug/commands/info/file.rb#38
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/info/file.rb#55
+ def info_file_basic(file); end
+
+ # source://byebug//lib/byebug/commands/info/file.rb#63
+ def info_file_breakpoints(file); end
+
+ # source://byebug//lib/byebug/commands/info/file.rb#70
+ def info_file_mtime(file); end
+
+ # source://byebug//lib/byebug/commands/info/file.rb#74
+ def info_file_sha1(file); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/info/file.rb#23
+ def description; end
+
+ # source://byebug//lib/byebug/commands/info/file.rb#19
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/info/file.rb#34
+ def short_description; end
+ end
+end
+
+# Information about current location
+#
+# source://byebug//lib/byebug/commands/info/line.rb#11
+class Byebug::InfoCommand::LineCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/info/line.rb#30
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/info/line.rb#18
+ def description; end
+
+ # source://byebug//lib/byebug/commands/info/line.rb#14
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/info/line.rb#26
+ def short_description; end
+ end
+end
+
+# Information about arguments of the current method/block
+#
+# source://byebug//lib/byebug/commands/info/program.rb#11
+class Byebug::InfoCommand::ProgramCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/info/program.rb#30
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/info/program.rb#37
+ def format_stop_reason(stop_reason); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/info/program.rb#18
+ def description; end
+
+ # source://byebug//lib/byebug/commands/info/program.rb#14
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/info/program.rb#26
+ def short_description; end
+ end
+end
+
+# Main Interface class
+#
+# Contains common functionality to all implemented interfaces.
+#
+# source://byebug//lib/byebug/interface.rb#16
+class Byebug::Interface
+ include ::Byebug::Helpers::FileHelper
+
+ # @return [Interface] a new instance of Interface
+ #
+ # source://byebug//lib/byebug/interface.rb#22
+ def initialize; end
+
+ # Restores history according to +autosave+ setting.
+ #
+ # source://byebug//lib/byebug/interface.rb#118
+ def autorestore; end
+
+ # Saves or clears history according to +autosave+ setting.
+ #
+ # source://byebug//lib/byebug/interface.rb#111
+ def autosave; end
+
+ # source://byebug//lib/byebug/interface.rb#105
+ def close; end
+
+ # Returns the value of attribute command_queue.
+ #
+ # source://byebug//lib/byebug/interface.rb#19
+ def command_queue; end
+
+ # Sets the attribute command_queue
+ #
+ # @param value the value to set the attribute command_queue to.
+ #
+ # source://byebug//lib/byebug/interface.rb#19
+ def command_queue=(_arg0); end
+
+ # Confirms user introduced an affirmative response to the input stream.
+ #
+ # source://byebug//lib/byebug/interface.rb#101
+ def confirm(prompt); end
+
+ # Prints an error message to the error stream.
+ #
+ # source://byebug//lib/byebug/interface.rb#80
+ def errmsg(message); end
+
+ # Returns the value of attribute error.
+ #
+ # source://byebug//lib/byebug/interface.rb#20
+ def error; end
+
+ # Returns the value of attribute history.
+ #
+ # source://byebug//lib/byebug/interface.rb#19
+ def history; end
+
+ # Sets the attribute history
+ #
+ # @param value the value to set the attribute history to.
+ #
+ # source://byebug//lib/byebug/interface.rb#19
+ def history=(_arg0); end
+
+ # Returns the value of attribute input.
+ #
+ # source://byebug//lib/byebug/interface.rb#20
+ def input; end
+
+ # source://byebug//lib/byebug/interface.rb#28
+ def last_if_empty(input); end
+
+ # Returns the value of attribute output.
+ #
+ # source://byebug//lib/byebug/interface.rb#20
+ def output; end
+
+ # Reads a new line from the interface's input stream.
+ #
+ # read now was empty.
+ #
+ # @return [String] New string read or the previous string if the string
+ #
+ # source://byebug//lib/byebug/interface.rb#70
+ def prepare_input(prompt); end
+
+ # Prints an output message to the output stream without a final "\n".
+ #
+ # source://byebug//lib/byebug/interface.rb#94
+ def print(message); end
+
+ # Prints an output message to the output stream.
+ #
+ # source://byebug//lib/byebug/interface.rb#87
+ def puts(message); end
+
+ # Pops a command from the input stream.
+ #
+ # source://byebug//lib/byebug/interface.rb#35
+ def read_command(prompt); end
+
+ # Pushes lines in +filename+ to the command queue.
+ #
+ # source://byebug//lib/byebug/interface.rb#44
+ def read_file(filename); end
+
+ # Reads a new line from the interface's input stream, parses it into
+ # commands and saves it to history.
+ #
+ # @return [String] Representing something to be run by the debugger.
+ #
+ # source://byebug//lib/byebug/interface.rb#54
+ def read_input(prompt, save_hist = T.unsafe(nil)); end
+
+ private
+
+ # Splits a command line of the form "cmd1 ; cmd2 ; ... ; cmdN" into an
+ # array of commands: [cmd1, cmd2, ..., cmdN]
+ #
+ # source://byebug//lib/byebug/interface.rb#128
+ def split_commands(cmd_line); end
+end
+
+# Interrupting execution of current thread.
+#
+# source://byebug//lib/byebug/commands/interrupt.rb#9
+class Byebug::InterruptCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/interrupt.rb#28
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/interrupt.rb#16
+ def description; end
+
+ # source://byebug//lib/byebug/commands/interrupt.rb#12
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/interrupt.rb#24
+ def short_description; end
+ end
+end
+
+# Enter IRB from byebug's prompt
+#
+# source://byebug//lib/byebug/commands/irb.rb#11
+class Byebug::IrbCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/irb.rb#30
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/irb.rb#40
+ def with_clean_argv; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/irb.rb#18
+ def description; end
+
+ # source://byebug//lib/byebug/commands/irb.rb#14
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/irb.rb#26
+ def short_description; end
+ end
+end
+
+# Send custom signals to the debugged program.
+#
+# source://byebug//lib/byebug/commands/kill.rb#9
+class Byebug::KillCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/kill.rb#30
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/kill.rb#16
+ def description; end
+
+ # source://byebug//lib/byebug/commands/kill.rb#12
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/kill.rb#26
+ def short_description; end
+ end
+end
+
+# Setting to enable/disable linetracing.
+#
+# source://byebug//lib/byebug/settings/linetrace.rb#9
+class Byebug::LinetraceSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/linetrace.rb#10
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/linetrace.rb#18
+ def value; end
+
+ # source://byebug//lib/byebug/settings/linetrace.rb#14
+ def value=(val); end
+end
+
+# List parts of the source code.
+#
+# source://byebug//lib/byebug/commands/list.rb#12
+class Byebug::ListCommand < ::Byebug::Command
+ include ::Byebug::Helpers::FileHelper
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def amend_final(*args, **_arg1, &block); end
+
+ # source://byebug//lib/byebug/commands/list.rb#40
+ def execute; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def max_line(*args, **_arg1, &block); end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def size(*args, **_arg1, &block); end
+
+ private
+
+ # Set line range to be printed by list
+ #
+ # @return first line number to list
+ # @return last line number to list
+ #
+ # source://byebug//lib/byebug/commands/list.rb#79
+ def auto_range(direction); end
+
+ # Show a range of lines in the current file.
+ #
+ # @param min [Integer] Lower bound
+ # @param max [Integer] Upper bound
+ #
+ # source://byebug//lib/byebug/commands/list.rb#115
+ def display_lines(min, max); end
+
+ # @param range [String] A string with an integer range format
+ # @return [String] The lower bound of the given range
+ #
+ # source://byebug//lib/byebug/commands/list.rb#126
+ def lower_bound(range); end
+
+ # source://byebug//lib/byebug/commands/list.rb#105
+ def move(line, size, direction = T.unsafe(nil)); end
+
+ # source://byebug//lib/byebug/commands/list.rb#89
+ def parse_range(input); end
+
+ # Line range to be printed by `list`.
+ #
+ # If is set, range is parsed from it.
+ #
+ # Otherwise it's automatically chosen.
+ #
+ # source://byebug//lib/byebug/commands/list.rb#60
+ def range(input); end
+
+ # source://byebug//lib/byebug/commands/list.rb#152
+ def source_file_formatter; end
+
+ # @param str [String] A string with an integer range format
+ # @return [Array] The upper & lower bounds of the given range
+ #
+ # source://byebug//lib/byebug/commands/list.rb#144
+ def split_range(str); end
+
+ # @param range [String] A string with an integer range format
+ # @return [String] The upper bound of the given range
+ #
+ # source://byebug//lib/byebug/commands/list.rb#135
+ def upper_bound(range); end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/commands/list.rb#69
+ def valid_range?(first, last); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/list.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/list.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/list.rb#36
+ def short_description; end
+ end
+end
+
+# Setting to customize the number of source code lines to be displayed every
+# time the "list" command is invoked.
+#
+# source://byebug//lib/byebug/settings/listsize.rb#10
+class Byebug::ListsizeSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/listsize.rb#13
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/listsize.rb#17
+ def to_s; end
+end
+
+# source://byebug//lib/byebug/settings/listsize.rb#11
+Byebug::ListsizeSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+# Interface class for standard byebug use.
+#
+# source://byebug//lib/byebug/interfaces/local_interface.rb#7
+class Byebug::LocalInterface < ::Byebug::Interface
+ # @return [LocalInterface] a new instance of LocalInterface
+ #
+ # source://byebug//lib/byebug/interfaces/local_interface.rb#10
+ def initialize; end
+
+ # Reads a single line of input using Readline. If Ctrl-D is pressed, it
+ # returns "continue", meaning that program's execution will go on.
+ #
+ # @param prompt Prompt to be displayed.
+ #
+ # source://byebug//lib/byebug/interfaces/local_interface.rb#23
+ def readline(prompt); end
+
+ # Yields the block handling Ctrl-C the following way: if pressed while
+ # waiting for input, the line is reset to only the prompt and we ask for
+ # input again.
+ #
+ # @note Any external 'INT' traps are overriden during this method.
+ #
+ # source://byebug//lib/byebug/interfaces/local_interface.rb#34
+ def with_repl_like_sigint; end
+
+ # Disable any Readline completion procs.
+ #
+ # Other gems, for example, IRB could've installed completion procs that are
+ # dependent on them being loaded. Disable those while byebug is the REPL
+ # making use of Readline.
+ #
+ # source://byebug//lib/byebug/interfaces/local_interface.rb#51
+ def without_readline_completion; end
+end
+
+# source://byebug//lib/byebug/interfaces/local_interface.rb#8
+Byebug::LocalInterface::EOF_ALIAS = T.let(T.unsafe(nil), String)
+
+# Show methods of specific classes/modules/objects.
+#
+# source://byebug//lib/byebug/commands/method.rb#10
+class Byebug::MethodCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+
+ # source://byebug//lib/byebug/commands/method.rb#37
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/method.rb#19
+ def description; end
+
+ # source://byebug//lib/byebug/commands/method.rb#15
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/method.rb#33
+ def short_description; end
+ end
+end
+
+# Implements the next functionality.
+#
+# Allows the user the continue execution until the next instruction in the
+# current frame.
+#
+# source://byebug//lib/byebug/commands/next.rb#13
+class Byebug::NextCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/next.rb#32
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/next.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/next.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/next.rb#28
+ def short_description; end
+ end
+end
+
+# Port number used for remote debugging
+#
+# source://byebug//lib/byebug/remote.rb#13
+Byebug::PORT = T.let(T.unsafe(nil), Integer)
+
+# Processes commands in post_mortem mode
+#
+# source://byebug//lib/byebug/processors/post_mortem_processor.rb#9
+class Byebug::PostMortemProcessor < ::Byebug::CommandProcessor
+ # source://byebug//lib/byebug/processors/post_mortem_processor.rb#10
+ def commands; end
+
+ # source://byebug//lib/byebug/processors/post_mortem_processor.rb#14
+ def prompt; end
+end
+
+# Setting to enable/disable post_mortem mode, i.e., a debugger prompt after
+# program termination by unhandled exception.
+#
+# source://byebug//lib/byebug/settings/post_mortem.rb#10
+class Byebug::PostMortemSetting < ::Byebug::Setting
+ # @return [PostMortemSetting] a new instance of PostMortemSetting
+ #
+ # source://byebug//lib/byebug/settings/post_mortem.rb#11
+ def initialize; end
+
+ # source://byebug//lib/byebug/settings/post_mortem.rb#15
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/post_mortem.rb#23
+ def value; end
+
+ # source://byebug//lib/byebug/settings/post_mortem.rb#19
+ def value=(val); end
+end
+
+# source://byebug//lib/byebug/printers/base.rb#6
+module Byebug::Printers; end
+
+# Base printer
+#
+# source://byebug//lib/byebug/printers/base.rb#10
+class Byebug::Printers::Base
+ # source://byebug//lib/byebug/printers/base.rb#16
+ def type; end
+
+ private
+
+ # source://byebug//lib/byebug/printers/base.rb#55
+ def array_of_args(collection, &_block); end
+
+ # source://byebug//lib/byebug/printers/base.rb#49
+ def contents; end
+
+ # source://byebug//lib/byebug/printers/base.rb#63
+ def contents_files; end
+
+ # @raise [MissedPath]
+ #
+ # source://byebug//lib/byebug/printers/base.rb#22
+ def locate(path); end
+
+ # source://byebug//lib/byebug/printers/base.rb#45
+ def parts(path); end
+
+ # source://byebug//lib/byebug/printers/base.rb#35
+ def translate(string, args = T.unsafe(nil)); end
+end
+
+# source://byebug//lib/byebug/printers/base.rb#12
+class Byebug::Printers::Base::MissedArgument < ::StandardError; end
+
+# source://byebug//lib/byebug/printers/base.rb#11
+class Byebug::Printers::Base::MissedPath < ::StandardError; end
+
+# source://byebug//lib/byebug/printers/base.rb#14
+Byebug::Printers::Base::SEPARATOR = T.let(T.unsafe(nil), String)
+
+# Plain text printer
+#
+# source://byebug//lib/byebug/printers/plain.rb#10
+class Byebug::Printers::Plain < ::Byebug::Printers::Base
+ # source://byebug//lib/byebug/printers/plain.rb#11
+ def print(path, args = T.unsafe(nil)); end
+
+ # source://byebug//lib/byebug/printers/plain.rb#17
+ def print_collection(path, collection, &block); end
+
+ # source://byebug//lib/byebug/printers/plain.rb#25
+ def print_variables(variables, *_unused); end
+
+ private
+
+ # source://byebug//lib/byebug/printers/plain.rb#39
+ def contents_files; end
+end
+
+# Enter Pry from byebug's prompt
+#
+# source://byebug//lib/byebug/commands/pry.rb#10
+class Byebug::PryCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/pry.rb#29
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/pry.rb#17
+ def description; end
+
+ # source://byebug//lib/byebug/commands/pry.rb#13
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/pry.rb#25
+ def short_description; end
+ end
+end
+
+# Exit from byebug.
+#
+# source://byebug//lib/byebug/commands/quit.rb#9
+class Byebug::QuitCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/quit.rb#33
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/quit.rb#17
+ def description; end
+
+ # source://byebug//lib/byebug/commands/quit.rb#13
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/quit.rb#29
+ def short_description; end
+ end
+end
+
+# source://byebug//lib/byebug/remote/server.rb#6
+module Byebug::Remote; end
+
+# Client for remote debugging
+#
+# source://byebug//lib/byebug/remote/client.rb#10
+class Byebug::Remote::Client
+ # @return [Client] a new instance of Client
+ #
+ # source://byebug//lib/byebug/remote/client.rb#13
+ def initialize(interface); end
+
+ # Returns the value of attribute interface.
+ #
+ # source://byebug//lib/byebug/remote/client.rb#11
+ def interface; end
+
+ # Returns the value of attribute socket.
+ #
+ # source://byebug//lib/byebug/remote/client.rb#11
+ def socket; end
+
+ # Connects to the remote byebug
+ #
+ # source://byebug//lib/byebug/remote/client.rb#21
+ def start(host = T.unsafe(nil), port = T.unsafe(nil)); end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/remote/client.rb#44
+ def started?; end
+
+ private
+
+ # source://byebug//lib/byebug/remote/client.rb#50
+ def connect_at(host, port); end
+end
+
+# Server for remote debugging
+#
+# source://byebug//lib/byebug/remote/server.rb#10
+class Byebug::Remote::Server
+ # @return [Server] a new instance of Server
+ #
+ # source://byebug//lib/byebug/remote/server.rb#13
+ def initialize(wait_connection:, &block); end
+
+ # Returns the value of attribute actual_port.
+ #
+ # source://byebug//lib/byebug/remote/server.rb#11
+ def actual_port; end
+
+ # Start the remote debugging server
+ #
+ # source://byebug//lib/byebug/remote/server.rb#22
+ def start(host, port); end
+
+ # Returns the value of attribute wait_connection.
+ #
+ # source://byebug//lib/byebug/remote/server.rb#11
+ def wait_connection; end
+end
+
+# Interface class for remote use of byebug.
+#
+# source://byebug//lib/byebug/interfaces/remote_interface.rb#9
+class Byebug::RemoteInterface < ::Byebug::Interface
+ # @return [RemoteInterface] a new instance of RemoteInterface
+ #
+ # source://byebug//lib/byebug/interfaces/remote_interface.rb#10
+ def initialize(socket); end
+
+ # source://byebug//lib/byebug/interfaces/remote_interface.rb#41
+ def close; end
+
+ # source://byebug//lib/byebug/interfaces/remote_interface.rb#23
+ def confirm(prompt); end
+
+ # source://byebug//lib/byebug/interfaces/remote_interface.rb#29
+ def print(message); end
+
+ # source://byebug//lib/byebug/interfaces/remote_interface.rb#35
+ def puts(message); end
+
+ # source://byebug//lib/byebug/interfaces/remote_interface.rb#17
+ def read_command(prompt); end
+
+ # source://byebug//lib/byebug/interfaces/remote_interface.rb#45
+ def readline(prompt); end
+end
+
+# Restart debugged program from within byebug.
+#
+# source://byebug//lib/byebug/commands/restart.rb#14
+class Byebug::RestartCommand < ::Byebug::Command
+ include ::Byebug::Helpers::BinHelper
+ include ::Byebug::Helpers::PathHelper
+
+ # source://byebug//lib/byebug/commands/restart.rb#40
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/restart.rb#54
+ def prepend_byebug_bin(cmd); end
+
+ # source://byebug//lib/byebug/commands/restart.rb#59
+ def prepend_ruby_bin(cmd); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/restart.rb#25
+ def description; end
+
+ # source://byebug//lib/byebug/commands/restart.rb#21
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/restart.rb#36
+ def short_description; end
+ end
+end
+
+# Save current settings to use them in another debug session.
+#
+# source://byebug//lib/byebug/commands/save.rb#9
+class Byebug::SaveCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/save.rb#36
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/save.rb#50
+ def save_breakpoints(file); end
+
+ # source://byebug//lib/byebug/commands/save.rb#56
+ def save_catchpoints(file); end
+
+ # source://byebug//lib/byebug/commands/save.rb#62
+ def save_displays(file); end
+
+ # source://byebug//lib/byebug/commands/save.rb#66
+ def save_settings(file); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/save.rb#17
+ def description; end
+
+ # source://byebug//lib/byebug/commands/save.rb#13
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/save.rb#32
+ def short_description; end
+ end
+end
+
+# Setting to customize the file where byebug's history is saved.
+#
+# source://byebug//lib/byebug/settings/savefile.rb#9
+class Byebug::SavefileSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/savefile.rb#12
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/savefile.rb#16
+ def to_s; end
+end
+
+# source://byebug//lib/byebug/settings/savefile.rb#10
+Byebug::SavefileSetting::DEFAULT = T.let(T.unsafe(nil), String)
+
+# Interface class for command execution from script files.
+#
+# source://byebug//lib/byebug/interfaces/script_interface.rb#7
+class Byebug::ScriptInterface < ::Byebug::Interface
+ # @return [ScriptInterface] a new instance of ScriptInterface
+ #
+ # source://byebug//lib/byebug/interfaces/script_interface.rb#8
+ def initialize(file, verbose = T.unsafe(nil)); end
+
+ # source://byebug//lib/byebug/interfaces/script_interface.rb#20
+ def close; end
+
+ # source://byebug//lib/byebug/interfaces/script_interface.rb#16
+ def read_command(prompt); end
+
+ # source://byebug//lib/byebug/interfaces/script_interface.rb#24
+ def readline(*_arg0); end
+end
+
+# Processes commands from a file
+#
+# source://byebug//lib/byebug/processors/script_processor.rb#9
+class Byebug::ScriptProcessor < ::Byebug::CommandProcessor
+ # source://byebug//lib/byebug/processors/script_processor.rb#28
+ def after_repl; end
+
+ # Available commands
+ #
+ # source://byebug//lib/byebug/processors/script_processor.rb#13
+ def commands; end
+
+ # Prompt shown before reading a command.
+ #
+ # source://byebug//lib/byebug/processors/script_processor.rb#37
+ def prompt; end
+
+ # source://byebug//lib/byebug/processors/script_processor.rb#17
+ def repl; end
+
+ private
+
+ # source://byebug//lib/byebug/processors/script_processor.rb#43
+ def without_exceptions; end
+end
+
+# Change byebug settings.
+#
+# source://byebug//lib/byebug/commands/set.rb#10
+class Byebug::SetCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/set.rb#42
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/set.rb#66
+ def get_onoff(arg, default); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/set.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/set.rb#38
+ def help; end
+
+ # source://byebug//lib/byebug/commands/set.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/set.rb#34
+ def short_description; end
+ end
+end
+
+# Parent class for all byebug settings.
+#
+# source://byebug//lib/byebug/setting.rb#9
+class Byebug::Setting
+ # @return [Setting] a new instance of Setting
+ #
+ # source://byebug//lib/byebug/setting.rb#14
+ def initialize; end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/setting.rb#18
+ def boolean?; end
+
+ # source://byebug//lib/byebug/setting.rb#28
+ def help; end
+
+ # @return [Boolean]
+ #
+ # source://byebug//lib/byebug/setting.rb#22
+ def integer?; end
+
+ # source://byebug//lib/byebug/setting.rb#37
+ def to_s; end
+
+ # source://byebug//lib/byebug/setting.rb#32
+ def to_sym; end
+
+ # Returns the value of attribute value.
+ #
+ # source://byebug//lib/byebug/setting.rb#10
+ def value; end
+
+ # Sets the attribute value
+ #
+ # @param value the value to set the attribute value to.
+ #
+ # source://byebug//lib/byebug/setting.rb#10
+ def value=(_arg0); end
+
+ class << self
+ # source://byebug//lib/byebug/setting.rb#46
+ def [](name); end
+
+ # source://byebug//lib/byebug/setting.rb#50
+ def []=(name, value); end
+
+ # source://byebug//lib/byebug/setting.rb#54
+ def find(shortcut); end
+
+ # @todo DRY this up. Very similar code exists in the CommandList class
+ #
+ # source://byebug//lib/byebug/setting.rb#65
+ def help_all; end
+
+ # source://byebug//lib/byebug/setting.rb#42
+ def settings; end
+ end
+end
+
+# source://byebug//lib/byebug/setting.rb#12
+Byebug::Setting::DEFAULT = T.let(T.unsafe(nil), FalseClass)
+
+# Show byebug settings.
+#
+# source://byebug//lib/byebug/commands/show.rb#9
+class Byebug::ShowCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/show.rb#35
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/show.rb#17
+ def description; end
+
+ # source://byebug//lib/byebug/commands/show.rb#31
+ def help; end
+
+ # source://byebug//lib/byebug/commands/show.rb#13
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/show.rb#27
+ def short_description; end
+ end
+end
+
+# Allows the user to continue execution until the next breakpoint, as
+# long as it is different from the current one
+#
+# source://byebug//lib/byebug/commands/skip.rb#11
+class Byebug::SkipCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/skip.rb#70
+ def auto_run; end
+
+ # source://byebug//lib/byebug/commands/skip.rb#77
+ def execute; end
+
+ # source://byebug//lib/byebug/commands/skip.rb#53
+ def initialize_attributes; end
+
+ # source://byebug//lib/byebug/commands/skip.rb#60
+ def keep_execution; end
+
+ # source://byebug//lib/byebug/commands/skip.rb#64
+ def reset_attributes; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/skip.rb#41
+ def description; end
+
+ # source://byebug//lib/byebug/commands/skip.rb#18
+ def file_line; end
+
+ # Sets the attribute file_line
+ #
+ # @param value the value to set the attribute file_line to.
+ #
+ # source://byebug//lib/byebug/commands/skip.rb#15
+ def file_line=(_arg0); end
+
+ # source://byebug//lib/byebug/commands/skip.rb#22
+ def file_path; end
+
+ # Sets the attribute file_path
+ #
+ # @param value the value to set the attribute file_path to.
+ #
+ # source://byebug//lib/byebug/commands/skip.rb#15
+ def file_path=(_arg0); end
+
+ # Returns the value of attribute previous_autolist.
+ #
+ # source://byebug//lib/byebug/commands/skip.rb#16
+ def previous_autolist; end
+
+ # source://byebug//lib/byebug/commands/skip.rb#37
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/skip.rb#31
+ def restore_autolist; end
+
+ # source://byebug//lib/byebug/commands/skip.rb#26
+ def setup_autolist(value); end
+
+ # source://byebug//lib/byebug/commands/skip.rb#49
+ def short_description; end
+ end
+end
+
+# Execute a file containing byebug commands.
+#
+# It can be used to restore a previously saved debugging session.
+#
+# source://byebug//lib/byebug/commands/source.rb#11
+class Byebug::SourceCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/source.rb#31
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/source.rb#19
+ def description; end
+
+ # source://byebug//lib/byebug/commands/source.rb#15
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/source.rb#27
+ def short_description; end
+ end
+end
+
+# Formats specific line ranges in a source file
+#
+# source://byebug//lib/byebug/source_file_formatter.rb#10
+class Byebug::SourceFileFormatter
+ include ::Byebug::Helpers::FileHelper
+
+ # @return [SourceFileFormatter] a new instance of SourceFileFormatter
+ #
+ # source://byebug//lib/byebug/source_file_formatter.rb#15
+ def initialize(file, annotator); end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#67
+ def amend(line, ceiling); end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#51
+ def amend_final(line); end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#47
+ def amend_initial(line); end
+
+ # Returns the value of attribute annotator.
+ #
+ # source://byebug//lib/byebug/source_file_formatter.rb#13
+ def annotator; end
+
+ # Returns the value of attribute file.
+ #
+ # source://byebug//lib/byebug/source_file_formatter.rb#13
+ def file; end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#20
+ def lines(min, max); end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#33
+ def lines_around(center); end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#55
+ def max_initial_line; end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#59
+ def max_line; end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#37
+ def range_around(center); end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#41
+ def range_from(min); end
+
+ # source://byebug//lib/byebug/source_file_formatter.rb#63
+ def size; end
+end
+
+# Setting to enable/disable the display of backtraces when evaluations raise
+# errors.
+#
+# source://byebug//lib/byebug/settings/stack_on_error.rb#10
+class Byebug::StackOnErrorSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/stack_on_error.rb#11
+ def banner; end
+end
+
+# Implements the step functionality.
+#
+# Allows the user the continue execution until the next instruction, possibily
+# in a different frame. Use step to step into method calls or blocks.
+#
+# source://byebug//lib/byebug/commands/step.rb#13
+class Byebug::StepCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/step.rb#32
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/step.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/step.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/step.rb#28
+ def short_description; end
+ end
+end
+
+# Subcommand additions.
+#
+# source://byebug//lib/byebug/subcommands.rb#12
+module Byebug::Subcommands
+ extend ::Forwardable
+
+ mixes_in_class_methods ::Byebug::Subcommands::ClassMethods
+
+ # Delegates to subcommands or prints help if no subcommand specified.
+ #
+ # @raise [CommandNotFound]
+ #
+ # source://byebug//lib/byebug/subcommands.rb#23
+ def execute; end
+
+ # source://forwardable/1.3.3/forwardable.rb#231
+ def subcommand_list(*args, **_arg1, &block); end
+
+ class << self
+ # @private
+ #
+ # source://byebug//lib/byebug/subcommands.rb#13
+ def included(command); end
+ end
+end
+
+# Class methods added to subcommands
+#
+# source://byebug//lib/byebug/subcommands.rb#36
+module Byebug::Subcommands::ClassMethods
+ include ::Byebug::Helpers::ReflectionHelper
+
+ # Default help text for a command with subcommands
+ #
+ # source://byebug//lib/byebug/subcommands.rb#42
+ def help; end
+
+ # Command's subcommands.
+ #
+ # source://byebug//lib/byebug/subcommands.rb#49
+ def subcommand_list; end
+end
+
+# Manipulation of Ruby threads
+#
+# source://byebug//lib/byebug/commands/thread/current.rb#9
+class Byebug::ThreadCommand < ::Byebug::Command
+ include ::Byebug::Subcommands
+ extend ::Byebug::Helpers::ReflectionHelper
+ extend ::Byebug::Subcommands::ClassMethods
+
+ class << self
+ # source://byebug//lib/byebug/commands/thread.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/thread.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/thread.rb#30
+ def short_description; end
+ end
+end
+
+# Information about the current thread
+#
+# source://byebug//lib/byebug/commands/thread/current.rb#13
+class Byebug::ThreadCommand::CurrentCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ThreadHelper
+
+ # source://byebug//lib/byebug/commands/thread/current.rb#32
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/thread/current.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/thread/current.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/thread/current.rb#28
+ def short_description; end
+ end
+end
+
+# Information about threads
+#
+# source://byebug//lib/byebug/commands/thread/list.rb#13
+class Byebug::ThreadCommand::ListCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ThreadHelper
+
+ # source://byebug//lib/byebug/commands/thread/list.rb#32
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/thread/list.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/thread/list.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/thread/list.rb#28
+ def short_description; end
+ end
+end
+
+# Resumes the specified thread
+#
+# source://byebug//lib/byebug/commands/thread/resume.rb#13
+class Byebug::ThreadCommand::ResumeCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ThreadHelper
+
+ # source://byebug//lib/byebug/commands/thread/resume.rb#32
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/thread/resume.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/thread/resume.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/thread/resume.rb#28
+ def short_description; end
+ end
+end
+
+# Stops the specified thread
+#
+# source://byebug//lib/byebug/commands/thread/stop.rb#13
+class Byebug::ThreadCommand::StopCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ThreadHelper
+
+ # source://byebug//lib/byebug/commands/thread/stop.rb#32
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/thread/stop.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/thread/stop.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/thread/stop.rb#28
+ def short_description; end
+ end
+end
+
+# Switches to the specified thread
+#
+# source://byebug//lib/byebug/commands/thread/switch.rb#13
+class Byebug::ThreadCommand::SwitchCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ThreadHelper
+
+ # source://byebug//lib/byebug/commands/thread/switch.rb#32
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/thread/switch.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/thread/switch.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/thread/switch.rb#28
+ def short_description; end
+ end
+end
+
+class Byebug::ThreadsTable; end
+
+# Show (and possibily stop) at every line that changes a global variable.
+#
+# source://byebug//lib/byebug/commands/tracevar.rb#9
+class Byebug::TracevarCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/tracevar.rb#32
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/tracevar.rb#48
+ def on_change(name, value, stop); end
+
+ class << self
+ # source://byebug//lib/byebug/commands/tracevar.rb#16
+ def description; end
+
+ # source://byebug//lib/byebug/commands/tracevar.rb#10
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/tracevar.rb#28
+ def short_description; end
+ end
+end
+
+# Remove expressions from display list.
+#
+# source://byebug//lib/byebug/commands/undisplay.rb#10
+class Byebug::UndisplayCommand < ::Byebug::Command
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/undisplay.rb#35
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/undisplay.rb#19
+ def description; end
+
+ # source://byebug//lib/byebug/commands/undisplay.rb#15
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/undisplay.rb#31
+ def short_description; end
+ end
+end
+
+# Stop tracing a global variable.
+#
+# source://byebug//lib/byebug/commands/untracevar.rb#9
+class Byebug::UntracevarCommand < ::Byebug::Command
+ # source://byebug//lib/byebug/commands/untracevar.rb#26
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/untracevar.rb#14
+ def description; end
+
+ # source://byebug//lib/byebug/commands/untracevar.rb#10
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/untracevar.rb#22
+ def short_description; end
+ end
+end
+
+# Move the current frame up in the backtrace.
+#
+# source://byebug//lib/byebug/commands/up.rb#12
+class Byebug::UpCommand < ::Byebug::Command
+ include ::Byebug::Helpers::FrameHelper
+ include ::Byebug::Helpers::ParseHelper
+
+ # source://byebug//lib/byebug/commands/up.rb#36
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/up.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/up.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/up.rb#32
+ def short_description; end
+ end
+end
+
+# Shows variables and its values
+#
+# source://byebug//lib/byebug/commands/var/all.rb#9
+class Byebug::VarCommand < ::Byebug::Command
+ include ::Byebug::Subcommands
+ extend ::Byebug::Helpers::ReflectionHelper
+ extend ::Byebug::Subcommands::ClassMethods
+
+ class << self
+ # source://byebug//lib/byebug/commands/var.rb#25
+ def description; end
+
+ # source://byebug//lib/byebug/commands/var.rb#21
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/var.rb#33
+ def short_description; end
+ end
+end
+
+# Shows global, instance and local variables
+#
+# source://byebug//lib/byebug/commands/var/all.rb#13
+class Byebug::VarCommand::AllCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+ include ::Byebug::Helpers::VarHelper
+
+ # source://byebug//lib/byebug/commands/var/all.rb#34
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/var/all.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/var/all.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/var/all.rb#30
+ def short_description; end
+ end
+end
+
+# Information about arguments of the current method/block
+#
+# source://byebug//lib/byebug/commands/var/args.rb#13
+class Byebug::VarCommand::ArgsCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+ include ::Byebug::Helpers::VarHelper
+
+ # source://byebug//lib/byebug/commands/var/args.rb#34
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/var/args.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/var/args.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/var/args.rb#30
+ def short_description; end
+ end
+end
+
+# Shows constants
+#
+# source://byebug//lib/byebug/commands/var/const.rb#13
+class Byebug::VarCommand::ConstCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+
+ # source://byebug//lib/byebug/commands/var/const.rb#34
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/var/const.rb#44
+ def str_obj; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/var/const.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/var/const.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/var/const.rb#30
+ def short_description; end
+ end
+end
+
+# Shows global variables
+#
+# source://byebug//lib/byebug/commands/var/global.rb#11
+class Byebug::VarCommand::GlobalCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+ include ::Byebug::Helpers::VarHelper
+
+ # source://byebug//lib/byebug/commands/var/global.rb#32
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/var/global.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/var/global.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/var/global.rb#28
+ def short_description; end
+ end
+end
+
+# Shows instance variables
+#
+# source://byebug//lib/byebug/commands/var/instance.rb#13
+class Byebug::VarCommand::InstanceCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+ include ::Byebug::Helpers::VarHelper
+
+ # source://byebug//lib/byebug/commands/var/instance.rb#34
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/var/instance.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/var/instance.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/var/instance.rb#30
+ def short_description; end
+ end
+end
+
+# Shows local variables in current scope
+#
+# source://byebug//lib/byebug/commands/var/local.rb#13
+class Byebug::VarCommand::LocalCommand < ::Byebug::Command
+ include ::Byebug::Helpers::EvalHelper
+ include ::Byebug::Helpers::VarHelper
+
+ # source://byebug//lib/byebug/commands/var/local.rb#34
+ def execute; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/var/local.rb#22
+ def description; end
+
+ # source://byebug//lib/byebug/commands/var/local.rb#18
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/var/local.rb#30
+ def short_description; end
+ end
+end
+
+# Show current backtrace.
+#
+# source://byebug//lib/byebug/commands/where.rb#11
+class Byebug::WhereCommand < ::Byebug::Command
+ include ::Byebug::Helpers::FrameHelper
+
+ # source://byebug//lib/byebug/commands/where.rb#39
+ def execute; end
+
+ private
+
+ # source://byebug//lib/byebug/commands/where.rb#45
+ def print_backtrace; end
+
+ class << self
+ # source://byebug//lib/byebug/commands/where.rb#20
+ def description; end
+
+ # source://byebug//lib/byebug/commands/where.rb#16
+ def regexp; end
+
+ # source://byebug//lib/byebug/commands/where.rb#35
+ def short_description; end
+ end
+end
+
+# Setting to customize the maximum width of byebug's output.
+#
+# source://byebug//lib/byebug/settings/width.rb#9
+class Byebug::WidthSetting < ::Byebug::Setting
+ # source://byebug//lib/byebug/settings/width.rb#12
+ def banner; end
+
+ # source://byebug//lib/byebug/settings/width.rb#16
+ def to_s; end
+end
+
+# source://byebug//lib/byebug/settings/width.rb#10
+Byebug::WidthSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+# Extends the extension class to be able to pass information about the
+# debugging environment from the c-extension to the user.
+#
+# source://byebug//lib/byebug/core.rb#113
+class Exception
+ # Returns the value of attribute __bb_context.
+ #
+ # source://byebug//lib/byebug/core.rb#114
+ def __bb_context; end
+end
+
+# Adds a `byebug` method to the Kernel module.
+#
+# Dropping a `byebug` call anywhere in your code, you get a debug prompt.
+#
+# source://byebug//lib/byebug/attacher.rb#34
+module Kernel
+ # source://byebug//lib/byebug/attacher.rb#35
+ def byebug; end
+
+ # source://byebug//lib/byebug/attacher.rb#35
+ def debugger; end
+
+ # source://byebug//lib/byebug/attacher.rb#41
+ def remote_byebug(host = T.unsafe(nil), port = T.unsafe(nil)); end
+end
diff --git a/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi b/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi
deleted file mode 100644
index 09e7c2582..000000000
--- a/sorbet/rbi/gems/concurrent-ruby@1.1.9.rbi
+++ /dev/null
@@ -1,2401 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `concurrent-ruby` gem.
-# Please instead update this file by running `bin/tapioca gem concurrent-ruby`.
-
-module Concurrent
- extend ::Concurrent::Utility::EngineDetector
- extend ::Concurrent::Utility::NativeExtensionLoader
- extend ::Logger::Severity
- extend ::Concurrent::Concern::Logging
- extend ::Concurrent::Concern::Deprecation
-
- private
-
- def abort_transaction; end
- def atomically; end
- def call_dataflow(method, executor, *inputs, &block); end
- def dataflow(*inputs, &block); end
- def dataflow!(*inputs, &block); end
- def dataflow_with(executor, *inputs, &block); end
- def dataflow_with!(executor, *inputs, &block); end
- def leave_transaction; end
- def monotonic_time; end
-
- class << self
- def abort_transaction; end
- def atomically; end
- def call_dataflow(method, executor, *inputs, &block); end
- def create_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
- def create_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
- def dataflow(*inputs, &block); end
- def dataflow!(*inputs, &block); end
- def dataflow_with(executor, *inputs, &block); end
- def dataflow_with!(executor, *inputs, &block); end
- def disable_at_exit_handlers!; end
- def executor(executor_identifier); end
- def global_fast_executor; end
- def global_immediate_executor; end
- def global_io_executor; end
- def global_logger; end
- def global_logger=(value); end
- def global_timer_set; end
- def leave_transaction; end
- def monotonic_time; end
- def new_fast_executor(opts = T.unsafe(nil)); end
- def new_io_executor(opts = T.unsafe(nil)); end
- def physical_processor_count; end
- def processor_count; end
- def processor_counter; end
- def use_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
- def use_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
- end
-end
-
-class Concurrent::AbstractExchanger < ::Concurrent::Synchronization::Object
- def initialize; end
-
- def exchange(value, timeout = T.unsafe(nil)); end
- def exchange!(value, timeout = T.unsafe(nil)); end
- def try_exchange(value, timeout = T.unsafe(nil)); end
-
- private
-
- def do_exchange(value, timeout); end
-end
-
-Concurrent::AbstractExchanger::CANCEL = T.let(T.unsafe(nil), Object)
-
-class Concurrent::AbstractExecutorService < ::Concurrent::Synchronization::LockableObject
- include ::Logger::Severity
- include ::Concurrent::Concern::Logging
- include ::Concurrent::ExecutorService
- include ::Concurrent::Concern::Deprecation
-
- def initialize(opts = T.unsafe(nil), &block); end
-
- def auto_terminate=(value); end
- def auto_terminate?; end
- def fallback_policy; end
- def kill; end
- def name; end
- def running?; end
- def shutdown; end
- def shutdown?; end
- def shuttingdown?; end
- def to_s; end
- def wait_for_termination(timeout = T.unsafe(nil)); end
-
- private
-
- def handle_fallback(*args); end
- def ns_auto_terminate?; end
- def ns_execute(*args, &task); end
- def ns_kill_execution; end
- def ns_shutdown_execution; end
-end
-
-Concurrent::AbstractExecutorService::FALLBACK_POLICIES = T.let(T.unsafe(nil), Array)
-
-class Concurrent::AbstractThreadLocalVar
- def initialize(default = T.unsafe(nil), &default_block); end
-
- def bind(value, &block); end
- def value; end
- def value=(value); end
-
- protected
-
- def allocate_storage; end
- def default; end
-end
-
-class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject
- include ::Concurrent::Concern::Observable
-
- def initialize(initial, opts = T.unsafe(nil)); end
-
- def <<(action); end
- def await; end
- def await_for(timeout); end
- def await_for!(timeout); end
- def deref; end
- def error; end
- def error_mode; end
- def failed?; end
- def post(*args, &action); end
- def reason; end
- def restart(new_value, opts = T.unsafe(nil)); end
- def send(*args, &action); end
- def send!(*args, &action); end
- def send_off(*args, &action); end
- def send_off!(*args, &action); end
- def send_via(executor, *args, &action); end
- def send_via!(executor, *args, &action); end
- def stopped?; end
- def value; end
- def wait(timeout = T.unsafe(nil)); end
-
- private
-
- def enqueue_action_job(action, args, executor); end
- def enqueue_await_job(latch); end
- def execute_next_job; end
- def handle_error(error); end
- def ns_enqueue_job(job, index = T.unsafe(nil)); end
- def ns_find_last_job_for_thread; end
- def ns_initialize(initial, opts); end
- def ns_post_next_job; end
- def ns_validate(value); end
-
- class << self
- def await(*agents); end
- def await_for(timeout, *agents); end
- def await_for!(timeout, *agents); end
- end
-end
-
-Concurrent::Agent::AWAIT_ACTION = T.let(T.unsafe(nil), Proc)
-Concurrent::Agent::AWAIT_FLAG = T.let(T.unsafe(nil), Object)
-Concurrent::Agent::DEFAULT_ERROR_HANDLER = T.let(T.unsafe(nil), Proc)
-Concurrent::Agent::DEFAULT_VALIDATOR = T.let(T.unsafe(nil), Proc)
-Concurrent::Agent::ERROR_MODES = T.let(T.unsafe(nil), Array)
-
-class Concurrent::Agent::Error < ::StandardError
- def initialize(message = T.unsafe(nil)); end
-end
-
-class Concurrent::Agent::Job < ::Struct
- def action; end
- def action=(_); end
- def args; end
- def args=(_); end
- def caller; end
- def caller=(_); end
- def executor; end
- def executor=(_); end
-
- class << self
- def [](*_arg0); end
- def inspect; end
- def members; end
- def new(*_arg0); end
- end
-end
-
-class Concurrent::Agent::ValidationError < ::Concurrent::Agent::Error
- def initialize(message = T.unsafe(nil)); end
-end
-
-class Concurrent::Array < ::Array; end
-Concurrent::ArrayImplementation = Array
-
-module Concurrent::Async
- mixes_in_class_methods ::Concurrent::Async::ClassMethods
-
- def async; end
- def await; end
- def call; end
- def cast; end
- def init_synchronization; end
-
- class << self
- def included(base); end
- def validate_argc(obj, method, *args); end
- end
-end
-
-class Concurrent::Async::AsyncDelegator < ::Concurrent::Synchronization::LockableObject
- def initialize(delegate); end
-
- def method_missing(method, *args, &block); end
- def perform; end
- def reset_if_forked; end
-
- private
-
- def respond_to_missing?(method, include_private = T.unsafe(nil)); end
-end
-
-class Concurrent::Async::AwaitDelegator
- def initialize(delegate); end
-
- def method_missing(method, *args, &block); end
-
- private
-
- def respond_to_missing?(method, include_private = T.unsafe(nil)); end
-end
-
-module Concurrent::Async::ClassMethods
- def new(*args, &block); end
-end
-
-class Concurrent::Atom < ::Concurrent::Synchronization::Object
- include ::Concurrent::Concern::Observable
-
- def initialize(value, opts = T.unsafe(nil)); end
-
- def __initialize_atomic_fields__; end
- def compare_and_set(old_value, new_value); end
- def deref; end
- def reset(new_value); end
- def swap(*args); end
- def value; end
-
- private
-
- def compare_and_set_value(expected, value); end
- def swap_value(value); end
- def update_value(&block); end
- def valid?(new_value); end
- def value=(value); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-class Concurrent::AtomicBoolean < ::Concurrent::MutexAtomicBoolean
- def inspect; end
- def to_s; end
-end
-
-Concurrent::AtomicBooleanImplementation = Concurrent::MutexAtomicBoolean
-
-module Concurrent::AtomicDirectUpdate
- def try_update; end
- def try_update!; end
- def update; end
-end
-
-class Concurrent::AtomicFixnum < ::Concurrent::MutexAtomicFixnum
- def inspect; end
- def to_s; end
-end
-
-Concurrent::AtomicFixnumImplementation = Concurrent::MutexAtomicFixnum
-
-class Concurrent::AtomicMarkableReference < ::Concurrent::Synchronization::Object
- def initialize(value = T.unsafe(nil), mark = T.unsafe(nil)); end
-
- def __initialize_atomic_fields__; end
- def compare_and_set(expected_val, new_val, expected_mark, new_mark); end
- def compare_and_swap(expected_val, new_val, expected_mark, new_mark); end
- def get; end
- def mark; end
- def marked?; end
- def set(new_val, new_mark); end
- def try_update; end
- def try_update!; end
- def update; end
- def value; end
-
- private
-
- def compare_and_set_reference(expected, value); end
- def immutable_array(*args); end
- def reference; end
- def reference=(value); end
- def swap_reference(value); end
- def update_reference(&block); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-module Concurrent::AtomicNumericCompareAndSetWrapper
- def compare_and_set(old_value, new_value); end
-end
-
-class Concurrent::AtomicReference < ::Concurrent::MutexAtomicReference
- def inspect; end
- def to_s; end
-end
-
-Concurrent::AtomicReferenceImplementation = Concurrent::MutexAtomicReference
-
-class Concurrent::CRubySet < ::Set
- def initialize(*args, &block); end
-
- def &(*args); end
- def +(*args); end
- def -(*args); end
- def <(*args); end
- def <<(*args); end
- def <=(*args); end
- def ==(*args); end
- def ===(*args); end
- def >(*args); end
- def >=(*args); end
- def ^(*args); end
- def add(*args); end
- def add?(*args); end
- def classify(*args); end
- def clear(*args); end
- def collect!(*args); end
- def compare_by_identity(*args); end
- def compare_by_identity?(*args); end
- def delete(*args); end
- def delete?(*args); end
- def delete_if(*args); end
- def difference(*args); end
- def disjoint?(*args); end
- def divide(*args); end
- def each(*args); end
- def empty?(*args); end
- def eql?(*args); end
- def filter!(*args); end
- def flatten(*args); end
- def flatten!(*args); end
- def flatten_merge(*args); end
- def freeze(*args); end
- def hash(*args); end
- def include?(*args); end
- def inspect(*args); end
- def intersect?(*args); end
- def intersection(*args); end
- def keep_if(*args); end
- def length(*args); end
- def map!(*args); end
- def member?(*args); end
- def merge(*args); end
- def pretty_print(*args); end
- def pretty_print_cycle(*args); end
- def proper_subset?(*args); end
- def proper_superset?(*args); end
- def reject!(*args); end
- def replace(*args); end
- def reset(*args); end
- def select!(*args); end
- def size(*args); end
- def subset?(*args); end
- def subtract(*args); end
- def superset?(*args); end
- def to_a(*args); end
- def to_s(*args); end
- def to_set(*args); end
- def union(*args); end
- def |(*args); end
-
- private
-
- def initialize_copy(other); end
-end
-
-class Concurrent::CachedThreadPool < ::Concurrent::ThreadPoolExecutor
- def initialize(opts = T.unsafe(nil)); end
-
- private
-
- def ns_initialize(opts); end
-end
-
-class Concurrent::CancelledOperationError < ::Concurrent::Error; end
-module Concurrent::Collection; end
-
-class Concurrent::Collection::CopyOnNotifyObserverSet < ::Concurrent::Synchronization::LockableObject
- def initialize; end
-
- def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
- def count_observers; end
- def delete_observer(observer); end
- def delete_observers; end
- def notify_and_delete_observers(*args, &block); end
- def notify_observers(*args, &block); end
-
- protected
-
- def ns_initialize; end
-
- private
-
- def duplicate_and_clear_observers; end
- def duplicate_observers; end
- def notify_to(observers, *args); end
-end
-
-class Concurrent::Collection::CopyOnWriteObserverSet < ::Concurrent::Synchronization::LockableObject
- def initialize; end
-
- def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
- def count_observers; end
- def delete_observer(observer); end
- def delete_observers; end
- def notify_and_delete_observers(*args, &block); end
- def notify_observers(*args, &block); end
-
- protected
-
- def ns_initialize; end
-
- private
-
- def clear_observers_and_return_old; end
- def notify_to(observers, *args); end
- def observers; end
- def observers=(new_set); end
-end
-
-Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend
-
-class Concurrent::Collection::MriMapBackend < ::Concurrent::Collection::NonConcurrentMapBackend
- def initialize(options = T.unsafe(nil)); end
-
- def []=(key, value); end
- def clear; end
- def compute(key); end
- def compute_if_absent(key); end
- def compute_if_present(key); end
- def delete(key); end
- def delete_pair(key, value); end
- def get_and_set(key, value); end
- def merge_pair(key, value); end
- def replace_if_exists(key, new_value); end
- def replace_pair(key, old_value, new_value); end
-end
-
-class Concurrent::Collection::NonConcurrentMapBackend
- def initialize(options = T.unsafe(nil)); end
-
- def [](key); end
- def []=(key, value); end
- def clear; end
- def compute(key); end
- def compute_if_absent(key); end
- def compute_if_present(key); end
- def delete(key); end
- def delete_pair(key, value); end
- def each_pair; end
- def get_and_set(key, value); end
- def get_or_default(key, default_value); end
- def key?(key); end
- def merge_pair(key, value); end
- def replace_if_exists(key, new_value); end
- def replace_pair(key, old_value, new_value); end
- def size; end
-
- private
-
- def _get(key); end
- def _set(key, value); end
- def dupped_backend; end
- def initialize_copy(other); end
- def pair?(key, expected_value); end
- def store_computed_value(key, new_value); end
-end
-
-class Concurrent::Collection::NonConcurrentPriorityQueue < ::Concurrent::Collection::RubyNonConcurrentPriorityQueue
- def <<(item); end
- def deq; end
- def enq(item); end
- def has_priority?(item); end
- def shift; end
- def size; end
-end
-
-Concurrent::Collection::NonConcurrentPriorityQueueImplementation = Concurrent::Collection::RubyNonConcurrentPriorityQueue
-
-class Concurrent::Collection::RubyNonConcurrentPriorityQueue
- def initialize(opts = T.unsafe(nil)); end
-
- def <<(item); end
- def clear; end
- def delete(item); end
- def deq; end
- def empty?; end
- def enq(item); end
- def has_priority?(item); end
- def include?(item); end
- def length; end
- def peek; end
- def pop; end
- def push(item); end
- def shift; end
- def size; end
-
- private
-
- def ordered?(x, y); end
- def sink(k); end
- def swap(x, y); end
- def swim(k); end
-
- class << self
- def from_list(list, opts = T.unsafe(nil)); end
- end
-end
-
-module Concurrent::Concern; end
-
-module Concurrent::Concern::Deprecation
- include ::Logger::Severity
- include ::Concurrent::Concern::Logging
- extend ::Logger::Severity
- extend ::Concurrent::Concern::Logging
- extend ::Concurrent::Concern::Deprecation
-
- def deprecated(message, strip = T.unsafe(nil)); end
- def deprecated_method(old_name, new_name); end
-end
-
-module Concurrent::Concern::Dereferenceable
- def deref; end
- def value; end
-
- protected
-
- def apply_deref_options(value); end
- def ns_set_deref_options(opts); end
- def set_deref_options(opts = T.unsafe(nil)); end
- def value=(value); end
-end
-
-module Concurrent::Concern::Logging
- include ::Logger::Severity
-
- def log(level, progname, message = T.unsafe(nil), &block); end
-end
-
-module Concurrent::Concern::Obligation
- include ::Concurrent::Concern::Dereferenceable
-
- def complete?; end
- def exception(*args); end
- def fulfilled?; end
- def incomplete?; end
- def no_error!(timeout = T.unsafe(nil)); end
- def pending?; end
- def realized?; end
- def reason; end
- def rejected?; end
- def state; end
- def unscheduled?; end
- def value(timeout = T.unsafe(nil)); end
- def value!(timeout = T.unsafe(nil)); end
- def wait(timeout = T.unsafe(nil)); end
- def wait!(timeout = T.unsafe(nil)); end
-
- protected
-
- def compare_and_set_state(next_state, *expected_current); end
- def event; end
- def get_arguments_from(opts = T.unsafe(nil)); end
- def if_state(*expected_states); end
- def init_obligation; end
- def ns_check_state?(expected); end
- def ns_set_state(value); end
- def set_state(success, value, reason); end
- def state=(value); end
-end
-
-module Concurrent::Concern::Observable
- def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
- def count_observers; end
- def delete_observer(observer); end
- def delete_observers; end
- def with_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
-
- protected
-
- def observers; end
- def observers=(_arg0); end
-end
-
-class Concurrent::ConcurrentUpdateError < ::ThreadError; end
-Concurrent::ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE = T.let(T.unsafe(nil), Array)
-class Concurrent::ConfigurationError < ::Concurrent::Error; end
-class Concurrent::CountDownLatch < ::Concurrent::MutexCountDownLatch; end
-Concurrent::CountDownLatchImplementation = Concurrent::MutexCountDownLatch
-
-class Concurrent::CyclicBarrier < ::Concurrent::Synchronization::LockableObject
- def initialize(parties, &block); end
-
- def broken?; end
- def number_waiting; end
- def parties; end
- def reset; end
- def wait(timeout = T.unsafe(nil)); end
-
- protected
-
- def ns_generation_done(generation, status, continue = T.unsafe(nil)); end
- def ns_initialize(parties, &block); end
- def ns_next_generation; end
-end
-
-class Concurrent::CyclicBarrier::Generation < ::Struct
- def status; end
- def status=(_); end
-
- class << self
- def [](*_arg0); end
- def inspect; end
- def members; end
- def new(*_arg0); end
- end
-end
-
-class Concurrent::Delay < ::Concurrent::Synchronization::LockableObject
- include ::Concurrent::Concern::Dereferenceable
- include ::Concurrent::Concern::Obligation
-
- def initialize(opts = T.unsafe(nil), &block); end
-
- def reconfigure(&block); end
- def value(timeout = T.unsafe(nil)); end
- def value!(timeout = T.unsafe(nil)); end
- def wait(timeout = T.unsafe(nil)); end
-
- protected
-
- def ns_initialize(opts, &block); end
-
- private
-
- def execute_task_once; end
-end
-
-class Concurrent::DependencyCounter
- def initialize(count, &block); end
-
- def update(time, value, reason); end
-end
-
-class Concurrent::Error < ::StandardError; end
-
-class Concurrent::Event < ::Concurrent::Synchronization::LockableObject
- def initialize; end
-
- def reset; end
- def set; end
- def set?; end
- def try?; end
- def wait(timeout = T.unsafe(nil)); end
-
- protected
-
- def ns_initialize; end
- def ns_set; end
-end
-
-class Concurrent::Exchanger < ::Concurrent::RubyExchanger; end
-Concurrent::ExchangerImplementation = Concurrent::RubyExchanger
-
-module Concurrent::ExecutorService
- include ::Logger::Severity
- include ::Concurrent::Concern::Logging
-
- def <<(task); end
- def can_overflow?; end
- def post(*args, &task); end
- def serialized?; end
-end
-
-class Concurrent::FixedThreadPool < ::Concurrent::ThreadPoolExecutor
- def initialize(num_threads, opts = T.unsafe(nil)); end
-end
-
-class Concurrent::Future < ::Concurrent::IVar
- def initialize(opts = T.unsafe(nil), &block); end
-
- def cancel; end
- def cancelled?; end
- def execute; end
- def set(value = T.unsafe(nil), &block); end
- def wait_or_cancel(timeout); end
-
- protected
-
- def ns_initialize(value, opts); end
-
- class << self
- def execute(opts = T.unsafe(nil), &block); end
- end
-end
-
-Concurrent::GLOBAL_FAST_EXECUTOR = T.let(T.unsafe(nil), Concurrent::Delay)
-Concurrent::GLOBAL_IMMEDIATE_EXECUTOR = T.let(T.unsafe(nil), Concurrent::ImmediateExecutor)
-Concurrent::GLOBAL_IO_EXECUTOR = T.let(T.unsafe(nil), Concurrent::Delay)
-Concurrent::GLOBAL_LOGGER = T.let(T.unsafe(nil), Concurrent::AtomicReference)
-Concurrent::GLOBAL_MONOTONIC_CLOCK = T.let(T.unsafe(nil), T.untyped)
-Concurrent::GLOBAL_TIMER_SET = T.let(T.unsafe(nil), Concurrent::Delay)
-class Concurrent::Hash < ::Hash; end
-Concurrent::HashImplementation = Hash
-
-class Concurrent::IVar < ::Concurrent::Synchronization::LockableObject
- include ::Concurrent::Concern::Dereferenceable
- include ::Concurrent::Concern::Obligation
- include ::Concurrent::Concern::Observable
-
- def initialize(value = T.unsafe(nil), opts = T.unsafe(nil), &block); end
-
- def add_observer(observer = T.unsafe(nil), func = T.unsafe(nil), &block); end
- def fail(reason = T.unsafe(nil)); end
- def set(value = T.unsafe(nil)); end
- def try_set(value = T.unsafe(nil), &block); end
-
- protected
-
- def check_for_block_or_value!(block_given, value); end
- def complete(success, value, reason); end
- def complete_without_notification(success, value, reason); end
- def notify_observers(value, reason); end
- def ns_complete_without_notification(success, value, reason); end
- def ns_initialize(value, opts); end
- def safe_execute(task, args = T.unsafe(nil)); end
-end
-
-class Concurrent::IllegalOperationError < ::Concurrent::Error; end
-
-class Concurrent::ImmediateExecutor < ::Concurrent::AbstractExecutorService
- include ::Concurrent::SerialExecutorService
-
- def initialize; end
-
- def <<(task); end
- def kill; end
- def post(*args, &task); end
- def running?; end
- def shutdown; end
- def shutdown?; end
- def shuttingdown?; end
- def wait_for_termination(timeout = T.unsafe(nil)); end
-end
-
-class Concurrent::ImmutabilityError < ::Concurrent::Error; end
-
-module Concurrent::ImmutableStruct
- include ::Concurrent::Synchronization::AbstractStruct
-
- def ==(other); end
- def [](member); end
- def each(&block); end
- def each_pair(&block); end
- def inspect; end
- def merge(other, &block); end
- def select(&block); end
- def to_a; end
- def to_h; end
- def to_s; end
- def values; end
- def values_at(*indexes); end
-
- private
-
- def initialize_copy(original); end
-
- class << self
- def included(base); end
- def new(*args, &block); end
- end
-end
-
-Concurrent::ImmutableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
-
-class Concurrent::IndirectImmediateExecutor < ::Concurrent::ImmediateExecutor
- def initialize; end
-
- def post(*args, &task); end
-end
-
-class Concurrent::InitializationError < ::Concurrent::Error; end
-class Concurrent::LifecycleError < ::Concurrent::Error; end
-
-class Concurrent::LockFreeStack < ::Concurrent::Synchronization::Object
- include ::Enumerable
-
- def initialize(head = T.unsafe(nil)); end
-
- def __initialize_atomic_fields__; end
- def clear; end
- def clear_each(&block); end
- def clear_if(head); end
- def compare_and_clear(head); end
- def compare_and_pop(head); end
- def compare_and_push(head, value); end
- def each(head = T.unsafe(nil)); end
- def empty?(head = T.unsafe(nil)); end
- def inspect; end
- def peek; end
- def pop; end
- def push(value); end
- def replace_if(head, new_head); end
- def to_s; end
-
- private
-
- def compare_and_set_head(expected, value); end
- def head; end
- def head=(value); end
- def swap_head(value); end
- def update_head(&block); end
-
- class << self
- def new(*args, &block); end
- def of1(value); end
- def of2(value1, value2); end
- end
-end
-
-Concurrent::LockFreeStack::EMPTY = T.let(T.unsafe(nil), Concurrent::LockFreeStack::Node)
-
-class Concurrent::LockFreeStack::Node
- def initialize(value, next_node); end
-
- def next_node; end
- def value; end
- def value=(_arg0); end
-
- class << self
- def [](*_arg0); end
- end
-end
-
-class Concurrent::MVar < ::Concurrent::Synchronization::Object
- include ::Concurrent::Concern::Dereferenceable
-
- def initialize(value = T.unsafe(nil), opts = T.unsafe(nil)); end
-
- def borrow(timeout = T.unsafe(nil)); end
- def empty?; end
- def full?; end
- def modify(timeout = T.unsafe(nil)); end
- def modify!; end
- def put(value, timeout = T.unsafe(nil)); end
- def set!(value); end
- def take(timeout = T.unsafe(nil)); end
- def try_put!(value); end
- def try_take!; end
-
- protected
-
- def synchronize(&block); end
-
- private
-
- def unlocked_empty?; end
- def unlocked_full?; end
- def wait_for_empty(timeout); end
- def wait_for_full(timeout); end
- def wait_while(condition, timeout); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-Concurrent::MVar::EMPTY = T.let(T.unsafe(nil), Object)
-Concurrent::MVar::TIMEOUT = T.let(T.unsafe(nil), Object)
-
-class Concurrent::Map < ::Concurrent::Collection::MriMapBackend
- def initialize(options = T.unsafe(nil), &block); end
-
- def [](key); end
- def []=(key, value); end
- def each; end
- def each_key; end
- def each_pair; end
- def each_value; end
- def empty?; end
- def fetch(key, default_value = T.unsafe(nil)); end
- def fetch_or_store(key, default_value = T.unsafe(nil)); end
- def get(key); end
- def inspect; end
- def key(value); end
- def keys; end
- def marshal_dump; end
- def marshal_load(hash); end
- def put(key, value); end
- def put_if_absent(key, value); end
- def value?(value); end
- def values; end
-
- private
-
- def initialize_copy(other); end
- def populate_from(hash); end
- def raise_fetch_no_key; end
- def validate_options_hash!(options); end
-end
-
-class Concurrent::MaxRestartFrequencyError < ::Concurrent::Error; end
-
-class Concurrent::Maybe < ::Concurrent::Synchronization::Object
- include ::Comparable
-
- def initialize(just, nothing); end
-
- def <=>(other); end
- def fulfilled?; end
- def just; end
- def just?; end
- def nothing; end
- def nothing?; end
- def or(other); end
- def reason; end
- def rejected?; end
- def value; end
-
- class << self
- def from(*args); end
- def just(value); end
- def nothing(error = T.unsafe(nil)); end
-
- private
-
- def new(*args, &block); end
- end
-end
-
-Concurrent::Maybe::NONE = T.let(T.unsafe(nil), Object)
-
-class Concurrent::MultipleAssignmentError < ::Concurrent::Error
- def initialize(message = T.unsafe(nil), inspection_data = T.unsafe(nil)); end
-
- def inspect; end
- def inspection_data; end
-end
-
-class Concurrent::MultipleErrors < ::Concurrent::Error
- def initialize(errors, message = T.unsafe(nil)); end
-
- def errors; end
-end
-
-module Concurrent::MutableStruct
- include ::Concurrent::Synchronization::AbstractStruct
-
- def ==(other); end
- def [](member); end
- def []=(member, value); end
- def each(&block); end
- def each_pair(&block); end
- def inspect; end
- def merge(other, &block); end
- def select(&block); end
- def to_a; end
- def to_h; end
- def to_s; end
- def values; end
- def values_at(*indexes); end
-
- private
-
- def initialize_copy(original); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-Concurrent::MutableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
-
-class Concurrent::MutexAtomicBoolean < ::Concurrent::Synchronization::LockableObject
- def initialize(initial = T.unsafe(nil)); end
-
- def false?; end
- def make_false; end
- def make_true; end
- def true?; end
- def value; end
- def value=(value); end
-
- protected
-
- def ns_initialize(initial); end
-
- private
-
- def ns_make_value(value); end
-end
-
-class Concurrent::MutexAtomicFixnum < ::Concurrent::Synchronization::LockableObject
- def initialize(initial = T.unsafe(nil)); end
-
- def compare_and_set(expect, update); end
- def decrement(delta = T.unsafe(nil)); end
- def down(delta = T.unsafe(nil)); end
- def increment(delta = T.unsafe(nil)); end
- def up(delta = T.unsafe(nil)); end
- def update; end
- def value; end
- def value=(value); end
-
- protected
-
- def ns_initialize(initial); end
-
- private
-
- def ns_set(value); end
-end
-
-class Concurrent::MutexAtomicReference < ::Concurrent::Synchronization::LockableObject
- include ::Concurrent::AtomicDirectUpdate
- include ::Concurrent::AtomicNumericCompareAndSetWrapper
-
- def initialize(value = T.unsafe(nil)); end
-
- def _compare_and_set(old_value, new_value); end
- def compare_and_swap(old_value, new_value); end
- def get; end
- def get_and_set(new_value); end
- def set(new_value); end
- def swap(new_value); end
- def value; end
- def value=(new_value); end
-
- protected
-
- def ns_initialize(value); end
-end
-
-class Concurrent::MutexCountDownLatch < ::Concurrent::Synchronization::LockableObject
- def initialize(count = T.unsafe(nil)); end
-
- def count; end
- def count_down; end
- def wait(timeout = T.unsafe(nil)); end
-
- protected
-
- def ns_initialize(count); end
-end
-
-class Concurrent::MutexSemaphore < ::Concurrent::Synchronization::LockableObject
- def initialize(count); end
-
- def acquire(permits = T.unsafe(nil)); end
- def available_permits; end
- def drain_permits; end
- def reduce_permits(reduction); end
- def release(permits = T.unsafe(nil)); end
- def try_acquire(permits = T.unsafe(nil), timeout = T.unsafe(nil)); end
-
- protected
-
- def ns_initialize(count); end
-
- private
-
- def try_acquire_now(permits); end
- def try_acquire_timed(permits, timeout); end
-end
-
-Concurrent::NULL = T.let(T.unsafe(nil), Object)
-Concurrent::NULL_LOGGER = T.let(T.unsafe(nil), Proc)
-
-module Concurrent::Options
- class << self
- def executor(executor_identifier); end
- def executor_from_options(opts = T.unsafe(nil)); end
- end
-end
-
-class Concurrent::Promise < ::Concurrent::IVar
- def initialize(opts = T.unsafe(nil), &block); end
-
- def catch(&block); end
- def execute; end
- def fail(reason = T.unsafe(nil)); end
- def flat_map(&block); end
- def on_error(&block); end
- def on_success(&block); end
- def rescue(&block); end
- def set(value = T.unsafe(nil), &block); end
- def then(*args, &block); end
- def zip(*others); end
-
- protected
-
- def complete(success, value, reason); end
- def notify_child(child); end
- def ns_initialize(value, opts); end
- def on_fulfill(result); end
- def on_reject(reason); end
- def realize(task); end
- def root?; end
- def set_pending; end
- def set_state!(success, value, reason); end
- def synchronized_set_state!(success, value, reason); end
-
- class << self
- def aggregate(method, *promises); end
- def all?(*promises); end
- def any?(*promises); end
- def execute(opts = T.unsafe(nil), &block); end
- def fulfill(value, opts = T.unsafe(nil)); end
- def reject(reason, opts = T.unsafe(nil)); end
- def zip(*promises); end
- end
-end
-
-class Concurrent::PromiseExecutionError < ::StandardError; end
-
-module Concurrent::Promises
- extend ::Concurrent::Promises::FactoryMethods::Configuration
- extend ::Concurrent::Promises::FactoryMethods
-end
-
-class Concurrent::Promises::AbstractAnyPromise < ::Concurrent::Promises::BlockedPromise; end
-
-class Concurrent::Promises::AbstractEventFuture < ::Concurrent::Synchronization::Object
- include ::Concurrent::Promises::InternalStates
-
- def initialize(promise, default_executor); end
-
- def __initialize_atomic_fields__; end
- def add_callback_clear_delayed_node(node); end
- def add_callback_notify_blocked(promise, index); end
- def blocks; end
- def callbacks; end
- def chain(*args, &task); end
- def chain_on(executor, *args, &task); end
- def chain_resolvable(resolvable); end
- def default_executor; end
- def inspect; end
- def internal_state; end
- def on_resolution(*args, &callback); end
- def on_resolution!(*args, &callback); end
- def on_resolution_using(executor, *args, &callback); end
- def pending?; end
- def promise; end
- def resolve_with(state, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
- def resolved?; end
- def state; end
- def tangle(resolvable); end
- def to_s; end
- def touch; end
- def touched?; end
- def wait(timeout = T.unsafe(nil)); end
- def waiting_threads; end
- def with_default_executor(executor); end
- def with_hidden_resolvable; end
-
- private
-
- def add_callback(method, *args); end
- def async_callback_on_resolution(state, executor, args, callback); end
- def call_callback(method, state, args); end
- def call_callbacks(state); end
- def callback_clear_delayed_node(state, node); end
- def callback_notify_blocked(state, promise, index); end
- def compare_and_set_internal_state(expected, value); end
- def internal_state=(value); end
- def swap_internal_state(value); end
- def update_internal_state(&block); end
- def wait_until_resolved(timeout); end
- def with_async(executor, *args, &block); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-class Concurrent::Promises::AbstractFlatPromise < ::Concurrent::Promises::BlockedPromise
- def initialize(delayed_because, blockers_count, event_or_future); end
-
- def touch; end
-
- private
-
- def add_delayed_of(future); end
- def on_resolvable(resolved_future, index); end
- def resolvable?(countdown, future, index); end
- def touched?; end
-end
-
-class Concurrent::Promises::AbstractPromise < ::Concurrent::Synchronization::Object
- include ::Concurrent::Promises::InternalStates
-
- def initialize(future); end
-
- def default_executor; end
- def delayed_because; end
- def event; end
- def future; end
- def inspect; end
- def state; end
- def to_s; end
- def touch; end
-
- private
-
- def evaluate_to(*args, block); end
- def resolve_with(new_state, raise_on_reassign = T.unsafe(nil)); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-class Concurrent::Promises::AnyFulfilledFuturePromise < ::Concurrent::Promises::AnyResolvedFuturePromise
- private
-
- def resolvable?(countdown, future, index); end
-end
-
-class Concurrent::Promises::AnyResolvedEventPromise < ::Concurrent::Promises::AbstractAnyPromise
- def initialize(delayed, blockers_count, default_executor); end
-
- private
-
- def on_resolvable(resolved_future, index); end
- def resolvable?(countdown, future, index); end
-end
-
-class Concurrent::Promises::AnyResolvedFuturePromise < ::Concurrent::Promises::AbstractAnyPromise
- def initialize(delayed, blockers_count, default_executor); end
-
- private
-
- def on_resolvable(resolved_future, index); end
- def resolvable?(countdown, future, index); end
-end
-
-class Concurrent::Promises::BlockedPromise < ::Concurrent::Promises::InnerPromise
- def initialize(delayed, blockers_count, future); end
-
- def blocked_by; end
- def delayed_because; end
- def on_blocker_resolution(future, index); end
- def touch; end
-
- private
-
- def clear_and_propagate_touch(stack_or_element = T.unsafe(nil)); end
- def on_resolvable(resolved_future, index); end
- def process_on_blocker_resolution(future, index); end
- def resolvable?(countdown, future, index); end
-
- class << self
- def add_delayed(delayed1, delayed2); end
- def new_blocked_by(blockers, *args, &block); end
- def new_blocked_by1(blocker, *args, &block); end
- def new_blocked_by2(blocker1, blocker2, *args, &block); end
- end
-end
-
-class Concurrent::Promises::BlockedTaskPromise < ::Concurrent::Promises::BlockedPromise
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
-
- def executor; end
-end
-
-class Concurrent::Promises::ChainPromise < ::Concurrent::Promises::BlockedTaskPromise
- private
-
- def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::DelayPromise < ::Concurrent::Promises::InnerPromise
- def initialize(default_executor); end
-
- def delayed_because; end
- def touch; end
-end
-
-class Concurrent::Promises::Event < ::Concurrent::Promises::AbstractEventFuture
- def &(other); end
- def any(event_or_future); end
- def delay; end
- def schedule(intended_time); end
- def then(*args, &task); end
- def to_event; end
- def to_future; end
- def with_default_executor(executor); end
- def zip(other); end
- def |(event_or_future); end
-
- private
-
- def callback_on_resolution(state, args, callback); end
- def rejected_resolution(raise_on_reassign, state); end
-end
-
-class Concurrent::Promises::EventWrapperPromise < ::Concurrent::Promises::BlockedPromise
- def initialize(delayed, blockers_count, default_executor); end
-
- private
-
- def on_resolvable(resolved_future, index); end
-end
-
-module Concurrent::Promises::FactoryMethods
- include ::Concurrent::Promises::FactoryMethods::Configuration
- extend ::Concurrent::ReInclude
- extend ::Concurrent::Promises::FactoryMethods
- extend ::Concurrent::Promises::FactoryMethods::Configuration
-
- def any(*futures_and_or_events); end
- def any_event(*futures_and_or_events); end
- def any_event_on(default_executor, *futures_and_or_events); end
- def any_fulfilled_future(*futures_and_or_events); end
- def any_fulfilled_future_on(default_executor, *futures_and_or_events); end
- def any_resolved_future(*futures_and_or_events); end
- def any_resolved_future_on(default_executor, *futures_and_or_events); end
- def delay(*args, &task); end
- def delay_on(default_executor, *args, &task); end
- def fulfilled_future(value, default_executor = T.unsafe(nil)); end
- def future(*args, &task); end
- def future_on(default_executor, *args, &task); end
- def make_future(argument = T.unsafe(nil), default_executor = T.unsafe(nil)); end
- def rejected_future(reason, default_executor = T.unsafe(nil)); end
- def resolvable_event; end
- def resolvable_event_on(default_executor = T.unsafe(nil)); end
- def resolvable_future; end
- def resolvable_future_on(default_executor = T.unsafe(nil)); end
- def resolved_event(default_executor = T.unsafe(nil)); end
- def resolved_future(fulfilled, value, reason, default_executor = T.unsafe(nil)); end
- def schedule(intended_time, *args, &task); end
- def schedule_on(default_executor, intended_time, *args, &task); end
- def zip(*futures_and_or_events); end
- def zip_events(*futures_and_or_events); end
- def zip_events_on(default_executor, *futures_and_or_events); end
- def zip_futures(*futures_and_or_events); end
- def zip_futures_on(default_executor, *futures_and_or_events); end
-end
-
-module Concurrent::Promises::FactoryMethods::Configuration
- def default_executor; end
-end
-
-class Concurrent::Promises::FlatEventPromise < ::Concurrent::Promises::AbstractFlatPromise
- def initialize(delayed, blockers_count, default_executor); end
-
- private
-
- def process_on_blocker_resolution(future, index); end
-end
-
-class Concurrent::Promises::FlatFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
- def initialize(delayed, blockers_count, levels, default_executor); end
-
- private
-
- def process_on_blocker_resolution(future, index); end
-end
-
-class Concurrent::Promises::Future < ::Concurrent::Promises::AbstractEventFuture
- def &(other); end
- def any(event_or_future); end
- def apply(args, block); end
- def delay; end
- def exception(*args); end
- def flat(level = T.unsafe(nil)); end
- def flat_event; end
- def flat_future(level = T.unsafe(nil)); end
- def fulfilled?; end
- def inspect; end
- def on_fulfillment(*args, &callback); end
- def on_fulfillment!(*args, &callback); end
- def on_fulfillment_using(executor, *args, &callback); end
- def on_rejection(*args, &callback); end
- def on_rejection!(*args, &callback); end
- def on_rejection_using(executor, *args, &callback); end
- def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
- def rejected?; end
- def rescue(*args, &task); end
- def rescue_on(executor, *args, &task); end
- def result(timeout = T.unsafe(nil)); end
- def run(run_test = T.unsafe(nil)); end
- def schedule(intended_time); end
- def then(*args, &task); end
- def then_on(executor, *args, &task); end
- def to_event; end
- def to_future; end
- def to_s; end
- def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
- def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil)); end
- def wait!(timeout = T.unsafe(nil)); end
- def with_default_executor(executor); end
- def zip(other); end
- def |(event_or_future); end
-
- private
-
- def async_callback_on_fulfillment(state, executor, args, callback); end
- def async_callback_on_rejection(state, executor, args, callback); end
- def callback_on_fulfillment(state, args, callback); end
- def callback_on_rejection(state, args, callback); end
- def callback_on_resolution(state, args, callback); end
- def rejected_resolution(raise_on_reassign, state); end
- def run_test(v); end
- def wait_until_resolved!(timeout = T.unsafe(nil)); end
-end
-
-class Concurrent::Promises::FutureWrapperPromise < ::Concurrent::Promises::BlockedPromise
- def initialize(delayed, blockers_count, default_executor); end
-
- private
-
- def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::ImmediateEventPromise < ::Concurrent::Promises::InnerPromise
- def initialize(default_executor); end
-end
-
-class Concurrent::Promises::ImmediateFuturePromise < ::Concurrent::Promises::InnerPromise
- def initialize(default_executor, fulfilled, value, reason); end
-end
-
-class Concurrent::Promises::InnerPromise < ::Concurrent::Promises::AbstractPromise; end
-module Concurrent::Promises::InternalStates; end
-
-class Concurrent::Promises::InternalStates::Fulfilled < ::Concurrent::Promises::InternalStates::ResolvedWithResult
- def initialize(value); end
-
- def apply(args, block); end
- def fulfilled?; end
- def reason; end
- def to_sym; end
- def value; end
-end
-
-class Concurrent::Promises::InternalStates::FulfilledArray < ::Concurrent::Promises::InternalStates::Fulfilled
- def apply(args, block); end
-end
-
-Concurrent::Promises::InternalStates::PENDING = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Pending)
-
-class Concurrent::Promises::InternalStates::PartiallyRejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
- def initialize(value, reason); end
-
- def apply(args, block); end
- def fulfilled?; end
- def reason; end
- def to_sym; end
- def value; end
-end
-
-class Concurrent::Promises::InternalStates::Pending < ::Concurrent::Promises::InternalStates::State
- def resolved?; end
- def to_sym; end
-end
-
-Concurrent::Promises::InternalStates::RESERVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Reserved)
-Concurrent::Promises::InternalStates::RESOLVED = T.let(T.unsafe(nil), Concurrent::Promises::InternalStates::Fulfilled)
-
-class Concurrent::Promises::InternalStates::Rejected < ::Concurrent::Promises::InternalStates::ResolvedWithResult
- def initialize(reason); end
-
- def apply(args, block); end
- def fulfilled?; end
- def reason; end
- def to_sym; end
- def value; end
-end
-
-class Concurrent::Promises::InternalStates::Reserved < ::Concurrent::Promises::InternalStates::Pending; end
-
-class Concurrent::Promises::InternalStates::ResolvedWithResult < ::Concurrent::Promises::InternalStates::State
- def apply; end
- def fulfilled?; end
- def reason; end
- def resolved?; end
- def result; end
- def to_sym; end
- def value; end
-end
-
-class Concurrent::Promises::InternalStates::State
- def resolved?; end
- def to_sym; end
-end
-
-class Concurrent::Promises::RescuePromise < ::Concurrent::Promises::BlockedTaskPromise
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
-
- private
-
- def on_resolvable(resolved_future, index); end
-end
-
-module Concurrent::Promises::Resolvable
- include ::Concurrent::Promises::InternalStates
-end
-
-class Concurrent::Promises::ResolvableEvent < ::Concurrent::Promises::Event
- include ::Concurrent::Promises::Resolvable
-
- def resolve(raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
- def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
- def with_hidden_resolvable; end
-end
-
-class Concurrent::Promises::ResolvableEventPromise < ::Concurrent::Promises::AbstractPromise
- def initialize(default_executor); end
-end
-
-class Concurrent::Promises::ResolvableFuture < ::Concurrent::Promises::Future
- include ::Concurrent::Promises::Resolvable
-
- def evaluate_to(*args, &block); end
- def evaluate_to!(*args, &block); end
- def fulfill(value, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
- def reason(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
- def reject(reason, raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
- def resolve(fulfilled = T.unsafe(nil), value = T.unsafe(nil), reason = T.unsafe(nil), raise_on_reassign = T.unsafe(nil), reserved = T.unsafe(nil)); end
- def result(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
- def value(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
- def value!(timeout = T.unsafe(nil), timeout_value = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
- def wait(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
- def wait!(timeout = T.unsafe(nil), resolve_on_timeout = T.unsafe(nil)); end
- def with_hidden_resolvable; end
-end
-
-class Concurrent::Promises::ResolvableFuturePromise < ::Concurrent::Promises::AbstractPromise
- def initialize(default_executor); end
-end
-
-class Concurrent::Promises::RunFuturePromise < ::Concurrent::Promises::AbstractFlatPromise
- def initialize(delayed, blockers_count, default_executor, run_test); end
-
- private
-
- def process_on_blocker_resolution(future, index); end
-end
-
-class Concurrent::Promises::ScheduledPromise < ::Concurrent::Promises::InnerPromise
- def initialize(default_executor, intended_time); end
-
- def inspect; end
- def intended_time; end
-end
-
-class Concurrent::Promises::ThenPromise < ::Concurrent::Promises::BlockedTaskPromise
- def initialize(delayed, blockers_count, default_executor, executor, args, &task); end
-
- private
-
- def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::ZipEventEventPromise < ::Concurrent::Promises::BlockedPromise
- def initialize(delayed, blockers_count, default_executor); end
-
- private
-
- def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::ZipEventsPromise < ::Concurrent::Promises::BlockedPromise
- def initialize(delayed, blockers_count, default_executor); end
-
- private
-
- def on_resolvable(resolved_future, index); end
-end
-
-class Concurrent::Promises::ZipFutureEventPromise < ::Concurrent::Promises::BlockedPromise
- def initialize(delayed, blockers_count, default_executor); end
-
- private
-
- def on_resolvable(resolved_future, index); end
- def process_on_blocker_resolution(future, index); end
-end
-
-class Concurrent::Promises::ZipFuturesPromise < ::Concurrent::Promises::BlockedPromise
- def initialize(delayed, blockers_count, default_executor); end
-
- private
-
- def on_resolvable(resolved_future, index); end
- def process_on_blocker_resolution(future, index); end
-end
-
-module Concurrent::ReInclude
- def extended(base); end
- def include(*modules); end
- def included(base); end
-end
-
-class Concurrent::ReadWriteLock < ::Concurrent::Synchronization::Object
- def initialize; end
-
- def acquire_read_lock; end
- def acquire_write_lock; end
- def has_waiters?; end
- def release_read_lock; end
- def release_write_lock; end
- def with_read_lock; end
- def with_write_lock; end
- def write_locked?; end
-
- private
-
- def max_readers?(c = T.unsafe(nil)); end
- def max_writers?(c = T.unsafe(nil)); end
- def running_readers(c = T.unsafe(nil)); end
- def running_readers?(c = T.unsafe(nil)); end
- def running_writer?(c = T.unsafe(nil)); end
- def waiting_writer?(c = T.unsafe(nil)); end
- def waiting_writers(c = T.unsafe(nil)); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-Concurrent::ReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer)
-Concurrent::ReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer)
-
-class Concurrent::ReentrantReadWriteLock < ::Concurrent::Synchronization::Object
- def initialize; end
-
- def acquire_read_lock; end
- def acquire_write_lock; end
- def release_read_lock; end
- def release_write_lock; end
- def try_read_lock; end
- def try_write_lock; end
- def with_read_lock; end
- def with_write_lock; end
-
- private
-
- def max_readers?(c = T.unsafe(nil)); end
- def max_writers?(c = T.unsafe(nil)); end
- def running_readers(c = T.unsafe(nil)); end
- def running_readers?(c = T.unsafe(nil)); end
- def running_writer?(c = T.unsafe(nil)); end
- def waiting_or_running_writer?(c = T.unsafe(nil)); end
- def waiting_writers(c = T.unsafe(nil)); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-Concurrent::ReentrantReadWriteLock::MAX_READERS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::MAX_WRITERS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::READER_BITS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::READ_LOCK_MASK = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::RUNNING_WRITER = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::WAITING_WRITER = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::WRITER_BITS = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::WRITE_LOCK_HELD = T.let(T.unsafe(nil), Integer)
-Concurrent::ReentrantReadWriteLock::WRITE_LOCK_MASK = T.let(T.unsafe(nil), Integer)
-class Concurrent::RejectedExecutionError < ::Concurrent::Error; end
-class Concurrent::ResourceLimitError < ::Concurrent::Error; end
-
-class Concurrent::RubyExchanger < ::Concurrent::AbstractExchanger
- def initialize; end
-
- def __initialize_atomic_fields__; end
- def compare_and_set_slot(expected, value); end
- def slot; end
- def slot=(value); end
- def swap_slot(value); end
- def update_slot(&block); end
-
- private
-
- def do_exchange(value, timeout); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-class Concurrent::RubyExchanger::Node < ::Concurrent::Synchronization::Object
- def initialize(item); end
-
- def __initialize_atomic_fields__; end
- def compare_and_set_value(expected, value); end
- def item; end
- def latch; end
- def swap_value(value); end
- def update_value(&block); end
- def value; end
- def value=(value); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-class Concurrent::RubyExecutorService < ::Concurrent::AbstractExecutorService
- def initialize(*args, &block); end
-
- def kill; end
- def post(*args, &task); end
- def shutdown; end
- def wait_for_termination(timeout = T.unsafe(nil)); end
-
- private
-
- def ns_running?; end
- def ns_shutdown?; end
- def ns_shutdown_execution; end
- def ns_shuttingdown?; end
- def stop_event; end
- def stopped_event; end
-end
-
-class Concurrent::RubySingleThreadExecutor < ::Concurrent::RubyThreadPoolExecutor
- def initialize(opts = T.unsafe(nil)); end
-end
-
-class Concurrent::RubyThreadLocalVar < ::Concurrent::AbstractThreadLocalVar
- def value; end
- def value=(value); end
-
- protected
-
- def allocate_storage; end
-
- private
-
- def get_default; end
- def get_threadlocal_array(thread = T.unsafe(nil)); end
- def next_index; end
- def set_threadlocal_array(array, thread = T.unsafe(nil)); end
- def value_for(thread); end
-
- class << self
- def semi_sync(&block); end
- def thread_finalizer(id); end
- def thread_local_finalizer(index); end
- end
-end
-
-Concurrent::RubyThreadLocalVar::FREE = T.let(T.unsafe(nil), Array)
-Concurrent::RubyThreadLocalVar::LOCK = T.let(T.unsafe(nil), Thread::Mutex)
-Concurrent::RubyThreadLocalVar::THREAD_LOCAL_ARRAYS = T.let(T.unsafe(nil), Hash)
-
-class Concurrent::RubyThreadPoolExecutor < ::Concurrent::RubyExecutorService
- def initialize(opts = T.unsafe(nil)); end
-
- def can_overflow?; end
- def completed_task_count; end
- def idletime; end
- def largest_length; end
- def length; end
- def max_length; end
- def max_queue; end
- def min_length; end
- def queue_length; end
- def ready_worker(worker); end
- def remaining_capacity; end
- def remove_busy_worker(worker); end
- def scheduled_task_count; end
- def synchronous; end
- def worker_died(worker); end
- def worker_not_old_enough(worker); end
- def worker_task_completed; end
-
- private
-
- def ns_add_busy_worker; end
- def ns_assign_worker(*args, &task); end
- def ns_enqueue(*args, &task); end
- def ns_execute(*args, &task); end
- def ns_initialize(opts); end
- def ns_kill_execution; end
- def ns_limited_queue?; end
- def ns_prune_pool; end
- def ns_ready_worker(worker, success = T.unsafe(nil)); end
- def ns_remove_busy_worker(worker); end
- def ns_reset_if_forked; end
- def ns_shutdown_execution; end
- def ns_worker_died(worker); end
- def ns_worker_not_old_enough(worker); end
-end
-
-Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE = T.let(T.unsafe(nil), Integer)
-Concurrent::RubyThreadPoolExecutor::DEFAULT_MAX_QUEUE_SIZE = T.let(T.unsafe(nil), Integer)
-Concurrent::RubyThreadPoolExecutor::DEFAULT_MIN_POOL_SIZE = T.let(T.unsafe(nil), Integer)
-Concurrent::RubyThreadPoolExecutor::DEFAULT_THREAD_IDLETIMEOUT = T.let(T.unsafe(nil), Integer)
-
-class Concurrent::RubyThreadPoolExecutor::Worker
- include ::Logger::Severity
- include ::Concurrent::Concern::Logging
-
- def initialize(pool, id); end
-
- def <<(message); end
- def kill; end
- def stop; end
-
- private
-
- def create_worker(queue, pool, idletime); end
- def run_task(pool, task, args); end
-end
-
-class Concurrent::SafeTaskExecutor < ::Concurrent::Synchronization::LockableObject
- def initialize(task, opts = T.unsafe(nil)); end
-
- def execute(*args); end
-end
-
-class Concurrent::ScheduledTask < ::Concurrent::IVar
- include ::Comparable
-
- def initialize(delay, opts = T.unsafe(nil), &task); end
-
- def <=>(other); end
- def cancel; end
- def cancelled?; end
- def execute; end
- def executor; end
- def initial_delay; end
- def process_task; end
- def processing?; end
- def reschedule(delay); end
- def reset; end
- def schedule_time; end
-
- protected
-
- def ns_reschedule(delay); end
- def ns_schedule(delay); end
-
- class << self
- def execute(delay, opts = T.unsafe(nil), &task); end
- end
-end
-
-class Concurrent::Semaphore < ::Concurrent::MutexSemaphore; end
-Concurrent::SemaphoreImplementation = Concurrent::MutexSemaphore
-
-module Concurrent::SerialExecutorService
- include ::Logger::Severity
- include ::Concurrent::Concern::Logging
- include ::Concurrent::ExecutorService
-
- def serialized?; end
-end
-
-class Concurrent::SerializedExecution < ::Concurrent::Synchronization::LockableObject
- include ::Logger::Severity
- include ::Concurrent::Concern::Logging
-
- def initialize; end
-
- def post(executor, *args, &task); end
- def posts(posts); end
-
- private
-
- def call_job(job); end
- def ns_initialize; end
- def work(job); end
-end
-
-class Concurrent::SerializedExecution::Job < ::Struct
- def args; end
- def args=(_); end
- def block; end
- def block=(_); end
- def call; end
- def executor; end
- def executor=(_); end
-
- class << self
- def [](*_arg0); end
- def inspect; end
- def members; end
- def new(*_arg0); end
- end
-end
-
-class Concurrent::SerializedExecutionDelegator < ::SimpleDelegator
- include ::Logger::Severity
- include ::Concurrent::Concern::Logging
- include ::Concurrent::ExecutorService
- include ::Concurrent::SerialExecutorService
-
- def initialize(executor); end
-
- def post(*args, &task); end
-end
-
-class Concurrent::Set < ::Concurrent::CRubySet; end
-Concurrent::SetImplementation = Concurrent::CRubySet
-
-module Concurrent::SettableStruct
- include ::Concurrent::Synchronization::AbstractStruct
-
- def ==(other); end
- def [](member); end
- def []=(member, value); end
- def each(&block); end
- def each_pair(&block); end
- def inspect; end
- def merge(other, &block); end
- def select(&block); end
- def to_a; end
- def to_h; end
- def to_s; end
- def values; end
- def values_at(*indexes); end
-
- private
-
- def initialize_copy(original); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-Concurrent::SettableStruct::FACTORY = T.let(T.unsafe(nil), T.untyped)
-
-class Concurrent::SimpleExecutorService < ::Concurrent::RubyExecutorService
- def <<(task); end
- def kill; end
- def post(*args, &task); end
- def running?; end
- def shutdown; end
- def shutdown?; end
- def shuttingdown?; end
- def wait_for_termination(timeout = T.unsafe(nil)); end
-
- private
-
- def ns_initialize(*args); end
-
- class << self
- def <<(task); end
- def post(*args); end
- end
-end
-
-class Concurrent::SingleThreadExecutor < ::Concurrent::RubySingleThreadExecutor; end
-Concurrent::SingleThreadExecutorImplementation = Concurrent::RubySingleThreadExecutor
-module Concurrent::Synchronization; end
-
-class Concurrent::Synchronization::AbstractLockableObject < ::Concurrent::Synchronization::Object
- protected
-
- def ns_broadcast; end
- def ns_signal; end
- def ns_wait(timeout = T.unsafe(nil)); end
- def ns_wait_until(timeout = T.unsafe(nil), &condition); end
- def synchronize; end
-end
-
-class Concurrent::Synchronization::AbstractObject
- def initialize; end
-
- def full_memory_barrier; end
-
- class << self
- def attr_volatile(*names); end
- end
-end
-
-module Concurrent::Synchronization::AbstractStruct
- def initialize(*values); end
-
- def length; end
- def members; end
- def size; end
-
- protected
-
- def ns_each; end
- def ns_each_pair; end
- def ns_equality(other); end
- def ns_get(member); end
- def ns_initialize_copy; end
- def ns_inspect; end
- def ns_merge(other, &block); end
- def ns_select; end
- def ns_to_h; end
- def ns_values; end
- def ns_values_at(indexes); end
- def pr_underscore(clazz); end
-
- class << self
- def define_struct_class(parent, base, name, members, &block); end
- end
-end
-
-class Concurrent::Synchronization::Condition < ::Concurrent::Synchronization::LockableObject
- def initialize(lock); end
-
- def broadcast; end
- def ns_broadcast; end
- def ns_signal; end
- def ns_wait(timeout = T.unsafe(nil)); end
- def ns_wait_until(timeout = T.unsafe(nil), &condition); end
- def signal; end
- def wait(timeout = T.unsafe(nil)); end
- def wait_until(timeout = T.unsafe(nil), &condition); end
-
- class << self
- def private_new(*args, &block); end
- end
-end
-
-module Concurrent::Synchronization::ConditionSignalling
- protected
-
- def ns_broadcast; end
- def ns_signal; end
-end
-
-class Concurrent::Synchronization::Lock < ::Concurrent::Synchronization::LockableObject
- def broadcast; end
- def signal; end
- def wait(timeout = T.unsafe(nil)); end
- def wait_until(timeout = T.unsafe(nil), &condition); end
-end
-
-class Concurrent::Synchronization::LockableObject < ::Concurrent::Synchronization::MutexLockableObject
- def new_condition; end
-end
-
-Concurrent::Synchronization::LockableObjectImplementation = Concurrent::Synchronization::MutexLockableObject
-
-class Concurrent::Synchronization::MonitorLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
- include ::Concurrent::Synchronization::ConditionSignalling
-
- def initialize(*defaults); end
-
- protected
-
- def ns_wait(timeout = T.unsafe(nil)); end
- def synchronize; end
-
- private
-
- def initialize_copy(other); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-module Concurrent::Synchronization::MriAttrVolatile
- mixes_in_class_methods ::Concurrent::Synchronization::MriAttrVolatile::ClassMethods
-
- def full_memory_barrier; end
-
- class << self
- def included(base); end
- end
-end
-
-module Concurrent::Synchronization::MriAttrVolatile::ClassMethods
- def attr_volatile(*names); end
-end
-
-class Concurrent::Synchronization::MriObject < ::Concurrent::Synchronization::AbstractObject
- include ::Concurrent::Synchronization::MriAttrVolatile
- extend ::Concurrent::Synchronization::MriAttrVolatile::ClassMethods
-
- def initialize; end
-end
-
-class Concurrent::Synchronization::MutexLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
- include ::Concurrent::Synchronization::ConditionSignalling
-
- def initialize(*defaults); end
-
- protected
-
- def ns_wait(timeout = T.unsafe(nil)); end
- def synchronize; end
-
- private
-
- def initialize_copy(other); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-class Concurrent::Synchronization::Object < ::Concurrent::Synchronization::MriObject
- def initialize; end
-
- private
-
- def __initialize_atomic_fields__; end
-
- class << self
- def atomic_attribute?(name); end
- def atomic_attributes(inherited = T.unsafe(nil)); end
- def attr_atomic(*names); end
- def ensure_safe_initialization_when_final_fields_are_present; end
- def safe_initialization!; end
- def safe_initialization?; end
-
- private
-
- def define_initialize_atomic_fields; end
- end
-end
-
-Concurrent::Synchronization::ObjectImplementation = Concurrent::Synchronization::MriObject
-
-module Concurrent::Synchronization::RbxAttrVolatile
- mixes_in_class_methods ::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
-
- def full_memory_barrier; end
-
- class << self
- def included(base); end
- end
-end
-
-module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
- def attr_volatile(*names); end
-end
-
-class Concurrent::Synchronization::RbxLockableObject < ::Concurrent::Synchronization::AbstractLockableObject
- def initialize(*defaults); end
-
- protected
-
- def ns_broadcast; end
- def ns_signal; end
- def ns_wait(timeout = T.unsafe(nil)); end
- def synchronize(&block); end
-
- private
-
- def initialize_copy(other); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-class Concurrent::Synchronization::RbxObject < ::Concurrent::Synchronization::AbstractObject
- include ::Concurrent::Synchronization::RbxAttrVolatile
- extend ::Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
-
- def initialize; end
-end
-
-module Concurrent::Synchronization::TruffleRubyAttrVolatile
- mixes_in_class_methods ::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
-
- def full_memory_barrier; end
-
- class << self
- def included(base); end
- end
-end
-
-module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
- def attr_volatile(*names); end
-end
-
-class Concurrent::Synchronization::TruffleRubyObject < ::Concurrent::Synchronization::AbstractObject
- include ::Concurrent::Synchronization::TruffleRubyAttrVolatile
- extend ::Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods
-
- def initialize; end
-end
-
-Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile
-
-class Concurrent::SynchronizedDelegator < ::SimpleDelegator
- def initialize(obj); end
-
- def method_missing(method, *args, &block); end
- def setup; end
- def teardown; end
-end
-
-class Concurrent::TVar < ::Concurrent::Synchronization::Object
- def initialize(value); end
-
- def unsafe_increment_version; end
- def unsafe_lock; end
- def unsafe_value; end
- def unsafe_value=(value); end
- def unsafe_version; end
- def value; end
- def value=(value); end
-
- class << self
- def new(*args, &block); end
- end
-end
-
-class Concurrent::ThreadLocalVar < ::Concurrent::RubyThreadLocalVar; end
-Concurrent::ThreadLocalVarImplementation = Concurrent::RubyThreadLocalVar
-class Concurrent::ThreadPoolExecutor < ::Concurrent::RubyThreadPoolExecutor; end
-Concurrent::ThreadPoolExecutorImplementation = Concurrent::RubyThreadPoolExecutor
-module Concurrent::ThreadSafe; end
-
-module Concurrent::ThreadSafe::Util
- class << self
- def make_synchronized_on_cruby(klass); end
- def make_synchronized_on_rbx(klass); end
- def make_synchronized_on_truffleruby(klass); end
- end
-end
-
-Concurrent::ThreadSafe::Util::CPU_COUNT = T.let(T.unsafe(nil), Integer)
-Concurrent::ThreadSafe::Util::FIXNUM_BIT_SIZE = T.let(T.unsafe(nil), Integer)
-Concurrent::ThreadSafe::Util::MAX_INT = T.let(T.unsafe(nil), Integer)
-class Concurrent::TimeoutError < ::Concurrent::Error; end
-
-class Concurrent::TimerSet < ::Concurrent::RubyExecutorService
- def initialize(opts = T.unsafe(nil)); end
-
- def kill; end
- def post(delay, *args, &task); end
-
- private
-
- def ns_initialize(opts); end
- def ns_post_task(task); end
- def ns_reset_if_forked; end
- def ns_shutdown_execution; end
- def post_task(task); end
- def process_tasks; end
- def remove_task(task); end
-end
-
-class Concurrent::TimerTask < ::Concurrent::RubyExecutorService
- include ::Concurrent::Concern::Dereferenceable
- include ::Concurrent::Concern::Observable
-
- def initialize(opts = T.unsafe(nil), &task); end
-
- def execute; end
- def execution_interval; end
- def execution_interval=(value); end
- def running?; end
- def timeout_interval; end
- def timeout_interval=(value); end
-
- private
-
- def execute_task(completion); end
- def ns_initialize(opts, &task); end
- def ns_kill_execution; end
- def ns_shutdown_execution; end
- def schedule_next_task(interval = T.unsafe(nil)); end
- def timeout_task(completion); end
-
- class << self
- def execute(opts = T.unsafe(nil), &task); end
- end
-end
-
-Concurrent::TimerTask::EXECUTION_INTERVAL = T.let(T.unsafe(nil), Integer)
-Concurrent::TimerTask::TIMEOUT_INTERVAL = T.let(T.unsafe(nil), Integer)
-
-class Concurrent::Transaction
- def initialize; end
-
- def abort; end
- def commit; end
- def read(tvar); end
- def unlock; end
- def valid?; end
- def write(tvar, value); end
-
- class << self
- def current; end
- def current=(transaction); end
- end
-end
-
-Concurrent::Transaction::ABORTED = T.let(T.unsafe(nil), Object)
-class Concurrent::Transaction::AbortError < ::StandardError; end
-class Concurrent::Transaction::LeaveError < ::StandardError; end
-
-class Concurrent::Transaction::ReadLogEntry < ::Struct
- def tvar; end
- def tvar=(_); end
- def version; end
- def version=(_); end
-
- class << self
- def [](*_arg0); end
- def inspect; end
- def members; end
- def new(*_arg0); end
- end
-end
-
-class Concurrent::Tuple
- include ::Enumerable
-
- def initialize(size); end
-
- def cas(i, old_value, new_value); end
- def compare_and_set(i, old_value, new_value); end
- def each; end
- def get(i); end
- def set(i, value); end
- def size; end
- def volatile_get(i); end
- def volatile_set(i, value); end
-end
-
-Concurrent::Tuple::Tuple = Array
-module Concurrent::Utility; end
-
-module Concurrent::Utility::EngineDetector
- def on_cruby?; end
- def on_jruby?; end
- def on_jruby_9000?; end
- def on_linux?; end
- def on_osx?; end
- def on_rbx?; end
- def on_truffleruby?; end
- def on_windows?; end
- def ruby_engine; end
- def ruby_version(version = T.unsafe(nil), comparison, major, minor, patch); end
-end
-
-module Concurrent::Utility::NativeExtensionLoader
- def allow_c_extensions?; end
- def c_extensions_loaded?; end
- def java_extensions_loaded?; end
- def load_native_extensions; end
-
- private
-
- def load_error_path(error); end
- def set_c_extensions_loaded; end
- def set_java_extensions_loaded; end
- def try_load_c_extension(path); end
-end
-
-module Concurrent::Utility::NativeInteger
- extend ::Concurrent::Utility::NativeInteger
-
- def ensure_integer(value); end
- def ensure_integer_and_bounds(value); end
- def ensure_lower_bound(value); end
- def ensure_positive(value); end
- def ensure_positive_and_no_zero(value); end
- def ensure_upper_bound(value); end
-end
-
-Concurrent::Utility::NativeInteger::MAX_VALUE = T.let(T.unsafe(nil), Integer)
-Concurrent::Utility::NativeInteger::MIN_VALUE = T.let(T.unsafe(nil), Integer)
-
-class Concurrent::Utility::ProcessorCounter
- def initialize; end
-
- def physical_processor_count; end
- def processor_count; end
-
- private
-
- def compute_physical_processor_count; end
- def compute_processor_count; end
-end
-
-Concurrent::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi b/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi
new file mode 100644
index 000000000..a740bb1e5
--- /dev/null
+++ b/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi
@@ -0,0 +1,11644 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `concurrent-ruby` gem.
+# Please instead update this file by running `bin/tapioca gem concurrent-ruby`.
+
+# {include:file:README.md}
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/version.rb#1
+module Concurrent
+ extend ::Concurrent::Utility::EngineDetector
+ extend ::Concurrent::Utility::NativeExtensionLoader
+ extend ::Logger::Severity
+ extend ::Concurrent::Concern::Logging
+ extend ::Concurrent::Concern::Deprecation
+
+ private
+
+ # Abort a currently running transaction - see `Concurrent::atomically`.
+ #
+ # @raise [Transaction::AbortError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#139
+ def abort_transaction; end
+
+ # Run a block that reads and writes `TVar`s as a single atomic transaction.
+ # With respect to the value of `TVar` objects, the transaction is atomic, in
+ # that it either happens or it does not, consistent, in that the `TVar`
+ # objects involved will never enter an illegal state, and isolated, in that
+ # transactions never interfere with each other. You may recognise these
+ # properties from database transactions.
+ #
+ # There are some very important and unusual semantics that you must be aware of:
+ #
+ # * Most importantly, the block that you pass to atomically may be executed
+ # more than once. In most cases your code should be free of
+ # side-effects, except for via TVar.
+ #
+ # * If an exception escapes an atomically block it will abort the transaction.
+ #
+ # * It is undefined behaviour to use callcc or Fiber with atomically.
+ #
+ # * If you create a new thread within an atomically, it will not be part of
+ # the transaction. Creating a thread counts as a side-effect.
+ #
+ # Transactions within transactions are flattened to a single transaction.
+ #
+ # @example
+ # a = new TVar(100_000)
+ # b = new TVar(100)
+ #
+ # Concurrent::atomically do
+ # a.value -= 10
+ # b.value += 10
+ # end
+ # @raise [ArgumentError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#82
+ def atomically; end
+
+ # @raise [ArgumentError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#56
+ def call_dataflow(method, executor, *inputs, &block); end
+
+ # Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+ # {include:file:docs-source/dataflow.md}
+ #
+ # @param inputs [Future] zero or more `Future` operations that this dataflow depends upon
+ # @raise [ArgumentError] if no block is given
+ # @raise [ArgumentError] if any of the inputs are not `IVar`s
+ # @return [Object] the result of all the operations
+ # @yield The operation to perform once all the dependencies are met
+ # @yieldparam inputs [Future] each of the `Future` inputs to the dataflow
+ # @yieldreturn [Object] the result of the block operation
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#34
+ def dataflow(*inputs, &block); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#44
+ def dataflow!(*inputs, &block); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#39
+ def dataflow_with(executor, *inputs, &block); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#49
+ def dataflow_with!(executor, *inputs, &block); end
+
+ # Leave a transaction without committing or aborting - see `Concurrent::atomically`.
+ #
+ # @raise [Transaction::LeaveError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#144
+ def leave_transaction; end
+
+ # Returns the current time as tracked by the application monotonic clock.
+ #
+ # @param unit [Symbol] the time unit to be returned, can be either
+ # :float_second, :float_millisecond, :float_microsecond, :second,
+ # :millisecond, :microsecond, or :nanosecond default to :float_second.
+ # @return [Float] The current monotonic time since some unspecified
+ # starting point
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/monotonic_time.rb#15
+ def monotonic_time(unit = T.unsafe(nil)); end
+
+ class << self
+ # Abort a currently running transaction - see `Concurrent::atomically`.
+ #
+ # @raise [Transaction::AbortError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#139
+ def abort_transaction; end
+
+ # Run a block that reads and writes `TVar`s as a single atomic transaction.
+ # With respect to the value of `TVar` objects, the transaction is atomic, in
+ # that it either happens or it does not, consistent, in that the `TVar`
+ # objects involved will never enter an illegal state, and isolated, in that
+ # transactions never interfere with each other. You may recognise these
+ # properties from database transactions.
+ #
+ # There are some very important and unusual semantics that you must be aware of:
+ #
+ # * Most importantly, the block that you pass to atomically may be executed
+ # more than once. In most cases your code should be free of
+ # side-effects, except for via TVar.
+ #
+ # * If an exception escapes an atomically block it will abort the transaction.
+ #
+ # * It is undefined behaviour to use callcc or Fiber with atomically.
+ #
+ # * If you create a new thread within an atomically, it will not be part of
+ # the transaction. Creating a thread counts as a side-effect.
+ #
+ # Transactions within transactions are flattened to a single transaction.
+ #
+ # @example
+ # a = new TVar(100_000)
+ # b = new TVar(100)
+ #
+ # Concurrent::atomically do
+ # a.value -= 10
+ # b.value += 10
+ # end
+ # @raise [ArgumentError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#82
+ def atomically; end
+
+ # Number of processors cores available for process scheduling.
+ # This method takes in account the CPU quota if the process is inside a cgroup with a
+ # dedicated CPU quota (typically Docker).
+ # Otherwise it returns the same value as #processor_count but as a Float.
+ #
+ # For performance reasons the calculated value will be memoized on the first
+ # call.
+ #
+ # @return [Float] number of available processors
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#194
+ def available_processor_count; end
+
+ # @raise [ArgumentError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#56
+ def call_dataflow(method, executor, *inputs, &block); end
+
+ # The maximum number of processors cores available for process scheduling.
+ # Returns `nil` if there is no enforced limit, or a `Float` if the
+ # process is inside a cgroup with a dedicated CPU quota (typically Docker).
+ #
+ # Note that nothing prevents setting a CPU quota higher than the actual number of
+ # cores on the system.
+ #
+ # For performance reasons the calculated value will be memoized on the first
+ # call.
+ #
+ # @return [nil, Float] Maximum number of available processors as set by a cgroup CPU quota, or nil if none set
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#209
+ def cpu_quota; end
+
+ # The CPU shares requested by the process. For performance reasons the calculated
+ # value will be memoized on the first call.
+ #
+ # @return [Float, nil] CPU shares requested by the process, or nil if not set
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#217
+ def cpu_shares; end
+
+ # @return [Logger] Logger with provided level and output.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#37
+ def create_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+
+ # @deprecated
+ # @return [Logger] Logger with provided level and output.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#69
+ def create_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+
+ # Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+ # {include:file:docs-source/dataflow.md}
+ #
+ # @param inputs [Future] zero or more `Future` operations that this dataflow depends upon
+ # @raise [ArgumentError] if no block is given
+ # @raise [ArgumentError] if any of the inputs are not `IVar`s
+ # @return [Object] the result of all the operations
+ # @yield The operation to perform once all the dependencies are met
+ # @yieldparam inputs [Future] each of the `Future` inputs to the dataflow
+ # @yieldreturn [Object] the result of the block operation
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#34
+ def dataflow(*inputs, &block); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#44
+ def dataflow!(*inputs, &block); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#39
+ def dataflow_with(executor, *inputs, &block); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/dataflow.rb#49
+ def dataflow_with!(executor, *inputs, &block); end
+
+ # Disables AtExit handlers including pool auto-termination handlers.
+ # When disabled it will be the application programmer's responsibility
+ # to ensure that the handlers are shutdown properly prior to application
+ # exit by calling `AtExit.run` method.
+ #
+ # @deprecated Has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841.
+ # @note this option should be needed only because of `at_exit` ordering
+ # issues which may arise when running some of the testing frameworks.
+ # E.g. Minitest's test-suite runs itself in `at_exit` callback which
+ # executes after the pools are already terminated. Then auto termination
+ # needs to be disabled and called manually after test-suite ends.
+ # @note This method should *never* be called
+ # from within a gem. It should *only* be used from within the main
+ # application and even then it should be used only when necessary.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#48
+ def disable_at_exit_handlers!; end
+
+ # General access point to global executors.
+ #
+ # @param executor_identifier [Symbol, Executor] symbols:
+ # - :fast - {Concurrent.global_fast_executor}
+ # - :io - {Concurrent.global_io_executor}
+ # - :immediate - {Concurrent.global_immediate_executor}
+ # @return [Executor]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#83
+ def executor(executor_identifier); end
+
+ # Global thread pool optimized for short, fast *operations*.
+ #
+ # @return [ThreadPoolExecutor] the thread pool
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#55
+ def global_fast_executor; end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#66
+ def global_immediate_executor; end
+
+ # Global thread pool optimized for long, blocking (IO) *tasks*.
+ #
+ # @return [ThreadPoolExecutor] the thread pool
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#62
+ def global_io_executor; end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#109
+ def global_logger; end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#113
+ def global_logger=(value); end
+
+ # Global thread pool user for global *timers*.
+ #
+ # @return [Concurrent::TimerSet] the thread pool
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#73
+ def global_timer_set; end
+
+ # Leave a transaction without committing or aborting - see `Concurrent::atomically`.
+ #
+ # @raise [Transaction::LeaveError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/tvar.rb#144
+ def leave_transaction; end
+
+ # Returns the current time as tracked by the application monotonic clock.
+ #
+ # @param unit [Symbol] the time unit to be returned, can be either
+ # :float_second, :float_millisecond, :float_microsecond, :second,
+ # :millisecond, :microsecond, or :nanosecond default to :float_second.
+ # @return [Float] The current monotonic time since some unspecified
+ # starting point
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/monotonic_time.rb#15
+ def monotonic_time(unit = T.unsafe(nil)); end
+
+ # @return [Boolean]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb#7
+ def mutex_owned_per_thread?; end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#87
+ def new_fast_executor(opts = T.unsafe(nil)); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/configuration.rb#98
+ def new_io_executor(opts = T.unsafe(nil)); end
+
+ # Number of physical processor cores on the current system. For performance
+ # reasons the calculated value will be memoized on the first call.
+ #
+ # On Windows the Win32 API will be queried for the `NumberOfCores from
+ # Win32_Processor`. This will return the total number "of cores for the
+ # current instance of the processor." On Unix-like operating systems either
+ # the `hwprefs` or `sysctl` utility will be called in a subshell and the
+ # returned value will be used. In the rare case where none of these methods
+ # work or an exception is raised the function will simply return 1.
+ #
+ # @return [Integer] number physical processor cores on the current system
+ # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
+ # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
+ # @see http://www.unix.com/man-page/osx/1/HWPREFS/
+ # @see http://linux.die.net/man/8/sysctl
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#181
+ def physical_processor_count; end
+
+ # Number of processors seen by the OS and used for process scheduling. For
+ # performance reasons the calculated value will be memoized on the first
+ # call.
+ #
+ # When running under JRuby the Java runtime call
+ # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
+ # to the Java documentation this "value may change during a particular
+ # invocation of the virtual machine... [applications] should therefore
+ # occasionally poll this property." We still memoize this value once under
+ # JRuby.
+ #
+ # Otherwise Ruby's Etc.nprocessors will be used.
+ #
+ # @return [Integer] number of processors seen by the OS or Java runtime
+ # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#160
+ def processor_count; end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/utility/processor_counter.rb#142
+ def processor_counter; end
+
+ # Use logger created by #create_simple_logger to log concurrent-ruby messages.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#63
+ def use_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+
+ # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
+ #
+ # @deprecated
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/concern/logging.rb#96
+ def use_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
+ end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#38
+class Concurrent::AbstractExchanger < ::Concurrent::Synchronization::Object
+ # @return [AbstractExchanger] a new instance of AbstractExchanger
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#44
+ def initialize; end
+
+ # Waits for another thread to arrive at this exchange point (unless the
+ # current thread is interrupted), and then transfers the given object to
+ # it, receiving its object in return. The timeout value indicates the
+ # approximate number of seconds the method should block while waiting
+ # for the exchange. When the timeout value is `nil` the method will
+ # block indefinitely.
+ #
+ #
+ # In some edge cases when a `timeout` is given a return value of `nil` may be
+ # ambiguous. Specifically, if `nil` is a valid value in the exchange it will
+ # be impossible to tell whether `nil` is the actual return value or if it
+ # signifies timeout. When `nil` is a valid value in the exchange consider
+ # using {#exchange!} or {#try_exchange} instead.
+ #
+ # @param value [Object] the value to exchange with another thread
+ # @param timeout [Numeric, nil] in seconds, `nil` blocks indefinitely
+ # @return [Object] the value exchanged by the other thread or `nil` on timeout
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#69
+ def exchange(value, timeout = T.unsafe(nil)); end
+
+ # Waits for another thread to arrive at this exchange point (unless the
+ # current thread is interrupted), and then transfers the given object to
+ # it, receiving its object in return. The timeout value indicates the
+ # approximate number of seconds the method should block while waiting
+ # for the exchange. When the timeout value is `nil` the method will
+ # block indefinitely.
+ #
+ #
+ # On timeout a {Concurrent::TimeoutError} exception will be raised.
+ #
+ # @param value [Object] the value to exchange with another thread
+ # @param timeout [Numeric, nil] in seconds, `nil` blocks indefinitely
+ # @raise [Concurrent::TimeoutError] on timeout
+ # @return [Object] the value exchanged by the other thread
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#80
+ def exchange!(value, timeout = T.unsafe(nil)); end
+
+ # Waits for another thread to arrive at this exchange point (unless the
+ # current thread is interrupted), and then transfers the given object to
+ # it, receiving its object in return. The timeout value indicates the
+ # approximate number of seconds the method should block while waiting
+ # for the exchange. When the timeout value is `nil` the method will
+ # block indefinitely.
+ #
+ #
+ # The return value will be a {Concurrent::Maybe} set to `Just` on success or
+ # `Nothing` on timeout.
+ #
+ # @example
+ #
+ # exchanger = Concurrent::Exchanger.new
+ #
+ # result = exchanger.exchange(:foo, 0.5)
+ #
+ # if result.just?
+ # puts result.value #=> :bar
+ # else
+ # puts 'timeout'
+ # end
+ # @param value [Object] the value to exchange with another thread
+ # @param timeout [Numeric, nil] in seconds, `nil` blocks indefinitely
+ # @return [Concurrent::Maybe] on success a `Just` maybe will be returned with
+ # the item exchanged by the other thread as `#value`; on timeout a
+ # `Nothing` maybe will be returned with {Concurrent::TimeoutError} as `#reason`
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#109
+ def try_exchange(value, timeout = T.unsafe(nil)); end
+
+ private
+
+ # Waits for another thread to arrive at this exchange point (unless the
+ # current thread is interrupted), and then transfers the given object to
+ # it, receiving its object in return. The timeout value indicates the
+ # approximate number of seconds the method should block while waiting
+ # for the exchange. When the timeout value is `nil` the method will
+ # block indefinitely.
+ #
+ # @param value [Object] the value to exchange with another thread
+ # @param timeout [Numeric, nil] in seconds, `nil` blocks indefinitely
+ # @raise [NotImplementedError]
+ # @return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#122
+ def do_exchange(value, timeout); end
+end
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/exchanger.rb#41
+Concurrent::AbstractExchanger::CANCEL = T.let(T.unsafe(nil), Object)
+
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#10
+class Concurrent::AbstractExecutorService < ::Concurrent::Synchronization::LockableObject
+ include ::Logger::Severity
+ include ::Concurrent::Concern::Logging
+ include ::Concurrent::ExecutorService
+ include ::Concurrent::Concern::Deprecation
+
+ # Create a new thread pool.
+ #
+ # @return [AbstractExecutorService] a new instance of AbstractExecutorService
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#23
+ def initialize(opts = T.unsafe(nil), &block); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#72
+ def auto_terminate=(value); end
+
+ # @return [Boolean]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#67
+ def auto_terminate?; end
+
+ # Returns the value of attribute fallback_policy.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#18
+ def fallback_policy; end
+
+ # @raise [NotImplementedError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#42
+ def kill; end
+
+ # Returns the value of attribute name.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#20
+ def name; end
+
+ # @return [Boolean]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#52
+ def running?; end
+
+ # @raise [NotImplementedError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#37
+ def shutdown; end
+
+ # @return [Boolean]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#62
+ def shutdown?; end
+
+ # @return [Boolean]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#57
+ def shuttingdown?; end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#32
+ def to_s; end
+
+ # @raise [NotImplementedError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#47
+ def wait_for_termination(timeout = T.unsafe(nil)); end
+
+ private
+
+ # Returns an action which executes the `fallback_policy` once the queue
+ # size reaches `max_queue`. The reason for the indirection of an action
+ # is so that the work can be deferred outside of synchronization.
+ #
+ # @param args [Array] the arguments to the task which is being handled.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#85
+ def fallback_action(*args); end
+
+ # @return [Boolean]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#126
+ def ns_auto_terminate?; end
+
+ # @raise [NotImplementedError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#106
+ def ns_execute(*args, &task); end
+
+ # Callback method called when the executor has been killed.
+ # The default behavior is to do nothing.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#122
+ def ns_kill_execution; end
+
+ # Callback method called when an orderly shutdown has completed.
+ # The default behavior is to signal all waiting threads.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#114
+ def ns_shutdown_execution; end
+end
+
+# The set of possible fallback policies that may be set at thread pool creation.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb#15
+Concurrent::AbstractExecutorService::FALLBACK_POLICIES = T.let(T.unsafe(nil), Array)
+
+# An abstract implementation of local storage, with sub-classes for
+# per-thread and per-fiber locals.
+#
+# Each execution context (EC, thread or fiber) has a lazily initialized array
+# of local variable values. Each time a new local variable is created, we
+# allocate an "index" for it.
+#
+# For example, if the allocated index is 1, that means slot #1 in EVERY EC's
+# locals array will be used for the value of that variable.
+#
+# The good thing about using a per-EC structure to hold values, rather than
+# a global, is that no synchronization is needed when reading and writing
+# those values (since the structure is only ever accessed by a single
+# thread).
+#
+# Of course, when a local variable is GC'd, 1) we need to recover its index
+# for use by other new local variables (otherwise the locals arrays could
+# get bigger and bigger with time), and 2) we need to null out all the
+# references held in the now-unused slots (both to avoid blocking GC of those
+# objects, and also to prevent "stale" values from being passed on to a new
+# local when the index is reused).
+#
+# Because we need to null out freed slots, we need to keep references to
+# ALL the locals arrays, so we can null out the appropriate slots in all of
+# them. This is why we need to use a finalizer to clean up the locals array
+# when the EC goes out of scope.
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#35
+class Concurrent::AbstractLocals
+ # @return [AbstractLocals] a new instance of AbstractLocals
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#36
+ def initialize; end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#89
+ def fetch(index); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#71
+ def free_index(index); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#55
+ def next_index(local); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#102
+ def set(index, value); end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#43
+ def synchronize; end
+
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#48
+ def weak_synchronize; end
+
+ private
+
+ # When the local goes out of scope, clean up that slot across all locals currently assigned.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#112
+ def local_finalizer(index); end
+
+ # Returns the locals for the current scope, or nil if none exist.
+ #
+ # @raise [NotImplementedError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#128
+ def locals; end
+
+ # Returns the locals for the current scope, creating them if necessary.
+ #
+ # @raise [NotImplementedError]
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#133
+ def locals!; end
+
+ # When a thread/fiber goes out of scope, remove the array from @all_arrays.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/atomic/locals.rb#119
+ def thread_fiber_finalizer(array_object_id); end
+end
+
+# `Agent` is inspired by Clojure's [agent](http://clojure.org/agents)
+# function. An agent is a shared, mutable variable providing independent,
+# uncoordinated, *asynchronous* change of individual values. Best used when
+# the value will undergo frequent, complex updates. Suitable when the result
+# of an update does not need to be known immediately. `Agent` is (mostly)
+# functionally equivalent to Clojure's agent, except where the runtime
+# prevents parity.
+#
+# Agents are reactive, not autonomous - there is no imperative message loop
+# and no blocking receive. The state of an Agent should be itself immutable
+# and the `#value` of an Agent is always immediately available for reading by
+# any thread without any messages, i.e. observation does not require
+# cooperation or coordination.
+#
+# Agent action dispatches are made using the various `#send` methods. These
+# methods always return immediately. At some point later, in another thread,
+# the following will happen:
+#
+# 1. The given `action` will be applied to the state of the Agent and the
+# `args`, if any were supplied.
+# 2. The return value of `action` will be passed to the validator lambda,
+# if one has been set on the Agent.
+# 3. If the validator succeeds or if no validator was given, the return value
+# of the given `action` will become the new `#value` of the Agent. See
+# `#initialize` for details.
+# 4. If any observers were added to the Agent, they will be notified. See
+# `#add_observer` for details.
+# 5. If during the `action` execution any other dispatches are made (directly
+# or indirectly), they will be held until after the `#value` of the Agent
+# has been changed.
+#
+# If any exceptions are thrown by an action function, no nested dispatches
+# will occur, and the exception will be cached in the Agent itself. When an
+# Agent has errors cached, any subsequent interactions will immediately throw
+# an exception, until the agent's errors are cleared. Agent errors can be
+# examined with `#error` and the agent restarted with `#restart`.
+#
+# The actions of all Agents get interleaved amongst threads in a thread pool.
+# At any point in time, at most one action for each Agent is being executed.
+# Actions dispatched to an agent from another single agent or thread will
+# occur in the order they were sent, potentially interleaved with actions
+# dispatched to the same agent from other sources. The `#send` method should
+# be used for actions that are CPU limited, while the `#send_off` method is
+# appropriate for actions that may block on IO.
+#
+# Unlike in Clojure, `Agent` cannot participate in `Concurrent::TVar` transactions.
+#
+# ## Example
+#
+# ```
+# def next_fibonacci(set = nil)
+# return [0, 1] if set.nil?
+# set + [set[-2..-1].reduce{|sum,x| sum + x }]
+# end
+#
+# # create an agent with an initial value
+# agent = Concurrent::Agent.new(next_fibonacci)
+#
+# # send a few update requests
+# 5.times do
+# agent.send{|set| next_fibonacci(set) }
+# end
+#
+# # wait for them to complete
+# agent.await
+#
+# # get the current value
+# agent.value #=> [0, 1, 1, 2, 3, 5, 8]
+# ```
+#
+# ## Observation
+#
+# Agents support observers through the {Concurrent::Observable} mixin module.
+# Notification of observers occurs every time an action dispatch returns and
+# the new value is successfully validated. Observation will *not* occur if the
+# action raises an exception, if validation fails, or when a {#restart} occurs.
+#
+# When notified the observer will receive three arguments: `time`, `old_value`,
+# and `new_value`. The `time` argument is the time at which the value change
+# occurred. The `old_value` is the value of the Agent when the action began
+# processing. The `new_value` is the value to which the Agent was set when the
+# action completed. Note that `old_value` and `new_value` may be the same.
+# This is not an error. It simply means that the action returned the same
+# value.
+#
+# ## Nested Actions
+#
+# It is possible for an Agent action to post further actions back to itself.
+# The nested actions will be enqueued normally then processed *after* the
+# outer action completes, in the order they were sent, possibly interleaved
+# with action dispatches from other threads. Nested actions never deadlock
+# with one another and a failure in a nested action will never affect the
+# outer action.
+#
+# Nested actions can be called using the Agent reference from the enclosing
+# scope or by passing the reference in as a "send" argument. Nested actions
+# cannot be post using `self` from within the action block/proc/lambda; `self`
+# in this context will not reference the Agent. The preferred method for
+# dispatching nested actions is to pass the Agent as an argument. This allows
+# Ruby to more effectively manage the closing scope.
+#
+# Prefer this:
+#
+# ```
+# agent = Concurrent::Agent.new(0)
+# agent.send(agent) do |value, this|
+# this.send {|v| v + 42 }
+# 3.14
+# end
+# agent.value #=> 45.14
+# ```
+#
+# Over this:
+#
+# ```
+# agent = Concurrent::Agent.new(0)
+# agent.send do |value|
+# agent.send {|v| v + 42 }
+# 3.14
+# end
+# ```
+#
+#
+# **NOTE** Never, *under any circumstances*, call any of the "await" methods
+# ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+# block/proc/lambda. The call will block the Agent and will always fail.
+# Calling either {#await} or {#wait} (with a timeout of `nil`) will
+# hopelessly deadlock the Agent with no possibility of recovery.
+#
+# @see http://clojure.org/Agents Clojure Agents
+# @see http://clojure.org/state Values and Change - Clojure's approach to Identity and State
+#
+# source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#145
+class Concurrent::Agent < ::Concurrent::Synchronization::LockableObject
+ include ::Concurrent::Concern::Observable
+
+ # Create a new `Agent` with the given initial value and options.
+ #
+ # The `:validator` option must be `nil` or a side-effect free proc/lambda
+ # which takes one argument. On any intended value change the validator, if
+ # provided, will be called. If the new value is invalid the validator should
+ # return `false` or raise an error.
+ #
+ # The `:error_handler` option must be `nil` or a proc/lambda which takes two
+ # arguments. When an action raises an error or validation fails, either by
+ # returning false or raising an error, the error handler will be called. The
+ # arguments to the error handler will be a reference to the agent itself and
+ # the error object which was raised.
+ #
+ # The `:error_mode` may be either `:continue` (the default if an error
+ # handler is given) or `:fail` (the default if error handler nil or not
+ # given).
+ #
+ # If an action being run by the agent throws an error or doesn't pass
+ # validation the error handler, if present, will be called. After the
+ # handler executes if the error mode is `:continue` the Agent will continue
+ # as if neither the action that caused the error nor the error itself ever
+ # happened.
+ #
+ # If the mode is `:fail` the Agent will become {#failed?} and will stop
+ # accepting new action dispatches. Any previously queued actions will be
+ # held until {#restart} is called. The {#value} method will still work,
+ # returning the value of the Agent before the error.
+ #
+ # @option opts
+ # @option opts
+ # @option opts
+ # @param initial [Object] the initial value
+ # @param opts [Hash] the configuration options
+ # @return [Agent] a new instance of Agent
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#220
+ def initialize(initial, opts = T.unsafe(nil)); end
+
+ # Dispatches an action to the Agent and returns immediately. Subsequently,
+ # in a thread from a thread pool, the {#value} will be set to the return
+ # value of the action. Appropriate for actions that may block on IO.
+ #
+ # @param action [Proc] the action dispatch to be enqueued
+ # @return [Concurrent::Agent] self
+ # @see #send_off
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#331
+ def <<(action); end
+
+ # Blocks the current thread (indefinitely!) until all actions dispatched
+ # thus far, from this thread or nested by the Agent, have occurred. Will
+ # block when {#failed?}. Will never return if a failed Agent is {#restart}
+ # with `:clear_actions` true.
+ #
+ # Returns a reference to `self` to support method chaining:
+ #
+ # ```
+ # current_value = agent.await.value
+ # ```
+ #
+ #
+ # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+ # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+ # block/proc/lambda. The call will block the Agent and will always fail.
+ # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+ # hopelessly deadlock the Agent with no possibility of recovery.
+ #
+ # @return [Boolean] self
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#350
+ def await; end
+
+ # Blocks the current thread until all actions dispatched thus far, from this
+ # thread or nested by the Agent, have occurred, or the timeout (in seconds)
+ # has elapsed.
+ #
+ #
+ # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+ # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+ # block/proc/lambda. The call will block the Agent and will always fail.
+ # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+ # hopelessly deadlock the Agent with no possibility of recovery.
+ #
+ # @param timeout [Float] the maximum number of seconds to wait
+ # @return [Boolean] true if all actions complete before timeout else false
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#363
+ def await_for(timeout); end
+
+ # Blocks the current thread until all actions dispatched thus far, from this
+ # thread or nested by the Agent, have occurred, or the timeout (in seconds)
+ # has elapsed.
+ #
+ #
+ # **NOTE** Never, *under any circumstances*, call any of the "await" methods
+ # ({#await}, {#await_for}, {#await_for!}, and {#wait}) from within an action
+ # block/proc/lambda. The call will block the Agent and will always fail.
+ # Calling either {#await} or {#wait} (with a timeout of `nil`) will
+ # hopelessly deadlock the Agent with no possibility of recovery.
+ #
+ # @param timeout [Float] the maximum number of seconds to wait
+ # @raise [Concurrent::TimeoutError] when timout is reached
+ # @return [Boolean] true if all actions complete before timeout
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#377
+ def await_for!(timeout); end
+
+ # The current value (state) of the Agent, irrespective of any pending or
+ # in-progress actions. The value is always available and is non-blocking.
+ #
+ # @return [Object] the current value
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#229
+ def deref; end
+
+ # When {#failed?} and {#error_mode} is `:fail`, returns the error object
+ # which caused the failure, else `nil`. When {#error_mode} is `:continue`
+ # will *always* return `nil`.
+ #
+ # @return [nil, Error] the error which caused the failure when {#failed?}
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#240
+ def error; end
+
+ # The error mode this Agent is operating in. See {#initialize} for details.
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#184
+ def error_mode; end
+
+ # Is the Agent in a failed state?
+ #
+ # @return [Boolean]
+ # @see #restart
+ #
+ # source://concurrent-ruby//lib/concurrent-ruby/concurrent/agent.rb#402
+ def failed?; end
+
+ # Dispatches an action to the Agent and returns immediately. Subsequently,
+ # in a thread from a thread pool, the {#value} will be set to the return
+ # value of the action. Action dispatches are only allowed when the Agent
+ # is not {#failed?}.
+ #
+ # The action must be a block/proc/lambda which takes 1 or more arguments.
+ # The first argument is the current {#value} of the Agent. Any arguments
+ # passed to the send method via the `args` parameter will be passed to the
+ # action as the remaining arguments. The action must return the new value
+ # of the Agent.
+ #
+ # * {#send} and {#send!} should be used for actions that are CPU limited
+ # * {#send_off}, {#send_off!}, and {#<<} are appropriate for actions that
+ # may block on IO
+ # * {#send_via} and {#send_via!} are used when a specific executor is to
+ # be used for the action
+ #
+ # @param args [Array