yard-lint 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 312a8649c021c9df03d03240a80da73a5985b692f784bbe1143cf6f7138dbb78
-  data.tar.gz: ba230c3af103171163396ccc31ac2b4b8fb400b98faba25705072558ee9b71bb
+  metadata.gz: 95017b70fd77952580b3bf10466c79efff2fb1bbd353d1ba49ce84eab7feb5e9
+  data.tar.gz: 0e5015d8cd2b15b38ccc98d149b3b923997c3952ccc8d799050e51e226d8f14b
 SHA512:
-  metadata.gz: d14c94827a3b20f08c283aff9e60f82473dd91522e35f434012cf7b90bd23f7aeaaa3e4f95788d3e7fd32870ac96ee75c953b2bf176c4f38cc44ef9d0cb2e874
-  data.tar.gz: b8d9bdf4583ea0553b8badd02266d03b402a50926f26492ba1d5c956ee275d2e9fab97bcc773e9d7d160acae76e10746a8103937fa5ea01aeb46e0480fd0a0e2
+  metadata.gz: d4825147326c85f9af2faaa95200f797321e06d12bbfe4063ea5b0acd851496bc541546d0885ccdd3d674242670a573be396bc4ae454361a266cadc240c813e8
+  data.tar.gz: cb1fa4762efdbecfc0265791a93ffb3ef4a9668e9a6905da29acb966f3bbd650ebd7b21ccb826a5dab2dd972762d4f642e17ecccd986d22354af4837633991cd

data/CHANGELOG.md

@@ -1,5 +1,45 @@
 # YARD-Lint Changelog
 
+## 1.1.0 (2025-11-11)
+- **[Feature]** Add `Tags/ExampleSyntax` validator to validate Ruby syntax in `@example` tags
+  - Uses Ruby 3.2's `RubyVM::InstructionSequence.compile()` to parse example code
+  - Automatically strips output indicators (`#=>`) before validation
+  - Intelligently skips incomplete single-line snippets (e.g., `multiply(3, 4)`)
+  - Reports multi-line syntax errors with full context from Ruby's parser
+  - Enabled by default with 'warning' severity
+  - Helps prevent broken code examples in documentation
+- **[Feature]** Add `Tags/RedundantParamDescription` validator to detect meaningless parameter descriptions
+  - Detects 7 types of redundant patterns: article+param, possessive, type restatement, param-to-verb, ID pattern, directional date, type+generic
+  - Configurable pattern toggles to enable/disable individual pattern types
+  - Word count threshold (`MaxRedundantWords`: 6) prevents false positives on longer descriptions
+  - Character length threshold (`MinMeaningfulLength`: 15) for additional context
+  - Configurable articles list (`Articles`: The, the, A, a, An, an)
+  - Configurable generic terms list (`GenericTerms`: object, instance, value, data, item, element)
+  - Pattern-specific error messages with actionable suggestions
+  - EXACT pattern matching (not prefix) to avoid false positives
+  - Enabled by default with 'convention' severity
+  - Helps maintain high-quality, meaningful documentation
+- **[Feature]** Add `--init` command to generate `.yard-lint.yml` configuration file with sensible defaults
+- **[Feature]** Add `--force` flag to overwrite existing config file when using `--init`
+- **[Feature]** Add `EnforcedStyle` configuration option to `Tags/CollectionType` validator for bidirectional style enforcement
+  - Supports 'long' style: `Hash{K => V}` (default, standard YARD syntax)
+  - Supports 'short' style: `{K => V}` (Ruby-like syntax without Hash prefix)
+  - Automatically detects violations in either direction and suggests correct style
+  - Updated messages to show correct suggestion based on enforced style
+- **[Feature]** Add `Documentation/UndocumentedOptions` validator to detect methods with options hash parameters but no @option tags
+  - Detects `options = {}`, `opts = {}`, `**kwargs`, and similar patterns
+  - Helps catch missing documentation for option hash parameters
+  - Configurable via `Documentation/UndocumentedOptions` in config
+- **[Feature]** Add `Documentation/MarkdownSyntax` validator to detect common markdown syntax errors in documentation
+  - Detects unclosed backticks in inline code
+  - Detects unclosed code blocks (```)
+  - Detects unclosed bold formatting (**)
+  - Detects invalid list markers (• instead of - or *)
+  - Configurable via `Documentation/MarkdownSyntax` in config
+- [Enhancement] Simplify README by condensing alternative style examples
+- [Documentation] Add Quick Start section to README with `--init` command
+- [Documentation] Update CLI help to show new `--init` and `--force` options
+
 ## 1.0.0 (2025-11-09)
 - [Fix] Fix "Argument list too long" error on large codebases by using xargs pattern with temporary file lists
 - [Enhancement] Expand default exclusion patterns to include typical Ruby/Rails directories (test/, log/, coverage/, db/migrate/, etc.)

data/README.md

@@ -31,6 +31,8 @@ YARD-Lint validates your YARD documentation for:
 - **API tag validation**: Enforce @api tags on public objects and validate API values
 - **Abstract method validation**: Ensure @abstract methods don't have real implementations
 - **Option hash documentation**: Validate that methods with options parameters have @option tags
+- **Example code syntax validation**: Validates Ruby syntax in `@example` tags to catch broken code examples
+- **Redundant parameter descriptions**: Detects meaningless parameter descriptions that add no value (e.g., `@param user [User] The user`)
 - **YARD warnings**: Unknown tags, invalid directives, duplicated parameter names, and more
 
 ## Installation
@@ -55,6 +57,16 @@ gem install yard-lint
 
 ## Usage
 
+### Quick Start
+
+Generate a default configuration file:
+
+```bash
+yard-lint --init
+```
+
+This creates `.yard-lint.yml` with sensible defaults in your current directory.
+
 ### Command Line
 
 Basic usage:
@@ -71,6 +83,10 @@ yard-lint --config config/yard-lint.yml lib/
 
 # Output as JSON
 yard-lint --format json lib/ > report.json
+
+# Generate config file (use --force to overwrite existing)
+yard-lint --init
+yard-lint --init --force
 ```
 
 ## Configuration
@@ -360,6 +376,8 @@ Supported glob patterns:
 | `Documentation/UndocumentedObjects` | Checks for classes, modules, and methods without documentation | Enabled (warning) | `Enabled`, `Severity`, `Exclude`, `ExcludedMethods` |
 | `Documentation/UndocumentedMethodArguments` | Checks for method parameters without `@param` tags | Enabled (warning) | `Enabled`, `Severity`, `Exclude` |
 | `Documentation/UndocumentedBooleanMethods` | Checks that question mark methods document their boolean return | Enabled (warning) | `Enabled`, `Severity`, `Exclude` |
+| `Documentation/UndocumentedOptions` | Detects methods with options hash/kwargs parameters but no `@option` tags | Enabled (warning) | `Enabled`, `Severity`, `Exclude` |
+| `Documentation/MarkdownSyntax` | Detects common markdown syntax errors in documentation (unclosed backticks, invalid list markers, etc.) | Enabled (warning) | `Enabled`, `Severity`, `Exclude` |
 | **Tags Validators** |
 | `Tags/Order` | Enforces consistent ordering of YARD tags | Enabled (convention) | `Enabled`, `Severity`, `Exclude`, `EnforcedOrder` |
 | `Tags/InvalidTypes` | Validates type definitions in `@param`, `@return`, `@option` tags | Enabled (warning) | `Enabled`, `Severity`, `Exclude`, `ValidatedTags`, `ExtraTypes` |
@@ -369,6 +387,8 @@ Supported glob patterns:
 | `Tags/TagTypePosition` | Validates type annotation position (`@param name [Type]` vs `@param [Type] name`) | Enabled (convention) | `Enabled`, `Severity`, `Exclude`, `CheckedTags`, `EnforcedStyle` |
 | `Tags/ApiTags` | Enforces `@api` tags on public objects | Disabled (opt-in) | `Enabled`, `Severity`, `Exclude`, `AllowedApis` |
 | `Tags/OptionTags` | Requires `@option` tags for methods with options parameters | Enabled (warning) | `Enabled`, `Severity`, `Exclude` |
+| `Tags/ExampleSyntax` | Validates Ruby syntax in `@example` tags to catch broken code examples | Enabled (warning) | `Enabled`, `Severity`, `Exclude` |
+| `Tags/RedundantParamDescription` | Detects meaningless parameter descriptions that add no value beyond the parameter name | Enabled (convention) | `Enabled`, `Severity`, `Exclude`, `CheckedTags`, `Articles`, `MaxRedundantWords`, `MinMeaningfulLength`, `GenericTerms`, `EnabledPatterns` |
 | **Warnings Validators** |
 | `Warnings/UnknownTag` | Detects unknown YARD tags | Enabled (error) | `Enabled`, `Severity`, `Exclude` |
 | `Warnings/UnknownDirective` | Detects unknown YARD directives | Enabled (error) | `Enabled`, `Severity`, `Exclude` |
@@ -379,117 +399,41 @@ Supported glob patterns:
 | **Semantic Validators** |
 | `Semantic/AbstractMethods` | Ensures `@abstract` methods don't have real implementations | Enabled (warning) | `Enabled`, `Severity`, `Exclude` |
 
-### Excluding Methods from Documentation Validation
-
-The `Documentation/UndocumentedObjects` validator supports a flexible `ExcludedMethods` configuration option that allows you to exclude specific methods from documentation requirements. This supports three pattern types:
+### Detailed Validator Documentation
 
-#### Pattern Types
+For detailed documentation on each validator including configuration examples, pattern types, and troubleshooting guides, see the validator module documentation:
 
-1. **Exact Name Matching**
-   ```yaml
-   ExcludedMethods:
-     - '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.
+- Each validator module file in `lib/yard/lint/validators/` contains comprehensive YARD documentation
+- You can browse the source files directly, or generate YARD documentation to view in HTML format:
 
-2. **Arity Notation** (method_name/N)
-   ```yaml
-   ExcludedMethods:
-     - 'initialize/0'   # Only excludes initialize with NO parameters (default)
-     - '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.
+```bash
+yard doc lib/yard/lint/validators/**/*.rb
+yard server
+```
 
-3. **Regex Patterns**
-   ```yaml
-   ExcludedMethods:
-     - '/^_/'           # Excludes all methods starting with underscore (private convention)
-     - '/^test_/'       # Excludes all test methods
-     - '/_(helper|util)$/' # Excludes methods ending with _helper or _util
-   ```
+Then open http://localhost:8808 in your browser to browse the full validator documentation with examples.
 
-#### Examples
+### Quick Configuration Examples
 
 ```yaml
-# Minimal setup: only exclude parameter-less initialize
-Documentation/UndocumentedObjects:
-  ExcludedMethods:
-    - 'initialize/0'
-
-# Common Rails/Ruby patterns
+# Exclude specific methods from documentation requirements
 Documentation/UndocumentedObjects:
   ExcludedMethods:
     - 'initialize/0'       # Parameter-less constructors
     - '/^_/'               # Private methods (by convention)
     - 'to_s'               # String conversion
-    - 'inspect'            # Object inspection
-    - 'hash'               # Hash code generation
-    - 'eql?'               # Equality comparison
-    - '=='                 # Binary equality operator
-    - '<=>'                # Spaceship operator (comparison)
-    - '+'                  # Addition operator
-    - '-'                  # Subtraction operator
-    - '+@'                 # Unary plus operator
-    - '-@'                 # Unary minus operator
-
-# Test framework exclusions
-Documentation/UndocumentedObjects:
-  ExcludedMethods:
-    - '/^test_/'           # Minitest methods
-    - '/^should_/'         # Shoulda methods
-    - 'setup/0'            # Setup with no params
-    - 'teardown/0'         # Teardown with no params
-```
 
-#### Pattern Validation & Edge Cases
-
-The `ExcludedMethods` feature includes robust validation and error handling:
-
-**Automatic Pattern Sanitization:**
-- **Nil values** are automatically removed
-- **Empty strings** and whitespace-only patterns are filtered out
-- **Whitespace trimming** is applied to all patterns
-- **Empty regex patterns** (`//`) are rejected (would match everything)
-- **Non-array values** are automatically converted to arrays
-
-**Invalid Pattern Handling:**
-- **Invalid regex patterns** (e.g., `/[/`, `/(unclosed`) are silently skipped without crashing
-- **Invalid arity notation** (e.g., `method/abc`, `method/`) is silently skipped
-- **Pattern matching is case-sensitive** for both exact names and regex
-
-**Operator Method Support:**
-YARD-Lint fully supports Ruby operator methods including:
-- Binary operators: `+`, `-`, `*`, `/`, `%`, `**`, `==`, `!=`, `===`, `<`, `>`, `<=`, `>=`, `<=>`, `&`, `|`, `^`, `<<`, `>>`
-- Unary operators: `+@`, `-@`, `!`, `~`
-- Other special methods: `[]`, `[]=`, `=~`
-
-**Pattern Matching Behavior:**
-- **Any match excludes**: If a method matches any pattern, it is excluded from validation
-- **Patterns are evaluated in order** as defined in the configuration
-- **Exact names have no arity restriction**: `'initialize'` excludes all initialize methods, regardless of parameters
-- **Arity notation is strict**: `'initialize/0'` only excludes initialize with exactly 0 parameters
-
-#### Troubleshooting ExcludedMethods
-
-**Methods still showing as undocumented:**
-1. Verify the method name matches exactly (case-sensitive)
-2. Check if you're using arity notation - ensure the arity count is correct
-3. For regex patterns, test your regex independently to ensure it matches
-4. Remember: Arity counts `required + optional` parameters, **excluding** splat (`*args`) and block (`&block`)
-
-**Regex patterns not working:**
-1. Ensure you're using `/pattern/` format with forward slashes
-2. Test the regex in Ruby: `Regexp.new('your_pattern').match?('method_name')`
-3. Escape special regex characters: `\.`, `\(`, `\)`, `\[`, `\]`, etc.
-4. Invalid regex patterns are silently skipped - check for syntax errors
-
-**Arity not matching:**
-1. Count parameters correctly: `def method(a, b = 1)` has arity 2 (required + optional)
-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
+# Enable @api tag validation (disabled by default)
+Tags/ApiTags:
+  Enabled: true
+  AllowedApis:
+    - public
+    - private
+
+# Disable a validator
+Tags/RedundantParamDescription:
+  Enabled: false
+```
 
 ### Global Configuration
 
@@ -537,173 +481,6 @@ Options:
 
 All configuration (tag order, exclude patterns, severity levels, validator settings) should be defined in `.yard-lint.yml`.
 
-## Examples
-
-### Check a directory
-
-```bash
-yard-lint lib/
-```
-
-### Check a single file
-
-```bash
-yard-lint lib/my_class.rb
-```
-
-### Use custom config file
-
-```bash
-yard-lint --config config/yard-lint.yml lib/
-```
-
-### Configure fail-on-severity
-
-Add to `.yard-lint.yml`:
-```yaml
-AllValidators:
-  FailOnSeverity: error  # Only fail on errors, not warnings
-```
-
-### Enable @api tag validation
-
-Add to `.yard-lint.yml`:
-```yaml
-Tags/ApiTags:
-  Enabled: true
-  AllowedApis:
-    - public
-    - private
-```
-
-This will enforce that all public classes, modules, and methods have an `@api` tag:
-
-```ruby
-# Good
-# @api public
-class MyClass
-  # @api public
-  def public_method
-  end
-
-  # @api private
-  def internal_helper
-  end
-end
-
-# Bad - missing @api tags
-class AnotherClass
-  def some_method
-  end
-end
-```
-
-### @option tag validation (enabled by default)
-
-This validator ensures that methods with options parameters document them. It's **enabled by default**. To disable it, add to `.yard-lint.yml`:
-
-```yaml
-Tags/OptionTags:
-  Enabled: false
-```
-
-Examples:
-
-```ruby
-# Good
-# @param name [String] the name
-# @param options [Hash] configuration options
-# @option options [Boolean] :enabled Whether to enable the feature
-# @option options [Integer] :timeout Timeout in seconds
-def configure(name, options = {})
-end
-
-# Bad - missing @option tags
-# @param name [String] the name
-# @param options [Hash] configuration options
-def configure(name, options = {})
-end
-```
-
-### Meaningless tag validation (enabled by default)
-
-This validator prevents `@param` and `@option` tags from being used on classes, modules, or constants, where they make no sense (these tags are only valid on methods).
-
-```ruby
-# Bad - @param on a class
-# @param name [String] this makes no sense on a class
-class User
-end
-
-# Bad - @option on a module
-# @option config [Boolean] :enabled modules don't have parameters
-module Authentication
-end
-
-# Good - @param on a method
-class User
-  # @param name [String] the user's name
-  def initialize(name)
-    @name = name
-  end
-end
-```
-
-To disable this validator:
-
-```yaml
-Tags/MeaninglessTag:
-  Enabled: false
-```
-
-### Collection type syntax validation (enabled by default)
-
-YARD uses `Hash{K => V}` syntax for hashes, not `Hash<K, V>` (which is generic syntax from other languages). This validator enforces the correct YARD syntax.
-
-```ruby
-# Bad - using generic syntax
-# @param options [Hash<Symbol, String>] configuration
-def configure(options)
-end
-
-# Good - using YARD syntax
-# @param options [Hash{Symbol => String}] configuration
-def configure(options)
-end
-
-# Also good - Array uses angle brackets
-# @param items [Array<String>] list of items
-def process(items)
-end
-```
-
-To disable this validator:
-
-```yaml
-Tags/CollectionType:
-  Enabled: false
-```
-
-### Type annotation position validation (enabled by default)
-
-This validator ensures consistent type annotation positioning. By default, it enforces YARD standard (`@param name [Type]`), but you can configure it to enforce `type_first` style if your team prefers it.
-
-```ruby
-# Good - type after parameter name (YARD standard)
-# @param name [String] the user's name
-# @param age [Integer] the user's age
-def create_user(name, age)
-end
-
-# Bad - type before parameter name
-# @param [String] name the user's name
-# @param [Integer] age the user's age
-def create_user(name, age)
-end
-```
-
-To use `type_first` style instead, set `EnforcedStyle: type_first` in your `.yard-lint.yml`.
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/yard-lint

@@ -32,6 +32,14 @@ OptionParser.new do |opts|
     options[:progress] = value
   end
 
+  opts.on('--init', 'Generate .yard-lint.yml config file with defaults') do
+    options[:init] = true
+  end
+
+  opts.on('--force', 'Force overwrite when using --init') do
+    options[:force] = true
+  end
+
   opts.on('-v', '--version', 'Show version') do
     puts "yard-lint #{Yard::Lint::VERSION}"
     exit
@@ -43,6 +51,18 @@ OptionParser.new do |opts|
   end
 end.parse!
 
+# Handle --init flag
+if options[:init]
+  if Yard::Lint::ConfigGenerator.generate(force: options[:force])
+    puts 'Created .yard-lint.yml with default configuration'
+    exit 0
+  else
+    puts 'Error: .yard-lint.yml already exists'
+    puts 'Use --init --force to overwrite'
+    exit 1
+  end
+end
+
 # Get path argument
 path = ARGV[0]
 

data/lib/yard/lint/config.rb

@@ -199,8 +199,6 @@ module Yard
         respond_to?(key) ? send(key) : nil
       end
 
-      private
-
       # Generic helper to set validator configuration
       # @param validator_name [String] full validator name (e.g., 'Tags/Order')
       # @param key [String] configuration key

data/lib/yard/lint/config_generator.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Yard
+  module Lint
+    # Generates default .yard-lint.yml configuration file
+    class ConfigGenerator
+      # Default configuration template
+      DEFAULT_CONFIG = <<~YAML
+        # YARD-Lint Configuration
+        # See https://github.com/mensfeld/yard-lint for documentation
+
+        # Global settings for all validators
+        AllValidators:
+          # YARD command-line options (applied to all validators by default)
+          YardOptions:
+            - --private
+            - --protected
+
+          # Global file exclusion patterns
+          Exclude:
+            - '\\.git'
+            - 'vendor/**/*'
+            - 'node_modules/**/*'
+            - 'spec/**/*'
+            - 'test/**/*'
+
+          # Exit code behavior (error, warning, convention, never)
+          FailOnSeverity: warning
+
+        # Documentation validators
+        Documentation/UndocumentedObjects:
+          Description: 'Checks for classes, modules, and methods without documentation.'
+          Enabled: true
+          Severity: warning
+          ExcludedMethods:
+            - 'initialize/0'  # Exclude parameter-less initialize
+            - '/^_/'          # Exclude private methods (by convention)
+
+        Documentation/UndocumentedMethodArguments:
+          Description: 'Checks for method parameters without @param tags.'
+          Enabled: true
+          Severity: warning
+
+        Documentation/UndocumentedBooleanMethods:
+          Description: 'Checks that question mark methods document their boolean return.'
+          Enabled: true
+          Severity: warning
+
+        Documentation/UndocumentedOptions:
+          Description: 'Detects methods with options hash parameters but no @option tags.'
+          Enabled: true
+          Severity: warning
+
+        Documentation/MarkdownSyntax:
+          Description: 'Detects common markdown syntax errors in documentation.'
+          Enabled: true
+          Severity: warning
+
+        # Tags validators
+        Tags/Order:
+          Description: 'Enforces consistent ordering of YARD tags.'
+          Enabled: true
+          Severity: convention
+          EnforcedOrder:
+            - param
+            - option
+            - return
+            - raise
+            - example
+
+        Tags/InvalidTypes:
+          Description: 'Validates type definitions in @param, @return, @option tags.'
+          Enabled: true
+          Severity: warning
+          ValidatedTags:
+            - param
+            - option
+            - return
+
+        Tags/TypeSyntax:
+          Description: 'Validates YARD type syntax using YARD parser.'
+          Enabled: true
+          Severity: warning
+          ValidatedTags:
+            - param
+            - option
+            - return
+            - yieldreturn
+
+        Tags/MeaninglessTag:
+          Description: 'Detects @param/@option tags on classes, modules, or constants.'
+          Enabled: true
+          Severity: warning
+          CheckedTags:
+            - param
+            - option
+          InvalidObjectTypes:
+            - class
+            - module
+            - constant
+
+        Tags/CollectionType:
+          Description: 'Validates Hash collection syntax consistency.'
+          Enabled: true
+          Severity: convention
+          EnforcedStyle: long  # 'long' for Hash{K => V} (YARD standard), 'short' for {K => V}
+          ValidatedTags:
+            - param
+            - option
+            - return
+            - yieldreturn
+
+        Tags/TagTypePosition:
+          Description: 'Validates type annotation position in tags.'
+          Enabled: true
+          Severity: convention
+          CheckedTags:
+            - param
+            - option
+          # EnforcedStyle: 'type_after_name' (YARD standard: @param name [Type])
+          #                or 'type_first' (@param [Type] name)
+          EnforcedStyle: type_after_name
+
+        Tags/ApiTags:
+          Description: 'Enforces @api tags on public objects.'
+          Enabled: false  # Opt-in validator
+          Severity: warning
+          AllowedApis:
+            - public
+            - private
+            - internal
+
+        Tags/OptionTags:
+          Description: 'Requires @option tags for methods with options parameters.'
+          Enabled: true
+          Severity: warning
+
+        # Warnings validators - catches YARD parser errors
+        Warnings/UnknownTag:
+          Description: 'Detects unknown YARD tags.'
+          Enabled: true
+          Severity: error
+
+        Warnings/UnknownDirective:
+          Description: 'Detects unknown YARD directives.'
+          Enabled: true
+          Severity: error
+
+        Warnings/InvalidTagFormat:
+          Description: 'Detects malformed tag syntax.'
+          Enabled: true
+          Severity: error
+
+        Warnings/InvalidDirectiveFormat:
+          Description: 'Detects malformed directive syntax.'
+          Enabled: true
+          Severity: error
+
+        Warnings/DuplicatedParameterName:
+          Description: 'Detects duplicate @param tags.'
+          Enabled: true
+          Severity: error
+
+        Warnings/UnknownParameterName:
+          Description: 'Detects @param tags for non-existent parameters.'
+          Enabled: true
+          Severity: error
+
+        # Semantic validators
+        Semantic/AbstractMethods:
+          Description: 'Ensures @abstract methods do not have real implementations.'
+          Enabled: true
+          Severity: warning
+      YAML
+
+      # Generate .yard-lint.yml file in current directory
+      # @param force [Boolean] overwrite existing file if true
+      # @return [Boolean] true if file was created, false if already exists
+      def self.generate(force: false)
+        config_path = File.join(Dir.pwd, Config::DEFAULT_CONFIG_FILE)
+
+        if File.exist?(config_path) && !force
+          false
+        else
+          File.write(config_path, DEFAULT_CONFIG)
+          true
+        end
+      end
+    end
+  end
+end