rubocop-spellcheck 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ed77adacb8aa94379378b10cebf66ffd8a710761d873c2eb845cebb15610c13
-  data.tar.gz: 949d777b38250c6f8427ec9509d5ea02bc181ef972515dec0e07e0d3ef974075
+  metadata.gz: 1632104e9d052f6d9f121d814c60b072fd5af231437efc0cb4e424c910fd5cf6
+  data.tar.gz: 4ed0b83c791c4ea57a8d5f6dd8ed2e3b37fdb67604b1c2f0376e4c3fe9dc4135
 SHA512:
-  metadata.gz: d54af9fc4f4faab80ff0f2d4476a2cd2dd923a22809d0e41d105137ef3d2d87e0df8e403be2d0c0a9d784f42d142b93c3a4b0499234987cfe791ede01e2501d8
-  data.tar.gz: 98c3511624a7244ce86a354a1842f04532bfb6cbd81b62f5783b7873b3221c60652bdee77d6a68eb82a5dea351afe63070dec44ad204b6d3c414dac8f859f40a
+  metadata.gz: 1cf73548e344df7cfbdece8a4ac0b82d983f68b5facf2cd820515ab64aa923bb197f377bd22ad1a805039fdbe89ed68659bf81b3b6cc161eefbffbb80ac1707f
+  data.tar.gz: b397a5491ea97e5040ed71288442d940558acb8a42d4089626210ed213dab5c18c473a3ddaefbb0b629ca980e4dbc53c6c7177dc5bdbfdd95aa73062558745cf

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## Changelog
 
+### 0.2.0 (2026/10/21)
+
+* [#28](https://github.com/dblock/rubocop-spellcheck/pull/28): Exclude `require`, `require_relative`, `load`, and `autoload` paths and `gem` names and version requirements from spelling checks in Ruby files and Markdown Ruby fences - [@dblock](https://github.com/dblock).
+* [#29](https://github.com/dblock/rubocop-spellcheck/pull/29): Display generated vocabulary paths relative to the working directory, matching RuboCop output - [@dblock](https://github.com/dblock).
+* [#27](https://github.com/dblock/rubocop-spellcheck/pull/27): Correct lowercase and title-case typos when the first suggestion is one edit away, even when multiple suggestions exist; require dictionary-accepted replacements to prevent correction loops and retain uppercase, mixed-case, and technical-token guards - [@dblock](https://github.com/dblock).
+* [#26](https://github.com/dblock/rubocop-spellcheck/pull/26): Restrict autocorrection to unique, single-edit lowercase typos outside dotted and identifier-like tokens; keep other suggestions report-only - [@dblock](https://github.com/dblock).
+* [#25](https://github.com/dblock/rubocop-spellcheck/pull/25): Skip spelling suggestions during vocabulary generation to speed up `--auto-gen-config` - [@dblock](https://github.com/dblock).
+* [#24](https://github.com/dblock/rubocop-spellcheck/pull/24): Fix spelling checks crashing on `__FILE__` in Ruby files and Markdown Ruby fences - [@dblock](https://github.com/dblock).
+* [#22](https://github.com/dblock/rubocop-spellcheck/pull/22): Check strings and opt-in identifiers in explicitly tagged Ruby Markdown fences; keep strings enabled and identifiers disabled by default in all Ruby checks - [@dblock](https://github.com/dblock).
+* [#21](https://github.com/dblock/rubocop-spellcheck/pull/21): Check Ruby strings and identifiers by default, with independent opt-outs, source-mapped string corrections, and report-only identifier diagnostics - [@dblock](https://github.com/dblock).
+* [#20](https://github.com/dblock/rubocop-spellcheck/pull/20): Generate project vocabulary and dictionary configuration with `rubocop --auto-gen-config` instead of suppressing spelling checks - [@dblock](https://github.com/dblock).
+* [#19](https://github.com/dblock/rubocop-spellcheck/pull/19): Add parser-backed AsciiDoc spelling checks and autocorrection - [@dblock](https://github.com/dblock).
+* [#18](https://github.com/dblock/rubocop-spellcheck/pull/18): Check RDoc files and parse RDoc markup in Ruby comments, excluding code examples and link destinations - [@dblock](https://github.com/dblock).
+* [#17](https://github.com/dblock/rubocop-spellcheck/pull/17): Select front matter values with dotted inclusion and exclusion paths - [@dblock](https://github.com/dblock).
+* [#16](https://github.com/dblock/rubocop-spellcheck/pull/16): Support Markdown HTML comment directives for spelling suppression - [@dblock](https://github.com/dblock).
+* [#15](https://github.com/dblock/rubocop-spellcheck/pull/15): Add spelling autocorrection for words with exactly one dictionary suggestion - [@dblock](https://github.com/dblock).
+* [#14](https://github.com/dblock/rubocop-spellcheck/pull/14): Reuse loaded dictionaries and word verdicts across file investigations instead of rebuilding them for every file - [@dblock](https://github.com/dblock).
 ### 0.1.0 (2026/10/20)
 
 * [#12](https://github.com/dblock/rubocop-spellcheck/pull/12): Preserve Markdown parsing and use original prose buffers - [@dblock](https://github.com/dblock).

data/README.md

@@ -5,15 +5,27 @@
 [![Package](https://github.com/dblock/rubocop-spellcheck/actions/workflows/package.yml/badge.svg)](https://github.com/dblock/rubocop-spellcheck/actions/workflows/package.yml)
 [![Gem Version](https://badge.fury.io/rb/rubocop-spellcheck.svg)](https://rubygems.org/gems/rubocop-spellcheck)
 
-Spellcheck Ruby comments, Markdown prose, and plain text with [RuboCop](https://rubocop.org/) and [Kotoshu](https://github.com/kotoshu/kotoshu).
+Spellcheck Ruby comments, strings, identifiers, and documentation with [RuboCop](https://rubocop.org/) and [Kotoshu](https://github.com/kotoshu/kotoshu).
 
 ## Table of Contents
 
 - [Installation](#installation)
 - [Usage](#usage)
+- [Other languages](#other-languages)
+- [Supported files](#supported-files)
+  - [Ruby comments](#ruby-comments)
+  - [Ruby strings and identifiers](#ruby-strings-and-identifiers)
+  - [RDoc](#rdoc)
+  - [Markdown](#markdown)
+  - [YAML front matter](#yaml-front-matter)
+  - [AsciiDoc](#asciidoc)
+  - [Plain text](#plain-text)
+- [Autocorrection](#autocorrection)
 - [Configuration](#configuration)
+  - [Front matter paths](#front-matter-paths)
   - [Dictionary files](#dictionary-files)
   - [Adding project vocabulary](#adding-project-vocabulary)
+  - [Generating project vocabulary](#generating-project-vocabulary)
   - [Replacing dictionaries and adding languages](#replacing-dictionaries-and-adding-languages)
   - [Exclusions and suppression](#exclusions-and-suppression)
 - [Scope and limitations](#scope-and-limitations)
@@ -46,7 +58,42 @@ bundle install
 bundle exec rubocop
 ```
 
-By default, the plugin uses the bundled American English dictionary. No dictionary setup, external cache, or network access is needed.
+No dictionary setup or network access is needed.
+
+## Usage
+
+`Spellcheck/Spelling` is enabled by default and checks Ruby comments, strings, Markdown, RDoc, AsciiDoc, and plain text. Identifier checking is opt-in:
+
+```sh
+bundle exec rubocop
+bundle exec rubocop --only Spellcheck/Spelling
+```
+
+For example, given `example.rb`:
+
+```ruby
+# The red brown fox jumsp over the lazy dog.
+```
+
+Running `bundle exec rubocop --only Spellcheck/Spelling example.rb` reports:
+
+```text
+example.rb:1:21: C: Spellcheck/Spelling: Misspelled word: jumsp. Did you mean jumps, jump, jumpy?
+# The red brown fox jumsp over the lazy dog.
+                    ^^^^^
+```
+
+Each offense highlights the misspelled word and includes up to three suggestions when available.
+
+Fix typos, then generate an initial `.spellcheck.txt` for remaining project-specific words:
+
+```sh
+bundle exec rubocop --auto-gen-config --only Spellcheck/Spelling
+```
+
+The command adds both the bundled English dictionary and `.spellcheck.txt` to your configuration when no dictionaries are configured. Review the generated vocabulary: remaining typos are accepted too. See [Generating project vocabulary](#generating-project-vocabulary) for regeneration behavior.
+
+## Other languages
 
 For another language, download a Hunspell dictionary and its license into your project. For example, download the [latest German resources](https://github.com/kotoshu/dictionaries/tree/v1/de/spelling):
 
@@ -66,49 +113,42 @@ Spellcheck:
       - dictionaries/de/de.dic
 ```
 
-The matching `dictionaries/de/de.aff` is loaded alongside it. Review the downloaded license and preserve its notices when committing or redistributing dictionary files. Commit these files or provision the same files in CI for reproducible results. You can also point to Hunspell files supplied by your operating system. The plugin does not use Kotoshu's resource cache, registration, or setup command; linting never downloads anything.
+The matching `.aff` file is required. Commit both files and their license, or provision them in CI. Review each dictionary's license before redistributing it; linting never downloads dictionaries.
 
-## Usage
+## Supported files
 
-`Spellcheck/Spelling` is enabled by default:
+### Ruby comments
 
-```ruby
-# bad
-# The red brown fox jumsp over the lazy dog.
+Ruby comments, including trailing and block comments, are checked. Shebangs, magic comments, RuboCop/Standard directives, and Sorbet `typed:` declarations are skipped. URLs and email addresses are ignored.
 
-# good
-# The red brown fox jumps over the lazy dog.
-```
+Comments are parsed as RDoc, excluding indented examples and inline code.
 
-```sh
-bundle exec rubocop
-bundle exec rubocop --only Spellcheck/Spelling
-```
+### Ruby strings and identifiers
 
-For example, given `example.rb`:
+Strings include ordinary and percent literals, string arrays, heredocs, and literal text inside interpolation. Contents are checked literally, not as markup. Paths passed to `require`, `require_relative`, `load`, and `autoload`, plus `gem` names and version requirements, are excluded. Symbols, regular expression text, and shell-command text are also excluded; Ruby expressions inside interpolation are still checked. Ruby code is never evaluated.
 
-```ruby
-# The red brown fox jumsp over the lazy dog.
-```
+Identifier checking is disabled by default. When enabled, every occurrence is checked, including method calls, definitions, constants, arguments, and variables. Names such as `hello_world`, `helloWorld`, and `HTTPClient` are split at underscores, numbers, and case boundaries. Add intentional API names and abbreviations to your project vocabulary.
 
-Running `bundle exec rubocop --only Spellcheck/Spelling example.rb` reports:
+Enable identifiers or disable strings independently:
 
-```text
-Inspecting 1 file
-C
+```yaml
+Spellcheck/Spelling:
+  Ruby:
+    Strings: false
+    Identifiers: true
+```
 
-Offenses:
+Standard Ruby suppression directives apply to all three scopes. Identifier errors are report-only: renaming one occurrence could break references or external APIs. Strings support `rubocop -A`, but changing a string can change program behavior; review these edits carefully.
 
-example.rb:1:21: C: Spellcheck/Spelling: Misspelled word: jumsp. Did you mean jumps, jump, jumpy?
-# The red brown fox jumsp over the lazy dog.
-                    ^^^^^
+Explicitly tagged `ruby` Markdown fences use the same string and identifier settings, including inside lists and blockquotes. Untagged or indented code, other languages, comments inside fences, and invalid Ruby snippets remain excluded.
 
-1 file inspected, 1 offense detected
-```
+### RDoc
+
+`.rdoc` files and Ruby comments use RDoc parsing. Headings, paragraphs, lists, and link labels are checked; code, link destinations, and documentation directives are skipped. Directives such as `:include:` are never executed.
 
-Each offense highlights the misspelled word and includes up to three suggestions when available. Spelling is ambiguous, so there is no autocorrection.
+### Markdown
 
-The same cop discovers `.md` and `.markdown` files and checks their prose:
+The cop discovers `.md` and `.markdown` files and checks their prose:
 
 ```markdown
 # The red brown fox jumsp over the lazy dog.
@@ -116,9 +156,11 @@ The same cop discovers `.md` and `.markdown` files and checks their prose:
 Check [the spelling](https://example.com) but not `code_identifiers`.
 ```
 
-Markdown headings, paragraphs, lists, blockquotes, table cells, link labels, image descriptions, and footnote text are checked. Code blocks and inline code, link destinations and reference identifiers, and HTML tags/comments and HTML blocks are skipped. URLs and email addresses are ignored in both formats. HTML entities and escaped punctuation are decoded with offenses mapped back to the original source. No `rubocop-md` plugin is required; Ruby code inside Markdown blocks is not inspected.
+Prose, headings, lists, tables, link labels, image descriptions, and footnotes are checked. Code other than explicitly tagged `ruby` fences, link destinations, HTML, Liquid expressions, URLs, and email addresses are skipped. No `rubocop-md` plugin is required.
+
+### YAML front matter
 
-YAML front matter checks string values recursively, including values inside mappings and arrays. Keys and strongly typed values such as numbers, booleans, dates, timestamps, and nulls are skipped. Quoted values are strings even when their contents resemble another type. Anchored strings are checked at their definition, not repeated through aliases; explicit string tags are supported, while other tags are ignored. YAML is parsed without constructing application objects. Plain and quoted values and multiline literal/folded values retain their original diagnostic locations, including quoted escape sequences. Invalid YAML produces an explicit error. Strings such as layout names and slugs are checked too; add intentional vocabulary to your dictionary. To disable front matter checks:
+String values are checked recursively, including multiline values and arrays. Keys, numbers, booleans, dates, and nulls are skipped. Layout names and slugs are strings too; use [front matter paths](#front-matter-paths) to select prose fields. Invalid YAML produces an error. To disable these checks:
 
 ```yaml
 Spellcheck/Spelling:
@@ -127,14 +169,51 @@ Spellcheck/Spelling:
       Enabled: false
 ```
 
-Before the first release, `Spellcheck/Comments` was renamed to `Spellcheck/Spelling`. Update any existing cop-specific configuration, `--only` arguments, or Ruby suppression directives to use the new name.
+### AsciiDoc
+
+`.adoc` and `.asciidoc` files use [Asciidoctor](https://asciidoctor.org/) to check prose, headings, lists, tables, and link labels. Code, comments, attributes, link destinations, and macros are skipped. Includes and extensions are disabled; linting does not render documents or access external resources.
+
+### Plain text
 
-Liquid output expressions and tags are ignored, including expressions inside link destinations. English words retain accented letters and internal apostrophes; surrounding quotation marks and numeric identifiers such as commit hashes and ordinals are not checked.
+`.txt` files are checked literally, excluding URLs and email addresses. Configured dictionaries and bundled resources are excluded automatically. Use normal RuboCop exclusions for other files you do not want checked.
 
-Plain `.txt` files are also discovered by default. Their entire contents are checked literally, including text that looks like Markdown code or headings; URLs and email addresses are still ignored. Configured dictionary files (including symbolic links to them) and this gem's bundled `data/` resources are excluded from spelling checks, so dictionary words and license/provenance files are not treated as prose. Hunspell `.dic` and `.aff` files are not included by default. Other text files, including project license files, can be excluded with normal `Spellcheck/Spelling` configuration.
+## Autocorrection
+
+Dictionary suggestions may not match your intended meaning, so spelling corrections require `rubocop -A`; `rubocop -a` leaves spelling unchanged. To apply corrections, use:
+
+```sh
+bundle exec rubocop -A --only Spellcheck/Spelling
+```
+
+Lowercase and title-case words whose first suggestion is at a distance of one edit are corrected: one insertion, deletion, substitution, or adjacent transposition. The replacement must pass the configured dictionaries. Other suggestions may be equally close; the first suggestion wins, preserving lowercase or title case. ALL CAPS, mixed-case words, and components of dotted or identifier-like tokens remain report-only. Corrections do not introduce multiple words or formatting characters. Title-case corrections can change people's names; review the resulting diff.
+
+Corrections preserve surrounding markup and string delimiters; escaped letters may become literal letters. Unsafe replacements such as a heredoc terminator or a typed YAML value are withheld. Identifiers are never renamed.
 
 ## Configuration
 
+### Front matter paths
+
+By default, all front matter string values are checked. Use dotted paths under `Markdown.FrontMatter` to select which values participate:
+
+```yaml
+Spellcheck/Spelling:
+  Markdown:
+    FrontMatter:
+      Enabled: true
+      Include:
+        - title
+        - description
+        - metadata
+        - authors.description
+      Exclude:
+        - metadata.slug
+        - metadata.internal
+```
+
+Paths are case-sensitive, with dots separating nested keys. Selecting a parent includes its descendants; `authors.description` selects descriptions in every author mapping without array indices. Wildcards and literal dots in key names are not supported.
+
+`Include: null` checks all paths; `Include: []` checks none. `Exclude` always takes precedence. These settings do not affect Markdown body prose.
+
 ### Dictionary files
 
 `DictionaryFiles` maps language codes to lists of dictionary paths. When omitted or `null`, it selects packaged English, equivalent to:
@@ -146,13 +225,13 @@ Spellcheck:
       - gem:rubocop-spellcheck/data/en/en.dic
 ```
 
-An explicit map replaces the default selection completely; no English dictionary is implicitly retained. Each language key determines Kotoshu's tokenization for its dictionaries. A word passes if any configured dictionary accepts it. This supports multilingual comments, but a typo that is valid in another active language will pass. There is no language detection or separate `Language` setting.
+An explicit map replaces the defaults: retain the English path if you still want English. A word passes if any configured dictionary accepts it; there is no automatic language detection.
 
-Paths beginning with `gem:<gem-name>/` resolve relative to that installed gem's root; for example, `gem:rubocop-spellcheck/data/en/en.dic`. Other paths are relative to the effective RuboCop configuration directory (or working directory without a configuration file). No ERB is needed. Missing gems, files, empty language lists, and unsupported file extensions produce explicit errors; there is no fallback.
+`gem:<gem-name>/` paths resolve inside the installed gem. Other paths are relative to the effective RuboCop configuration directory. Missing dictionaries and invalid settings produce errors rather than falling back to defaults.
 
 Hunspell `.dic` files load their matching `.aff` file in the same directory with the same basename. Plain `.txt` files contain literal words, one per line, matched case-insensitively without automatic inflection. Blank lines and lines starting with `#` are ignored; phrases are rejected.
 
-Settings can also be overridden for `Spellcheck/Spelling` using normal RuboCop department/cop configuration. RuboCop merges explicitly inherited hashes by its normal configuration rules; within an explicit map, arrays replace inherited arrays unless `inherit_mode` says otherwise. Kotoshu's personal dictionary is not consulted. Changes to any selected dictionary or affix file invalidate cached results.
+Normal RuboCop inheritance and cop-specific overrides apply. Dictionary changes invalidate cached results; Kotoshu's personal dictionary is not used.
 
 ### Adding project vocabulary
 
@@ -172,9 +251,27 @@ Kotoshu
 RuboCop
 ```
 
-In `.spellcheck.txt`, blank lines and `#` comments are ignored. Words match case-insensitively, with no automatic inflection: list plural or other forms explicitly when needed. Unlike this literal word list, the bundled English dictionary uses Hunspell's `.dic` word list and `.aff` rules to recognize forms such as plurals and suffixes. Both formats can be combined in `DictionaryFiles`.
+Words match case-insensitively; list plural and other forms explicitly. Blank lines and `#` comments are ignored. To use only your own word list, omit the gem path.
+
+### Generating project vocabulary
 
-There is no separate `AllowedWords`, `DictionaryPath`, or additional-files option. To use only your own word list, omit the gem path.
+Use the RuboCop configuration generator to build an initial vocabulary:
+
+```sh
+bundle exec rubocop --auto-gen-config
+```
+
+Spelling offenses create or update `.spellcheck.txt`. To generate vocabulary without configuring other cops:
+
+```sh
+bundle exec rubocop --auto-gen-config --only Spellcheck/Spelling
+```
+
+Every reported misspelling becomes accepted vocabulary, including genuine typos and words with correction suggestions. **Review the generated list**, remove mistakes, and fix them in the source. Generation does not correct source files.
+
+Rerunning rebuilds `.spellcheck.txt` from current violations without accepting its existing words during checking. Unneeded entries are removed, including manually added ones. Comments and capitalization of retained words are preserved; new words are lowercase, sorted, and added without duplicates. The command adds the vocabulary to `DictionaryFiles` while retaining existing dictionaries, or bundled English when using defaults.
+
+Vocabulary is written beside the effective configuration, including nested configurations. Exclusions and suppression still apply. **Run against the full intended file set:** words needed only in omitted files will be removed. Clean runs clear obsolete entries but do not create a new vocabulary file.
 
 ### Replacing dictionaries and adding languages
 
@@ -207,7 +304,17 @@ Spellcheck/Spelling:
 # rubocop:enable Spellcheck/Spelling
 ```
 
-Ruby inline directives apply to comments; Markdown HTML comments are ignored, not interpreted as suppression directives. To check only one format, use standard file inclusion:
+Ruby directives apply to comments, strings, and identifiers, including within tagged Ruby fences. In Markdown, use HTML comments:
+
+```markdown
+<!-- rubocop:disable Spellcheck/Spelling -->
+Intentional project vocabulary.
+<!-- rubocop:enable Spellcheck/Spelling -->
+```
+
+A trailing `disable` or any `todo` applies only to its own line. Directives accept `all`, cop lists, and reasons after ` -- `. HTML-comment directives inside code, Liquid, or front matter are ignored; Ruby directives apply within their own fence. Suppression prevents diagnostics and autocorrection.
+
+To check only one format, use standard file inclusion:
 
 ```yaml
 Spellcheck/Spelling:
@@ -217,9 +324,9 @@ Spellcheck/Spelling:
 
 ## Scope and limitations
 
-The first release checks Ruby comments, including trailing comments, Markdown prose, and plain `.txt` files. Ruby checks skip shebangs, magic comments, RuboCop/Standard directives, and Sorbet `typed:` declarations. It does not inspect Ruby strings, identifiers, symbols, or regular expressions.
+English words retain accented letters and internal apostrophes; surrounding quotation marks and numeric identifiers such as commit hashes and ordinals are not checked.
 
-Other comment content, including embedded code and documentation tags, is treated as text. Use a project dictionary or standard suppression for intentional non-prose. Word boundaries and spelling follow Kotoshu's selected language; this extension does not add language detection or grammar checking.
+Ruby comments use RDoc markup, not YARD or other documentation syntaxes. Other documentation tags are treated as text. Use a project dictionary or standard suppression for intentional non-prose. Word boundaries and spelling follow Kotoshu's selected language; this extension does not add language detection or grammar checking.
 
 Kotoshu ships precompiled gems for macOS, Linux, and Windows. Building native dependencies from source on other platforms may require a Rust toolchain.
 
@@ -233,4 +340,4 @@ Copyright (c) 2026 Daniel (dB.) Doubrovkine. MIT License; see [LICENSE.txt](LICE
 
 Kotoshu is a separate BSD-2-Clause dependency. The bundled SCOWL-derived American English dictionary carries its own copyright and redistribution terms; see [its full license](data/en/LICENSE) and [pinned provenance](data/en/README.md). Dictionary files and notices are included in the packaged gem.
 
-As of October 20, 2026, `kotoshu/dictionaries` describes its repository as MIT-licensed, but individual dictionaries retain their own licenses. The English package declares [`MIT AND BSD`](https://github.com/kotoshu/dictionaries/blob/v1/en/spelling/package.json); its [full notice](data/en/LICENSE) includes SCOWL's permissive redistribution grant, Ispell's BSD-style terms, and constituent word-list notices. The German dictionary used in the download example is [`GPL-2.0 OR GPL-3.0`](https://github.com/kotoshu/dictionaries/blob/v1/de/spelling/package.json), confirmed by its [license notice](https://github.com/kotoshu/dictionaries/blob/v1/de/spelling/license). German is not bundled with this gem. Other languages vary: inspect each dictionary's own license before using or redistributing it; the repository's MIT label does not relicense those files.
+Other dictionaries have their own licenses regardless of the dictionary repository's license. The German example is [`GPL-2.0 OR GPL-3.0`](https://github.com/kotoshu/dictionaries/blob/v1/de/spelling/license) and is not bundled. Review each dictionary's notices before redistributing it.

data/config/default.yml

@@ -7,11 +7,21 @@ AllCops:
     - "**/*.md"
     - "**/*.markdown"
     - "**/*.txt"
+    - "**/*.rdoc"
+    - "**/*.adoc"
+    - "**/*.asciidoc"
 
 Spellcheck/Spelling:
-  Description: Check spelling in Ruby comments, Markdown prose, and plain text.
+  Description: Check spelling in Ruby comments, strings, identifiers, and documentation.
   Enabled: true
+  SafeAutoCorrect: false
+  Ruby:
+    Strings: true
+    Identifiers: false
   Markdown:
     FrontMatter:
       Enabled: true
+      Include:
+      Exclude: []
   VersionAdded: "0.1"
+  VersionChanged: "0.2"

data/lib/rubocop/cop/spellcheck/spelling.rb

@@ -3,25 +3,24 @@
 module RuboCop
   module Cop
     module Spellcheck
-      # Checks Ruby comments, Markdown prose, and plain text with shared dictionaries.
+      # Checks Ruby code and documentation with shared spelling dictionaries.
       class Spelling < Base
+        extend AutoCorrector
+
         BUNDLED_DATA = File.expand_path('../../../../data', __dir__).freeze
-        DIRECTIVE = /
-          \A\#\s*(?:!|(?:rubocop|standard|coding|encoding|frozen_string_literal|
-          warn_indent|shareable_constant_value|typed)\s*:)|\A\#.*-\*-\s*(?:coding|encoding):
-        /x
         ADDRESS = %r{(?:https?://|www\.)[^\s<>]+|[\w.+-]+@[\w.-]+\.[a-zA-Z]{2,}}
 
+        def self.support_multiple_source?
+          true
+        end
+
         def on_new_investigation
           super
           if RuboCop::Spellcheck::Markdown.file?(processed_source.path)
             check_markdown
           else
-            processed_source.comments.each do |comment|
-              next if DIRECTIVE.match?(comment.text)
-
-              check_comment(comment)
-            end
+            RuboCop::Spellcheck::RubyCode.new(processed_source, config: cop_config.fetch('Ruby', {}))
+                                         .each_span { |span| check_markdown_span(span) }
           end
         end
 
@@ -30,6 +29,8 @@ module RuboCop
             check_text
           elsif RuboCop::Spellcheck::Markdown.file?(processed_source.path)
             check_markdown
+          elsif (extractor = prose_extractor)
+            extractor.new(prose_buffer).each_span { |span| check_markdown_span(span) }
           else
             super
           end
@@ -47,23 +48,40 @@ module RuboCop
           checker.checksum
         end
 
+        def current_corrector
+          return super unless RuboCop::Spellcheck::ProseSource.file?(processed_source.path)
+
+          # Prose deliberately bypasses Ruby parsing, but its buffer can still be rewritten.
+          @current_corrector ||= Corrector.new(processed_source)
+        end
+
         private
 
-        def front_matter_enabled?
-          cop_config.fetch('Markdown', {}).fetch('FrontMatter', {}).fetch('Enabled', true)
+        def prose_extractor
+          [RuboCop::Spellcheck::RDoc, RuboCop::Spellcheck::AsciiDoc].find do |extractor|
+            extractor.file?(processed_source.path)
+          end
         end
 
         def check_markdown
-          if front_matter_enabled?
-            RuboCop::Spellcheck::FrontMatter.new(prose_buffer).each_span do |text, positions|
-              check_markdown_span(text, positions)
-            end
+          check_front_matter
+          markdown = RuboCop::Spellcheck::Markdown.new(prose_buffer)
+          markdown.each_span do |text, positions|
+            check_markdown_span(RuboCop::Spellcheck::Span.new(text, positions))
           end
-          RuboCop::Spellcheck::Markdown.new(prose_buffer).each_span do |text, positions|
-            check_markdown_span(text, positions)
+          markdown.each_ruby_span(processed_source.ruby_version, config: cop_config.fetch('Ruby', {})) do |span|
+            check_markdown_span(span)
           end
         end
 
+        def check_front_matter
+          front_matter = cop_config.fetch('Markdown', {}).fetch('FrontMatter', {})
+          return unless front_matter.fetch('Enabled', true)
+
+          RuboCop::Spellcheck::FrontMatter.new(prose_buffer, config: front_matter)
+                                          .each_span { |span| check_markdown_span(span) }
+        end
+
         def check_text
           checker.misspellings(mask_addresses(processed_source.buffer.source)).each do |word, position|
             next unless word.match?(/\p{L}/)
@@ -73,32 +91,31 @@ module RuboCop
         end
 
         def checker
-          @checker ||= RuboCop::Spellcheck::Checker.new(
+          @checker ||= spelling_checker.new(
             dictionary_files: cop_config['DictionaryFiles'],
             base_directory: config.base_dir_for_path_parameters
           )
         end
 
-        def check_comment(comment)
-          checker.misspellings(prose(comment.text)).each do |word, position|
-            first = comment.source_range.begin_pos + position
-            report_word(word, first, first + word.length)
-          end
+        def spelling_checker
+          @options[:auto_gen_config] ? RuboCop::Spellcheck::Vocabulary::Checker : RuboCop::Spellcheck::Checker
         end
 
-        def check_markdown_span(text, positions)
-          text = text.sub(/\A['’]s\b/, '  ')
-          checker.misspellings(mask_addresses(text)).each do |word, position|
-            next unless word.match?(/\p{L}/)
-
-            report_word(word, positions.fetch(position).first, positions.fetch(position + word.length - 1).last)
+        def check_markdown_span(span)
+          text = mask_addresses(span.text.sub(/\A['’]s\b/, '  '))
+          span.each_misspelling(checker, text) do |word, first, last, correction, whole|
+            report_word(word, first, last, correction: correction, correctable: whole)
           end
         end
 
-        def report_word(word, first, last)
+        def report_word(word, first, last, correction: nil, correctable: true)
           range = Parser::Source::Range.new(prose_buffer, first, last)
           range = markdown_document.processed_range(range) if markdown_document
-          add_offense(range, message: spelling_message(word))
+          correction ||= RuboCop::Spellcheck::Correction.new(word, checker.suggestions(word))
+          replacement = correction.replacement_in(prose_buffer.source, first, last, checker: checker)
+          add_offense(range, message: correction.message) do |corrector|
+            corrector.replace(range, replacement) if replacement && correctable
+          end
         end
 
         def markdown_document
@@ -109,22 +126,9 @@ module RuboCop
           markdown_document ? markdown_document.buffer : processed_source.buffer
         end
 
-        def prose(text)
-          # Preserve character offsets while removing non-prose addresses and block delimiters.
-          mask_addresses(text).gsub(/^=(?:begin|end)\b[^\n]*/) { |marker| ' ' * marker.length }
-        end
-
         def mask_addresses(text)
           text.gsub(ADDRESS) { |address| ' ' * address.length }
         end
-
-        def spelling_message(word)
-          suggestions = checker.suggestions(word)
-          message = "Misspelled word: `#{word}`."
-          return message if suggestions.empty?
-
-          "#{message} Did you mean #{suggestions.map { |suggestion| "`#{suggestion}`" }.join(', ')}?"
-        end
       end
     end
   end

data/lib/rubocop/spellcheck/asciidoc.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'asciidoctor'
+
+module RuboCop
+  module Spellcheck
+    # Extracts original prose selected by the Asciidoctor block parser in secure mode.
+    class AsciiDoc
+      PROSE = %i[paragraph admonition verse list_item table_cell].freeze
+      SKIP = %i[listing literal pass stem comment].freeze
+
+      def self.file?(path)
+        path && %w[.adoc .asciidoc].include?(File.extname(path).downcase)
+      end
+
+      def initialize(buffer)
+        @buffer = buffer
+        @lines = buffer.source.lines
+      end
+
+      def each_span(&)
+        return enum_for(__method__) unless block_given?
+
+        @columns = Hash.new(0)
+        @tables = {}
+        source = @buffer.source.gsub(/^include::.*$/) { |line| ' ' * line.length }
+        document = ::Asciidoctor.load(source, safe: :secure, sourcemap: true, extensions: false)
+        spans(document, &)
+      end
+
+      private
+
+      def spans(document, &block)
+        document.find_by.each do |node|
+          next if excluded?(node) || !node.source_location
+
+          if node.context == :table_cell
+            table_spans(node, &block)
+          else
+            fragments(node).each { |text, line| yield mapped_span(text, line) }
+          end
+        end
+      end
+
+      def table_spans(node, &)
+        table = node.parent.parent
+        span = (@tables[table] ||= AsciiDocTable.new(@buffer, table)).span(node)
+        return if node.style == :literal
+        return spans(node.inner_document, &) if node.style == :asciidoc
+
+        yield span
+      end
+
+      def excluded?(node)
+        return false if node.context == :document
+        return true if SKIP.include?(node.context)
+
+        node.parent && excluded?(node.parent)
+      end
+
+      def fragments(node)
+        line = node.source_location.lineno
+        return [] if node.context == :document
+        return heading(line) if node.context == :section
+
+        titles(node, line) + prose(node, line)
+      end
+
+      def heading(line)
+        source = @lines.fetch(line - 1)
+        title = source[/\A={1,6} (.*)/, 1]
+        title ||= source.chomp if @lines[line]&.match?(/\A[=\-~^+]{2,}\s*\z/)
+        title ? [[title, line]] : []
+      end
+
+      def titles(node, line)
+        return [] unless node.title?
+
+        index = line - 2
+        index -= 1 while index >= 0 && @lines[index].start_with?('[')
+        text = @lines[index] if index >= 0
+        text&.start_with?('.') ? [[text.chomp.delete_prefix('.'), index + 1]] : []
+      end
+
+      def prose(node, line)
+        return [] unless PROSE.include?(node.context)
+
+        if node.context == :list_item
+          node.subs.clear
+          text = node.text
+        else
+          text = node.source
+        end
+        text ? [[text, line]] : []
+      end
+
+      def mapped_span(text, line)
+        positions = text.lines.flat_map do |part|
+          line += 1 while @lines.fetch(line - 1).start_with?('//')
+          mapped = line_positions(part, line)
+          line += 1
+          mapped
+        end
+        AsciiDocInline.new(text, positions).span
+      end
+
+      def line_positions(part, line)
+        column = column_for(part, line)
+        first = @buffer.line_range(line).begin_pos + column
+        @columns[line] = column + part.chomp.length
+        part.length.times.map { |index| [first + index, first + index + 1] }
+      end
+
+      def column_for(part, line)
+        @lines.fetch(line - 1).index(part.chomp, @columns[line]) ||
+          raise(RuboCop::ValidationError, "Cannot map AsciiDoc prose in #{@buffer.name}:#{line}: #{part.inspect}")
+      end
+    end
+  end
+end