rbs 3.1.3 → 3.2.0.pre.1

data/lib/rbs/prototype/runtime.rb

@@ -9,6 +9,7 @@ module RBS
       attr_reader :env
       attr_reader :merge
       attr_reader :owners_included
+      attr_accessor :outline
 
       def initialize(patterns:, env:, merge:, owners_included: [])
         @patterns = patterns
@@ -19,6 +20,7 @@ module RBS
         @owners_included = owners_included.map do |name|
           Object.const_get(name)
         end
+        @outline = false
       end
 
       def target?(const)
@@ -378,7 +380,7 @@ module RBS
           RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
           nil
         else
-          super_name = to_type_name(const_name(mod.superclass), full_name: true)
+          super_name = to_type_name(const_name(mod.superclass), full_name: true).absolute!
           super_args = type_args(super_name)
           AST::Declarations::Class::Super.new(name: super_name, args: super_args, location: nil)
         end
@@ -393,7 +395,7 @@ module RBS
         unless decl
           decl = AST::Declarations::Class.new(
             name: to_type_name(only_name(mod)),
-            type_params: [],
+            type_params: type_params(mod),
             super_class: generate_super_class(mod),
             members: [],
             annotations: [],
@@ -426,7 +428,7 @@ module RBS
           )
         end
 
-        generate_methods(mod, type_name, decl.members)
+        generate_methods(mod, type_name, decl.members) unless outline
 
         generate_constants mod, decl.members
       end
@@ -447,7 +449,7 @@ module RBS
         unless decl
           decl = AST::Declarations::Module.new(
             name: to_type_name(only_name(mod)),
-            type_params: [],
+            type_params: type_params(mod),
             self_types: [],
             members: [],
             annotations: [],
@@ -480,7 +482,7 @@ module RBS
           )
         end
 
-        generate_methods(mod, type_name, decl.members)
+        generate_methods(mod, type_name, decl.members) unless outline
 
         generate_constants mod, decl.members
       end
@@ -502,7 +504,7 @@ module RBS
             if outer_module.is_a?(Class)
               outer_decl = AST::Declarations::Class.new(
                 name: to_type_name(outer_module_name),
-                type_params: [],
+                type_params: type_params(outer_module),
                 super_class: generate_super_class(outer_module),
                 members: [],
                 annotations: [],
@@ -512,7 +514,7 @@ module RBS
             else
               outer_decl = AST::Declarations::Module.new(
                 name: to_type_name(outer_module_name),
-                type_params: [],
+                type_params: type_params(outer_module),
                 self_types: [],
                 members: [],
                 annotations: [],
@@ -539,7 +541,17 @@ module RBS
 
       def const_name(const)
         @module_name_method ||= Module.instance_method(:name)
-        @module_name_method.bind(const).call
+        name = @module_name_method.bind(const).call
+        return nil unless name
+
+        begin
+          Object.const_get(name)
+        rescue NameError
+          # Should generate const name if anonymous or internal module (e.g. NameError::message)
+          nil
+        else
+          name
+        end
       end
 
       def type_args(type_name)
@@ -550,6 +562,15 @@ module RBS
         end
       end
 
+      def type_params(mod)
+        type_name = to_type_name(const_name(mod), full_name: true)
+        if class_decl = env.class_decls[type_name.absolute!]
+          class_decl.type_params
+        else
+          []
+        end
+      end
+
       def block_from_ast_of(method)
         return nil if RUBY_VERSION < '3.1'
 

data/lib/rbs/subtractor.rb

@@ -51,6 +51,7 @@ module RBS
       context = _ = [context, decl.name]
       children = call(decl.each_decl.to_a, context: context) +
         decl.each_member.reject { |m| member_exist?(owner, m, context: context) }
+      children = filter_redundunt_access_modifiers(children)
       return nil if children.empty?
 
       update_decl(decl, members: children)
@@ -144,6 +145,22 @@ module RBS
       end
     end
 
+    private def filter_redundunt_access_modifiers(decls)
+      decls = decls.dup
+      decls.pop while access_modifier?(decls.last)
+      decls = decls.map.with_index do |decl, i|
+        if access_modifier?(decl) && access_modifier?(decls[i + 1])
+          nil
+        else
+          decl
+        end
+      end.compact
+    end
+
+    private def access_modifier?(decl)
+      decl.is_a?(AST::Members::Public) || decl.is_a?(AST::Members::Private)
+    end
+
     private def update_decl(decl, members:)
       case decl
       when AST::Declarations::Class

data/lib/rbs/type_name.rb

@@ -9,12 +9,12 @@ module RBS
     def initialize(namespace:, name:)
       @namespace = namespace
       @name = name
-      @kind = case name.to_s[0,1]
-              when /[A-Z]/
+      @kind = case
+              when name.match?(/\A[A-Z]/)
                 :class
-              when /[a-z]/
+              when name.match?(/\A[a-z]/)
                 :alias
-              when "_"
+              when name.start_with?("_")
                 :interface
               else
                 # Defaults to :class

data/lib/rbs/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBS
-  VERSION = "3.1.3"
+  VERSION = "3.2.0.pre.1"
 end

data/rbs.gemspec

@@ -35,5 +35,5 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 2.6"
+  spec.required_ruby_version = ">= 3.0"
 end

data/schema/decls.json

@@ -60,7 +60,7 @@
       "required": ["declaration", "name", "type", "comment", "location"]
     },
     "global": {
-      "title": "Global declaration: `$DEBUG: bool`, ...",
+      "title": "Global declaration: `$DEBUG: boolish`, ...",
       "type": "object",
       "properties": {
         "declaration": {

data/sig/errors.rbs

@@ -16,9 +16,23 @@ module RBS
   class BaseError < StandardError
   end
 
+  interface _Location
+    %a{pure} def location: () -> Location[untyped, untyped]?
+  end
+
+  interface _DetailedMessage
+    def detailed_message: (**untyped) -> String
+  end
+
+  module DetailedMessageable : _Location, _DetailedMessage
+    def detailed_message: (?highlight: boolish, **untyped) -> String
+  end
+
   # Error class for errors raised during parsing.
   #
   class ParsingError < BaseError
+    include DetailedMessageable
+
     attr_reader location: Location[untyped, untyped]
     attr_reader error_message: String
     attr_reader token_type: String
@@ -67,6 +81,8 @@ module RBS
   end
 
   class NoTypeFoundError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader location: Location[untyped, untyped]?
 
@@ -85,6 +101,8 @@ module RBS
   end
 
   class NoSelfTypeFoundError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader location: Location[untyped, untyped]?
 
@@ -96,6 +114,8 @@ module RBS
   end
 
   class NoMixinFoundError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader member: AST::Members::t
 
@@ -107,6 +127,8 @@ module RBS
   end
 
   class DuplicatedMethodDefinitionError < DefinitionError
+    include DetailedMessageable
+
     type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
     type original = DefinitionBuilder::MethodBuilder::Methods::Definition::original
 
@@ -143,6 +165,8 @@ module RBS
   # ```
   #
   class DuplicatedInterfaceMethodDefinitionError < DefinitionError
+    include DetailedMessageable
+
     type ty = Types::ClassSingleton | Types::ClassInstance | Types::Interface
     type mixin_member = AST::Members::Include | AST::Members::Extend
 
@@ -155,11 +179,15 @@ module RBS
     def type_name: () -> TypeName
 
     def qualified_method_name: () -> String
+
+    def location: () -> AST::Members::Mixin::loc?
   end
 
   # The `alias` member declares an alias from unknown method
   #
   class UnknownMethodAliasError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader original_name: Symbol
     attr_reader aliased_name: Symbol
@@ -178,12 +206,16 @@ module RBS
   # The *overloading* method definition cannot find *non-overloading* method definition
   #
   class InvalidOverloadMethodError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader method_name: Symbol
     attr_reader kind: :instance | :singleton
     attr_reader members: Array[AST::Members::MethodDefinition]
 
     def initialize: (type_name: TypeName, method_name: Symbol, kind: :instance | :singleton, members: Array[AST::Members::MethodDefinition]) -> void
+
+    def location: () -> AST::Members::MethodDefinition::loc?
   end
 
   class GenericParameterMismatchError < LoadingError
@@ -201,6 +233,8 @@ module RBS
   end
 
   class InvalidVarianceAnnotationError < DefinitionError
+    include DetailedMessageable
+
     attr_reader type_name: TypeName
     attr_reader param: AST::TypeParam
     attr_reader location: Location[untyped, untyped]?
@@ -209,6 +243,8 @@ module RBS
   end
 
   class RecursiveAliasDefinitionError < DefinitionError
+    include DetailedMessageable
+
     type ty = Types::ClassInstance | Types::ClassSingleton | Types::Interface
     type defn = DefinitionBuilder::MethodBuilder::Methods::Definition
 
@@ -223,6 +259,8 @@ module RBS
   # MixinClassError is raised if a include/prepend/extend has a class (not a module) to mix-in
   #
   class MixinClassError < DefinitionError
+    include DetailedMessageable
+
     type member = AST::Members::Include | AST::Members::Prepend | AST::Members::Extend
 
     attr_reader type_name: TypeName
@@ -240,6 +278,8 @@ module RBS
   # InheritModuleError is raised if a class definition inherits a module (not a class)
   #
   class InheritModuleError < DefinitionError
+    include DetailedMessageable
+
     attr_reader super_decl: AST::Declarations::Class::Super
 
     def initialize: (AST::Declarations::Class::Super) -> void
@@ -254,6 +294,8 @@ module RBS
   end
 
   class RecursiveTypeAliasError < BaseError
+    include DetailedMessageable
+
     attr_reader alias_names: Array[TypeName]
     attr_reader location: Location[untyped, untyped]?
 
@@ -263,6 +305,8 @@ module RBS
   end
 
   class NonregularTypeAliasError < BaseError
+    include DetailedMessageable
+
     # Diagnostic reported from `TypeAliasRegularity`.
     attr_reader diagnostic: TypeAliasRegularity::Diagnostic
 
@@ -273,6 +317,8 @@ module RBS
   end
 
   class CyclicTypeParameterBound < BaseError
+    include DetailedMessageable
+
     attr_reader location: Location[untyped, untyped]?
 
     # Array of parameters which contains cyclic dependencies.
@@ -295,16 +341,24 @@ module RBS
   # ```
   #
   class InconsistentClassModuleAliasError < BaseError
+    include DetailedMessageable
+
     attr_reader alias_entry: Environment::ModuleAliasEntry | Environment::ClassAliasEntry
 
     def initialize: (Environment::ModuleAliasEntry | Environment::ClassAliasEntry) -> void
+
+    def location: () -> AST::Declarations::AliasDecl::loc?
   end
 
   # A module/class alias declaration is cyclic
   #
   class CyclicClassAliasDefinitionError < BaseError
+    include DetailedMessageable
+
     attr_reader alias_entry: Environment::ModuleAliasEntry | Environment::ClassAliasEntry
 
     def initialize: (Environment::ModuleAliasEntry | Environment::ClassAliasEntry) -> void
+
+    def location: () -> AST::Declarations::AliasDecl::loc?
   end
 end

data/sig/parser.rbs

@@ -2,7 +2,7 @@ module RBS
   class Parser
     # Parse a method type and return it
     #
-    # When `range` keyword is specified, it starts parsing from the `begin` to the `endo` the range.
+    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
     #
     # ```ruby
     # RBS::Parser.parse_method_type("() -> void")                                # => `() -> void`
@@ -25,7 +25,7 @@ module RBS
 
     # Parse a type and return it
     #
-    # When `range` keyword is specified, it starts parsing from the `begin` to the `endo` the range.
+    # When `range` keyword is specified, it starts parsing from the `begin` to the `end` of the range.
     #
     # ```ruby
     # RBS::Parser.parse_type("String")                          # => `String`

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)).