yard 0.9.39 → 0.9.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b836f5d9002f597a10995cf2cad6397d7b165eb97f62913dc8139edcebecd447
-  data.tar.gz: 97acbcdc84297f679bd3b47964e11fb4f8db59b147f4d2a18e8969b81788ba7f
+  metadata.gz: f30a7254915dfc58291d8bdbf05f6e65bbb392d9c359bb0df535c5d290dbf2f8
+  data.tar.gz: bd261832603492535a89218415f59c84c3e5c732dd8a0cc25f5a294a0b2c98a5
 SHA512:
-  metadata.gz: 98c9eb39c6f8d904630317d2d322339fa427e6b44e38b5e1d51ebcf8f7a97db74b1959e33c98ba9b6eb4f4ff6ef25b3422bdac600b66007235ed008691e3bded
-  data.tar.gz: 3758da9b0b0a6c8ef9e169aee6774d31e1b4599e1c7fbe4e912b40bfb6f27136485342a3b273b0aab2d55e39df396be9076bb83da67d1284576b9cb2f027d464
+  metadata.gz: 132b2b6ea721780a3f36001216fa16aade784e2936d89684249f92c3ddd2180f2820e24c339551ce33405779c627b82bb085978b6f3a785b1450f17204b00d88
+  data.tar.gz: e4410e47b0b7871241611b3328fa2e5219ba5632c4648e3d4f3d5ac66bf54986ac046bae935bc68911d905210159cc1dc70ca6aba0870056aef9ba36f70dbae3

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # main
 
+# [0.9.40] - April 12th, 2026
+
+[0.9.40]: https://github.com/lsegal/yard/compare/v0.9.39...v0.9.40
+
+- Add support for Ruby .rbs files (docstrings included) (#1673)
+- Add built-in hybrid RDoc/Markdown renderer (`HybridMarkdown`) requiring no external gems (#1674)
+- Add support for `#-` as a comment-block separator. See Getting Started Guide.
+- Add support for `commonmarker` version `>= 1.0`.
+- Remove usage of jQuery in default templates. jQuery library is still packaged in templates for backward compatibility (#1675)
+- Fix false self-referential mixin when bare name matches ancestor namespace (#1672)
+- Fix bracket/brace map corruption from Ruby 3.0+ pattern matching deconstruction (#1671)
+- Fix `@!scope class` on attributes (#1582, #1655, #1666)
+- Fix `@!parse` directives not including source for block (#1665)
+- Fix inherited methods not appearing in groups (#1656)
+
 # [0.9.39] - April 8th, 2026
 
 [0.9.39]: https://github.com/lsegal/yard/compare/v0.9.38...v0.9.39
@@ -858,7 +873,7 @@ contributions to this version.
 
 [0.4.0]: https://github.com/lsegal/yard/compare/v0.2.3.5...v0.4.0
 
-- Added new templating engine based on [tadpole](http://github.com/lsegal/tadpole)
+- Added new templating engine based on [tadpole](https://github.com/lsegal/tadpole)
 - Added YARD queries (`--query` CLI argument to yardoc)
 - Greatly expanded YARD documentation
 - Added plugin support

data/README.md

@@ -1,10 +1,10 @@
 # YARD: Yay! A Ruby Documentation Tool
 
-[![Homepage](https://img.shields.io/badge/home-yardoc.org-blue.svg)](http://yardoc.org)
-[![GitHub](https://img.shields.io/badge/github-lsegal/yard-blue.svg)](http://github.com/lsegal/yard)
-[![Documentation](https://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://rubydoc.org/gems/yard/frames)
+[![Homepage](https://img.shields.io/badge/home-yardoc.org-blue.svg)](https://yardoc.org)
+[![GitHub](https://img.shields.io/badge/github-lsegal/yard-blue.svg)](https://github.com/lsegal/yard)
+[![Documentation](https://img.shields.io/badge/docs-rdoc.info-blue.svg)](https://rubydoc.org/gems/yard/frames)
 
-[![Gem Version](https://badge.fury.io/rb/yard.svg)](http://github.com/lsegal/yard/releases)
+[![Gem Version](https://badge.fury.io/rb/yard.svg)](https://github.com/lsegal/yard/releases)
 [![Unit Tests](https://github.com/lsegal/yard/actions/workflows/ci.yml/badge.svg)](https://github.com/lsegal/yard/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/github/lsegal/yard/badge.svg)](https://coveralls.io/github/lsegal/yard)
 [![License](https://img.shields.io/badge/license-MIT-yellowgreen.svg)](#license)
@@ -19,10 +19,10 @@ summary of some of YARD's notable features.
 
 ## Feature List
 
-**1. RDoc/SimpleMarkup Formatting Compatibility**: YARD is made to be compatible
-with RDoc formatting. In fact, YARD does no processing on RDoc documentation
-strings, and leaves this up to the output generation tool to decide how to
-render the documentation.
+**1. Builtin RDoc/Markdown Hybrid Support**: YARD ships with a builtin markup
+renderer that supports both RDoc and Markdown formatting out of the box—no
+external gem required. You can freely mix RDoc-style and Markdown-style
+documentation without installing any additional libraries.
 
 **2. Yardoc Meta-tag Formatting Like Python, Java, Objective-C and other
 languages**: YARD uses a '@tag' style definition syntax for meta tags alongside
@@ -114,20 +114,17 @@ $ gem install yard
 Alternatively, if you've checked the source out directly, you can call
 `rake install` from the root project directory.
 
-**Important Note for Debian/Ubuntu users:** there's a possible chance your Ruby
-install lacks RDoc, which is occasionally used by YARD to convert markup to
-HTML. If running `which rdoc` turns up empty, install RDoc by issuing:
+### Markup rendering
 
-```sh
-$ sudo apt-get install rdoc
-```
-
-### Markdown parser
+YARD includes a builtin renderer that handles both RDoc and Markdown markup
+types without any external dependencies. To switch the default markup type,
+pass `-m markdown` (or `-m rdoc`) to `yard doc`, or add it to your `.yardopts`
+file.
 
-When rendering markdown, yard will use one of several possible markdown providers,
-[in order of priority](https://github.com/lsegal/yard/blob/e833aac7a01510245dd4ae1d1d18b046c8293c2d/lib/yard/templates/helpers/markup_helper.rb#L26-L33).
-If you are experiencing rendering bugs (example [1](https://github.com/lsegal/yard/issues/1410) [2](https://github.com/lsegal/yard/issues/1543)), try adding one of the
-gems further up in the list to your Gemfile.
+For optional extra rendering features (e.g. GitHub-Flavoured Markdown fenced
+code blocks, tables, or specific Markdown extensions), you can install an
+additional provider gem such as `redcarpet`, `commonmarker`, or `kramdown` and
+select it explicitly with `-M PROVIDER` (e.g. `yard doc -m markdown -M redcarpet`).
 
 ## Usage
 
@@ -307,7 +304,7 @@ the first request of a newly parsed gem.
 ### 5. `yard graph` Graphviz Generator
 
 You can use `yard graph` to generate dot graphs of your code. This, of course,
-requires [Graphviz](http://www.graphviz.org) and the `dot` binary. By default
+requires [Graphviz](https://www.graphviz.org) and the `dot` binary. By default
 this will generate a graph of the classes and modules in the best UML2 notation
 that Graphviz can support, but without any methods listed. With the `--full`
 option, methods and attributes will be listed. There is also a `--dependencies`

data/docs/GettingStarted.md

@@ -61,15 +61,41 @@ Using tags we can add semantic metadata to our code without worrying about
 presentation. YARD will handle presentation for us when we decide to generate
 documentation later.
 
+### Disconnecting Comment Blocks
+
+YARD attaches a comment block to the next relevant object by default. That is
+usually what you want, but file headers are a common exception. If you keep a
+copyright notice, license note or general file-level description at the top of
+the file, it can accidentally become the docstring for the first class or
+module unless you explicitly break the block.
+
+To disconnect the block, end the header with an attached `#-` line:
+
+    # Copyright (c) Example Corp
+    # Shared support code for the client layer.
+    #-
+
+    class Client
+    end
+
+In this example, the header comment is not attached to `Client`.
+
+This only works with `#-`. If you write `# -` with a space before the hyphen,
+YARD treats it as a normal comment line and it remains part of the docstring.
+
 ## Which Markup Format?
 
-YARD does not impose a specific markup. The above example uses standard RDoc
-markup formatting, but YARD also supports textile and markdown via the
-command-line switch or `.yardopts` file (see below). This means that you are
-free to use whatever formatting you like. This guide is actually written
-using markdown. YARD, however, does add a few important syntaxes that are
-processed no matter which markup formatting you use, such as tag support
-and inter-document linking. These syntaxes are discussed below.
+YARD does not impose a specific markup format. YARD ships with a builtin
+renderer that supports both RDoc and Markdown out of the box—no external gem
+required. You can use either format (or switch between them) without installing
+anything extra. YARD also supports textile, asciidoc, and other formats via
+optional gems.
+
+To select a markup format, use the command-line switch `-m FORMAT` or add
+`--markup FORMAT` to your `.yardopts` file. This guide is written in Markdown.
+YARD adds a few important syntaxes that are processed regardless of which
+markup format you choose, such as tag support and inter-document linking.
+These syntaxes are discussed below.
 
 ## Adding Tags to Documentation
 
@@ -182,7 +208,7 @@ Symbols:
 We mentioned that these type fields are "mostly" free-form. In truth, they
 are defined "by convention". To view samples of common type specifications
 and recommended conventions for writing type specifications, see
-[http://yardoc.org/types.html](http://yardoc.org/types.html). Note that these
+[https://yardoc.org/types.html](https://yardoc.org/types.html). Note that these
 conventions may change every now and then, although we are working on a more
 "formal" type specification proposal.
 
@@ -200,7 +226,7 @@ YARD will automatically wire up the correct method types and information
 by simply defining documentation in the `@return` tag. For example,
 the following declaration will show the correct information for the
 `waveform` attribute, both for the getter's return type and the
-setter's value parameter type: 
+setter's value parameter type:
 
     # @return [Numeric] the amplitude of the waveform
     attr_accessor :amplitude
@@ -248,7 +274,7 @@ The most common is the `attr_accessor` method, which of course has built-in
 support in YARD. However, frameworks and libraries often expose custom
 methods that perform similar metaprogramming tasks, and it is often useful
 to document their functionality in your application. Consider the `property`
-method in a project like [DataMapper](http://datamapper.org), which creates
+method in a project like [DataMapper](https://datamapper.org), which creates
 a typed attribute for a database model. The code might look like:
 
     class Post
@@ -386,11 +412,11 @@ If you want to use a Hash, prefix the first { with "!":
 
    # !{ :some_key => 'value' }
 
-### Linking URLs `{http://...}`
+### Linking URLs `{https://...}`
 
 URLs are also linked using this `{...}` syntax:
 
-    {http://example.com Optional Title}
+    {https://example.com Optional Title}
     {mailto:email@example.com}
 
 ### Linking Files `{file:...}`
@@ -672,8 +698,8 @@ not exist, so you may need to create it.
 You may find some useful YARD plugins on [RubyGems][RubyGemsQuery] or with
 a [Google advanced query][GoogleAdvancedQuery].
 
-[graphviz]:http://www.graphviz.org
-[yard-rspec]:http://github.com/lsegal/yard-spec-plugin
-[rspec]:http://rspec.info
+[graphviz]:https://www.graphviz.org
+[yard-rspec]:https://github.com/lsegal/yard-spec-plugin
+[rspec]:https://rspec.info
 [GoogleAdvancedQuery]:https://www.google.com/search?q=site%3Arubygems.org+intitle%3A%22yard-%22+OR+intitle%3A%22yard_%22
 [RubyGemsQuery]:https://rubygems.org/search?utf8=%E2%9C%93&query=name%3A+yard

data/docs/Tags.md

@@ -141,7 +141,7 @@ a set of conventions for how to list types is described below.
 
 <p class="note">
   A list of examples of common type listings and what they translate into is
-  available at <a href="http://yardoc.org/types">http://yardoc.org/types</a>.
+  available at <a href="https://yardoc.org/types">https://yardoc.org/types</a>.
 </p>
 
 Typically, a type list contains a list of classes or modules that are associated
@@ -213,9 +213,10 @@ having exactly those 3 elements) would be listed as: `Array(String, Fixnum, Hash
 Some literals are accepted by virtue of being Ruby literals, but also by YARD
 conventions. Here is a non-exhaustive list of certain accepted literal values:
 
-* `true`, `false`, `nil` &mdash; used when a method returns these explicit literal
-  values. Note that if your method returns both `true` or `false`, you should use
-  the `Boolean` conventional type instead.
+* `true`, `false`, `nil`, `:foo` &mdash; used when a method returns
+  these explicit literal values. Note that if your method returns both
+  `true` or `false`, you should use the `Boolean` conventional type
+  instead.
 * `self` &mdash; has the same meaning as Ruby's "self" keyword in the context of
   parameters or return types. Recommended mostly for {tag:return} tags that are
   chainable.
@@ -280,4 +281,3 @@ Note that you might not need a tag title if you are hiding it. The title
 part can be omitted.
 
 {yard:include_tags}
-

data/docs/WhatsNew.md

@@ -1,5 +1,57 @@
 # @title What's New?
 
+# What's New in 0.9.x?
+
+## Support for Ruby Signature Files (.rbs) (0.9.40)
+
+YARD now supports parsing Ruby signature files (.rbs) with full docstring support. This means you can write your documentation in `.rbs` files and have it show up in generated documentation, and use `.rbs` files alongside `.rb` sources to supplement type and API information.
+
+## New built-in Markdown renderer (0.9.40)
+
+YARD now ships with a built-in Markdown renderer (`YARD::Templates::Helpers::Markup::HybridMarkdown`)
+that requires **no external gems**. It supports a practical subset of GitHub Flavored Markdown (GFM)
+as well as common RDoc markup forms, including:
+
+- Headings (`#`, `=`)
+- Fenced code blocks (`` ``` `` and `~~~`) as well as RDoc formatted `+text+` blocks.
+- Tables, blockquotes, and thematic breaks
+- Ordered and unordered lists (including RDoc-style)
+- Inline emphasis, code, links, and images
+- HTML passthrough blocks
+
+This renderer is the **default** for both the `rdoc` and `markdown` markup types—no gem
+installation required. If an optional provider gem (e.g. `redcarpet`, `kramdown`,
+`commonmarker`) is installed and selected, YARD will use it instead for extra features such
+as custom extensions or stricter spec compliance.
+
+## `#-` comment block separators (0.9.40)
+
+YARD now recognizes a trailing `#-` line as a separator between comment
+blocks. This is useful when you want to keep a file header comment at the top
+of a Ruby file without having that header attach itself to the first class,
+module or method in the file.
+
+For example:
+
+    # Copyright (c) Example Corp
+    # This file defines support code shared by the client.
+    #-
+
+    class Client
+    end
+
+In the example above, the file header stays disconnected from `Client`.
+Note that `# -` does **not** act as a separator; only an attached `#-`
+line has this behavior.
+
+## Ruby 4.x support (0.9.39)
+
+Added support for Ruby 4.x along with new syntaxes.
+
+## Other changes
+
+See the [CHANGELOG](CHANGELOG.md) for a full list of changes in 0.9.x.
+
 # What's New in 0.8.x?
 
 1. **Directives (new behavioural tag syntax)** (0.8.0)
@@ -171,7 +223,7 @@ only mixins inside of a "Foo::Bar" namespace by doing:
 YARD now ships with the beginnings of internationalization support
 for translating documentation into multiple languages. The
 `yard i18n` command now allows you to generate ".pot" and ultimately
-".po" files for translation with [gettext](http://www.gnu.org/software/gettext).
+".po" files for translation with [gettext](https://www.gnu.org/software/gettext).
 
 Note that this tool is a small step in the larger transition for
 proper I18n support in YARD. We still have to add proper gettext
@@ -283,7 +335,7 @@ above example would be:
 But note that `--query` does not work when YARD is in "safe mode"
 due to security concerns, whereas `--api` works in either mode.
 This enables `--api` to function on remote documentation sites like
-[rubydoc.info](http://rubydoc.info).
+[rubydoc.info](https://rubydoc.info).
 
 ## Added `--non-transitive-tag` to disable transitive tag (0.8.3)
 
@@ -307,7 +359,7 @@ with `yard server -B PORT` or `yard server --bind PORT`.
 
 Support for the AsciiDoc markup type is now introduced using the `asciidoc`
 markup type (`yard doc -m asciidoc`). Requires the
-[asciidoctor](http://rubygems.org/gems/asciidoctor) RubyGem library to be
+[asciidoctor](https://rubygems.org/gems/asciidoctor) RubyGem library to be
 installed before running YARD.
 
 ## Added `yard markups` command to list available markup types (0.8.6)
@@ -645,7 +697,7 @@ templates. To serve documentation for installed gems:
   will do this for you on-the-fly. It is therefore possible to speed up your
   gem installs by using `gem install GEMNAME --no-rdoc` without repercussion.
   You can also add this switch to your `~/.gemrc` file so that you don't need
-   to re-type it each time. See [this link](http://stackoverflow.com/questions/1789376/how-do-i-make-no-ri-no-rdoc-the-default-for-gem-install)
+   to re-type it each time. See [this link](https://stackoverflow.com/questions/1789376/how-do-i-make-no-ri-no-rdoc-the-default-for-gem-install)
    for exact instructions.</span>
 
 ## Groups support for method listing (0.6.0)
@@ -718,7 +770,7 @@ regular diffing tells you which lines have been added/removed in a file,
 object diffing allows you to see what classes/methods/modules have been
 added/removed between versions of a codebase.
 
-For an overview of how to use `yard diff`, see [YARD Object Oriented Diffing](http://gnuu.org/2010/06/26/yard-object-oriented-diffing/).
+For an overview of how to use `yard diff`, see [YARD Object Oriented Diffing](https://gnuu.org/2010/06/26/yard-object-oriented-diffing/).
 
 ## `yard stats` to display statistics and undocumented objects (0.6.0)
 
@@ -902,7 +954,7 @@ Support for documenting native Ruby C code (0.5.0)
 
 It is now possible to document native Ruby extensions with YARD with a new
 C parser mostly borrowed from RDoc. This enables the ability to document
-Ruby's core and stdlibs which will be hosted on http://yardoc.org/docs. In
+Ruby's core and stdlibs which will be hosted on https://yardoc.org/docs. In
 addition, the .yardoc dump for the Ruby-core classes will become available
 as an installable gem for yri support (see #3).
 
@@ -1144,7 +1196,7 @@ Default rake task is now `rake yard`
 Not a big change, but anyone using the default "rake yardoc" task should
 update their scripts:
 
-[http://github.com/lsegal/yard/commit/ad38a68dd73898b06bd5d0a1912b7d815878fae0](http://github.com/lsegal/yard/commit/ad38a68dd73898b06bd5d0a1912b7d815878fae0)
+[https://github.com/lsegal/yard/commit/ad38a68dd73898b06bd5d0a1912b7d815878fae0](https://github.com/lsegal/yard/commit/ad38a68dd73898b06bd5d0a1912b7d815878fae0)
 
 
 What's New in 0.2.3.x?

data/docs/templates/default/yard_tags/html/setup.rb

@@ -22,5 +22,5 @@ def tag_signature(tag)
             else
               "description"
             end
-  signature + h(extra).gsub(/\n/, "<br/>&nbsp;&nbsp;&nbsp;")
+  signature + h(extra).gsub(/\n/, "<br>&nbsp;&nbsp;&nbsp;")
 end

data/lib/yard/autoload.rb

@@ -69,6 +69,16 @@ module YARD
       autoload :MethodHandler,            __p('handlers/common/method_handler')
     end
 
+    # RBS type signature handlers
+    module RBS
+      autoload :Base,               __p('handlers/rbs/base')
+      autoload :AttributeHandler,   __p('handlers/rbs/attribute_handler')
+      autoload :ConstantHandler,    __p('handlers/rbs/constant_handler')
+      autoload :MethodHandler,      __p('handlers/rbs/method_handler')
+      autoload :MixinHandler,       __p('handlers/rbs/mixin_handler')
+      autoload :NamespaceHandler,   __p('handlers/rbs/namespace_handler')
+    end
+
     # CRuby Handlers
     # @since 0.8.0
     module C
@@ -183,6 +193,12 @@ module YARD
       autoload :TokenResolver,     __p('parser/ruby/token_resolver')
     end
 
+    # RBS type signature parser
+    module RBS
+      autoload :RbsParser, __p('parser/rbs/rbs_parser')
+      autoload :Statement, __p('parser/rbs/statement')
+    end
+
     autoload :Base,                __p('parser/base')
     autoload :ParserSyntaxError,   __p('parser/source_parser')
     autoload :SourceParser,        __p('parser/source_parser')
@@ -271,6 +287,7 @@ module YARD
   module Templates
     module Helpers # Namespace for template helpers
       module Markup # Namespace for markup providers
+        autoload :HybridMarkdown,           __p('templates/helpers/markup/hybrid_markdown')
         autoload :RDocMarkup,               __p('templates/helpers/markup/rdoc_markup')
         autoload :RDocMarkdown,             __p('templates/helpers/markup/rdoc_markdown')
       end

data/lib/yard/cli/diff.rb

@@ -2,6 +2,7 @@
 require 'tmpdir'
 require 'fileutils'
 require 'open-uri'
+require 'open3'
 
 module YARD
   module CLI
@@ -108,7 +109,11 @@ module YARD
         FileUtils.mkdir_p(tmpdir)
         FileUtils.cp_r('.', tmpdir)
         Dir.chdir(tmpdir)
-        log.info("git says: " + `git reset --hard #{commit}`.chomp)
+        out, status = Open3.capture2e('git', 'reset', '--hard', commit)
+        log.info("git says: " + out.chomp)
+        unless status.success?
+          raise "git reset --hard #{commit.inspect} failed with exit status #{status.exitstatus}: #{out}"
+        end
         generate_yardoc(tmpdir)
       ensure
         Dir.chdir(@old_path)
@@ -158,7 +163,7 @@ module YARD
         end
 
         # Remote gemfile from rubygems.org
-        url = "http://rubygems.org/downloads/#{gemfile}"
+        url = "https://rubygems.org/downloads/#{gemfile}"
         log.info "Searching for remote gem file #{url}"
         begin
           # Note: In Ruby 2.4.x, URI.open is a private method. After

data/lib/yard/code_objects/proxy.rb

@@ -201,7 +201,7 @@ module YARD
 
       private
 
-      # @note this method fixes a bug in 1.9.2: http://gist.github.com/437136
+      # @note this method fixes a bug in 1.9.2: https://gist.github.com/437136
       def to_ary; nil end
 
       # Attempts to find the object that this unresolved object

data/lib/yard/handlers/processor.rb

@@ -35,6 +35,7 @@ module YARD
       register_handler_namespace :ruby, Ruby
       register_handler_namespace :ruby18, Ruby::Legacy
       register_handler_namespace :c, C
+      register_handler_namespace :rbs, RBS
 
       # @return [String] the filename
       attr_accessor :file

data/lib/yard/handlers/rbs/attribute_handler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+# Handles RBS attr_reader, attr_writer, and attr_accessor declarations.
+#
+# Registers one or two {YARD::CodeObjects::MethodObject} instances (reader
+# and/or writer) with @return / @param tags derived from the RBS type.
+class YARD::Handlers::RBS::AttributeHandler < YARD::Handlers::RBS::Base
+  handles :attr_reader, :attr_writer, :attr_accessor
+
+  process do
+    attr_name  = statement.name
+    rbs_type   = statement.attr_rbs_type
+    yard_types = rbs_type ? YARD::Handlers::RBS::MethodHandler.rbs_type_to_yard_types(rbs_type) : nil
+    mscope     = statement.visibility == :class ? :class : :instance
+
+    case statement.type
+    when :attr_reader
+      register_reader(attr_name, yard_types, mscope)
+    when :attr_writer
+      register_writer(attr_name, yard_types, mscope)
+    when :attr_accessor
+      register_reader(attr_name, yard_types, mscope)
+      register_writer(attr_name, yard_types, mscope)
+    end
+  end
+
+  private
+
+  def register_reader(name, types, scope)
+    obj = register MethodObject.new(namespace, name, scope)
+    if types && !obj.has_tag?(:return)
+      obj.add_tag YARD::Tags::Tag.new(:return, '', types)
+    end
+    obj
+  end
+
+  def register_writer(name, types, scope)
+    obj = register MethodObject.new(namespace, "#{name}=", scope)
+    if types && !obj.has_tag?(:param)
+      obj.add_tag YARD::Tags::Tag.new(:param, '', types, "value")
+    end
+    obj
+  end
+end

data/lib/yard/handlers/rbs/base.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module YARD
+  module Handlers
+    # Handlers for RBS (Ruby type signature) files.
+    module RBS
+      # Base class for all RBS handlers.
+      # Handlers match on the {Parser::RBS::Statement#type} symbol of the
+      # current statement and process it to create or annotate code objects.
+      class Base < Handlers::Base
+        # @return [Boolean] whether this handler matches the given statement
+        def self.handles?(statement, _processor)
+          handlers.any? do |matcher|
+            case matcher
+            when Symbol
+              statement.type == matcher
+            when String
+              statement.type.to_s == matcher
+            when Regexp
+              (statement.source || '') =~ matcher
+            else
+              false
+            end
+          end
+        end
+
+        # Recurse into the body of a namespace statement.
+        # @param opts [Hash] state overrides
+        # @see #push_state
+        def parse_block(opts = {})
+          return if statement.block.nil? || statement.block.empty?
+          push_state(opts) do
+            parser.process(statement.block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yard/handlers/rbs/constant_handler.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+# Handles RBS constant declarations: `Name: Type`
+class YARD::Handlers::RBS::ConstantHandler < YARD::Handlers::RBS::Base
+  handles :constant
+
+  process do
+    obj = register ConstantObject.new(namespace, statement.name)
+    if statement.attr_rbs_type && !obj.has_tag?(:return)
+      obj.add_tag YARD::Tags::Tag.new(:return, '', rbs_types(statement.attr_rbs_type))
+    end
+  end
+
+  private
+
+  def rbs_types(type_str)
+    YARD::Handlers::RBS::MethodHandler.rbs_type_to_yard_types(type_str)
+  end
+end