yard-lint 1.5.1 → 1.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88a6ef4d1499a08d7c1776c73605011fd32af9c7afc3f473e4e2c000b2f1d4b6
-  data.tar.gz: a4002c074922df07b82d963f8844745bdd925087b1f6f4b2ba87af10dab1e523
+  metadata.gz: 1c96b4e1a2adb1c849b9716bbf413db8a9515cab506a350219351f56f140e19c
+  data.tar.gz: c5857861bf183876d1030d9b07b7ed295cb08f6951629d651a54a2aec4e4df54
 SHA512:
-  metadata.gz: 4c7cd92f75e9b839a90340241288966f157c50ba2d82bea1a50892f70b6d62493e81d2f60c4a147616adeada79f65e9ed3ad00fddc6353a9229ec705073ae1c2
-  data.tar.gz: ce364d5460ee86d59e058a78e3d7c72f6d76f32b96279436dd71f9f50b0ff4fb7e16e2bc60a06542642a337707df0df6e8d1e798b0c5282d7f350a3f39a38680
+  metadata.gz: 1c3b748cfcc894cd34715e4cda65a62b321fb1d96372a3b49934c2516dc8f74e60ab1cf3e632cca6491da37951a0b0713149f57545aae6d495b6e45530bc169b
+  data.tar.gz: 95132fedf072bb07466bc1d83e8a3b0bcc37df8e5ad85a811e20ddeaf8c30c354af89282de66df03cbcfc2fdae7721637772863828eba3a2b228e95993985faa

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # YARD-Lint Changelog
 
+## 1.5.2 (2026-06-02)
+- **[Fix]** `Tags/InvalidTypes` no longer reports false positives for YARD pseudo-types `undefined`, `unspecified`, and `unknown` (#152)
+  - These lowercase pseudo-types are used in real-world YARD docs (e.g. Solargraph uses `Hash{String => undefined}` extensively) to signal that a type is intentionally unspecified
+  - They are now treated as valid types alongside the existing `nil`, `void`, `self`, `true`, `false` defaults
+- **[Fix]** `Tags/InvalidTypes` no longer reports false positives for string literal hash keys (e.g. `Hash{"to" => String}`) (#152)
+  - String literal keys like `"email"` or `"name"` are valid YARD hash key notation and are now treated as valid alongside the existing symbol literal support (`:key`)
+- **[Fix]** `Tags/InvalidTypes` no longer reports false positives for nested `Hash{K => V}` types (#151, #152)
+  - Complex hash types such as `Hash{String => Hash{Symbol => Array<String>}}` were occasionally flagged as invalid; the `extract_type_names` splitter already handled them correctly after the 1.5.2 sanitizer rewrite, and regression tests now lock that behaviour in
+  - Invalid types genuinely nested inside hash values (e.g. `Hash{String => bad_type}`) are still caught and surfaced correctly
+- **[Enhancement]** `Tags/InvalidTypes` offense messages now name the invalid type(s) and the tag they appear in (#151)
+  - Previously reported a generic `"has at least one tag with an invalid type definition"` message with no further detail
+  - Now reports `"has invalid type(s): @param body: \`bad_type\`; @return: \`wrong_type\`"` — the exact offending type and the tag (including param name for `@param`) where it was found
+- **[Fix]** Do not flag `@param` on `Struct.new` / `Data.define` constants in `Tags/MeaninglessTag` (#152)
+  - Solargraph uses `@param` annotations on these constants to type the synthesised accessors; flagging them was a false positive
+  - `@option` on these constants is still reported as meaningless
+- **[Fix]** Fix `--auto-gen-config` crash (`NoMethodError`) when a YARD warning is emitted without file context (#150)
+  - A `@!macro [new]` body with an invalid tag format (e.g. `@return name [Type]`) that is also referenced inside the defining method's body causes YARD to expand the macro with `object=nil`, emitting `Invalid tag format` without a file path → `offense[:location] = nil` → `make_relative_path(nil)` → crash
+  - `TodoGenerator#make_relative_path` now returns `nil` for `nil` input; `run_linting` uses `filter_map` to skip nil locations when building exclusion lists
+  - `Runner#filter_result_offenses` now always drops nil-location offenses before exclusion-pattern filtering (they would otherwise appear as `:0` in output)
+  - Fix `Warnings/DuplicatedParameterName::Parser`: was inheriting from `OneLineBase` despite YARD emitting the warning across two lines (same format as `UnknownParameterName`), causing `offense[:location]` to always be `nil`; switched to `TwoLineBase` and corrected the location regex to match YARD's backtick-open/single-quote-close path format
+- **[Fix]** Stop false positives for allowed defaults (`self`, `nil`, `true`, `false`, `void`) inside generic types in `Tags/InvalidTypes` validator
+  - Types like `Array<self>`, `Hash{Symbol => nil}`, `Array<true>` were incorrectly flagged as `InvalidTagType` because the sanitize logic concatenated type components (e.g., `Array<self>` became `Arrayself`, which is not in `ALLOWED_DEFAULTS`)
+  - Replaced the `tr`-based sanitizer with a proper type name splitter that checks each component individually
+- **[Fix]** Validate types inside `@overload` blocks across all type validators (`Tags/TypeSyntax`, `Tags/InvalidTypes`, `Tags/CollectionType`, `Tags/NonAsciiType`)
+  - YARD stores `@overload` inner tags on the overload's own docstring, making them invisible to validators that only traverse `object.docstring.tags`
+  - Added `all_typed_tags` helper to `Validators::Base` that collects matching tags from both the docstring and any `@overload` blocks
+- **[Fix]** Add `@raise` and `@yieldparam` to `ValidatedTags` in all type validators
+  - `@raise` tag types (e.g., `@raise [ArgumentError]`) were never validated for type syntax or correctness by any validator
+  - `@yieldparam` was missing from `Tags/InvalidTypes`, `Tags/TypeSyntax`, and `Tags/CollectionType` (only `Tags/NonAsciiType` included it)
+  - Both tags are now validated consistently across `Tags/InvalidTypes`, `Tags/TypeSyntax`, `Tags/CollectionType`, and `Tags/NonAsciiType`
+- **[Fix]** Skip attribute methods in `Tags/ApiTags` validator (#128)
+  - Methods generated by `attr_*`, `@!attribute` directives, `Struct.new`, and `Data.define` are no longer flagged for missing `@api` tags
+  - YARD's `Data.define` and `Struct.new` handlers hard-replace the generated methods' docstrings, stripping any `@api` tag inherited from the enclosing class, and `@!attribute` directives written above a `Data.define` constant attach to the wrong namespace — leaving users with no way to attach per-method `@api` tags to those accessors
+  - Matches the approach taken for `UndocumentedMethodArguments` in #115
+
 ## 1.5.1 (2026-04-09)
 - **[Fix]** Remove `mise.toml` and `proxy_types` from the repository and exclude non-production files (`.ruby-version`, `Rakefile`, `misc/`, `renovate.json`, `package.json`, `package-lock.json`, lock files) from RubyGems releases
 

data/README.md

@@ -197,8 +197,11 @@ Tags/Order:
 Tags/InvalidTypes:
   Enabled: true
   Severity: warning
+  # ExtraTypes: declare non-standard type names that should not be flagged.
+  # Useful for project aliases, LSP extensions (e.g. Solargraph's `generic`),
+  # or any informal type name your team uses in YARD docs.
   ExtraTypes:
-    - CustomType
+    - generic          # Solargraph generic type parameter (lsegal/yard#1683)
     - MyNamespace::CustomType
 
 # Opt-in: Require @return tags on all methods
@@ -222,6 +225,44 @@ Tags/ExampleStyle:
 
 **Learn more:** [Complete Configuration Guide](https://github.com/mensfeld/yard-lint/wiki/Configuration)
 
+## Handling Non-Standard Types
+
+By default `Tags/InvalidTypes` accepts all built-in Ruby classes, constants, and a set of YARD pseudo-types (`nil`, `true`, `false`, `self`, `void`, `undefined`, `unspecified`, `unknown`). If your project uses additional type names that are not real Ruby classes - project-specific aliases, LSP extensions, or informal conventions - you can declare them via `ExtraTypes` so yard-lint does not report them as `InvalidTagType` offenses.
+
+### Project-Specific Type Aliases
+
+```yaml
+Tags/InvalidTypes:
+  ExtraTypes:
+    - Callable        # informal "anything that responds to #call"
+    - Awaitable       # async type alias used across the project
+    - Result          # dry-monad-style Result type used in prose docs
+```
+
+### LSP / Tool-Specific Extensions
+
+[Solargraph](https://solargraph.org) supports a `generic` type-parameter notation (e.g. `Hash{Class<generic<T>> => Set<generic<T>>}`) that is [proposed for adoption](https://github.com/lsegal/yard/issues/1683) but not yet part of the YARD standard. Until it is, add it to `ExtraTypes` to prevent false positives:
+
+```yaml
+Tags/InvalidTypes:
+  ExtraTypes:
+    - generic
+```
+
+### Built-In Pseudo-Types (no configuration needed)
+
+The following lowercase YARD pseudo-types are accepted out of the box and do **not** need to be listed in `ExtraTypes`:
+
+| Type | Meaning |
+|------|---------|
+| `nil` | Explicitly nil |
+| `true` / `false` | Boolean literals |
+| `self` | Returns the receiver |
+| `void` | No meaningful return value |
+| `undefined` | Type is intentionally unspecified (used by Solargraph) |
+| `unspecified` | Alias for undefined |
+| `unknown` | Type is unknown |
+
 ## CI Integration
 
 ### GitHub Actions

data/lib/yard/lint/runner.rb

@@ -108,12 +108,18 @@ module Yard
       end
 
       # Filter result offenses based on per-validator exclusions
-      # Removes offenses where the file path matches exclusion patterns
+      # Also always removes offenses with no file location (e.g. YARD warnings
+      # emitted without file context such as from macro expansion with nil object)
+      # since they carry no actionable information and would display as `:0`.
       # @param validator_name [String] full validator name
       # @param result [Results::Base] result object with offenses
       # @return [Results::Base, nil] result with filtered offenses, or nil if no offenses remain
       def filter_result_offenses(validator_name, result)
         validator_excludes = config.validator_all_excludes(validator_name)
+
+        # Drop offenses with no file location regardless of exclusion config
+        result.offenses = result.offenses.reject { |o| (o[:location] || o[:file]).nil? }
+        return nil if result.offenses.empty?
         return result if validator_excludes.empty?
 
         working_dir = Dir.pwd

data/lib/yard/lint/todo_generator.rb

@@ -95,8 +95,8 @@ module Yard
           validator_result = result_builder.build(validator_name, raw_results)
           next unless validator_result && validator_result.offenses.any?
 
-          # Extract file paths from offenses
-          file_paths = validator_result.offenses.map do |offense|
+          # Extract file paths from offenses, skipping those without a location
+          file_paths = validator_result.offenses.filter_map do |offense|
             make_relative_path(offense[:location])
           end.uniq.sort
 
@@ -128,9 +128,11 @@ module Yard
       end
 
       # Convert absolute path to relative path from current directory
-      # @param path [String] absolute or relative file path
-      # @return [String] relative path from current directory
+      # @param path [String, nil] absolute or relative file path
+      # @return [String, nil] relative path from current directory, or nil if path is nil
       def make_relative_path(path)
+        return path if path.nil?
+
         pwd = Dir.pwd
         path.start_with?(pwd) ? path.sub("#{pwd}/", '') : path
       end

data/lib/yard/lint/validators/base.rb

@@ -78,6 +78,25 @@ module Yard
 
         private
 
+        # Collect tags matching the given tag names from a docstring, including
+        # tags nested inside @overload blocks. YARD stores @overload inner tags
+        # on the overload's own docstring, so they are invisible to
+        # `docstring.tags` — this helper traverses them.
+        # @param docstring [YARD::Docstring] the docstring to search
+        # @param tag_names [Array<String>] tag names to collect (e.g., %w[param return])
+        # @return [Array<YARD::Tags::Tag>] matching tags from the docstring and any overloads
+        def all_typed_tags(docstring, tag_names)
+          tags = docstring.tags.select { |tag| tag_names.include?(tag.tag_name) }
+
+          docstring.tags(:overload).each do |overload|
+            overload.docstring.tags.each do |tag|
+              tags << tag if tag_names.include?(tag.tag_name)
+            end
+          end
+
+          tags
+        end
+
         # Retrieves configuration value with fallback to default
         # Automatically determines the validator name from the class namespace
         #

data/lib/yard/lint/validators/tags/api_tags/validator.rb

@@ -25,6 +25,18 @@ module Yard
                   collector.puts "invalid:#{api_value}"
                 end
               elsif require_api_tags?
+                # Skip missing-tag reports for attribute methods (attr_reader/writer/accessor,
+                # @!attribute directives, Struct.new and Data.define generated readers/writers).
+                # These are auto-generated accessors where per-method @api tags either flow
+                # through the declaration's docstring automatically or cannot be attached at
+                # all — for example, YARD's Data.define handler creates getters with only a
+                # @return tag (hard-replacing their docstring and stripping any inherited @api
+                # from the enclosing class), and @!attribute directives written above a
+                # Data.define constant attach to the enclosing namespace, not the Data class
+                # itself. Note: attribute methods that *do* carry an explicit @api tag still
+                # hit the branch above and get their value validated. See issue #128.
+                return if object.type == :method && object.is_attribute?
+
                 # Only check public methods/classes if require_api_tags is enabled
                 visibility = object.visibility.to_s
                 if visibility == 'public' && !object.root?

data/lib/yard/lint/validators/tags/collection_type/config.rb

@@ -11,7 +11,7 @@ module Yard
             self.defaults = {
               'Enabled' => true,
               'Severity' => 'convention',
-              'ValidatedTags' => %w[param option return yieldreturn],
+              'ValidatedTags' => %w[param option return yieldreturn yieldparam raise],
               'EnforcedStyle' => 'long' # 'long' (Hash{K => V}) or 'short' ({K => V})
             }.freeze
           end

data/lib/yard/lint/validators/tags/collection_type/validator.rb

@@ -19,9 +19,7 @@ module Yard
               validated_tags = config_or_default('ValidatedTags')
               style = enforced_style
 
-              object.docstring.tags
-                    .select { |tag| validated_tags.include?(tag.tag_name) }
-                    .each do |tag|
+              all_typed_tags(object.docstring, validated_tags).each do |tag|
                 next unless tag.types
 
                 tag.types.each do |type_str|

data/lib/yard/lint/validators/tags/invalid_types/config.rb

@@ -11,7 +11,7 @@ module Yard
             self.defaults = {
               'Enabled' => true,
               'Severity' => 'warning',
-              'ValidatedTags' => %w[param option return yieldreturn],
+              'ValidatedTags' => %w[param option return yieldreturn yieldparam raise],
               'ExtraTypes' => []
             }.freeze
           end

data/lib/yard/lint/validators/tags/invalid_types/messages_builder.rb

@@ -9,11 +9,22 @@ module Yard
           class MessagesBuilder
             class << self
               # Build message for invalid tag types
-              # @param offense [Hash] offense data with :method_name key
+              # @param offense [Hash] offense data with :method_name and :tag_violations keys
               # @return [String] formatted message
               def call(offense)
-                "The `#{offense[:method_name]}` has at least one tag " \
-                  'with an invalid type definition.'
+                violations = offense[:tag_violations]
+
+                if violations&.any?
+                  details = violations.map do |v|
+                    label = v[:param] ? "#{v[:tag]} #{v[:param]}" : v[:tag]
+                    types = v[:types].map { |t| "`#{t}`" }.join(', ')
+                    "#{label}: #{types}"
+                  end.join('; ')
+
+                  "The `#{offense[:method_name]}` has invalid type(s): #{details}"
+                else
+                  "The `#{offense[:method_name]}` has at least one tag with an invalid type definition."
+                end
               end
             end
           end

data/lib/yard/lint/validators/tags/invalid_types/parser.rb

@@ -5,9 +5,69 @@ module Yard
     module Validators
       module Tags
         module InvalidTypes
-          # Parser for invalid tags types output
-          # Reuses location parsing logic from undocumented method arguments
-          class Parser < Validators::Documentation::UndocumentedMethodArguments::Parser
+          # Parser for invalid tag types output.
+          # The validator emits two lines per offense:
+          #   /path/to/file.rb:10: ClassName#method_name
+          #   @tagname param_name:BadType1,BadType2|@tagname2:BadType3
+          class Parser < Parsers::Base
+            # @return [Regexp] matches "file:line: ClassName#method"
+            LOCATION_REGEX = /^(.+):(\d+):\s+(.+)[#.](.+)$/
+            # @return [Regexp] matches the tag violations line (starts with @)
+            TAG_VIOLATIONS_REGEX = /^@/
+
+            # @param yard_output [String] raw validator output
+            # @return [Array<Hash>] parsed offenses
+            def call(yard_output)
+              lines = yard_output.split("\n").reject(&:empty?)
+              results = []
+              i = 0
+
+              while i < lines.size
+                match = lines[i].match(LOCATION_REGEX)
+
+                unless match
+                  i += 1
+                  next
+                end
+
+                offense = {
+                  location: match[1],
+                  line: match[2].to_i,
+                  class_name: match[3],
+                  method_name: match[4],
+                  tag_violations: []
+                }
+
+                next_line = lines[i + 1]
+                if next_line&.match?(TAG_VIOLATIONS_REGEX)
+                  offense[:tag_violations] = parse_tag_violations(next_line)
+                  i += 2
+                else
+                  i += 1
+                end
+
+                results << offense
+              end
+
+              results
+            end
+
+            private
+
+            # Parse "tagname param:Type1,Type2|tagname2:Type3" into structured data
+            # @param line [String] the violations line
+            # @return [Array<Hash>] each entry has :tag, :param (may be nil), :types
+            def parse_tag_violations(line)
+              line.split('|').map do |entry|
+                label, types_str = entry.split(':', 2)
+                parts = label.split(' ', 2)
+                {
+                  tag: parts[0],
+                  param: parts[1],
+                  types: (types_str || '').split(',').reject(&:empty?)
+                }
+              end
+            end
           end
         end
       end

data/lib/yard/lint/validators/tags/invalid_types/validator.rb

@@ -19,6 +19,9 @@ module Yard
               nil
               self
               void
+              undefined
+              unspecified
+              unknown
             ].freeze
 
             private_constant :ALLOWED_DEFAULTS
@@ -33,35 +36,47 @@ module Yard
               extra_types = config_or_default('ExtraTypes')
               allowed_types = ALLOWED_DEFAULTS + extra_types
 
-              # Sanitize type string (remove type syntax characters)
-              sanitize = ->(type) { type.tr('=><>,{} ()', '') }
+              # Collect per-tag violations to surface in the offense message.
+              # Each entry is "tagname param_name:Type1,Type2" (param_name omitted when nil).
+              tag_violations = all_typed_tags(object.docstring, checked_tags).filter_map do |tag|
+                bad = (tag.types || [])
+                        .compact
+                        .flat_map { |type| extract_type_names(type) }
+                        .uniq
+                        .reject { |type| allowed_types.include?(type) }
+                        .reject { |type| type_defined?(type) }
+                        .reject { |type| type.include?('#') }
+                next if bad.empty?
 
-              # Check for invalid types
-              invalid_types = object.docstring.tags
-                                    .select { |tag| checked_tags.include?(tag.tag_name) }
-                                    .flat_map(&:types)
-                                    .compact
-                                    .uniq
-                                    .map(&sanitize)
-                                    .reject { |type| allowed_types.include?(type) }
-                                    .reject { |type| type_defined?(type) }
-                                    .reject { |type| type.include?('#') }
+                label = tag.name ? "@#{tag.tag_name} #{tag.name}" : "@#{tag.tag_name}"
+                "#{label}:#{bad.join(',')}"
+              end
 
-              return if invalid_types.empty?
+              return if tag_violations.empty?
 
               collector.puts "#{object.file}:#{object.line}: #{object.title}"
+              collector.puts tag_violations.join('|')
             end
 
             private
 
+            # Extract individual type names from a compound type string.
+            # Instead of stripping all syntax characters and concatenating (which
+            # turns "Array<self>" into "Arrayself"), this splits on syntax boundaries
+            # and returns each type name individually.
+            # @param type_str [String] the raw type string (e.g., "Array<self>", "Hash{Symbol => String}")
+            # @return [Array<String>] individual type names (e.g., ["Array", "self"], ["Hash", "Symbol", "String"])
+            def extract_type_names(type_str)
+              type_str.split(/[=><,{}\s()]+/).reject(&:empty?)
+            end
+
             # Check if a type is defined in Ruby runtime or YARD registry
             # In in-process mode, parsed classes are in YARD registry but not loaded into Ruby
             # @param type [String] type name to check
             # @return [Boolean] true if type is defined (or at least recognized as a valid type)
             def type_defined?(type)
-              # Symbol types like :foo are valid YARD documentation notations
-              # They document that a method accepts specific symbol values
-              return true if type.start_with?(':')
+              # Symbol and string literal types (:foo, "bar") are valid hash key notations
+              return true if type.start_with?(':', '"', "'")
 
               # Check Ruby runtime first
               # The shell query uses: !(Kernel.const_defined?(type) rescue nil).nil?

data/lib/yard/lint/validators/tags/meaningless_tag/validator.rb

@@ -22,8 +22,13 @@ module Yard
 
               return unless invalid_types.include?(object_type)
 
+              # @param is meaningful on Struct.new / Data.define constants because
+              # Solargraph uses those annotations to type the synthesized accessors.
+              effective_tags = struct_or_data_class?(object) ? tags_to_check - ['param'] : tags_to_check
+              return if effective_tags.empty?
+
               object.docstring.tags.each do |tag|
-                next unless tags_to_check.include?(tag.tag_name)
+                next unless effective_tags.include?(tag.tag_name)
 
                 collector.puts "#{object.file}:#{object.line}: #{object.title}"
                 collector.puts "#{object_type}|#{tag.tag_name}"
@@ -42,6 +47,16 @@ module Yard
             def invalid_object_types
               config_or_default('InvalidObjectTypes')
             end
+
+            # @param object [YARD::CodeObjects::Base] the code object to inspect
+            # @return [Boolean] true when the object is a class synthesised by Struct.new
+            #   or Data.define, where @param documents the generated accessors
+            def struct_or_data_class?(object)
+              return false unless object.type == :class
+
+              sc_path = object.superclass&.path
+              sc_path == 'Struct' || sc_path == 'Data'
+            end
           end
         end
       end

data/lib/yard/lint/validators/tags/non_ascii_type/config.rb

@@ -11,7 +11,7 @@ module Yard
             self.defaults = {
               'Enabled' => true,
               'Severity' => 'warning',
-              'ValidatedTags' => %w[param option return yieldreturn yieldparam]
+              'ValidatedTags' => %w[param option return yieldreturn yieldparam raise]
             }.freeze
           end
         end

data/lib/yard/lint/validators/tags/non_ascii_type/validator.rb

@@ -23,9 +23,7 @@ module Yard
               validated_tags = config.validator_config('Tags/NonAsciiType', 'ValidatedTags') ||
                                %w[param option return yieldreturn yieldparam]
 
-              object.docstring.tags
-                    .select { |tag| validated_tags.include?(tag.tag_name) }
-                    .each do |tag|
+              all_typed_tags(object.docstring, validated_tags).each do |tag|
                 next unless tag.types
 
                 tag.types.each do |type_str|

data/lib/yard/lint/validators/tags/type_syntax/config.rb

@@ -11,7 +11,7 @@ module Yard
             self.defaults = {
               'Enabled' => true,
               'Severity' => 'warning',
-              'ValidatedTags' => %w[param option return yieldreturn]
+              'ValidatedTags' => %w[param option return yieldreturn yieldparam raise]
             }.freeze
           end
         end

data/lib/yard/lint/validators/tags/type_syntax/validator.rb

@@ -31,9 +31,7 @@ module Yard
               validated_tags = config.validator_config('Tags/TypeSyntax', 'ValidatedTags') ||
                                %w[param option return yieldreturn]
 
-              object.docstring.tags
-                    .select { |tag| validated_tags.include?(tag.tag_name) }
-                    .each do |tag|
+              all_typed_tags(object.docstring, validated_tags).each do |tag|
                 next unless tag.types
 
                 tag.types.each do |type_str|

data/lib/yard/lint/validators/warnings/duplicated_parameter_name/parser.rb

@@ -6,13 +6,13 @@ module Yard
       module Warnings
         module DuplicatedParameterName
           # Parser for DuplicatedParameterName warnings
-          class Parser < ::Yard::Lint::Parsers::OneLineBase
+          class Parser < ::Yard::Lint::Parsers::TwoLineBase
             # Set of regexps for detecting warnings reported by YARD stats
             self.regexps = {
               general: /^\[warn\]: @param tag has duplicate parameter name/,
-              message: /\[warn\]: (.*) in file/,
-              location: /in file `(.*)`/,
-              line: /line (\d*)/
+              message: /\[warn\]: (.*)$/,
+              location: /in file `(.*?)'\s*near/,
+              line: /near line (\d+)/
             }.freeze
           end
         end

data/lib/yard/lint/version.rb

@@ -3,6 +3,6 @@
 module Yard
   module Lint
     # @return [String] version of the YARD Lint gem
-    VERSION = '1.5.1'
+    VERSION = '1.5.2'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yard-lint
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.5.2
 platform: ruby
 authors:
 - Maciej Mensfeld
@@ -278,7 +278,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.10
 specification_version: 4
 summary: YARD documentation linter and validator
 test_files: []