rbs 2.0.0 → 2.1.0

data/sig/annotate/annotations.rbs

@@ -0,0 +1,102 @@
+module RBS
+  module Annotate
+    class Annotations
+      type t = Skip | Source | Copy
+
+      def self.parse: (AST::Annotation) -> t?
+
+      attr_reader items: Array[t]
+
+      def initialize: (Array[t]) -> void
+
+      def skip?: () -> bool
+
+      def skip_all?: () -> bool
+
+      def test_path: (String path) -> bool
+
+      def test_path_string: (String pattern, String path) -> bool
+
+      def copy_annotation: -> Copy?
+
+      # Skip annotation allows skipping generating annotation of a subject.
+      #
+      #     %a{annotate:rdoc:skip}
+      #     %a{annotate:rdoc:skip:all}
+      #
+      class Skip
+        attr_reader annotation: AST::Annotation
+
+        attr_reader skip_children: bool
+
+        def initialize: (annotation: AST::Annotation, skip_children: bool) -> void
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+
+      # Source annotation allows where the documents are copied from.
+      #
+      # It allows specifying two directions: the source to read from, and the source to skip.
+      #
+      #     %a{annotate:rdoc:source:from=ext/pathname}
+      #     %a{annotate:rdoc:source:skip=ext/pathname/doc}
+      #
+      # When you want to specify several paths, repeat writing the Source annotation.
+      #
+      class Source
+        attr_reader annotation: AST::Annotation
+
+        attr_reader include_source: String?
+        attr_reader skip_source: String?
+
+        def initialize: (annotation: AST::Annotation, include: String) -> void
+                      | (annotation: AST::Annotation, skip: String) -> void
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+
+      # Copy annotation allows copying the doc from another subject.
+      # This helps working with incorrect RDoc annotations.
+      #
+      #     %a{annotate:rdoc:copy:Bar#baz}
+      #     %a{annotate:rdoc:copy:Bar.baz}
+      #     %a{annotate:rdoc:copy:Bar::Baz}
+      #
+      class Copy
+        attr_reader annotation: AST::Annotation
+
+        attr_reader source: String
+
+        def initialize: (annotation: AST::Annotation, source: String) -> void
+
+        # Returns a tuple of:
+        #
+        # - Type name
+        # - A pair of:
+        #   - Boolean which holds if it is singleton
+        #   - Name of method
+        def partition: () -> [TypeName, [bool, Symbol]?]
+
+        def type_name: () -> TypeName
+
+        def method_name: () -> Symbol?
+
+        def singleton?: () -> bool
+
+        def hash: () -> Integer
+
+        def ==: (untyped) -> bool
+
+        alias eql? ==
+      end
+    end
+  end
+end

data/sig/annotate/formatter.rbs

@@ -0,0 +1,24 @@
+module RBS
+  module Annotate
+    class Formatter
+      attr_reader buffer: String
+
+      @pending_separator: String?
+
+      def initialize: () -> void
+
+      def <<: (String | RDoc::Markup::Document | nil) -> self
+
+      def margin: (?separator: String) -> self
+
+      def empty?: () -> bool
+
+      def format: (newline_at_end: bool) -> String
+
+      def self.translate: (RDoc::Markup::Document) -> String?
+
+      def self.each_part: (RDoc::Markup::Document) { (RDoc::Markup::Document) -> void } -> void
+                        | (RDoc::Markup::Document) -> Enumerator[RDoc::Markup::Document, void]
+    end
+  end
+end

data/sig/annotate/rdoc_annotater.rbs

@@ -0,0 +1,82 @@
+module RBS
+  module Annotate
+    class RDocAnnotator
+      attr_reader source: RDocSource
+
+      attr_accessor include_arg_lists: bool
+      attr_accessor include_filename: bool
+
+      def initialize: (source: RDocSource) -> void
+
+      def annotate_file: (Pathname) -> void
+
+      def annotate_decls: (Array[AST::Declarations::t], ?outer: Array[Namespace]) -> void
+
+      interface _PathTester
+        def test_path: (String) -> bool
+      end
+
+      interface _WithRDocComment
+        def comment: () -> RDoc::Markup::Document
+      end
+
+      def each_part: (Array[Object & _WithRDocComment], tester: _PathTester) { ([RDoc::Markup::Document, Object & _WithRDocComment]) -> void } -> void
+                   | (Array[Object & _WithRDocComment], tester: _PathTester) -> Enumerator[[RDoc::Markup::Document, Object & _WithRDocComment], void]
+
+      def join_docs: (Array[String?], ?separator: String) -> String?
+
+      def doc_for_class: (TypeName, tester: _PathTester) -> String?
+
+      # Returns the formatted document of given method.
+      #
+      # Expands attribute documents, or alias documents if needed.
+      #
+      def doc_for_method: (TypeName, instance_method: Symbol, tester: _PathTester) -> String?
+                        | (TypeName, singleton_method: Symbol, tester: _PathTester) -> String?
+
+
+      def doc_for_method0: (TypeName, instance_method: Symbol, tester: _PathTester) -> String?
+                         | (TypeName, singleton_method: Symbol, tester: _PathTester) -> String?
+
+      # Having `require: nil` means any attribute is okay.
+      # Having `require: "R"` means _read attr_ is required.
+      # Having `require: "W"` means write attr_ is required.
+      #
+      def doc_for_attribute: (TypeName, Symbol, singleton: bool, ?require: nil | "R" | "W", tester: _PathTester) -> String?
+
+      def doc_for_alias: (TypeName, name: Symbol, singleton: bool, tester: _PathTester) -> String?
+
+      def doc_for_constant: (TypeName, tester: _PathTester) -> String?
+
+      def resolve_doc_source: (Annotations::Copy?, tester: _PathTester) { () -> String? } -> String?
+
+      def annotate_class: (AST::Declarations::Class | AST::Declarations::Module, outer: Array[Namespace]) -> void
+
+      def annotate_constant: (AST::Declarations::Constant, outer: Array[Namespace]) -> void
+
+      def annotate_method: (TypeName, AST::Members::MethodDefinition) -> void
+
+      def annotate_alias: (TypeName, AST::Members::Alias) -> void
+
+      def annotate_attribute: (TypeName, AST::Members::AttrReader | AST::Members::AttrWriter | AST::Members::AttrAccessor) -> void
+
+      def annotations: (_Annotated) -> Annotations
+
+      interface _Annotated
+        def annotations: -> Array[AST::Annotation]
+      end
+
+      # - If a string is given as `comment`, the content is attached to the object as a comment.
+      # - If empty string is given as `comment`, it deletes the original comment.
+      # - If `nil` is given as `comment`, it keeps the original comment.
+      #
+      def replace_comment: (Object & _Commented, String? comment) -> void
+
+      interface _Commented
+        def comment: () -> AST::Comment?
+      end
+
+      def resolve_name: (TypeName, outer: Array[Namespace]) -> TypeName
+    end
+  end
+end

data/sig/annotate/rdoc_source.rbs

@@ -0,0 +1,30 @@
+module RBS
+  module Annotate
+    class RDocSource
+      attr_accessor with_system_dir: bool
+      attr_accessor with_gems_dir: bool
+      attr_accessor with_site_dir: bool
+      attr_accessor with_home_dir: bool
+
+      attr_reader extra_dirs: Array[Pathname]
+
+      attr_reader stores: Array[RDoc::Store]
+
+      def initialize: () -> void
+
+      def load: () -> void
+
+      # Extract documents from `CodeObject`s
+      def docs: () { () -> Array[RDoc::CodeObject]? } -> Array[RDoc::Markup::Document]?
+
+      def find_class: (TypeName) -> Array[RDoc::ClassModule]?
+
+      def find_const: (TypeName) -> Array[RDoc::Constant]?
+
+      def find_method: (TypeName, instance_method: Symbol) -> Array[RDoc::AnyMethod]?
+                     | (TypeName, singleton_method: Symbol) -> Array[RDoc::AnyMethod]?
+
+      def find_attribute: (TypeName, Symbol, singleton: bool) -> Array[RDoc::Attr]?
+    end
+  end
+end

data/sig/cli.rbs

@@ -66,6 +66,8 @@ module RBS
 
     def run_collection: (Array[String], LibraryOptions) -> void
 
+    def run_annotate: (Array[String], top) -> void
+
     def test_opt: (LibraryOptions) -> String?
 
     def collection_options: (Array[String]) -> OptionParser

data/sig/location.rbs

@@ -87,6 +87,12 @@ module RBS
     def each_required_key: () { (Symbol) -> void } -> void
                          | () -> Enumerator[Symbol, void]
 
+    def optional_key?: (Symbol) -> bool
+
+    def required_key?: (Symbol) -> bool
+
+    def key?: (Symbol) -> bool
+
     private
 
     def _start_loc: () -> Buffer::loc?

data/sig/method_types.rbs

@@ -7,7 +7,11 @@ module RBS
     # ^^^                      type_params
     #     ^^^^^^^^^^^^^^^^^^^  type
     #
-    type loc = Location[:type, :type_params]
+    type def_loc = Location[:type, :type_params]
+
+    type attr_loc = AST::Members::Attribute::loc
+
+    type loc = def_loc | attr_loc
 
     attr_reader type_params: Array[AST::TypeParam]
     attr_reader type: Types::Function

data/sig/polyfill.rbs

@@ -25,3 +25,81 @@ module Bundler
     def version: () -> String
   end
 end
+
+module RDoc
+  class Store
+    def initialize: (?String? path, ?Symbol? type) -> void
+
+    def find_class_or_module: (String) -> ClassModule?
+
+    def load_all: () -> void
+  end
+
+  module RI
+    module Paths
+      type path_type = :system | :site | :home | :gem | :extra
+
+      type gem_filter = :latest | :all
+
+      def self.each: (?bool system, ?bool site, ?bool home, ?gem_filter | false gems, *String extra_dirs) { (String, path_type) -> void } -> void
+    end
+  end
+
+  class CodeObject
+    def comment: () -> RDoc::Markup::Document
+  end
+
+  class Context < CodeObject
+
+  end
+
+  class ClassModule < Context
+    def constants: () -> Array[Constant]
+
+    def method_list: () -> Array[AnyMethod]
+
+    def attributes: () -> Array[Attr]
+  end
+
+  class Constant < CodeObject
+    def name: () -> String
+  end
+
+  class AnyMethod < MethodAttr
+    def arglists: () -> String?
+
+    def callseq: () -> String?
+  end
+
+  class MethodAttr < CodeObject
+    attr_reader name: String
+
+    attr_reader singleton: bool
+
+    attr_reader is_alias_for: MethodAttr?
+
+    attr_reader call_seq: String
+
+    attr_reader arglists: String
+  end
+
+  class Attr < MethodAttr
+    attr_accessor rw: "RW" | "R" | "W"
+  end
+
+  module Markup
+    class Document
+      include Enumerable[Document]
+
+      def each: () { (Document) -> void } -> void
+              | () -> Enumerator[Document, void]
+
+      def file: () -> String?
+
+      def accept: (untyped) -> String
+    end
+
+    class ToMarkdown
+    end
+  end
+end

data/stdlib/abbrev/0/abbrev.rbs

@@ -1,3 +1,4 @@
+# <!-- rdoc-file=lib/abbrev.rb -->
 # Calculates the set of unambiguous abbreviations for a given set of strings.
 #
 #     require 'abbrev'
@@ -34,6 +35,10 @@
 #       "w"       => "winter" }
 #
 module Abbrev
+  # <!--
+  #   rdoc-file=lib/abbrev.rb
+  #   - abbrev(words, pattern = nil)
+  # -->
   # Given a set of strings, calculate the set of unambiguous abbreviations for
   # those strings, and return a hash where the keys are all the possible
   # abbreviations and the values are the full strings.
@@ -56,5 +61,6 @@ module Abbrev
   #
   #     Abbrev.abbrev(%w{car box cone}, 'ca')
   #     #=> {"car"=>"car", "ca"=>"car"}
+  #
   def self?.abbrev: (Array[String], ?String | Regexp | nil) -> Hash[String, String]
 end

data/stdlib/abbrev/0/array.rbs

@@ -0,0 +1,26 @@
+%a{annotate:rdoc:skip}
+class Array[unchecked out Elem]
+  # <!--
+  #   rdoc-file=lib/abbrev.rb
+  #   - abbrev(pattern = nil)
+  # -->
+  # Calculates the set of unambiguous abbreviations for the strings in `self`.
+  #
+  #     require 'abbrev'
+  #     %w{ car cone }.abbrev
+  #     #=> {"car"=>"car", "ca"=>"car", "cone"=>"cone", "con"=>"cone", "co"=>"cone"}
+  #
+  # The optional `pattern` parameter is a pattern or a string. Only input strings
+  # that match the pattern or start with the string are included in the output
+  # hash.
+  #
+  #     %w{ fast boat day }.abbrev(/^.a/)
+  #     #=> {"fast"=>"fast", "fas"=>"fast", "fa"=>"fast", "day"=>"day", "da"=>"day"}
+  #
+  #     Abbrev.abbrev(%w{car box cone}, "ca")
+  #     #=> {"car"=>"car", "ca"=>"car"}
+  #
+  # See also Abbrev.abbrev
+  #
+  def abbrev: (?String | Regexp | nil) -> Hash[String, String]
+end

data/stdlib/base64/0/base64.rbs

@@ -1,3 +1,4 @@
+# <!-- rdoc-file=lib/base64.rb -->
 # The Base64 module provides for the encoding (#encode64, #strict_encode64,
 # #urlsafe_encode64) and decoding (#decode64, #strict_decode64,
 # #urlsafe_decode64) of binary data using a Base64 representation.
@@ -17,6 +18,10 @@
 # data into purely printable characters.
 #
 module Base64
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - decode64(str)
+  # -->
   # Returns the Base64-decoded version of `str`. This method complies with RFC
   # 2045. Characters outside the base alphabet are ignored.
   #
@@ -32,8 +37,13 @@ module Base64
   #     This is line two
   #     This is line three
   #     And so on...
+  #
   def self?.decode64: (String str) -> String
 
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - encode64(bin)
+  # -->
   # Returns the Base64-encoded version of `bin`. This method complies with RFC
   # 2045. Line feeds are added to every 60 encoded characters.
   #
@@ -44,28 +54,49 @@ module Base64
   #
   #     Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g
   #     UnVieQ==
+  #
   def self?.encode64: (String bin) -> String
 
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - strict_decode64(str)
+  # -->
   # Returns the Base64-decoded version of `str`. This method complies with RFC
   # 4648. ArgumentError is raised if `str` is incorrectly padded or contains
   # non-alphabet characters.  Note that CR or LF are also rejected.
+  #
   def self?.strict_decode64: (String str) -> String
 
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - strict_encode64(bin)
+  # -->
   # Returns the Base64-encoded version of `bin`. This method complies with RFC
   # 4648. No line feeds are added.
+  #
   def self?.strict_encode64: (String bin) -> String
 
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - urlsafe_decode64(str)
+  # -->
   # Returns the Base64-decoded version of `str`. This method complies with ``Base
   # 64 Encoding with URL and Filename Safe Alphabet'' in RFC 4648. The alphabet
   # uses '-' instead of '+' and '_' instead of '/'.
   #
   # The padding character is optional. This method accepts both correctly-padded
   # and unpadded input. Note that it still rejects incorrectly-padded input.
+  #
   def self?.urlsafe_decode64: (String str) -> String
 
+  # <!--
+  #   rdoc-file=lib/base64.rb
+  #   - urlsafe_encode64(bin, padding: true)
+  # -->
   # Returns the Base64-encoded version of `bin`. This method complies with ``Base
   # 64 Encoding with URL and Filename Safe Alphabet'' in RFC 4648. The alphabet
   # uses '-' instead of '+' and '_' instead of '/'. Note that the result can still
   # contain '='. You can remove the padding by setting `padding` as false.
+  #
   def self?.urlsafe_encode64: (String bin, ?padding: boolish) -> String
 end