rbs 4.1.0.pre.2-java

data/stdlib/time/0/time.rbs

@@ -0,0 +1,434 @@
+%a{annotate:rdoc:skip}
+class Time
+  interface _TimeLike
+    def year: () -> Integer
+
+    def mon: () -> Integer
+
+    def day: () -> Integer
+  end
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - zone_offset(zone, year=nil)
+  # -->
+  # Return the number of seconds the specified time zone differs from UTC.
+  #
+  # Numeric time zones that include minutes, such as <code>-10:00</code> or
+  # <code>+1330</code> will work, as will simpler hour-only time zones like
+  # <code>-10</code> or <code>+13</code>.
+  #
+  # Textual time zones listed in ZoneOffset are also supported.
+  #
+  # If the time zone does not match any of the above, `zone_offset` will check if
+  # the local time zone (both with and without potential Daylight Saving Time
+  # changes being in effect) matches `zone`. Specifying a value for `year` will
+  # change the year used to find the local time zone.
+  #
+  # If `zone_offset` is unable to determine the offset, nil will be returned.
+  #
+  #     require 'time'
+  #
+  #     Time.zone_offset("EST") #=> -18000
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.zone_offset: (String zone, ?Integer year) -> Integer
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - parse(date, now=self.now) { |year| ... }
+  # -->
+  # Takes a string representation of a Time and attempts to parse it using a
+  # heuristic.
+  #
+  # This method **does not** function as a validator.  If the input string does
+  # not match valid formats strictly, you may get a cryptic result.  Should
+  # consider to use Time.strptime instead of this method as possible.
+  #
+  #     require 'time'
+  #
+  #     Time.parse("2010-10-31") #=> 2010-10-31 00:00:00 -0500
+  #
+  # Any missing pieces of the date are inferred based on the current date.
+  #
+  #     require 'time'
+  #
+  #     # assuming the current date is "2011-10-31"
+  #     Time.parse("12:00") #=> 2011-10-31 12:00:00 -0500
+  #
+  # We can change the date used to infer our missing elements by passing a second
+  # object that responds to #mon, #day and #year, such as Date, Time or DateTime.
+  # We can also use our own object.
+  #
+  #     require 'time'
+  #
+  #     class MyDate
+  #       attr_reader :mon, :day, :year
+  #
+  #       def initialize(mon, day, year)
+  #         @mon, @day, @year = mon, day, year
+  #       end
+  #     end
+  #
+  #     d  = Date.parse("2010-10-28")
+  #     t  = Time.parse("2010-10-29")
+  #     dt = DateTime.parse("2010-10-30")
+  #     md = MyDate.new(10,31,2010)
+  #
+  #     Time.parse("12:00", d)  #=> 2010-10-28 12:00:00 -0500
+  #     Time.parse("12:00", t)  #=> 2010-10-29 12:00:00 -0500
+  #     Time.parse("12:00", dt) #=> 2010-10-30 12:00:00 -0500
+  #     Time.parse("12:00", md) #=> 2010-10-31 12:00:00 -0500
+  #
+  # If a block is given, the year described in `date` is converted by the block.
+  # This is specifically designed for handling two digit years. For example, if
+  # you wanted to treat all two digit years prior to 70 as the year 2000+ you
+  # could write this:
+  #
+  #     require 'time'
+  #
+  #     Time.parse("01-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
+  #     #=> 2001-10-31 00:00:00 -0500
+  #     Time.parse("70-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
+  #     #=> 1970-10-31 00:00:00 -0500
+  #
+  # If the upper components of the given time are broken or missing, they are
+  # supplied with those of `now`.  For the lower components, the minimum values (1
+  # or 0) are assumed if broken or missing.  For example:
+  #
+  #     require 'time'
+  #
+  #     # Suppose it is "Thu Nov 29 14:33:20 2001" now and
+  #     # your time zone is EST which is GMT-5.
+  #     now = Time.parse("Thu Nov 29 14:33:20 2001")
+  #     Time.parse("16:30", now)     #=> 2001-11-29 16:30:00 -0500
+  #     Time.parse("7/23", now)      #=> 2001-07-23 00:00:00 -0500
+  #     Time.parse("Aug 31", now)    #=> 2001-08-31 00:00:00 -0500
+  #     Time.parse("Aug 2000", now)  #=> 2000-08-01 00:00:00 -0500
+  #
+  # Since there are numerous conflicts among locally defined time zone
+  # abbreviations all over the world, this method is not intended to understand
+  # all of them.  For example, the abbreviation "CST" is used variously as:
+  #
+  #     -06:00 in America/Chicago,
+  #     -05:00 in America/Havana,
+  #     +08:00 in Asia/Harbin,
+  #     +09:30 in Australia/Darwin,
+  #     +10:30 in Australia/Adelaide,
+  #     etc.
+  #
+  # Based on this fact, this method only understands the time zone abbreviations
+  # described in RFC 822 and the system time zone, in the order named. (i.e. a
+  # definition in RFC 822 overrides the system time zone definition.)  The system
+  # time zone is taken from <code>Time.local(year, 1, 1).zone</code> and
+  # <code>Time.local(year, 7, 1).zone</code>. If the extracted time zone
+  # abbreviation does not match any of them, it is ignored and the given time is
+  # regarded as a local time.
+  #
+  # ArgumentError is raised if Date._parse cannot extract information from `date`
+  # or if the Time class cannot represent specified date.
+  #
+  # This method can be used as a fail-safe for other parsing methods as:
+  #
+  #     Time.rfc2822(date) rescue Time.parse(date)
+  #     Time.httpdate(date) rescue Time.parse(date)
+  #     Time.xmlschema(date) rescue Time.parse(date)
+  #
+  # A failure of Time.parse should be checked, though.
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.parse: (String date, ?_TimeLike now) ?{ (Integer) -> Integer } -> Time
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - strptime(date, format, now=self.now) { |year| ... }
+  # -->
+  # Works similar to `parse` except that instead of using a heuristic to detect
+  # the format of the input string, you provide a second argument that describes
+  # the format of the string.
+  #
+  # Raises ArgumentError if the date or format is invalid.
+  #
+  # If a block is given, the year described in `date` is converted by the block.
+  # For example:
+  #
+  #     Time.strptime(...) {|y| y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}
+  #
+  # Below is a list of the formatting options:
+  #
+  # %a
+  # :   The abbreviated weekday name ("Sun")
+  #
+  # %A
+  # :   The  full  weekday  name ("Sunday")
+  #
+  # %b
+  # :   The abbreviated month name ("Jan")
+  #
+  # %B
+  # :   The  full  month  name ("January")
+  #
+  # %c
+  # :   The preferred local date and time representation
+  #
+  # %C
+  # :   Century (20 in 2009)
+  #
+  # %d
+  # :   Day of the month (01..31)
+  #
+  # %D
+  # :   Date (%m/%d/%y)
+  #
+  # %e
+  # :   Day of the month, blank-padded ( 1..31)
+  #
+  # %F
+  # :   Equivalent to %Y-%m-%d (the ISO 8601 date format)
+  #
+  # %g
+  # :   The last two digits of the commercial year
+  #
+  # %G
+  # :   The week-based year according to ISO-8601 (week 1 starts on Monday and
+  #     includes January 4)
+  #
+  # %h
+  # :   Equivalent to %b
+  #
+  # %H
+  # :   Hour of the day, 24-hour clock (00..23)
+  #
+  # %I
+  # :   Hour of the day, 12-hour clock (01..12)
+  #
+  # %j
+  # :   Day of the year (001..366)
+  #
+  # %k
+  # :   hour, 24-hour clock, blank-padded ( 0..23)
+  #
+  # %l
+  # :   hour, 12-hour clock, blank-padded ( 0..12)
+  #
+  # %L
+  # :   Millisecond of the second (000..999)
+  #
+  # %m
+  # :   Month of the year (01..12)
+  #
+  # %M
+  # :   Minute of the hour (00..59)
+  #
+  # %n
+  # :   Newline (n)
+  #
+  # %N
+  # :   Fractional seconds digits
+  #
+  # %p
+  # :   Meridian indicator ("AM" or "PM")
+  #
+  # %P
+  # :   Meridian indicator ("am" or "pm")
+  #
+  # %r
+  # :   time, 12-hour (same as %I:%M:%S %p)
+  #
+  # %R
+  # :   time, 24-hour (%H:%M)
+  #
+  # %s
+  # :   Number of seconds since 1970-01-01 00:00:00 UTC.
+  #
+  # %S
+  # :   Second of the minute (00..60)
+  #
+  # %t
+  # :   Tab character (t)
+  #
+  # %T
+  # :   time, 24-hour (%H:%M:%S)
+  #
+  # %u
+  # :   Day of the week as a decimal, Monday being 1. (1..7)
+  #
+  # %U
+  # :   Week number of the current year, starting with the first Sunday as the
+  #     first day of the first week (00..53)
+  #
+  # %v
+  # :   VMS date (%e-%b-%Y)
+  #
+  # %V
+  # :   Week number of year according to ISO 8601 (01..53)
+  #
+  # %W
+  # :   Week  number  of the current year, starting with the first Monday as the
+  #     first day of the first week (00..53)
+  #
+  # %w
+  # :   Day of the week (Sunday is 0, 0..6)
+  #
+  # %x
+  # :   Preferred representation for the date alone, no time
+  #
+  # %X
+  # :   Preferred representation for the time alone, no date
+  #
+  # %y
+  # :   Year without a century (00..99)
+  #
+  # %Y
+  # :   Year which may include century, if provided
+  #
+  # %z
+  # :   Time zone as hour offset from UTC (e.g. +0900)
+  #
+  # %Z
+  # :   Time zone name
+  #
+  # %%
+  # :   Literal "%" character
+  #
+  # %+
+  # :   date(1) (%a %b %e %H:%M:%S %Z %Y)
+  #
+  #
+  #     require 'time'
+  #
+  #     Time.strptime("2000-10-31", "%Y-%m-%d") #=> 2000-10-31 00:00:00 -0500
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.strptime: (String date, String format, ?_TimeLike now) ?{ (Integer) -> Integer } -> Time
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - rfc2822(date)
+  # -->
+  # Parses `date` as date-time defined by RFC 2822 and converts it to a Time
+  # object.  The format is identical to the date format defined by RFC 822 and
+  # updated by RFC 1123.
+  #
+  # ArgumentError is raised if `date` is not compliant with RFC 2822 or if the
+  # Time class cannot represent specified date.
+  #
+  # See #rfc2822 for more information on this format.
+  #
+  #     require 'time'
+  #
+  #     Time.rfc2822("Wed, 05 Oct 2011 22:26:12 -0400")
+  #     #=> 2010-10-05 22:26:12 -0400
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.rfc2822: (String date) -> Time
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - rfc822(date)
+  # -->
+  #
+  alias self.rfc822 self.rfc2822
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - httpdate(date)
+  # -->
+  # Parses `date` as an HTTP-date defined by RFC 2616 and converts it to a Time
+  # object.
+  #
+  # ArgumentError is raised if `date` is not compliant with RFC 2616 or if the
+  # Time class cannot represent specified date.
+  #
+  # See #httpdate for more information on this format.
+  #
+  #     require 'time'
+  #
+  #     Time.httpdate("Thu, 06 Oct 2011 02:26:12 GMT")
+  #     #=> 2011-10-06 02:26:12 UTC
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.httpdate: (String date) -> Time
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - xmlschema(time)
+  # -->
+  # Parses `time` as a dateTime defined by the XML Schema and converts it to a
+  # Time object.  The format is a restricted version of the format defined by ISO
+  # 8601.
+  #
+  # ArgumentError is raised if `time` is not compliant with the format or if the
+  # Time class cannot represent the specified time.
+  #
+  # See #xmlschema for more information on this format.
+  #
+  #     require 'time'
+  #
+  #     Time.xmlschema("2011-10-05T22:26:12-04:00")
+  #     #=> 2011-10-05 22:26:12-04:00
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.xmlschema: (String date) -> Time
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - iso8601(time)
+  # -->
+  #
+  alias self.iso8601 self.xmlschema
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - rfc2822()
+  # -->
+  # Returns a string which represents the time as date-time defined by RFC 2822:
+  #
+  #     day-of-week, DD month-name CCYY hh:mm:ss zone
+  #
+  # where zone is [+-]hhmm.
+  #
+  # If `self` is a UTC time, -0000 is used as zone.
+  #
+  #     require 'time'
+  #
+  #     t = Time.now
+  #     t.rfc2822  # => "Wed, 05 Oct 2011 22:26:12 -0400"
+  #
+  # You must require 'time' to use this method.
+  #
+  def rfc2822: () -> String
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - rfc822()
+  # -->
+  #
+  alias rfc822 rfc2822
+
+  # <!--
+  #   rdoc-file=lib/time.rb
+  #   - httpdate()
+  # -->
+  # Returns a string which represents the time as RFC 1123 date of HTTP-date
+  # defined by RFC 2616:
+  #
+  #     day-of-week, DD month-name CCYY hh:mm:ss GMT
+  #
+  # Note that the result is always UTC (GMT).
+  #
+  #     require 'time'
+  #
+  #     t = Time.now
+  #     t.httpdate # => "Thu, 06 Oct 2011 02:26:12 GMT"
+  #
+  # You must require 'time' to use this method.
+  #
+  def httpdate: () -> String
+end

data/stdlib/timeout/0/timeout.rbs

@@ -0,0 +1,137 @@
+# <!-- rdoc-file=lib/timeout.rb -->
+# Timeout long-running blocks
+#
+# ## Synopsis
+#
+#     require 'timeout'
+#     status = Timeout.timeout(5) {
+#       # Something that should be interrupted if it takes more than 5 seconds...
+#     }
+#
+# ## Description
+#
+# Timeout provides a way to auto-terminate a potentially long-running operation
+# if it hasn't finished in a fixed amount of time.
+#
+# ## Copyright
+#
+# Copyright
+# :   (C) 2000  Network Applied Communication Laboratory, Inc.
+#
+# Copyright
+# :   (C) 2000  Information-technology Promotion Agency, Japan
+#
+module Timeout
+  # <!--
+  #   rdoc-file=lib/timeout.rb
+  #   - timeout(sec, klass = nil, message = nil) { |sec| ... }
+  # -->
+  # Perform an operation in a block, raising an exception if it takes longer than
+  # `sec` seconds to complete.
+  #
+  # `sec`
+  # :   Number of seconds to wait for the block to terminate. Any non-negative
+  #     number or nil may be used, including Floats to specify fractional seconds.
+  #     A value of 0 or `nil` will execute the block without any timeout. Any
+  #     negative number will raise an ArgumentError.
+  #
+  # `klass`
+  # :   Exception Class to raise if the block fails to terminate in `sec` seconds.
+  #      Omitting will use the default, Timeout::Error
+  #
+  # `message`
+  # :   Error message to raise with Exception Class. Omitting will use the
+  #     default, "execution expired"
+  #
+  #
+  # Returns the result of the block **if** the block completed before `sec`
+  # seconds, otherwise raises an exception, based on the value of `klass`.
+  #
+  # The exception raised to terminate the given block is the given `klass`, or
+  # Timeout::ExitException if `klass` is not given. The reason for that behavior
+  # is that Timeout::Error inherits from RuntimeError and might be caught
+  # unexpectedly by `rescue`. Timeout::ExitException inherits from Exception so it
+  # will only be rescued by `rescue Exception`. Note that the
+  # Timeout::ExitException is translated to a Timeout::Error once it reaches the
+  # Timeout.timeout call, so outside that call it will be a Timeout::Error.
+  #
+  # In general, be aware that the code block may rescue the exception, and in such
+  # a case not respect the timeout. Also, the block can use `ensure` to prevent
+  # the handling of the exception. For those reasons, this method cannot be relied
+  # on to enforce timeouts for untrusted blocks.
+  #
+  # If a scheduler is defined, it will be used to handle the timeout by invoking
+  # Scheduler#timeout_after.
+  #
+  # Note that this is both a method of module Timeout, so you can `include
+  # Timeout` into your classes so they have a #timeout method, as well as a module
+  # method, so you can call it directly as Timeout.timeout().
+  #
+  # #### Ensuring the exception does not fire inside ensure blocks
+  #
+  # When using Timeout.timeout it can be desirable to ensure the timeout exception
+  # does not fire inside an `ensure` block. The simplest and best way to do so it
+  # to put the Timeout.timeout call inside the body of the begin/ensure/end:
+  #
+  #     begin
+  #       Timeout.timeout(sec) { some_long_operation }
+  #     ensure
+  #       cleanup # safe, cannot be interrupt by timeout
+  #     end
+  #
+  # If that is not feasible, e.g. if there are `ensure` blocks inside
+  # `some_long_operation`, they need to not be interrupted by timeout, and it's
+  # not possible to move these ensure blocks outside, one can use
+  # Thread.handle_interrupt to delay the timeout exception like so:
+  #
+  #     Thread.handle_interrupt(Timeout::Error => :never) {
+  #       Timeout.timeout(sec, Timeout::Error) do
+  #         setup # timeout cannot happen here, no matter how long it takes
+  #         Thread.handle_interrupt(Timeout::Error => :immediate) {
+  #           some_long_operation # timeout can happen here
+  #         }
+  #       ensure
+  #         cleanup # timeout cannot happen here, no matter how long it takes
+  #       end
+  #     }
+  #
+  # An important thing to note is the need to pass an exception klass to
+  # Timeout.timeout, otherwise it does not work. Specifically, using
+  # +Thread.handle_interrupt(Timeout::ExitException => ...)+ is unsupported and
+  # causes subtle errors like raising the wrong exception outside the block, do
+  # not use that.
+  #
+  # Note that Thread.handle_interrupt is somewhat dangerous because if setup or
+  # cleanup hangs then the current thread will hang too and the timeout will never
+  # fire. Also note the block might run for longer than `sec` seconds: e.g.
+  # some_long_operation executes for `sec` seconds + whatever time cleanup takes.
+  #
+  # If you want the timeout to only happen on blocking operations one can use
+  # :on_blocking instead of :immediate. However, that means if the block uses no
+  # blocking operations after `sec` seconds, the block will not be interrupted.
+  # ----
+  # <!--
+  #   rdoc-file=lib/timeout.rb
+  #   - timeout(*args, &block)
+  # -->
+  #
+  def self?.timeout: [T] (Numeric? sec, ?singleton(Exception) klass, ?String message) { (Numeric sec) -> T } -> T
+end
+
+# <!-- rdoc-file=lib/timeout.rb -->
+# Internal exception raised to when a timeout is triggered.
+#
+class Timeout::ExitException < Exception
+end
+
+# <!-- rdoc-file=lib/timeout.rb -->
+# Raised by Timeout.timeout when the block times out.
+#
+class Timeout::Error < RuntimeError
+  attr_reader thread: Thread?
+end
+
+# <!-- rdoc-file=lib/timeout.rb -->
+# The version
+#
+Timeout::VERSION: String

data/stdlib/tmpdir/0/tmpdir.rbs

@@ -0,0 +1,69 @@
+%a{annotate:rdoc:skip}
+class Dir
+  # <!--
+  #   rdoc-file=lib/tmpdir.rb
+  #   - tmpdir()
+  # -->
+  # Returns the operating system's temporary file path.
+  #
+  #     require 'tmpdir'
+  #     Dir.tmpdir # => "/tmp"
+  #
+  def self.tmpdir: () -> String
+
+  # <!--
+  #   rdoc-file=lib/tmpdir.rb
+  #   - mktmpdir(prefix_suffix=nil, *rest, **options) { |dup| ... }
+  # -->
+  # Dir.mktmpdir creates a temporary directory.
+  #
+  #     require 'tmpdir'
+  #     Dir.mktmpdir {|dir|
+  #       # use the directory
+  #     }
+  #
+  # The directory is created with 0700 permission. Application should not change
+  # the permission to make the temporary directory accessible from other users.
+  #
+  # The prefix and suffix of the name of the directory is specified by the
+  # optional first argument, *prefix_suffix*.
+  # *   If it is not specified or nil, "d" is used as the prefix and no suffix is
+  #     used.
+  # *   If it is a string, it is used as the prefix and no suffix is used.
+  # *   If it is an array, first element is used as the prefix and second element
+  #     is used as a suffix.
+  #
+  #     Dir.mktmpdir {|dir| dir is ".../d..." }
+  #     Dir.mktmpdir("foo") {|dir| dir is ".../foo..." }
+  #     Dir.mktmpdir(["foo", "bar"]) {|dir| dir is ".../foo...bar" }
+  #
+  # The directory is created under Dir.tmpdir or the optional second argument
+  # *tmpdir* if non-nil value is given.
+  #
+  #     Dir.mktmpdir {|dir| dir is "#{Dir.tmpdir}/d..." }
+  #     Dir.mktmpdir(nil, "/var/tmp") {|dir| dir is "/var/tmp/d..." }
+  #
+  # If a block is given, it is yielded with the path of the directory. The
+  # directory and its contents are removed using FileUtils.remove_entry before
+  # Dir.mktmpdir returns. The value of the block is returned.
+  #
+  #     Dir.mktmpdir {|dir|
+  #       # use the directory...
+  #       open("#{dir}/foo", "w") { something using the file }
+  #     }
+  #
+  # If a block is not given, The path of the directory is returned. In this case,
+  # Dir.mktmpdir doesn't remove the directory.
+  #
+  #     dir = Dir.mktmpdir
+  #     begin
+  #       # use the directory...
+  #       open("#{dir}/foo", "w") { something using the file }
+  #     ensure
+  #       # remove the directory.
+  #       FileUtils.remove_entry dir
+  #     end
+  #
+  def self.mktmpdir: (?string | [ string, string ] | nil, ?path?, ?max_try: Integer?) -> String
+                   | [X] (?string | [string, string ] | nil, ?path?, ?max_try: Integer?) { (String) -> X } -> X
+end

data/stdlib/tsort/0/cyclic.rbs

@@ -0,0 +1,8 @@
+%a{annotate:rdoc:skip}
+module TSort[N]
+  # <!-- rdoc-file=lib/tsort.rb -->
+  # Exception class to be raised when a cycle is found.
+  #
+  class Cyclic < StandardError
+  end
+end

data/stdlib/tsort/0/interfaces.rbs

@@ -0,0 +1,20 @@
+%a{annotate:rdoc:skip}
+module TSort[N]
+  interface _Sortable[N]
+    # #tsort_each_node is used to iterate for all nodes over a graph.
+    #
+    def tsort_each_node: () { (N) -> void } -> void
+
+    # #tsort_each_child is used to iterate for child nodes of node.
+    #
+    def tsort_each_child: (N) { (N) -> void } -> void
+  end
+
+  interface _EachNode[N]
+    def call: () { (N) -> void } -> void
+  end
+
+  interface _EachChild[N]
+    def call: (N) { (N) -> void } -> void
+  end
+end