yard-lint 1.0.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 312a8649c021c9df03d03240a80da73a5985b692f784bbe1143cf6f7138dbb78
-  data.tar.gz: ba230c3af103171163396ccc31ac2b4b8fb400b98faba25705072558ee9b71bb
+  metadata.gz: 72ea0cf00858078029ca28144f64d7722abcf1a646e1365560542a064a37de24
+  data.tar.gz: 2d68009b8610f26b2bfaeb053692f36a714e96ff145cc60c71ed5b2c01c2a43c
 SHA512:
-  metadata.gz: d14c94827a3b20f08c283aff9e60f82473dd91522e35f434012cf7b90bd23f7aeaaa3e4f95788d3e7fd32870ac96ee75c953b2bf176c4f38cc44ef9d0cb2e874
-  data.tar.gz: b8d9bdf4583ea0553b8badd02266d03b402a50926f26492ba1d5c956ee275d2e9fab97bcc773e9d7d160acae76e10746a8103937fa5ea01aeb46e0480fd0a0e2
+  metadata.gz: 48313464b85f0d161d39cf151fbbc681fcb5b8271efcc87a371f72199f692c6a75bf24f478dd169ad53babe987c43f88987cc89d51835085db7180eb0906a2f1
+  data.tar.gz: c2fa9aa46f81613ee4aacdee0dd6aba4492d61bb9776daf11c7754b94aec7011a5337ccfbe937b136004d240974b0fa336c406d91bb0982dc322235c02b1fdc8

data/CHANGELOG.md

@@ -1,5 +1,82 @@
 # YARD-Lint Changelog
 
+## 1.2.0 (2025-11-12)
+- **[Fix]** Add Ruby 3.5+ compatibility without requiring IRB gem dependency
+  - Ruby 3.5 moved IRB out of default gems, requiring explicit installation
+  - YARD's legacy parser depends on `IRB::Notifier` for debug output
+  - Created lightweight `IRB::Notifier` shim to satisfy YARD without full IRB gem
+  - Shim tries to load real IRB first, only provides fallback if LoadError occurs
+  - Does not override or interfere with real IRB gem when present
+  - Safe to use in applications that depend on yard-lint and also use IRB
+  - Shim automatically loaded in subprocesses via RUBYOPT environment variable
+  - Avoids adding IRB and its transitive dependencies to supply chain
+  - All 977 tests pass on Ruby 3.5.0-preview1 without IRB gem
+- **[Feature]** Add Documentation Coverage Statistics with minimum threshold enforcement
+  - `--min-coverage PERCENT` - Fail if documentation coverage is below threshold (0-100)
+  - `--stats` flag now displays coverage metrics (total objects, documented, undocumented, percentage)
+  - `MinCoverage` configuration option in `.yard-lint.yml` under `AllValidators` section
+  - CLI flag overrides config file setting for flexibility in CI/CD pipelines
+  - Coverage calculation uses YARD queries to count documented vs undocumented objects
+  - Works seamlessly with diff mode (--diff, --staged, --changed) to calculate coverage for changed files only
+  - Exit code 1 when coverage is below minimum threshold, even if no linting offenses found
+  - Summary-only output in --quiet mode shows coverage with pass/fail status
+  - Comprehensive unit and integration test coverage for all scenarios
+  - Performance optimized with auto-cleanup temp directories for large codebases
+- **[Feature]** Add Diff Mode for incremental linting - only analyze files that changed
+  - `--diff [REF]` - Lint only files changed since REF (auto-detects main/master if not specified)
+  - `--staged` - Lint only staged files (git index)
+  - `--changed` - Lint only uncommitted files
+  - Enables practical usage in large legacy codebases
+  - Perfect for CI/CD pipelines (only check what changed in PR)
+  - Ideal for pre-commit hooks (only check staged files)
+  - Auto-detects main/master branch with fallback to master
+  - Applies global exclusion patterns to git diff results
+  - Silently skips deleted files
+  - Returns clean result when no files are changed
+  - Uses shell-based git commands via Open3 (no new dependencies)
+  - Configuration support via `AllValidators.DiffMode` section
+  - Mutually exclusive diff flags (--diff, --staged, --changed)
+
+## 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:
@@ -67,12 +79,124 @@ With options:
 
 ```bash
 # Use a specific config file
-yard-lint --config config/yard-lint.yml lib/
+yard-lint lib/ --config config/yard-lint.yml
 
 # Output as JSON
-yard-lint --format json lib/ > report.json
+yard-lint lib/ --format json > report.json
+
+# Generate config file (use --force to overwrite existing)
+yard-lint --init
+yard-lint --init --force
+```
+
+### Diff Mode (Incremental Linting)
+
+Lint only files that changed - perfect for large projects, CI/CD, and pre-commit hooks:
+
+```bash
+# Lint only files changed since main branch (auto-detects main/master)
+yard-lint lib/ --diff
+
+# Lint only files changed since specific branch/commit
+yard-lint lib/ --diff develop
+yard-lint lib/ --diff HEAD~3
+
+# Lint only staged files (perfect for pre-commit hooks)
+yard-lint lib/ --staged
+
+# Lint only uncommitted files
+yard-lint lib/ --changed
+```
+
+**Use Cases:**
+
+**Pre-commit Hook:**
+```bash
+#!/bin/bash
+# .git/hooks/pre-commit
+bundle exec yard-lint lib/ --staged --fail-on-severity error
+```
+
+**GitHub Actions CI/CD:**
+```yaml
+name: YARD Lint
+on: [pull_request]
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0  # Need full history for --diff
+      - name: Run YARD-Lint on changed files
+        run: bundle exec yard-lint lib/ --diff origin/${{ github.base_ref }}
+```
+
+**Legacy Codebase Incremental Adoption:**
+```bash
+# Only enforce rules on NEW code
+yard-lint lib/ --diff main
+```
+
+### Documentation Coverage Statistics
+
+Monitor and enforce minimum documentation coverage thresholds:
+
+```bash
+# Show coverage statistics with --stats flag
+yard-lint lib/ --stats
+
+# Output:
+# Documentation Coverage: 85.5%
+#   Total objects:      120
+#   Documented:         102
+#   Undocumented:       18
+
+# Enforce minimum coverage threshold (fails if below)
+yard-lint lib/ --min-coverage 80
+
+# Use with diff mode to check coverage only for changed files
+yard-lint lib/ --diff main --min-coverage 90
+
+# Quiet mode shows only summary with coverage
+yard-lint lib/ --quiet --min-coverage 80
+```
+
+**Configuration File:**
+```yaml
+# .yard-lint.yml
+AllValidators:
+  # Fail if documentation coverage is below this percentage
+  MinCoverage: 80.0
+```
+
+**CI/CD Pipeline Example:**
+```yaml
+name: Documentation Quality
+on: [pull_request]
+jobs:
+  coverage:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Check documentation coverage for new code
+        run: |
+          bundle exec yard-lint \
+            lib/ \
+            --diff origin/${{ github.base_ref }} \
+            --min-coverage 90 \
+            --quiet
 ```
 
+**Key Features:**
+- Calculates percentage of documented classes, modules, and methods
+- CLI `--min-coverage` flag overrides config file setting
+- Exit code 1 if coverage is below threshold
+- Works with diff mode to enforce coverage only on changed files
+- Performance optimized with auto-cleanup temp directories for large codebases
+
 ## Configuration
 
 YARD-Lint is configured via a `.yard-lint.yml` configuration file (similar to `.rubocop.yml`).
@@ -100,6 +224,13 @@ AllValidators:
   # Exit code behavior (error, warning, convention, never)
   FailOnSeverity: warning
 
+  # Diff mode settings
+  DiffMode:
+    # Default base ref for --diff (auto-detects main/master if not specified)
+    DefaultBaseRef: ~
+    # Include untracked files in diff mode (not yet implemented)
+    IncludeUntracked: false
+
 # Individual validator configuration
 Documentation/UndocumentedObjects:
   Description: 'Checks for classes, modules, and methods without documentation.'
@@ -257,7 +388,7 @@ YARD-Lint will automatically search for `.yard-lint.yml` in the current director
 You can specify a different config file:
 
 ```bash
-yard-lint --config path/to/config.yml lib/
+yard-lint lib/ --config path/to/config.yml
 ```
 
 #### Configuration Inheritance
@@ -360,6 +491,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 +502,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 +514,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
+### Detailed Validator Documentation
 
-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:
+For detailed documentation on each validator including configuration examples, pattern types, and troubleshooting guides, see the validator module documentation:
 
-#### Pattern Types
+- 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:
 
-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.
-
-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 +596,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).