rbs 3.1.3 → 3.2.0

data/sig/prototype/rb.rbs

@@ -12,12 +12,18 @@ module RBS
 
         attr_accessor namespace: Namespace
 
-        def initialize: (module_function: bool, singleton: bool, namespace: Namespace) -> void
+        attr_accessor in_def: bool
+
+        def initialize: (module_function: bool, singleton: bool, namespace: Namespace, in_def: bool) -> void
 
         def method_kind: () -> method_kind
 
         def attribute_kind: () -> (:singleton | :instance)
 
+        def enter_namespace: (Namespace) -> Context
+
+        def update: (?module_function: bool, ?singleton: bool, ?in_def: bool) -> Context
+
         def self.initial: (?namespace: Namespace) -> Context
       end
 
@@ -83,6 +89,8 @@ module RBS
       def is_accessibility?: (decl) -> bool
 
       def find_def_index_by_name: (Array[decl] decls, Symbol name) -> [Integer, AST::Members::MethodDefinition | AST::Members::AttrReader | AST::Members::AttrWriter]?
+
+      def sort_members!: (Array[decl] decls) -> void
     end
   end
 end

data/sig/subtractor.rbs

@@ -24,6 +24,10 @@ module RBS
 
     private def mixin_exist?: (TypeName owner, AST::Members::Include | AST::Members::Extend | AST::Members::Prepend, context: Resolver::context) -> boolish
 
+    private def filter_redundunt_access_modifiers: (Array[AST::Declarations::t | AST::Members::t]) -> Array[AST::Declarations::t | AST::Members::t]
+
+    private def access_modifier?: (AST::Declarations::t | AST::Members::t?) -> bool
+
     private def update_decl: (decl_with_members, members: Array[AST::Declarations::t | AST::Members::t]) -> decl_with_members
 
     private def absolute_typename: (TypeName, context: Resolver::context) -> TypeName

data/stdlib/logger/0/logger.rbs

@@ -796,7 +796,7 @@ class Logger
   #     periodic log file rotation; default is `'%Y%m%d'`. See [Periodic
   #     Rotation](rdoc-ref:Logger@Periodic+Rotation).
   #
-  def initialize: (logdev logdev, ?Numeric | String shift_age, ?Integer shift_size, ?shift_period_suffix: String, ?binmode: boolish, ?datetime_format: String, ?formatter: _Formatter, ?progname: String, ?level: Integer | String | Symbol) -> void
+  def initialize: (logdev? logdev, ?Numeric | String shift_age, ?Integer shift_size, ?shift_period_suffix: String, ?binmode: boolish, ?datetime_format: String, ?formatter: _Formatter, ?progname: String, ?level: Integer | String | Symbol) -> void
 end
 
 Logger::ProgName: String

data/stdlib/observable/0/observable.rbs

@@ -0,0 +1,219 @@
+# <!-- rdoc-file=lib/observer.rb -->
+# The Observer pattern (also known as publish/subscribe) provides a simple
+# mechanism for one object to inform a set of interested third-party objects
+# when its state changes.
+#
+# ## Mechanism
+#
+# The notifying class mixes in the `Observable` module, which provides the
+# methods for managing the associated observer objects.
+#
+# The observable object must:
+# *   assert that it has `#changed`
+# *   call `#notify_observers`
+#
+#
+# An observer subscribes to updates using Observable#add_observer, which also
+# specifies the method called via #notify_observers. The default method for
+# #notify_observers is #update.
+#
+# ### Example
+#
+# The following example demonstrates this nicely.  A `Ticker`, when run,
+# continually receives the stock `Price` for its `@symbol`.  A `Warner` is a
+# general observer of the price, and two warners are demonstrated, a `WarnLow`
+# and a `WarnHigh`, which print a warning if the price is below or above their
+# set limits, respectively.
+#
+# The `update` callback allows the warners to run without being explicitly
+# called.  The system is set up with the `Ticker` and several observers, and the
+# observers do their duty without the top-level code having to interfere.
+#
+# Note that the contract between publisher and subscriber (observable and
+# observer) is not declared or enforced.  The `Ticker` publishes a time and a
+# price, and the warners receive that.  But if you don't ensure that your
+# contracts are correct, nothing else can warn you.
+#
+#     require "observer"
+#
+#     class Ticker          ### Periodically fetch a stock price.
+#       include Observable
+#
+#       def initialize(symbol)
+#         @symbol = symbol
+#       end
+#
+#       def run
+#         last_price = nil
+#         loop do
+#           price = Price.fetch(@symbol)
+#           print "Current price: #{price}\n"
+#           if price != last_price
+#             changed                 # notify observers
+#             last_price = price
+#             notify_observers(Time.now, price)
+#           end
+#           sleep 1
+#         end
+#       end
+#     end
+#
+#     class Price           ### A mock class to fetch a stock price (60 - 140).
+#       def self.fetch(symbol)
+#         60 + rand(80)
+#       end
+#     end
+#
+#     class Warner          ### An abstract observer of Ticker objects.
+#       def initialize(ticker, limit)
+#         @limit = limit
+#         ticker.add_observer(self)
+#       end
+#     end
+#
+#     class WarnLow < Warner
+#       def update(time, price)       # callback for observer
+#         if price < @limit
+#           print "--- #{time.to_s}: Price below #@limit: #{price}\n"
+#         end
+#       end
+#     end
+#
+#     class WarnHigh < Warner
+#       def update(time, price)       # callback for observer
+#         if price > @limit
+#           print "+++ #{time.to_s}: Price above #@limit: #{price}\n"
+#         end
+#       end
+#     end
+#
+#     ticker = Ticker.new("MSFT")
+#     WarnLow.new(ticker, 80)
+#     WarnHigh.new(ticker, 120)
+#     ticker.run
+#
+# Produces:
+#
+#     Current price: 83
+#     Current price: 75
+#     --- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 75
+#     Current price: 90
+#     Current price: 134
+#     +++ Sun Jun 09 00:10:25 CDT 2002: Price above 120: 134
+#     Current price: 134
+#     Current price: 112
+#     Current price: 79
+#     --- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 79
+#
+# ### Usage with procs
+#
+# The `#notify_observers` method can also be used with +proc+s by using the
+# `:call` as `func` parameter.
+#
+# The following example illustrates the use of a lambda:
+#
+#     require 'observer'
+#
+#     class Ticker
+#       include Observable
+#
+#       def run
+#         # logic to retrieve the price (here 77.0)
+#         changed
+#         notify_observers(77.0)
+#       end
+#     end
+#
+#     ticker = Ticker.new
+#     warner = ->(price) { puts "New price received: #{price}" }
+#     ticker.add_observer(warner, :call)
+#     ticker.run
+#
+module Observable
+  public
+
+  # <!--
+  #   rdoc-file=lib/observer.rb
+  #   - add_observer(observer, func=:update)
+  # -->
+  # Add `observer` as an observer on this object. So that it will receive
+  # notifications.
+  #
+  # `observer`
+  # :   the object that will be notified of changes.
+  # `func`
+  # :   Symbol naming the method that will be called when this Observable has
+  #     changes.
+  #
+  #     This method must return true for `observer.respond_to?` and will receive
+  #     `*arg` when #notify_observers is called, where `*arg` is the value passed
+  #     to #notify_observers by this Observable
+  #
+  def add_observer: (untyped observer, ?Symbol func) -> void
+
+  # <!--
+  #   rdoc-file=lib/observer.rb
+  #   - changed(state=true)
+  # -->
+  # Set the changed state of this object.  Notifications will be sent only if the
+  # changed `state` is `true`.
+  #
+  # `state`
+  # :   Boolean indicating the changed state of this Observable.
+  #
+  def changed: (?bool state) -> void
+
+  # <!--
+  #   rdoc-file=lib/observer.rb
+  #   - changed?()
+  # -->
+  # Returns true if this object's state has been changed since the last
+  # #notify_observers call.
+  #
+  def changed?: () -> bool
+
+  # <!--
+  #   rdoc-file=lib/observer.rb
+  #   - count_observers()
+  # -->
+  # Return the number of observers associated with this object.
+  #
+  def count_observers: () -> Integer
+
+  # <!--
+  #   rdoc-file=lib/observer.rb
+  #   - delete_observer(observer)
+  # -->
+  # Remove `observer` as an observer on this object so that it will no longer
+  # receive notifications.
+  #
+  # `observer`
+  # :   An observer of this Observable
+  #
+  def delete_observer: (untyped observer) -> void
+
+  # <!--
+  #   rdoc-file=lib/observer.rb
+  #   - delete_observers()
+  # -->
+  # Remove all observers associated with this object.
+  #
+  def delete_observers: () -> void
+
+  # <!--
+  #   rdoc-file=lib/observer.rb
+  #   - notify_observers(*arg)
+  # -->
+  # Notify observers of a change in state **if** this object's changed state is
+  # `true`.
+  #
+  # This will invoke the method named in #add_observer, passing `*arg`. The
+  # changed state is then set to `false`.
+  #
+  # `*arg`
+  # :   Any arguments to pass to the observers.
+  #
+  def notify_observers: (*untyped arg) -> void
+
+  VERSION: String
+end

data/stdlib/uri/0/common.rbs

@@ -1,3 +1,27 @@
+# <!-- rdoc-file=lib/uri/common.rb -->
+# Base class for all URI exceptions.
+#
+class URI::Error < StandardError
+end
+
+# <!-- rdoc-file=lib/uri/common.rb -->
+# Not a URI.
+#
+class URI::InvalidURIError < URI::Error
+end
+
+# <!-- rdoc-file=lib/uri/common.rb -->
+# Not a URI component.
+#
+class URI::InvalidComponentError < URI::Error
+end
+
+# <!-- rdoc-file=lib/uri/common.rb -->
+# URI is valid, bad usage is not.
+#
+class URI::BadURIError < URI::Error
+end
+
 # <!-- rdoc-file=lib/uri.rb -->
 # URI is a module providing classes to handle Uniform Resource Identifiers
 # ([RFC2396](http://tools.ietf.org/html/rfc2396)).

data/stdlib/zlib/0/buf_error.rbs

@@ -0,0 +1,79 @@
+# <!-- rdoc-file=ext/zlib/zlib.c -->
+# This module provides access to the [zlib library](http://zlib.net). Zlib is
+# designed to be a portable, free, general-purpose, legally unencumbered -- that
+# is, not covered by any patents -- lossless data-compression library for use on
+# virtually any computer hardware and operating system.
+#
+# The zlib compression library provides in-memory compression and decompression
+# functions, including integrity checks of the uncompressed data.
+#
+# The zlib compressed data format is described in RFC 1950, which is a wrapper
+# around a deflate stream which is described in RFC 1951.
+#
+# The library also supports reading and writing files in gzip (.gz) format with
+# an interface similar to that of IO. The gzip format is described in RFC 1952
+# which is also a wrapper around a deflate stream.
+#
+# The zlib format was designed to be compact and fast for use in memory and on
+# communications channels. The gzip format was designed for single-file
+# compression on file systems, has a larger header than zlib to maintain
+# directory information, and uses a different, slower check method than zlib.
+#
+# See your system's zlib.h for further information about zlib
+#
+# ## Sample usage
+#
+# Using the wrapper to compress strings with default parameters is quite simple:
+#
+#     require "zlib"
+#
+#     data_to_compress = File.read("don_quixote.txt")
+#
+#     puts "Input size: #{data_to_compress.size}"
+#     #=> Input size: 2347740
+#
+#     data_compressed = Zlib::Deflate.deflate(data_to_compress)
+#
+#     puts "Compressed size: #{data_compressed.size}"
+#     #=> Compressed size: 887238
+#
+#     uncompressed_data = Zlib::Inflate.inflate(data_compressed)
+#
+#     puts "Uncompressed data is: #{uncompressed_data}"
+#     #=> Uncompressed data is: The Project Gutenberg EBook of Don Quixote...
+#
+# ## Class tree
+#
+# *   Zlib::Deflate
+# *   Zlib::Inflate
+# *   Zlib::ZStream
+# *   Zlib::Error
+#     *   Zlib::StreamEnd
+#     *   Zlib::NeedDict
+#     *   Zlib::DataError
+#     *   Zlib::StreamError
+#     *   Zlib::MemError
+#     *   Zlib::BufError
+#     *   Zlib::VersionError
+#     *   Zlib::InProgressError
+#
+#
+#
+# (if you have GZIP_SUPPORT)
+# *   Zlib::GzipReader
+# *   Zlib::GzipWriter
+# *   Zlib::GzipFile
+# *   Zlib::GzipFile::Error
+#     *   Zlib::GzipFile::LengthError
+#     *   Zlib::GzipFile::CRCError
+#     *   Zlib::GzipFile::NoFooter
+#
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Subclass of Zlib::Error when zlib returns a Z_BUF_ERROR.
+  #
+  # Usually if no progress is possible.
+  #
+  class BufError < Zlib::Error
+  end
+end

data/stdlib/zlib/0/data_error.rbs

@@ -0,0 +1,79 @@
+# <!-- rdoc-file=ext/zlib/zlib.c -->
+# This module provides access to the [zlib library](http://zlib.net). Zlib is
+# designed to be a portable, free, general-purpose, legally unencumbered -- that
+# is, not covered by any patents -- lossless data-compression library for use on
+# virtually any computer hardware and operating system.
+#
+# The zlib compression library provides in-memory compression and decompression
+# functions, including integrity checks of the uncompressed data.
+#
+# The zlib compressed data format is described in RFC 1950, which is a wrapper
+# around a deflate stream which is described in RFC 1951.
+#
+# The library also supports reading and writing files in gzip (.gz) format with
+# an interface similar to that of IO. The gzip format is described in RFC 1952
+# which is also a wrapper around a deflate stream.
+#
+# The zlib format was designed to be compact and fast for use in memory and on
+# communications channels. The gzip format was designed for single-file
+# compression on file systems, has a larger header than zlib to maintain
+# directory information, and uses a different, slower check method than zlib.
+#
+# See your system's zlib.h for further information about zlib
+#
+# ## Sample usage
+#
+# Using the wrapper to compress strings with default parameters is quite simple:
+#
+#     require "zlib"
+#
+#     data_to_compress = File.read("don_quixote.txt")
+#
+#     puts "Input size: #{data_to_compress.size}"
+#     #=> Input size: 2347740
+#
+#     data_compressed = Zlib::Deflate.deflate(data_to_compress)
+#
+#     puts "Compressed size: #{data_compressed.size}"
+#     #=> Compressed size: 887238
+#
+#     uncompressed_data = Zlib::Inflate.inflate(data_compressed)
+#
+#     puts "Uncompressed data is: #{uncompressed_data}"
+#     #=> Uncompressed data is: The Project Gutenberg EBook of Don Quixote...
+#
+# ## Class tree
+#
+# *   Zlib::Deflate
+# *   Zlib::Inflate
+# *   Zlib::ZStream
+# *   Zlib::Error
+#     *   Zlib::StreamEnd
+#     *   Zlib::NeedDict
+#     *   Zlib::DataError
+#     *   Zlib::StreamError
+#     *   Zlib::MemError
+#     *   Zlib::BufError
+#     *   Zlib::VersionError
+#     *   Zlib::InProgressError
+#
+#
+#
+# (if you have GZIP_SUPPORT)
+# *   Zlib::GzipReader
+# *   Zlib::GzipWriter
+# *   Zlib::GzipFile
+# *   Zlib::GzipFile::Error
+#     *   Zlib::GzipFile::LengthError
+#     *   Zlib::GzipFile::CRCError
+#     *   Zlib::GzipFile::NoFooter
+#
+module Zlib
+  # <!-- rdoc-file=ext/zlib/zlib.c -->
+  # Subclass of Zlib::Error when zlib returns a Z_DATA_ERROR.
+  #
+  # Usually if a stream was prematurely freed.
+  #
+  class DataError < Zlib::Error
+  end
+end