rbs 4.1.0.pre.2-java

data/stdlib/rdoc/0/context.rbs

@@ -0,0 +1,153 @@
+%a{annotate:rdoc:skip}
+module RDoc
+  # <!-- rdoc-file=lib/rdoc/context.rb -->
+  # A Context is something that can hold modules, classes, methods, attributes,
+  # aliases, requires, and includes. Classes, modules, and files are all Contexts.
+  #
+  class Context < CodeObject
+    include Comparable
+
+    # <!-- rdoc-file=lib/rdoc/context.rb -->
+    # Types of methods
+    #
+    TYPES: ::Array["class" | "instance"]
+
+    TOMDOC_TITLES: ::Array[nil | "Public" | "Internal" | "Deprecated"]
+
+    type class_types = singleton(RDoc::NormalClass) | singleton(RDoc::SingleClass)
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - new()
+    # -->
+    # Creates an unnamed empty context with public current visibility
+    #
+    def initialize: () -> void
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - add_alias(an_alias)
+    # -->
+    # Adds `an_alias` that is automatically resolved
+    #
+    def add_alias: (RDoc::Alias an_alias) -> RDoc::Alias
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - add_attribute(attribute)
+    # -->
+    # Adds `attribute` if not already there. If it is (as method(s) or attribute),
+    # updates the comment if it was empty.
+    #
+    # The attribute is registered only if it defines a new method. For instance,
+    # `attr_reader :foo` will not be registered if method `foo` exists, but
+    # `attr_accessor :foo` will be registered if method `foo` exists, but `foo=`
+    # does not.
+    #
+    def add_attribute: (RDoc::Attr attribute) -> RDoc::Attr
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - add_class(class_type, given_name, superclass = '::Object')
+    # -->
+    # Adds a class named `given_name` with `superclass`.
+    #
+    # Both `given_name` and `superclass` may contain '::', and are interpreted
+    # relative to the `self` context. This allows handling correctly examples like
+    # these:
+    #     class RDoc::Gauntlet < Gauntlet
+    #     module Mod
+    #       class Object   # implies < ::Object
+    #       class SubObject < Object  # this is _not_ ::Object
+    #
+    # Given `class Container::Item` RDoc assumes `Container` is a module unless it
+    # later sees `class Container`.  `add_class` automatically upgrades `given_name`
+    # to a class in this case.
+    #
+    def add_class: (class_types class_type, ::String given_name, ?::String superclass) -> (RDoc::NormalClass | RDoc::SingleClass)
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - add_constant(constant)
+    # -->
+    # Adds `constant` if not already there. If it is, updates the comment, value
+    # and/or is_alias_for of the known constant if they were empty/nil.
+    #
+    def add_constant: (RDoc::Constant constant) -> RDoc::Constant
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - add_include(include)
+    # -->
+    # Adds included module `include` which should be an RDoc::Include
+    #
+    def add_include: (RDoc::Include `include`) -> RDoc::Include
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - add_extend(ext)
+    # -->
+    # Adds extension module `ext` which should be an RDoc::Extend
+    #
+    def add_extend: (RDoc::Extend ext) -> RDoc::Extend
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - add_method(method)
+    # -->
+    # Adds `method` if not already there. If it is (as method or attribute), updates
+    # the comment if it was empty.
+    #
+    def add_method: (RDoc::AnyMethod method) -> RDoc::AnyMethod
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - add_module(class_type, name)
+    # -->
+    # Adds a module named `name`.  If RDoc already knows `name` is a class then that
+    # class is returned instead.  See also #add_class.
+    #
+    def add_module: (singleton(RDoc::NormalModule) class_type, String name) -> RDoc::NormalModule
+
+    # <!-- rdoc-file=lib/rdoc/context.rb -->
+    # All attr* methods
+    #
+    def attributes: () -> Array[Attr]
+
+    # <!-- rdoc-file=lib/rdoc/context.rb -->
+    # Constants defined
+    #
+    def constants: () -> Array[Constant]
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - find_module_named(name)
+    # -->
+    # Find a module with `name` using ruby's scoping rules
+    #
+    def find_module_named: (untyped name) -> (untyped | self)
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - full_name()
+    # -->
+    # The full name for this context.  This method is overridden by subclasses.
+    #
+    def full_name: () -> "(unknown)"
+
+    # <!-- rdoc-file=lib/rdoc/context.rb -->
+    # Methods defined in this context
+    #
+    def method_list: () -> Array[AnyMethod]
+
+    def to_s: () -> ::String
+
+    # <!--
+    #   rdoc-file=lib/rdoc/context.rb
+    #   - top_level()
+    # -->
+    # Return the TopLevel that owns us
+    #
+    def top_level: () -> RDoc::TopLevel
+  end
+end

data/stdlib/rdoc/0/markup.rbs

@@ -0,0 +1,117 @@
+%a{annotate:rdoc:skip}
+module RDoc
+  # <!-- rdoc-file=lib/rdoc/markup.rb -->
+  # RDoc::Markup parses plain text documents and attempts to decompose them into
+  # their constituent parts.  Some of these parts are high-level: paragraphs,
+  # chunks of verbatim text, list entries and the like.  Other parts happen at the
+  # character level: a piece of bold text, a word in code font.  This markup is
+  # similar in spirit to that used on WikiWiki webs, where folks create web pages
+  # using a simple set of formatting rules.
+  #
+  # RDoc::Markup and other markup formats do no output formatting, this is handled
+  # by the RDoc::Markup::Formatter subclasses.
+  #
+  # # Markup Formats
+  #
+  # `RDoc` supports these markup formats:
+  #
+  # *   `rdoc`: the `RDoc` markup format; see RDoc::MarkupReference.
+  # *   `markdown`: The `markdown` markup format as described in the [Markdown
+  #     Guide](https://www.markdownguide.org); see RDoc::Markdown.
+  # *   `rd`: the `rd` markup format format; see RDoc::RD.
+  # *   `tomdoc`: the TomDoc format as described in [TomDoc for
+  #     Ruby](http://tomdoc.org); see RDoc::TomDoc.
+  #
+  # You can choose a markup format using the following methods:
+  #
+  # per project
+  # :   If you build your documentation with rake use RDoc::Task#markup.
+  #
+  #     If you build your documentation by hand run:
+  #
+  #         rdoc --markup your_favorite_format --write-options
+  #
+  #     and commit `.rdoc_options` and ship it with your packaged gem.
+  #
+  # per file
+  # :   At the top of the file use the `:markup:` directive to set the default
+  #     format for the rest of the file.
+  #
+  # per comment
+  # :   Use the `:markup:` directive at the top of a comment you want to write in
+  #     a different format.
+  #
+  #
+  # # RDoc::Markup
+  #
+  # RDoc::Markup is extensible at runtime: you can add new markup elements to be
+  # recognized in the documents that RDoc::Markup parses.
+  #
+  # RDoc::Markup is intended to be the basis for a family of tools which share the
+  # common requirement that simple, plain-text should be rendered in a variety of
+  # different output formats and media.  It is envisaged that RDoc::Markup could
+  # be the basis for formatting RDoc style comment blocks, Wiki entries, and
+  # online FAQs.
+  #
+  # ## Synopsis
+  #
+  # This code converts `input_string` to HTML.  The conversion takes place in the
+  # `convert` method, so you can use the same RDoc::Markup converter to convert
+  # multiple input strings.
+  #
+  #     require 'rdoc'
+  #
+  #     h = RDoc::Markup::ToHtml.new(RDoc::Options.new)
+  #
+  #     puts h.convert(input_string)
+  #
+  # You can extend the RDoc::Markup parser to recognize new markup sequences, and
+  # to add regexp handling. Here we make WikiWords significant to the parser, and
+  # also make the sequences {word} and <no>text...</no> signify strike-through
+  # text.  We then subclass the HTML output class to deal with these:
+  #
+  #     require 'rdoc'
+  #
+  #     class WikiHtml < RDoc::Markup::ToHtml
+  #       def handle_regexp_WIKIWORD(target)
+  #         "<font color=red>" + target.text + "</font>"
+  #       end
+  #     end
+  #
+  #     markup = RDoc::Markup.new
+  #     markup.add_word_pair("{", "}", :STRIKE)
+  #     markup.add_html("no", :STRIKE)
+  #
+  #     markup.add_regexp_handling(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
+  #
+  #     wh = WikiHtml.new RDoc::Options.new, markup
+  #     wh.add_tag(:STRIKE, "<strike>", "</strike>")
+  #
+  #     puts "<body>#{wh.convert ARGF.read}</body>"
+  #
+  # ## Encoding
+  #
+  # Where Encoding support is available, RDoc will automatically convert all
+  # documents to the same output encoding.  The output encoding can be set via
+  # RDoc::Options#encoding and defaults to Encoding.default_external.
+  #
+  # # RDoc Markup Reference
+  #
+  # See RDoc::MarkupReference.
+  #
+  class 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/rdoc/0/options.rbs

@@ -0,0 +1,76 @@
+%a{annotate:rdoc:skip}
+module RDoc
+  # <!-- rdoc-file=lib/rdoc/options.rb -->
+  # RDoc::Options handles the parsing and storage of options
+  #
+  # ## Saved Options
+  #
+  # You can save some options like the markup format in the `.rdoc_options` file
+  # in your gem.  The easiest way to do this is:
+  #
+  #     rdoc --markup tomdoc --write-options
+  #
+  # Which will automatically create the file and fill it with the options you
+  # specified.
+  #
+  # The following options will not be saved since they interfere with the user's
+  # preferences or with the normal operation of RDoc:
+  #
+  # *   `--coverage-report`
+  # *   `--dry-run`
+  # *   `--encoding`
+  # *   `--force-update`
+  # *   `--format`
+  # *   `--pipe`
+  # *   `--quiet`
+  # *   `--template`
+  # *   `--verbose`
+  #
+  # ## Custom Options
+  #
+  # Generators can hook into RDoc::Options to add generator-specific command line
+  # options.
+  #
+  # When `--format` is encountered in ARGV, RDoc calls ::setup_options on the
+  # generator class to add extra options to the option parser.  Options for custom
+  # generators must occur after `--format`.  `rdoc --help` will list options for
+  # all installed generators.
+  #
+  # Example:
+  #
+  #     class RDoc::Generator::Spellcheck
+  #       RDoc::RDoc.add_generator self
+  #
+  #       def self.setup_options rdoc_options
+  #         op = rdoc_options.option_parser
+  #
+  #         op.on('--spell-dictionary DICTIONARY',
+  #               RDoc::Options::Path) do |dictionary|
+  #           rdoc_options.spell_dictionary = dictionary
+  #         end
+  #       end
+  #     end
+  #
+  # Of course, RDoc::Options does not respond to `spell_dictionary` by default so
+  # you will need to add it:
+  #
+  #     class RDoc::Options
+  #
+  #       ##
+  #       # The spell dictionary used by the spell-checking plugin.
+  #
+  #       attr_accessor :spell_dictionary
+  #
+  #     end
+  #
+  # ## Option Validators
+  #
+  # OptionParser validators will validate and cast user input values.  In addition
+  # to the validators that ship with OptionParser (String, Integer, Float,
+  # TrueClass, FalseClass, Array, Regexp, Date, Time, URI, etc.), RDoc::Options
+  # adds Path, PathArray and Template.
+  #
+  class Options
+    def initialize: (?untyped loaded_options) -> void
+  end
+end

data/stdlib/rdoc/0/parser.rbs

@@ -0,0 +1,56 @@
+%a{annotate:rdoc:skip}
+module RDoc
+  # <!-- rdoc-file=lib/rdoc/parser.rb -->
+  # A parser is simple a class that subclasses RDoc::Parser and implements #scan
+  # to fill in an RDoc::TopLevel with parsed data.
+  #
+  # The initialize method takes an RDoc::TopLevel to fill with parsed content, the
+  # name of the file to be parsed, the content of the file, an RDoc::Options
+  # object and an RDoc::Stats object to inform the user of parsed items.  The scan
+  # method is then called to parse the file and must return the RDoc::TopLevel
+  # object.  By calling super these items will be set for you.
+  #
+  # In order to be used by RDoc the parser needs to register the file extensions
+  # it can parse.  Use ::parse_files_matching to register extensions.
+  #
+  #     require 'rdoc'
+  #
+  #     class RDoc::Parser::Xyz < RDoc::Parser
+  #       parse_files_matching /\.xyz$/
+  #
+  #       def initialize top_level, file_name, content, options, stats
+  #         super
+  #
+  #         # extra initialization if needed
+  #       end
+  #
+  #       def scan
+  #         # parse file and fill in @top_level
+  #       end
+  #     end
+  #
+  class Parser
+    # <!--
+    #   rdoc-file=lib/rdoc/parser.rb
+    #   - parse_files_matching(regexp)
+    # -->
+    # Record which file types this parser can understand.
+    #
+    # It is ok to call this multiple times.
+    #
+    def self?.parse_files_matching: (Regexp path) -> void
+
+    # <!--
+    #   rdoc-file=lib/rdoc/parser.rb
+    #   - new(top_level, content, options, stats)
+    # -->
+    # Creates a new Parser storing `top_level`, `file_name`, `content`, `options`
+    # and `stats` in instance variables.  In +@preprocess+ an
+    # RDoc::Markup::PreProcess object is created which allows processing of
+    # directives.
+    #
+    def initialize: (RDoc::TopLevel top_level, String filename, String content, Hash[untyped, untyped] options, RDoc::Stats stats) -> void
+
+    def scan: () -> RDoc::TopLevel
+  end
+end