yard 0.9.44 → 0.9.45

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87aef8f8a0b6c25d1a2c05214992313aa6278659214af6650d07876346b771ec
-  data.tar.gz: 149cee78996a555a97d7223252df845be60ecaf9bf92d7c9bedeeb8fe14952bf
+  metadata.gz: 8e6dbc08e061218c5f0736d4b07923de3407ef37427f48307c01917e84c904e2
+  data.tar.gz: 7fc6e859d2f4a385eb7a956796782b3d6f45b0b480aadb566ed31aa862c5191b
 SHA512:
-  metadata.gz: e7bd349e0d31fb2b79dd0c18a057ff9323206c4d6be3535f902f9fa45ee30a8649bd3036861fdf2ab90e017bfaf7622eb744461a2728a88b68792bc8acbd3fa9
-  data.tar.gz: 2f4e486d27daf722a02c2efc2e7af568c12a76ebd30b23871a46c25c54e03f9e6f51397953dac330dba6b0581b7088882e581b04f43fe9ef64e3a0a93862df15
+  metadata.gz: 0ef54ea2c613b5b67200f0770ca5accb0c592511087efb5b66cb8c8847e89277247030befc947838eae3ef1f3f911acc66dfbaa0691e9119168e0d76d546ca76
+  data.tar.gz: 1d459a1eed141b9183ed4323e16cf0802b42c3043bd7fecc8aa6cc234e4c73a4b4fe90a39ad9bf063f6bc8b42ed911ab16ae56437ac7e4deaa595ef9829485aa

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # main
 
+# [0.9.45] - July 14th, 2026
+
+[0.9.45]: https://github.com/lsegal/yard/compare/v0.9.44...v0.9.45
+
+- Use `@param` types to document generated `Struct.new` and `Data.define` members (#1684)
+- Add compatibility with RDoc 8
+- Fix TypesExplainer parsing of types following Hash collections (#1688)
+- Fix HTML generation for RBS constants without source values (#1686)
+- Fix method redefinition warnings when loading YARD with Ruby warnings enabled (#1687)
+- Improve sanitization of `yard server` request paths
+
 # [0.9.44] - May 25th, 2026
 
 [0.9.44]: https://github.com/lsegal/yard/compare/v0.9.43...v0.9.44

data/lib/yard/handlers/ruby/struct_handler_methods.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-# Helper methods to parse @attr_* tags on a class.
+# Helper methods to document generated Struct and Data members.
 #
 # @deprecated The use of +@attr+ tags are deprecated since 0.8.0 in favour of
 #   the +@!attribute+ directive. This module should not be relied on.
@@ -19,6 +19,26 @@ module YARD::Handlers::Ruby::StructHandlerMethods
     (klass.tags(specific_tag) + klass.tags(:attr)).find {|tag| tag.name == member }
   end
 
+  # Extracts the user's defined @param tag for a given generated member.
+  #
+  # @param [ClassObject] klass the class whose tags we're searching
+  # @param [String] member the name of the struct or data member we need
+  # @return [Tags::Tag, nil] the matching tag, or nil if not found
+  def parameter_tag_for_member(klass, member)
+    klass.tags(:param).find {|tag| tag.name == member }
+  end
+
+  # Returns the tag that supplies a generated member's type. Existing @attr*
+  # tags take precedence over the more concise @param form.
+  #
+  # @param [ClassObject] klass the class whose tags we're searching
+  # @param [String] member the name of the struct or data member we need
+  # @param [Symbol] type reader method, or writer method?
+  # @return [Tags::Tag, nil] the tag supplying the type, or nil if not found
+  def type_tag_for_member(klass, member, type = :read)
+    member_tag_for_member(klass, member, type) || parameter_tag_for_member(klass, member)
+  end
+
   # Retrieves all members defined in @attr* tags
   #
   # @param [ClassObject] klass the class with the attributes
@@ -61,7 +81,7 @@ module YARD::Handlers::Ruby::StructHandlerMethods
   # @return [String] a docstring to be attached to the getter method for this member
   def add_reader_tags(klass, new_method, member)
     member_tag = member_tag_for_member(klass, member, :read)
-    return_type = return_type_from_tag(member_tag)
+    return_type = return_type_from_tag(type_tag_for_member(klass, member, :read))
     getter_doc_text = member_tag ? member_tag.text : "Returns the value of attribute #{member}"
     new_method.docstring.replace(getter_doc_text)
     new_method.add_tag YARD::Tags::Tag.new(:return, "the current value of #{member}", return_type)
@@ -76,7 +96,7 @@ module YARD::Handlers::Ruby::StructHandlerMethods
   # @return [String] a docstring to be attached to the setter method for this member
   def add_writer_tags(klass, new_method, member)
     member_tag = member_tag_for_member(klass, member, :write)
-    return_type = return_type_from_tag(member_tag)
+    return_type = return_type_from_tag(type_tag_for_member(klass, member, :write))
     setter_doc_text = member_tag ? member_tag.text : "Sets the attribute #{member}"
     new_method.docstring.replace(setter_doc_text)
     new_method.add_tag YARD::Tags::Tag.new(:param, "the value to set the attribute #{member} to.", return_type, "value")
@@ -104,7 +124,7 @@ module YARD::Handlers::Ruby::StructHandlerMethods
   def create_writer(klass, member)
     # We want to convert these members into attributes just like
     # as if they were declared using attr_accessor.
-    new_meth = register MethodObject.new(klass, "#{member}=", :instance) do |o|
+    new_meth = register_struct_member_method MethodObject.new(klass, "#{member}=", :instance) do |o|
       o.parameters = [['value', nil]]
       o.signature ||= "def #{member}=(value)"
       o.source ||= "#{o.signature}\n  @#{member} = value\nend"
@@ -119,7 +139,7 @@ module YARD::Handlers::Ruby::StructHandlerMethods
   # @param [ClassObject] klass the class to attach the method to
   # @param [String] member the name of the member we're generating a method for
   def create_reader(klass, member)
-    new_meth = register MethodObject.new(klass, member, :instance) do |o|
+    new_meth = register_struct_member_method MethodObject.new(klass, member, :instance) do |o|
       o.signature ||= "def #{member}"
       o.source ||= "#{o.signature}\n  @#{member}\nend"
     end
@@ -140,4 +160,20 @@ module YARD::Handlers::Ruby::StructHandlerMethods
       create_reader klass, member if create_member_method?(klass, member, :read)
     end
   end
+
+  # Registers an auto-generated member method without reapplying the class's
+  # docstring to it. The generated reader or writer receives its own docstring
+  # and tags immediately after registration.
+  def register_struct_member_method(method, &block)
+    previous = @registering_struct_member_method
+    @registering_struct_member_method = true
+    register(method, &block)
+  ensure
+    @registering_struct_member_method = previous
+  end
+
+  def register_docstring(object, docstring = statement.comments, stmt = statement)
+    docstring = nil if @registering_struct_member_method
+    super(object, docstring, stmt)
+  end
 end

data/lib/yard/parser/ruby/ruby_parser.rb

@@ -379,6 +379,7 @@ module YARD
         # entries from corrupting source ranges of later hash literals and brace blocks.
         # Bare hash patterns (key: val without braces) fire no brace scanner events, so
         # we only clean up when @map[:rbrace] confirms a closing brace was scanned.
+        begin; undef on_hshptn; rescue NameError; end
         def on_hshptn(*args)
           if (@map[:rbrace] ||= []).any?
             (@map[:lbrace] ||= []).pop
@@ -443,6 +444,7 @@ module YARD
         # on_rbracket scanner events. The corresponding parser events are on_aryptn/on_fndptn
         # (not on_aref), so we must clean up the bracket maps to prevent stale entries from
         # corrupting source ranges of later array indexing expressions.
+        begin; undef on_aryptn; rescue NameError; end
         def on_aryptn(*args)
           (@map[:lbracket] ||= []).pop
           (@map[:aref] ||= []).shift
@@ -451,6 +453,7 @@ module YARD
           AstNode.new(:aryptn, args)
         end
 
+        begin; undef on_fndptn; rescue NameError; end
         def on_fndptn(*args)
           (@map[:lbracket] ||= []).pop
           (@map[:aref] ||= []).shift

data/lib/yard/server/commands/base.rb

@@ -88,7 +88,7 @@ module YARD
         #   of status, headers, and body wrapped in an array.
         def call(request)
           self.request = request
-          self.path ||= File.cleanpath(request.path_info[1..-1])
+          self.path ||= Server.clean_path(request.path_info[1..-1])
           self.headers = {'Content-Type' => 'text/html'}
           self.body = ''
           self.status = 200

data/lib/yard/server/router.rb

@@ -179,7 +179,7 @@ module YARD
       # @param (see #route_docs)
       # @return [Hash] finalized options
       def final_options(library, paths)
-        path = File.cleanpath(paths.join('/')).gsub(%r{^(\.\./)+}, '')
+        path = Server.clean_path(paths.join('/'))
         adapter.options.merge(:library => library, :path => path)
       end
     end

data/lib/yard/server.rb

@@ -1,6 +1,15 @@
 # frozen_string_literal: true
 module YARD
   module Server
+    # Normalizes an HTTP request path into a relative command path.
+    # @api private
+    # @param [String] path the request path to normalize
+    # @return [String] a relative path using forward slashes
+    def self.clean_path(path)
+      path = File.cleanpath(path.tr('\\', '/'))
+      path.sub(/\A[A-Za-z]:(?!:)/, '').sub(%r{\A/+}, '')
+    end
+
     # Registers a static path to be used in static asset lookup.
     # @param [String] path the pathname to register
     # @return [void]

data/lib/yard/tags/types_explainer.rb

@@ -176,17 +176,25 @@ module YARD
 
         # @return [Array(Boolean, Array<Type>)] - finished, types
         def parse(until_tokens: [:parse_end])
+          parse_until(until_tokens).first
+        end
+
+        private
+
+        def parse_until(until_tokens)
           current_parsed_types = []
           type = nil
           name = nil
           finished = false
-          parse_with_handlers do |token_type, token|
+          end_token = nil
+          types = parse_with_handlers do |token_type, token|
             case token_type
             when *until_tokens
               raise SyntaxError, "expecting name, got '#{token}'" if name.nil?
               type = create_type(name) unless type
               current_parsed_types << type
               finished = true
+              end_token = token_type
             when :type_name
               raise SyntaxError, "expecting END, got name '#{token}'" if name
               name = token
@@ -199,7 +207,8 @@ module YARD
             when :fixed_collection_start, :collection_start
               name ||= "Array"
               klass = token_type == :collection_start ? CollectionType : FixedCollectionType
-              type = klass.new(name, parse(until_tokens: [:fixed_collection_end, :collection_end, :parse_end]))
+              nested_types, = parse_until([:fixed_collection_end, :collection_end, :parse_end])
+              type = klass.new(name, nested_types)
             when :hash_collection_start
               name ||= "Hash"
               type = parse_hash_collection(name)
@@ -207,10 +216,9 @@ module YARD
 
             [finished, current_parsed_types]
           end
+          [types, end_token]
         end
 
-        private
-
         # @return [Array<Type>]
         def parse_with_handlers
           loop do
@@ -245,9 +253,10 @@ module YARD
             when :hash_collection_value
               # => - current keys map to the next value(s)
               raise SyntaxError, "no keys before =>" if current_keys.empty?
-              values = parse(until_tokens: [:hash_collection_value_end, :parse_end])
+              values, end_token = parse_until([:hash_collection_value_end, :hash_collection_end, :parse_end])
               key_value_pairs << [current_keys, values]
               current_keys = []
+              finished = end_token != :hash_collection_value_end
             when :hash_collection_end, :parse_end
               # End of hash
               finished = true

data/lib/yard/templates/helpers/markup/rdoc_markup.rb

@@ -11,7 +11,11 @@ module YARD
           require 'rdoc/markup/to_html'
           class RDocMarkup; MARKUP = RDoc::Markup end
           class RDocMarkupToHtml < RDoc::Markup::ToHtml
-            if defined?(RDoc::VERSION) && RDoc::VERSION >= '4.0.0' &&
+            if defined?(RDoc::VERSION) && RDoc::VERSION.to_i >= 8
+              def initialize
+                super(pipe: true)
+              end
+            elsif defined?(RDoc::VERSION) && RDoc::VERSION >= '4.0.0' &&
                defined?(RDoc::Options)
               def initialize
                 options = RDoc::Options.new

data/lib/yard/templates/helpers/method_helper.rb

@@ -66,6 +66,8 @@ module YARD
 
       # @return [String] formats source code of a constant value
       def format_constant(value)
+        return "" unless value
+
         # last can return nil, so default to empty string
         sp = value.split("\n").last || ""
         sp = sp[/^(\s+)/, 1]

data/lib/yard/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module YARD
-  VERSION = '0.9.44'
+  VERSION = '0.9.45'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yard
 version: !ruby/object:Gem::Version
-  version: 0.9.44
+  version: 0.9.45
 platform: ruby
 authors:
 - Loren Segal
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-25 00:00:00.000000000 Z
+date: 2026-07-14 00:00:00.000000000 Z
 dependencies: []
 description: |2
       YARD is a documentation generation tool for the Ruby programming language.
@@ -409,6 +409,7 @@ licenses:
 metadata:
   yard.run: yri
   changelog_uri: https://rubydoc.info/gems/yard/file/CHANGELOG.md
+  source_code_uri: https://github.com/lsegal/yard
 post_install_message:
 rdoc_options: []
 require_paths: