yard-lint 1.2.2 → 1.3.0.rc1

data/lib/yard/lint/validators/documentation/undocumented_method_arguments.rb

@@ -29,7 +29,6 @@ module Yard
         #
         #     Documentation/UndocumentedMethodArguments:
         #       Enabled: false
-        #
         module UndocumentedMethodArguments
         end
       end

data/lib/yard/lint/validators/documentation/undocumented_objects/parser.rb

@@ -16,7 +16,7 @@ module Yard
 
             # @param yard_list_output [String] raw yard list results string
             # @param config [Yard::Lint::Config, nil] configuration object (optional)
-            # @param _kwargs [Hash] unused keyword arguments (for compatibility)
+            # @option _kwargs [Object] :unused this parameter accepts no options (reserved for future use)
             # @return [Array<Hash>] Array with undocumented objects details
             def call(yard_list_output, config: nil, **_kwargs)
               excluded_methods = config&.validator_config(
@@ -108,7 +108,7 @@ module Yard
 
             # Match an arity pattern like "initialize/0"
             # @param method_name [String] the method name
-            # @param arity [Integer, nil] the method's arity
+            # @param arity [Integer, nil] number of parameters the method accepts (nil if unknown)
             # @param pattern [String] the full pattern like "initialize/0"
             # @return [Boolean] true if matches
             def match_arity_pattern(method_name, arity, pattern)

data/lib/yard/lint/validators/documentation/undocumented_objects/validator.rb

@@ -7,33 +7,25 @@ module Yard
         module UndocumentedObjects
           # Runs yard list to check for undocumented objects
           class Validator < Base
-            private
+            # Enable in-process execution for this validator
+            in_process visibility: :public
 
-            # Runs yard list query with proper settings on a given dir and files
-            # @param dir [String] dir where we should generate the temp docs
-            # @param file_list_path [String] path to temp file containing file paths (one per line)
-            # @return [Hash] shell command execution hash results
-            def yard_cmd(dir, file_list_path)
-              cmd = <<~CMD
-                cat #{Shellwords.escape(file_list_path)} | xargs yard list \
-                  #{shell_arguments} \
-                  --query #{query} \
-                  -q \
-                  -b #{Shellwords.escape(dir)}
-              CMD
-              cmd = cmd.tr("\n", ' ')
+            # Execute query for a single object during in-process execution.
+            # Checks for empty docstrings and outputs location with arity for methods.
+            # @param object [YARD::CodeObjects::Base] the code object to query
+            # @param collector [Executor::ResultCollector] collector for output
+            # @return [void]
+            def in_process_query(object, collector)
+              # Check if docstring is empty
+              return unless object.docstring.all.empty?
 
-              shell(cmd)
-            end
-
-            # Custom query that outputs parameter count for methods
-            # Format: file.rb:LINE: ElementName|ARITY
-            # Arity counts all parameters (required + optional) excluding splat and block
-            # @return [String] YARD query string
-            def query
-              <<~QUERY.chomp
-                "if docstring.all.empty? then if object.is_a?(YARD::CodeObjects::MethodObject) then arity = object.parameters.reject { |p| p[0].start_with?('*', '&') }.size; puts object.file + ':' + object.line.to_s + ': ' + object.title + '|' + arity.to_s; else puts object.file + ':' + object.line.to_s + ': ' + object.title; end; false; end"
-              QUERY
+              if object.is_a?(YARD::CodeObjects::MethodObject)
+                # For methods, include arity (excluding splat and block params)
+                arity = object.parameters.reject { |p| p[0].to_s.start_with?('*', '&') }.size
+                collector.puts "#{object.file}:#{object.line}: #{object.title}|#{arity}"
+              else
+                collector.puts "#{object.file}:#{object.line}: #{object.title}"
+              end
             end
           end
         end

data/lib/yard/lint/validators/documentation/undocumented_objects.rb

@@ -22,8 +22,8 @@ module Yard
         #       - 'to_s'           # Excludes ALL to_s methods regardless of parameters
         #       - 'inspect'        # Excludes ALL inspect methods
         #
-        # Note: Exact name matching excludes the method with **any arity**. If you need
-        # arity-specific exclusions, use arity notation instead.
+        # @note Exact name matching excludes the method with **any arity**. If you need
+        #   arity-specific exclusions, use arity notation instead.
         #
         # ### 2. Arity Notation (method_name/N)
         #
@@ -34,8 +34,8 @@ module Yard
         #       - 'call/1'         # Only excludes call methods with exactly 1 parameter
         #       - 'initialize/2'   # Only excludes initialize with exactly 2 parameters
         #
-        # Note: Arity counts total parameters (required + optional) excluding splat (*)
-        # and block (&) parameters.
+        # @note Arity counts total parameters (required + optional) excluding splat (*)
+        #   and block (&) parameters.
         #
         # ### 3. Regex Patterns
         #
@@ -134,7 +134,6 @@ module Yard
         # 2. Splat parameters don't count: `def method(a, *rest)` has arity 1
         # 3. Block parameters don't count: `def method(a, &block)` has arity 1
         # 4. Keyword arguments count as individual parameters: `def method(a:, b:)` has arity 2
-        #
         module UndocumentedObjects
         end
       end

data/lib/yard/lint/validators/documentation/undocumented_options/validator.rb

@@ -7,28 +7,37 @@ module Yard
         module UndocumentedOptions
           # Validates that methods with options hash parameters have @option tags
           class Validator < Validators::Base
-            # YARD query to detect methods with options parameters but no @option tags
-            # @return [String] YARD Ruby query code
-            def query
-              <<~QUERY.strip
-                'if object.is_a?(YARD::CodeObjects::MethodObject); params = object.parameters || []; has_options_param = params.any? { |p| p[0] =~ /^(options?|opts?|kwargs)$/ || p[0] =~ /^\\*\\*/ || (p[0] =~ /^(options?|opts?|kwargs)$/ && p[1] =~ /^\\{\\}/) }; if has_options_param; option_tags = object.tags(:option); if option_tags.empty?; puts object.file + ":" + object.line.to_s + ": " + object.title; puts params.map { |p| p.join(" ") }.join(", "); end; end; end; false'
-              QUERY
-            end
+            # Enable in-process execution for this validator
+            in_process visibility: :public
+
+            # Execute query for a single object during in-process execution.
+            # Finds methods with options parameters but no @option tags.
+            # @param object [YARD::CodeObjects::Base] the code object to query
+            # @param collector [Executor::ResultCollector] collector for output
+            # @return [void]
+            def in_process_query(object, collector)
+              # Only check method objects
+              return unless object.is_a?(YARD::CodeObjects::MethodObject)
+
+              params = object.parameters || []
+
+              # Check for options-style parameters
+              has_options_param = params.any? do |p|
+                param_name = p[0].to_s
+                # Match options, option, opts, opt, kwargs or double-splat (**)
+                param_name.match?(/^(options?|opts?|kwargs)$/) ||
+                  param_name.start_with?('**')
+              end
+
+              return unless has_options_param
+
+              # Check if @option tags are missing
+              option_tags = object.tags(:option)
+              return unless option_tags.empty?
 
-            # Builds and executes the YARD command to detect undocumented options
-            # @param dir [String] the directory containing the .yardoc database
-            # @param file_list_path [String] path to file containing list of files to analyze
-            # @return [String] command output
-            def yard_cmd(dir, file_list_path)
-              cmd = <<~CMD
-                cat #{Shellwords.escape(file_list_path)} | xargs yard list \
-                  #{shell_arguments} \
-                --query #{query} \
-                -q \
-                -b #{Shellwords.escape(dir)}
-              CMD
-              cmd = cmd.tr("\n", ' ')
-              shell(cmd)
+              # Output method location and parameter info
+              collector.puts "#{object.file}:#{object.line}: #{object.title}"
+              collector.puts params.map { |p| p.join(' ') }.join(', ')
             end
           end
         end

data/lib/yard/lint/validators/documentation/undocumented_options.rb

@@ -31,7 +31,6 @@ module Yard
         #
         #     Documentation/UndocumentedOptions:
         #       Enabled: false
-        #
         module UndocumentedOptions
         end
       end

data/lib/yard/lint/validators/semantic/abstract_methods/result.rb

@@ -24,14 +24,14 @@ module Yard
             # @return [Array<Hash>] array of offense hashes
             def build_offenses
               @parsed_data.map do |offense_data|
-                {
+                offense_data.merge(
                   severity: configured_severity,
                   type: self.class.offense_type,
                   name: offense_data[:name] || self.class.offense_name,
                   message: build_message(offense_data),
                   location: offense_data[:location] || offense_data[:file],
                   location_line: offense_data[:line] || offense_data[:location_line] || 0
-                }
+                )
               end
             end
           end

data/lib/yard/lint/validators/semantic/abstract_methods/validator.rb

@@ -7,54 +7,42 @@ module Yard
         module AbstractMethods
           # Validator to check @abstract methods have proper implementation
           class Validator < Base
-            private
+            # Enable in-process execution with all visibility
+            in_process visibility: :all
 
-            # Runs YARD list query to find abstract methods with implementation
-            # @param dir [String] dir where the YARD db is (or where it should be generated)
-            # @param file_list_path [String] path to temp file containing file paths (one per line)
-            # @return [Hash] shell command execution hash results
-            def yard_cmd(dir, file_list_path)
-              cmd = <<~CMD
-                cat #{Shellwords.escape(file_list_path)} | xargs yard list \
-                --private \
-                --protected \
-                -b #{Shellwords.escape(dir)}
-              CMD
-              cmd = cmd.tr("\n", ' ')
-              cmd = cmd.gsub('yard list', "yard list --query #{query}")
+            # Execute query for a single object during in-process execution.
+            # Checks if @abstract methods have implementation.
+            # @param object [YARD::CodeObjects::Base] the code object to query
+            # @param collector [Executor::ResultCollector] collector for output
+            # @return [void]
+            def in_process_query(object, collector)
+              return unless object.has_tag?(:abstract)
+              return unless object.is_a?(YARD::CodeObjects::MethodObject)
 
-              shell(cmd)
-            end
+              # Check if method has actual implementation (not just NotImplementedError)
+              source = begin
+                object.source
+              rescue StandardError
+                nil
+              end
+              return unless source && !source.empty?
+
+              # Simple heuristic: abstract methods should be empty or raise NotImplementedError
+              lines = source.split("\n").map(&:strip).reject(&:empty?)
+              # Skip def line and end
+              body_lines = lines[1...-1] || []
 
-            # @return [String] yard query to find abstract methods with implementation
-            def query
-              <<~QUERY
-                '
-                  if object.has_tag?(:abstract) && object.is_a?(YARD::CodeObjects::MethodObject)
-                      # Check if method has actual implementation (not just NotImplementedError)
-                    source = object.source rescue nil
-                    if source && !source.empty?
-                        # Simple heuristic: abstract methods should be empty or raise NotImplementedError
-                      lines = source.split("\\n").map(&:strip).reject(&:empty?)
-                        # Skip def line and end
-                      body_lines = lines[1...-1] || []
+              has_real_implementation = body_lines.any? do |line|
+                !line.start_with?('#') &&
+                  !line.include?('NotImplementedError') &&
+                  !line.include?('raise') &&
+                  line != 'end'
+              end
 
-                      has_real_implementation = body_lines.any? do |line|
-                        !line.start_with?('#') &&
-                        !line.include?('NotImplementedError') &&
-                        !line.include?('raise') &&
-                        line != 'end'
-                        end
+              return unless has_real_implementation
 
-                      if has_real_implementation
-                        puts object.file + ':' + object.line.to_s + ': ' + object.title
-                        puts 'has_implementation'
-                        end
-                      end
-                    end
-                  false
-                '
-              QUERY
+              collector.puts "#{object.file}:#{object.line}: #{object.title}"
+              collector.puts 'has_implementation'
             end
           end
         end

data/lib/yard/lint/validators/semantic/abstract_methods.rb

@@ -34,7 +34,6 @@ module Yard
         #
         #     Semantic/AbstractMethods:
         #       Enabled: false
-        #
         module AbstractMethods
         end
       end

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

@@ -7,49 +7,34 @@ module Yard
         module ApiTags
           # Validator to check for @api tag presence and validity
           class Validator < Base
-            private
+            # Enable in-process execution with all visibility
+            in_process visibility: :all
 
-            # Runs yard list query to find objects missing or with invalid @api tags
-            # @param dir [String] dir where the yard db is (or where it should be generated)
-            # @param file_list_path [String] path to temp file containing file paths (one per line)
-            # @return [Hash] shell command execution hash results
-            def yard_cmd(dir, file_list_path)
-              cmd = <<~CMD
-                cat #{Shellwords.escape(file_list_path)} | xargs yard list \
-                --private \
-                --protected \
-                -b #{Shellwords.escape(dir)}
-              CMD
-              cmd = cmd.tr("\n", ' ')
-              cmd = cmd.gsub('yard list', "yard list --query #{query}")
+            # Execute query for a single object during in-process execution.
+            # Checks for @api tag presence and validity.
+            # @param object [YARD::CodeObjects::Base] the code object to query
+            # @param collector [Executor::ResultCollector] collector for output
+            # @return [void]
+            def in_process_query(object, collector)
+              allowed_list = allowed_apis
 
-              shell(cmd)
+              if object.has_tag?(:api)
+                api_value = object.tag(:api).text
+                unless allowed_list.include?(api_value)
+                  collector.puts "#{object.file}:#{object.line}: #{object.title}"
+                  collector.puts "invalid:#{api_value}"
+                end
+              elsif require_api_tags?
+                # Only check public methods/classes if require_api_tags is enabled
+                visibility = object.visibility.to_s
+                if visibility == 'public' && !object.root?
+                  collector.puts "#{object.file}:#{object.line}: #{object.title}"
+                  collector.puts 'missing'
+                end
+              end
             end
 
-            # @return [String] yard query to find objects with missing or invalid @api tags
-            def query
-              allowed_list = allowed_apis.map { |api| "'#{api}'" }.join(', ')
-
-              <<~QUERY
-                '
-                  if object.has_tag?(:api)
-                    api_value = object.tag(:api).text
-                    unless [#{allowed_list}].include?(api_value)
-                      puts object.file + ':' + object.line.to_s + ': ' + object.title
-                      puts 'invalid:' + api_value
-                      end
-                  elsif #{require_api_tags?}
-                      # Only check public methods/classes if require_api_tags is enabled
-                    visibility = object.visibility.to_s
-                    if visibility == 'public' && !object.root?
-                      puts object.file + ':' + object.line.to_s + ': ' + object.title
-                      puts 'missing'
-                      end
-                    end
-                  false
-                '
-              QUERY
-            end
+            private
 
             # @return [Array<String>] list of allowed API values
             def allowed_apis

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

@@ -37,7 +37,6 @@ module Yard
         #     def some_method
         #     end
         #   end
-        #
         module ApiTags
         end
       end

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

@@ -9,7 +9,7 @@ module Yard
           class Parser < ::Yard::Lint::Parsers::Base
             # Parses YARD query output into structured violation data
             # @param yard_output [String] raw output from YARD query
-            # @param _kwargs [Hash] additional keyword arguments (unused)
+            # @option _kwargs [Object] :unused this parameter accepts no options (reserved for future use)
             # @return [Array<Hash>] array of violation hashes
             def call(yard_output, **_kwargs)
               return [] if yard_output.nil? || yard_output.strip.empty?

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

@@ -7,83 +7,54 @@ module Yard
         module CollectionType
           # Validates Hash collection type syntax in YARD tags
           class Validator < Base
-            private
-
-            # Runs YARD query to find incorrect Hash<K, V> syntax
-            # @param dir [String] directory where YARD database is stored
-            # @param file_list_path [String] path to temp file containing file paths (one per line)
-            # @return [Hash] shell command execution results
-            def yard_cmd(dir, file_list_path)
-              # Write query to a temporary file to avoid shell escaping issues
-              cmd = "cat #{Shellwords.escape(file_list_path)} | xargs yard list --query #{query} "
-
-              Tempfile.create(['yard_query', '.sh']) do |f|
-                f.write("#!/bin/bash\n")
-                f.write(cmd)
-                f.write("#{shell_arguments} -b #{Shellwords.escape(dir)}\n")
-                f.flush
-                f.chmod(0o755)
-
-                shell("bash #{Shellwords.escape(f.path)}")
-              end
-            end
-
-            # YARD query that finds incorrect collection syntax based on EnforcedStyle
-            # Format output as two lines per violation:
-            #   Line 1: file.rb:LINE: ClassName#method_name
-            #   Line 2: tag_name|type_string|detected_style
-            # @return [String] YARD query string
-            def query
+            # Enable in-process execution
+            in_process visibility: :public
+
+            # Execute query for a single object during in-process execution.
+            # Validates Hash collection type syntax based on EnforcedStyle.
+            # @param object [YARD::CodeObjects::Base] the code object to query
+            # @param collector [Executor::ResultCollector] collector for output
+            # @return [void]
+            def in_process_query(object, collector)
+              validated_tags = config_or_default('ValidatedTags')
               style = enforced_style
 
-              <<~QUERY.strip
-                '
-                docstring
-                  .tags
-                  .select { |tag| #{validated_tags_array}.include?(tag.tag_name) }
-                  .each do |tag|
-                    next unless tag.types
-
-                    tag.types.each do |type_str|
-                      detected_style = nil
-
-                      # Check for Hash<...> syntax (angle brackets)
-                      if type_str =~ /Hash<.*>/
-                        detected_style = "short"
-                      # Check for Hash{...} syntax (curly braces)
-                      elsif type_str =~ /Hash\\{.*\\}/
-                        detected_style = "long"
-                      # Check for {...} syntax without Hash prefix
-                      elsif type_str =~ /^\\{.*\\}$/
-                        detected_style = "short"
-                      end
-
-                      # Report violations based on enforced style
-                      if detected_style && detected_style != "#{style}"
-                        puts object.file + ":" + object.line.to_s + ": " + object.title
-                        puts tag.tag_name + "|" + type_str + "|" + detected_style
-                        break
-                      end
-                    end
+              object.docstring.tags
+                    .select { |tag| validated_tags.include?(tag.tag_name) }
+                    .each do |tag|
+                next unless tag.types
+
+                tag.types.each do |type_str|
+                  detected_style = nil
+
+                  # Check for Hash<...> syntax (angle brackets)
+                  if type_str =~ /Hash<.*>/
+                    detected_style = 'short'
+                  # Check for Hash{...} syntax (curly braces)
+                  elsif type_str =~ /Hash\{.*\}/
+                    detected_style = 'long'
+                  # Check for {...} syntax without Hash prefix
+                  elsif type_str =~ /^\{.*\}$/
+                    detected_style = 'short'
                   end
 
-                false
-                '
-              QUERY
+                  # Report violations based on enforced style
+                  if detected_style && detected_style != style
+                    collector.puts "#{object.file}:#{object.line}: #{object.title}"
+                    collector.puts "#{tag.tag_name}|#{type_str}|#{detected_style}"
+                    break
+                  end
+                end
+              end
             end
 
+            private
+
             # Gets the enforced collection style from configuration
             # @return [String] 'long' or 'short'
             def enforced_style
               config_or_default('EnforcedStyle')
             end
-
-            # Array of tag names to validate, formatted for YARD query
-            # @return [String] Ruby array literal string
-            def validated_tags_array
-              tags = config_or_default('ValidatedTags')
-              "[#{tags.map { |t| "\"#{t}\"" }.join(',')}]"
-            end
           end
         end
       end

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

@@ -41,7 +41,6 @@ module Yard
         #
         #     Tags/CollectionType:
         #       Enabled: false
-        #
         module CollectionType
         end
       end