rbs 2.0.0 → 2.1.0

data/stdlib/bigdecimal-math/0/big_math.rbs

@@ -1,3 +1,4 @@
+# <!-- rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb -->
 # Provides mathematical functions.
 #
 # Example:
@@ -10,22 +11,34 @@
 #     puts sin(a,100) # => 0.99999999999999999999......e0
 #
 module BigMath
+  # <!--
+  #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
+  #   - E(numeric) -> BigDecimal
+  # -->
   # Computes e (the base of natural logarithms) to the specified number of digits
   # of precision, `numeric`.
   #
   #     BigMath.E(10).to_s
   #     #=> "0.271828182845904523536028752390026306410273e1"
   #
-  def self.E: (Numeric prec) -> BigDecimal
+  def self?.E: (Numeric prec) -> BigDecimal
 
+  # <!--
+  #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
+  #   - PI(numeric) -> BigDecimal
+  # -->
   # Computes the value of pi to the specified number of digits of precision,
   # `numeric`.
   #
   #     BigMath.PI(10).to_s
   #     #=> "0.3141592653589793238462643388813853786957412e1"
   #
-  def self.PI: (Numeric prec) -> BigDecimal
+  def self?.PI: (Numeric prec) -> BigDecimal
 
+  # <!--
+  #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
+  #   - atan(decimal, numeric) -> BigDecimal
+  # -->
   # Computes the arctangent of `decimal` to the specified number of digits of
   # precision, `numeric`.
   #
@@ -34,8 +47,12 @@ module BigMath
   #     BigMath.atan(BigDecimal('-1'), 16).to_s
   #     #=> "-0.785398163397448309615660845819878471907514682065e0"
   #
-  def self.atan: (BigDecimal x, Numeric prec) -> BigDecimal
+  def self?.atan: (BigDecimal x, Numeric prec) -> BigDecimal
 
+  # <!--
+  #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
+  #   - cos(decimal, numeric) -> BigDecimal
+  # -->
   # Computes the cosine of `decimal` to the specified number of digits of
   # precision, `numeric`.
   #
@@ -44,8 +61,12 @@ module BigMath
   #     BigMath.cos(BigMath.PI(4), 16).to_s
   #     #=> "-0.999999999999999999999999999999856613163740061349e0"
   #
-  def self.cos: (BigDecimal x, Numeric prec) -> BigDecimal
+  def self?.cos: (BigDecimal x, Numeric prec) -> BigDecimal
 
+  # <!--
+  #   rdoc-file=ext/bigdecimal/bigdecimal.c
+  #   - BigMath.exp(decimal, numeric)    -> BigDecimal
+  # -->
   # Computes the value of e (the base of natural logarithms) raised to the power
   # of `decimal`, to the specified number of digits of precision.
   #
@@ -53,8 +74,12 @@ module BigMath
   #
   # If `decimal` is NaN, returns NaN.
   #
-  def self.exp: (BigDecimal, Numeric prec) -> BigDecimal
+  def self?.exp: (BigDecimal, Numeric prec) -> BigDecimal
 
+  # <!--
+  #   rdoc-file=ext/bigdecimal/bigdecimal.c
+  #   - BigMath.log(decimal, numeric)    -> BigDecimal
+  # -->
   # Computes the natural logarithm of `decimal` to the specified number of digits
   # of precision, `numeric`.
   #
@@ -64,8 +89,12 @@ module BigMath
   #
   # If `decimal` is NaN, returns NaN.
   #
-  def self.log: (BigDecimal, Numeric prec) -> BigDecimal
+  def self?.log: (BigDecimal, Numeric prec) -> BigDecimal
 
+  # <!--
+  #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
+  #   - sin(decimal, numeric) -> BigDecimal
+  # -->
   # Computes the sine of `decimal` to the specified number of digits of precision,
   # `numeric`.
   #
@@ -74,69 +103,17 @@ module BigMath
   #     BigMath.sin(BigMath.PI(5)/4, 5).to_s
   #     #=> "0.70710678118654752440082036563292800375e0"
   #
-  def self.sin: (BigDecimal x, Numeric prec) -> BigDecimal
+  def self?.sin: (BigDecimal x, Numeric prec) -> BigDecimal
 
+  # <!--
+  #   rdoc-file=ext/bigdecimal/lib/bigdecimal/math.rb
+  #   - sqrt(decimal, numeric) -> BigDecimal
+  # -->
   # Computes the square root of `decimal` to the specified number of digits of
   # precision, `numeric`.
   #
   #     BigMath.sqrt(BigDecimal('2'), 16).to_s
   #     #=> "0.1414213562373095048801688724e1"
   #
-  def self.sqrt: (BigDecimal x, Numeric prec) -> BigDecimal
-
-  private
-
-  # Computes e (the base of natural logarithms) to the specified number of digits
-  # of precision, `numeric`.
-  #
-  #     BigMath.E(10).to_s
-  #     #=> "0.271828182845904523536028752390026306410273e1"
-  #
-  def E: (Numeric prec) -> BigDecimal
-
-  # Computes the value of pi to the specified number of digits of precision,
-  # `numeric`.
-  #
-  #     BigMath.PI(10).to_s
-  #     #=> "0.3141592653589793238462643388813853786957412e1"
-  #
-  def PI: (Numeric prec) -> BigDecimal
-
-  # Computes the arctangent of `decimal` to the specified number of digits of
-  # precision, `numeric`.
-  #
-  # If `decimal` is NaN, returns NaN.
-  #
-  #     BigMath.atan(BigDecimal('-1'), 16).to_s
-  #     #=> "-0.785398163397448309615660845819878471907514682065e0"
-  #
-  def atan: (BigDecimal x, Numeric prec) -> BigDecimal
-
-  # Computes the cosine of `decimal` to the specified number of digits of
-  # precision, `numeric`.
-  #
-  # If `decimal` is Infinity or NaN, returns NaN.
-  #
-  #     BigMath.cos(BigMath.PI(4), 16).to_s
-  #     #=> "-0.999999999999999999999999999999856613163740061349e0"
-  #
-  def cos: (BigDecimal x, Numeric prec) -> BigDecimal
-
-  # Computes the sine of `decimal` to the specified number of digits of precision,
-  # `numeric`.
-  #
-  # If `decimal` is Infinity or NaN, returns NaN.
-  #
-  #     BigMath.sin(BigMath.PI(5)/4, 5).to_s
-  #     #=> "0.70710678118654752440082036563292800375e0"
-  #
-  def sin: (BigDecimal x, Numeric prec) -> BigDecimal
-
-  # Computes the square root of `decimal` to the specified number of digits of
-  # precision, `numeric`.
-  #
-  #     BigMath.sqrt(BigDecimal('2'), 16).to_s
-  #     #=> "0.1414213562373095048801688724e1"
-  #
-  def sqrt: (BigDecimal x, Numeric prec) -> BigDecimal
+  def self?.sqrt: (BigDecimal x, Numeric prec) -> BigDecimal
 end

data/stdlib/cgi/0/core.rbs

@@ -1,3 +1,4 @@
+# <!-- rdoc-file=lib/cgi.rb -->
 # ## Overview
 #
 # The Common Gateway Interface (CGI) is a simple protocol for passing an HTTP
@@ -266,7 +267,13 @@
 #     include CGI::Util
 #     escapeHTML('Usage: foo "bar" <baz>')
 #     h('Usage: foo "bar" <baz>') # alias
+#
 class CGI
+  # <!--
+  #   rdoc-file=lib/cgi/core.rb
+  #   - CGI.new(tag_maker) { block }
+  #   - CGI.new(options_hash = {}) { block }
+  # -->
   # Create a new CGI instance.
   #
   # `tag_maker`
@@ -343,16 +350,31 @@ class CGI
   def initialize: (?String tag_maker) ?{ (String name, String value) -> void } -> void
                 | (Hash[Symbol, untyped] options_hash) ?{ (String name, String value) -> void } -> void
 
+  # <!-- rdoc-file=lib/cgi/core.rb -->
+  # Return the accept character set for this CGI instance.
+  #
   attr_reader accept_charset: String
 
+  # <!--
+  #   rdoc-file=lib/cgi/core.rb
+  #   - accept_charset()
+  # -->
   # Return the accept character set for all new CGI instances.
   #
   def self.accept_charset: () -> String
 
+  # <!--
+  #   rdoc-file=lib/cgi/core.rb
+  #   - accept_charset=(accept_charset)
+  # -->
   # Set the accept character set for all new CGI instances.
   #
   def self.accept_charset=: (String accept_charset) -> String
 
+  # <!--
+  #   rdoc-file=lib/cgi/core.rb
+  #   - parse(query)
+  # -->
   # Parse an HTTP query string into a hash of key=>value pairs.
   #
   #     params = CGI.parse("query_string")
@@ -363,6 +385,7 @@ class CGI
 
   public
 
+  # <!-- rdoc-file=lib/cgi/core.rb -->
   # This method is an alias for #http_header, when HTML5 tag maker is inactive.
   #
   # NOTE: use #http_header to create HTTP header blocks, this alias is only
@@ -372,6 +395,11 @@ class CGI
   #
   alias header http_header
 
+  # <!--
+  #   rdoc-file=lib/cgi/core.rb
+  #   - http_header(content_type_string="text/html")
+  #   - http_header(headers_hash)
+  # -->
   # Create an HTTP header block as a string.
   #
   # Includes the empty line that ends the header block.
@@ -487,6 +515,11 @@ class CGI
 
   def nph?: () -> boolish
 
+  # <!--
+  #   rdoc-file=lib/cgi/core.rb
+  #   - cgi.out(content_type_string='text/html')
+  #   - cgi.out(headers_hash)
+  # -->
   # Print an HTTP header and body to $DEFAULT_OUTPUT ($>)
   #
   # `content_type_string`
@@ -551,6 +584,10 @@ class CGI
   def out: (?String content_type_string) { () -> String } -> void
          | (Hash[String | Symbol, untyped] headers_hash) { () -> String } -> void
 
+  # <!--
+  #   rdoc-file=lib/cgi/core.rb
+  #   - print(*options)
+  # -->
   # Print an argument or list of arguments to the default output stream
   #
   #     cgi = CGI.new
@@ -560,34 +597,56 @@ class CGI
 
   private
 
+  # <!--
+  #   rdoc-file=lib/cgi/core.rb
+  #   - stdinput()
+  # -->
   # Synonym for $stdin.
   #
   def stdinput: () -> ::IO
 
+  # <!--
+  #   rdoc-file=lib/cgi/core.rb
+  #   - stdoutput()
+  # -->
   # Synonym for $stdout.
   #
   def stdoutput: () -> ::IO
 end
 
+# <!-- rdoc-file=lib/cgi/core.rb -->
 # String for carriage return
+#
 CGI::CR: String
 
+# <!-- rdoc-file=lib/cgi/core.rb -->
 # Standard internet newline sequence
+#
 CGI::EOL: String
 
+# <!-- rdoc-file=lib/cgi/core.rb -->
 # HTTP status codes.
+#
 CGI::HTTP_STATUS: Hash[String, String]
 
+# <!-- rdoc-file=lib/cgi/core.rb -->
 # String for linefeed
+#
 CGI::LF: String
 
+# <!-- rdoc-file=lib/cgi/core.rb -->
 # Maximum number of request parameters when multipart
+#
 CGI::MAX_MULTIPART_COUNT: Integer
 
+# <!-- rdoc-file=lib/cgi/core.rb -->
 # Whether processing will be required in binary vs text
+#
 CGI::NEEDS_BINMODE: bool
 
+# <!-- rdoc-file=lib/cgi/core.rb -->
 # Path separators in different environments.
+#
 CGI::PATH_SEPARATOR: Hash[String, String]
 
 CGI::REVISION: String

data/stdlib/coverage/0/coverage.rbs

@@ -1,6 +1,10 @@
+# <!-- rdoc-file=ext/coverage/coverage.c -->
 # Coverage provides coverage measurement feature for Ruby. This feature is
 # experimental, so these APIs may be changed in future.
 #
+# Caveat: Currently, only process-global coverage measurement is supported. You
+# cannot measure per-thread covearge.
+#
 # # Usage
 #
 # 1.  require "coverage"
@@ -12,7 +16,7 @@
 #     disabled for this line (lines like `else` and `end`).
 #
 #
-# # Example
+# # Examples
 #
 #     [foo.rb]
 #     s = 0
@@ -32,9 +36,129 @@
 #     require "foo.rb"
 #     p Coverage.result  #=> {"foo.rb"=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil]}
 #
+# ## Lines Coverage
+#
+# If a coverage mode is not explicitly specified when starting coverage, lines
+# coverage is what will run. It reports the number of line executions for each
+# line.
+#
+#     require "coverage"
+#     Coverage.start(lines: true)
+#     require "foo.rb"
+#     p Coverage.result #=> {"foo.rb"=>{:lines=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil]}}
+#
+# The value of the lines coverage result is an array containing how many times
+# each line was executed. Order in this array is important. For example, the
+# first item in this array, at index 0, reports how many times line 1 of this
+# file was executed while coverage was run (which, in this example, is one
+# time).
+#
+# A `nil` value means coverage is disabled for this line (lines like `else` and
+# `end`).
+#
+# ## Oneshot Lines Coverage
+#
+# Oneshot lines coverage tracks and reports on the executed lines while coverage
+# is running. It will not report how many times a line was executed, only that
+# it was executed.
+#
+#     require "coverage"
+#     Coverage.start(oneshot_lines: true)
+#     require "foo.rb"
+#     p Coverage.result #=> {"foo.rb"=>{:oneshot_lines=>[1, 2, 3, 6, 7]}}
+#
+# The value of the oneshot lines coverage result is an array containing the line
+# numbers that were executed.
+#
+# ## Branches Coverage
+#
+# Branches coverage reports how many times each branch within each conditional
+# was executed.
+#
+#     require "coverage"
+#     Coverage.start(branches: true)
+#     require "foo.rb"
+#     p Coverage.result #=> {"foo.rb"=>{:branches=>{[:if, 0, 6, 0, 10, 3]=>{[:then, 1, 7, 2, 7, 7]=>1, [:else, 2, 9, 2, 9, 7]=>0}}}}
+#
+# Each entry within the branches hash is a conditional, the value of which is
+# another hash where each entry is a branch in that conditional. The values are
+# the number of times the method was executed, and the keys are identifying
+# information about the branch.
+#
+# The information that makes up each key identifying branches or conditionals is
+# the following, from left to right:
+#
+# 1.  A label for the type of branch or conditional.
+# 2.  A unique identifier.
+# 3.  The starting line number it appears on in the file.
+# 4.  The starting column number it appears on in the file.
+# 5.  The ending line number it appears on in the file.
+# 6.  The ending column number it appears on in the file.
+#
+#
+# ## Methods Coverage
+#
+# Methods coverage reports how many times each method was executed.
+#
+#     [foo_method.rb]
+#     class Greeter
+#       def greet
+#         "welcome!"
+#       end
+#     end
+#
+#     def hello
+#       "Hi"
+#     end
+#
+#     hello()
+#     Greeter.new.greet()
+#     [EOF]
+#
+#     require "coverage"
+#     Coverage.start(methods: true)
+#     require "foo_method.rb"
+#     p Coverage.result #=> {"foo_method.rb"=>{:methods=>{[Object, :hello, 7, 0, 9, 3]=>1, [Greeter, :greet, 2, 2, 4, 5]=>1}}}
+#
+# Each entry within the methods hash represents a method. The values in this
+# hash are the number of times the method was executed, and the keys are
+# identifying information about the method.
+#
+# The information that makes up each key identifying a method is the following,
+# from left to right:
+#
+# 1.  The class.
+# 2.  The method name.
+# 3.  The starting line number the method appears on in the file.
+# 4.  The starting column number the method appears on in the file.
+# 5.  The ending line number the method appears on in the file.
+# 6.  The ending column number the method appears on in the file.
+#
+#
+# ## All Coverage Modes
+#
+# You can also run all modes of coverage simultaneously with this shortcut. Note
+# that running all coverage modes does not run both lines and oneshot lines.
+# Those modes cannot be run simultaneously. Lines coverage is run in this case,
+# because you can still use it to determine whether or not a line was executed.
+#
+#     require "coverage"
+#     Coverage.start(:all)
+#     require "foo.rb"
+#     p Coverage.result #=> {"foo.rb"=>{:lines=>[1, 1, 10, nil, nil, 1, 1, nil, 0, nil], :branches=>{[:if, 0, 6, 0, 10, 3]=>{[:then, 1, 7, 2, 7, 7]=>1, [:else, 2, 9, 2, 9, 7]=>0}}, :methods=>{}}}
+#
 module Coverage
+  # <!--
+  #   rdoc-file=ext/coverage/lib/coverage.rb
+  #   - line_stub(file)
+  # -->
+  #
   def self.line_stub: () -> Array[Integer?]
 
+  # <!--
+  #   rdoc-file=ext/coverage/coverage.c
+  #   - Coverage.peek_result  => hash
+  # -->
   # Returns a hash that contains filename as key and coverage array as value. This
   # is the same as `Coverage.result(stop: false, clear: false)`.
   #
@@ -45,18 +169,56 @@ module Coverage
   #
   def self.peek_result: () -> Hash[String, untyped]
 
+  # <!--
+  #   rdoc-file=ext/coverage/coverage.c
+  #   - Coverage.result(stop: true, clear: true)  => hash
+  # -->
   # Returns a hash that contains filename as key and coverage array as value. If
   # `clear` is true, it clears the counters to zero. If `stop` is true, it
   # disables coverage measurement.
   #
   def self.result: (?stop: boolish, ?clear: boolish) -> Hash[String, untyped]
 
+  # <!--
+  #   rdoc-file=ext/coverage/coverage.c
+  #   - Coverage.running?  => bool
+  # -->
   # Returns true if coverage stats are currently being collected (after
   # Coverage.start call, but before Coverage.result call)
   #
   def self.running?: () -> bool
 
-  # Enables coverage measurement.
+  # <!--
+  #   rdoc-file=ext/coverage/coverage.c
+  #   - Coverage.start                                              => nil
+  #   - Coverage.start(:all)                                        => nil
+  #   - Coverage.start(lines: bool, branches: bool, methods: bool)  => nil
+  #   - Coverage.start(oneshot_lines: true)                         => nil
+  # -->
+  # Enables the coverage measurement. See the documentation of Coverage class in
+  # detail. This is equivalent to Coverage.setup and Coverage.resume.
   #
   def self.start: (?lines: boolish, ?branches: boolish, ?methods: boolish, ?oneshot_lines: boolish) -> nil
+
+  # <!--
+  #   rdoc-file=ext/coverage/coverage.c
+  #   - Coverage.resume  => nil
+  # -->
+  # Start/resume the coverage measurement.
+  #
+  # Caveat: Currently, only process-global coverage measurement is supported. You
+  # cannot measure per-thread covearge. If your process has multiple thread, using
+  # Coverage.resume/suspend to capture code coverage executed from only a limited
+  # code block, may yield misleading results.
+  #
+  def self.resume: () -> nil
+
+  # <!--
+  #   rdoc-file=ext/coverage/coverage.c
+  #   - Coverage.suspend  => nil
+  # -->
+  # Suspend the coverage measurement. You can use Coverage.resume to restart the
+  # measurement.
+  #
+  def self.suspend: () -> nil
 end