rubocop-spellcheck 0.1.0 → 0.2.0

data/lib/rubocop/spellcheck/asciidoc_inline.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Spellcheck
+    # Masks Asciidoctor inline syntax without substituting attributes or generating HTML.
+    class AsciiDocInline
+      def initialize(source, positions)
+        @source = source.dup
+        @positions = positions
+      end
+
+      def span
+        mask_code
+        mask_macros
+        mask_quotes
+        decoded_span
+      end
+
+      private
+
+      def decoded_span
+        text = +''
+        positions = []
+        @source.to_enum(:scan, Markdown::PIECE).each do
+          decoded, mapped = decoded_piece(Regexp.last_match)
+          text << decoded
+          positions.concat(mapped)
+        end
+        Span.new(text, positions)
+      end
+
+      def decoded_piece(match)
+        decoded = Markdown.decode(match[0])
+        range = [@positions.fetch(match.begin(0)).first, @positions.fetch(match.end(0) - 1).last]
+        [decoded, Array.new(decoded.length, range)]
+      end
+
+      def mask_code
+        mask_matches(::Asciidoctor::InlinePassMacroRx)
+        mask_matches(::Asciidoctor::InlinePassRx[false][2], 6)
+        mask_matches(::Asciidoctor::InlineStemMacroRx)
+        mask_matches(::Asciidoctor::InlineKbdBtnMacroRx)
+        mask_matches(::Asciidoctor::InlineImageMacroRx)
+        mask_matches(::Asciidoctor::InlineIndextermMacroRx)
+        mask_matches(::Asciidoctor::InlineMenuMacroRx)
+      end
+
+      def mask_macros
+        keep_capture(::Asciidoctor::InlineLinkMacroRx, 3)
+        keep_capture(::Asciidoctor::InlineLinkRx, 5)
+        keep_capture(/<<[^>,]+(?:,([^>]+))?>>|xref:[^\s\[]+\[([^\]]*)\]/, 1, 2)
+        keep_capture(::Asciidoctor::InlineFootnoteMacroRx, 3)
+        mask_matches(::Asciidoctor::InlineAnchorRx)
+        mask_matches(::Asciidoctor::AttributeReferenceRx)
+      end
+
+      def mask_quotes
+        ::Asciidoctor::QUOTE_SUBS[false].each do |type, scope, pattern|
+          capture = scope == :constrained ? 3 : 2
+          type == :monospaced ? mask_matches(pattern) : keep_capture(pattern, capture)
+        end
+      end
+
+      def mask_matches(pattern, capture = 0)
+        @source.dup.to_enum(:scan, pattern).each do
+          match = Regexp.last_match
+          mask(match.begin(capture), match.end(capture))
+        end
+      end
+
+      def keep_capture(pattern, *captures)
+        @source.dup.to_enum(:scan, pattern).each do
+          match = Regexp.last_match
+          capture = captures.find { |index| match[index] }
+          if capture
+            mask(match.begin(0), match.begin(capture))
+            mask(match.end(capture), match.end(0))
+          else
+            mask(match.begin(0), match.end(0))
+          end
+        end
+      end
+
+      def mask(first, last)
+        @source[first...last] = @source[first...last].gsub(/[^\n]/, ' ')
+      end
+    end
+  end
+end

data/lib/rubocop/spellcheck/asciidoc_table.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Spellcheck
+    # Cell line numbers can repeat in CSV tables; locate cells in source order within their table.
+    class AsciiDocTable
+      def initialize(buffer, table)
+        @buffer = buffer
+        @cursor = buffer.line_range(table.source_location.lineno).end_pos + 1
+        @last = table_end(table)
+      end
+
+      def span(cell)
+        match = locate(cell.source)
+        first = @cursor + match.begin(0)
+        @cursor += match.end(0)
+        positions = match[0].length.times.map { |index| [first + index, first + index + 1] }
+        AsciiDocInline.new(match[0], positions).span
+      end
+
+      private
+
+      def table_end(table)
+        lines = @buffer.source_lines
+        line = table.source_location.lineno
+        delimiter = lines.fetch(line - 1)
+        last = (line...lines.length).find { |index| lines[index] == delimiter }
+        last ? @buffer.line_range(last + 1).begin_pos : @buffer.source.length
+      end
+
+      def locate(text)
+        match = pattern(text).match(@buffer.source[@cursor...@last])
+        return match if match
+
+        raise RuboCop::ValidationError, "Cannot map AsciiDoc table cell in #{@buffer.name}: #{text.inspect}"
+      end
+
+      def pattern(text)
+        Regexp.new(text.each_char.map do |character|
+          case character
+          when '|' then /\\?\|/.source
+          when '"' then /"{1,2}/.source
+          else Regexp.escape(character)
+          end
+        end.join)
+      end
+    end
+  end
+end

data/lib/rubocop/spellcheck/checker.rb

@@ -41,6 +41,12 @@ module RuboCop
         end.uniq.first(3)
       end
 
+      def correct?(word)
+        return @verdicts[word] if @verdicts.key?(word)
+
+        @verdicts[word] = @checkers.any? { |checker| checker.correct?(word) }
+      end
+
       private
 
       def tokens(checker, text)
@@ -128,12 +134,6 @@ module RuboCop
 
         word
       end
-
-      def correct?(word)
-        return @verdicts[word] if @verdicts.key?(word)
-
-        @verdicts[word] = @checkers.any? { |checker| checker.correct?(word) }
-      end
     end
   end
 end

data/lib/rubocop/spellcheck/correction.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'kotoshu/algorithms/edit_distance'
+
+module RuboCop
+  module Spellcheck
+    # Restricts unsafe corrections to single-edit lowercase and title-case typos.
+    class Correction
+      WORD = /\A[\p{L}\p{M}]+(?:['’][\p{L}\p{M}]+)*\z/
+
+      def self.standalone?(text, position, length)
+        before = text[0...position]
+        after = text[(position + length)..]
+        !before.match?(/[\p{L}\p{M}\p{N}_](?:[.-])?\z/) &&
+          !after.match?(/\A(?:[.-])?[\p{L}\p{M}\p{N}_]/)
+      end
+
+      def self.whole_word?(positions, position, length)
+        first = positions.fetch(position).first
+        last = positions.fetch(position + length - 1).last
+        (position.zero? || positions[position - 1].last <= first) &&
+          (position + length == positions.length || positions[position + length].first >= last)
+      end
+
+      def initialize(word, suggestions)
+        @word = word
+        @suggestions = suggestions
+      end
+
+      def replacement
+        replacement_word
+      end
+
+      def replacement_word
+        return if @suggestions.empty? || !correctable_case?
+
+        suggestion = @suggestions.first.downcase
+        return unless WORD.match?(suggestion)
+
+        return unless Kotoshu::Algorithms::EditDistance.distance_with_threshold(@word.downcase, suggestion, 1) == 1
+
+        @word == @word.downcase ? suggestion : suggestion.capitalize
+      end
+
+      def replacement_in(source, first, last, checker:)
+        word = replacement_word
+        return unless word && checker.correct?(word)
+
+        replacement if Correction.standalone?(source, first, last - first)
+      end
+
+      def message
+        message = "Misspelled word: `#{@word}`."
+        return message if @suggestions.empty?
+
+        "#{message} Did you mean #{@suggestions.map { |suggestion| "`#{suggestion}`" }.join(', ')}?"
+      end
+
+      private
+
+      def correctable_case?
+        @word == @word.downcase || (@word == @word.capitalize && @word != @word.upcase)
+      end
+    end
+  end
+end

data/lib/rubocop/spellcheck/front_matter.rb

@@ -7,12 +7,47 @@ module RuboCop
   module Spellcheck
     # Reads YAML string values without constructing application objects.
     class FrontMatter
+      # Retains scalar syntax at extraction time rather than in the reporting code.
+      class Span < Spellcheck::Span
+        def initialize(text, positions, style)
+          super(text, positions)
+          @style = style
+        end
+
+        def correction(word, suggestions)
+          Correction.new(word, suggestions, @style)
+        end
+      end
+
+      # Applies YAML quoting and scalar-type constraints to a spelling replacement.
+      class Correction < Spellcheck::Correction
+        def initialize(word, suggestions, style)
+          super(word, suggestions)
+          @style = style
+        end
+
+        def replacement
+          suggestion = super
+          return unless suggestion
+
+          case @style
+          when Psych::Nodes::Scalar::SINGLE_QUOTED
+            suggestion.gsub("'", "''")
+          when Psych::Nodes::Scalar::PLAIN
+            suggestion if Psych::ScalarScanner.new(Psych::ClassLoader.new).tokenize(suggestion).is_a?(String)
+          else
+            suggestion
+          end
+        end
+      end
+
       HEADER = /\A(?:\uFEFF)?---[ \t]*\n.*?^(?:---|\.\.\.)[ \t]*(?:\n|\z)/m
       ESCAPE = /\\(?:U[0-9a-fA-F]{8}|u[0-9a-fA-F]{4}|x[0-9a-fA-F]{2}|.)/m
 
-      def initialize(buffer)
+      def initialize(buffer, config: {})
         @buffer = buffer
         @scanner = Psych::ScalarScanner.new(Psych::ClassLoader.new)
+        @paths = FrontMatterPaths.new(config)
       end
 
       def each_span
@@ -33,14 +68,21 @@ module RuboCop
         raise RuboCop::ValidationError, "Invalid YAML front matter in #{@buffer.name}: #{e.message}"
       end
 
-      def string_values(node, &block)
+      def string_values(node, path = [], &block)
         case node
         when Psych::Nodes::Mapping
-          node.children.each_slice(2) { |_key, value| string_values(value, &block) }
+          mapping_values(node, path, &block)
         when Psych::Nodes::Sequence
-          node.children.each { |value| string_values(value, &block) }
+          node.children.each { |value| string_values(value, path, &block) }
         when Psych::Nodes::Scalar
-          yield node if string_scalar?(node)
+          yield node if @paths.include?(path) && string_scalar?(node)
+        end
+      end
+
+      def mapping_values(node, path, &block)
+        node.children.each_slice(2) do |key, value|
+          name = key.is_a?(Psych::Nodes::Scalar) ? key.value : nil
+          string_values(value, [*path, name], &block)
         end
       end
 
@@ -60,7 +102,8 @@ module RuboCop
         last = position(node.end_line, node.end_column)
         raw = @buffer.source[first...last]
         prefix = raw[/\A(?:(?:&\S+|!\S+)[ \t]+)+/].to_s.length
-        map_pieces(raw[prefix..], node.style, first + prefix)
+        style = node.style
+        Span.new(*map_pieces(raw[prefix..], style, first + prefix), style)
       end
 
       def map_pieces(raw, style, first)

data/lib/rubocop/spellcheck/front_matter_paths.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Spellcheck
+    # Selects YAML values by exact dotted paths, including selected descendants.
+    class FrontMatterPaths
+      def initialize(config)
+        @include = paths(config.fetch('Include', nil), 'Include', nullable: true)
+        @exclude = paths(config.fetch('Exclude', []), 'Exclude')
+      end
+
+      def include?(path)
+        (@include.nil? || matches?(@include, path)) && !matches?(@exclude, path)
+      end
+
+      private
+
+      def paths(value, setting, nullable: false)
+        return if nullable && value.nil?
+        return value.map { |path| path.split('.') } if valid?(value)
+
+        raise RuboCop::ValidationError,
+              "Spellcheck/Spelling Markdown.FrontMatter.#{setting} must be a list of nonempty dotted paths."
+      end
+
+      def valid?(value)
+        value.is_a?(Array) && value.all? do |path|
+          path.is_a?(String) && !path.empty? && path.split('.', -1).none?(&:empty?)
+        end
+      end
+
+      def matches?(patterns, path)
+        patterns.any? { |pattern| path.first(pattern.length) == pattern }
+      end
+    end
+  end
+end

data/lib/rubocop/spellcheck/markdown.rb

@@ -11,10 +11,20 @@ module RuboCop
       PIECE = /#{ENTITY}|\\[[:punct:]]|./m
       LIQUID = /\{\{.*?\}\}|\{%.*?%\}/m
 
+      attr_reader :buffer, :directives
+
       def self.file?(path)
         path && EXTENSIONS.include?(File.extname(path).downcase)
       end
 
+      def self.decode(piece)
+        return piece.delete_prefix('\\') if piece.start_with?('\\')
+        return piece unless ENTITY.match?(piece)
+
+        document = Commonmarker.parse(piece, options: { parse: { smart: false } })
+        document.walk.select { |node| node.type == :text }.map(&:string_content).join
+      end
+
       def initialize(buffer)
         @buffer = buffer
         @lines = buffer.source.lines
@@ -23,10 +33,7 @@ module RuboCop
       def each_span
         return enum_for(__method__) unless block_given?
 
-        document = Commonmarker.parse(parser_source, options: {
-                                        parse: { smart: false },
-                                        extension: { shortcodes: false, footnotes: true }
-                                      })
+        document = parsed_document
         document.walk do |node|
           next unless node.type == :text
 
@@ -35,8 +42,29 @@ module RuboCop
         end
       end
 
+      def each_ruby_span(version, config:, &)
+        parsed_document.walk do |node|
+          next unless node.type == :code_block && node.fence_info.to_s.split.first == 'ruby'
+
+          MarkdownRuby.new(self, node, version, config: config).each_span(&)
+        end
+      end
+
+      def parser_lines
+        @parser_lines ||= parser_source.lines(chomp: true)
+      end
+
       private
 
+      def parsed_document
+        @parsed_document ||= Commonmarker.parse(parser_source, options: {
+                                                  parse: { smart: false },
+                                                  extension: { shortcodes: false, footnotes: true }
+                                                }).tap do |document|
+          @directives = MarkdownDirectives.new(@buffer, document)
+        end
+      end
+
       def parser_source
         without_front_matter.gsub(LIQUID) do |expression|
           expression.gsub(/[^\n]/) { |character| 'x' * character.bytesize }
@@ -62,12 +90,12 @@ module RuboCop
       end
 
       def decode_text(raw, first)
-        raw = without_liquid(raw)
+        raw = without_liquid(@directives.mask(raw, first))
         text = +''
         positions = []
         raw.to_enum(:scan, PIECE).each do
           match = Regexp.last_match
-          decoded = decode(match[0])
+          decoded = Markdown.decode(match[0])
           text << decoded
           decoded.length.times { positions << [first + match.begin(0), first + match.end(0)] }
         end
@@ -77,14 +105,6 @@ module RuboCop
       def without_liquid(raw)
         raw.gsub(LIQUID) { |expression| expression.gsub(/[^\n]/, ' ') }
       end
-
-      def decode(piece)
-        return piece.delete_prefix('\\') if piece.start_with?('\\')
-        return piece unless ENTITY.match?(piece)
-
-        document = Commonmarker.parse(piece, options: { parse: { smart: false } })
-        document.walk.select { |node| node.type == :text }.map(&:string_content).join
-      end
     end
   end
 end

data/lib/rubocop/spellcheck/markdown_directives.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Spellcheck
+    # Recognizes spelling directives only in Markdown HTML comment nodes.
+    class MarkdownDirectives
+      COMMENT = /<!--(.*?)-->/m
+      DIRECTIVE = /\A\s*rubocop:(disable|enable|todo)\s+(.+?)\s*\z/m
+
+      def initialize(buffer, document)
+        @buffer = buffer
+        @lines = buffer.source.lines
+        @disabled = Set.new
+        events = document.walk.filter_map { |node| comment_event(node) }.flatten(1).sort_by(&:first)
+        collect_lines(events)
+      end
+
+      def mask(raw, first)
+        line = @buffer.decompose_position(first).first
+        raw.lines.map.with_index do |text, index|
+          @disabled.include?(line + index) ? text.gsub(/[^\n]/, ' ') : text
+        end.join
+      end
+
+      def disabled?(line)
+        @disabled.include?(line)
+      end
+
+      private
+
+      def comment_event(node)
+        return unless %i[html_inline html_block].include?(node.type)
+
+        raw, first = node_source(node)
+        return unless raw.gsub(COMMENT, '').strip.empty?
+
+        raw.to_enum(:scan, COMMENT).filter_map { event(Regexp.last_match, first) }
+      end
+
+      def node_source(node)
+        location = node.source_position
+        first = position(location.fetch(:start_line), location.fetch(:start_column) - 1)
+        last = position(location.fetch(:end_line), location.fetch(:end_column))
+        [@buffer.source[first...last], first]
+      end
+
+      def event(match, first)
+        directive = DIRECTIVE.match(match[1])
+        return unless directive && relevant?(directive[2])
+
+        line, column = @buffer.decompose_position(first + match.begin(0))
+        prefix = @lines.fetch(line - 1)[0...column]
+        [line, directive[1], !prefix.strip.empty?]
+      end
+
+      def position(line, column)
+        @buffer.line_range(line).begin_pos + @lines.fetch(line - 1).byteslice(0, column).length
+      end
+
+      def relevant?(names)
+        names.split(/\s*--\s*/, 2).first.split(/[,\s]+/).intersect?(%w[all Spellcheck/Spelling])
+      end
+
+      def collect_lines(events)
+        events = events.group_by(&:first)
+        @lines.each_index do |index|
+          line = index + 1
+          @disabled << line if @block_disabled
+          events.fetch(line, []).each { |event| apply_event(*event) }
+        end
+      end
+
+      def apply_event(line, action, inline)
+        if inline || action == 'todo'
+          @disabled << line unless action == 'enable'
+        else
+          @block_disabled = action == 'disable'
+          @disabled << line if @block_disabled
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/spellcheck/markdown_ruby.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Spellcheck
+    # Maps explicitly tagged Ruby fences back through Markdown container prefixes.
+    class MarkdownRuby
+      # Retains Ruby string escaping and report-only identifier corrections.
+      class Span < Spellcheck::Span
+        def initialize(original, text, positions)
+          super(text, positions)
+          @original = original
+        end
+
+        def correction(word, suggestions)
+          @original.correction(word, suggestions)
+        end
+      end
+
+      def initialize(markdown, node, version, config:)
+        @buffer = markdown.buffer
+        @node = node
+        @config = config
+        @directives = markdown.directives
+        @parser_lines = markdown.parser_lines
+        @positions = []
+        @source = RuboCop::ProcessedSource.new(mapped_source, version, "#{@buffer.name}.rb")
+        @source.config = RuboCop::Config.new
+        @source.registry = RuboCop::Cop::Registry.global
+      end
+
+      def each_span
+        return enum_for(__method__) unless block_given?
+        return unless @source.valid_syntax?
+
+        RubyCode.new(@source, config: @config).each_code_span do |span|
+          yield mapped_span(span)
+        end
+      end
+
+      private
+
+      def mapped_span(span)
+        positions = span.positions.map { |first, last| [@positions.fetch(first), @positions.fetch(last - 1) + 1] }
+        Span.new(span, enabled_text(span, positions), positions)
+      end
+
+      def enabled_text(span, positions)
+        span.text.each_char.with_index.map do |character, index|
+          disabled?(span.positions[index].first, positions[index].first) ? ' ' : character
+        end.join
+      end
+
+      def mapped_source
+        first = @node.source_position.fetch(:start_line) + 1
+        @node.string_content.lines.each_with_index.map do |line, index|
+          mapped_line(line, first + index)
+        end.join
+      end
+
+      def mapped_line(line, number)
+        content = line.delete_suffix("\n")
+        suffix = mapped_suffix(content, number)
+        prefix = @parser_lines.fetch(number - 1).bytesize - suffix.bytesize
+        raw = @buffer.source_line(number).byteslice(prefix..)
+        indentation = content.delete_suffix(suffix)
+        offset = @buffer.line_range(number).end_pos - raw.length
+        map_positions(indentation, raw, offset, number)
+        "#{indentation}#{raw}\n"
+      end
+
+      def mapped_suffix(content, number)
+        parsed = @parser_lines.fetch(number - 1)
+        suffix = parsed.end_with?(content) ? content : content.lstrip
+        unless parsed.end_with?(suffix)
+          raise RuboCop::ValidationError, "Cannot map Ruby fence in #{@buffer.name}:#{number}."
+        end
+
+        suffix
+      end
+
+      def map_positions(indentation, raw, offset, number)
+        indentation.length.times { @positions << [offset - 1, @buffer.line_range(number).begin_pos].max }
+        (raw.length + 1).times { |column| @positions << (offset + column) }
+      end
+
+      def disabled?(ruby_position, original_position)
+        line = @source.buffer.decompose_position(ruby_position).first
+        original_line = @buffer.decompose_position(original_position).first
+        @directives.disabled?(original_line) ||
+          !@source.comment_config.cop_enabled_at_line?('Spellcheck/Spelling', line)
+      end
+    end
+  end
+end

data/lib/rubocop/spellcheck/plugin.rb

@@ -11,7 +11,7 @@ module RuboCop
           name: 'rubocop-spellcheck',
           version: VERSION,
           homepage: 'https://github.com/dblock/rubocop-spellcheck',
-          description: 'Spellcheck Ruby comments, Markdown prose, and plain text.'
+          description: 'Spellcheck Ruby comments, strings, identifiers, and documentation.'
         )
       end
 

data/lib/rubocop/spellcheck/prose_source.rb

@@ -5,7 +5,7 @@ module RuboCop
     # Prose files use the non-Ruby callback, with an untouched source buffer.
     module ProseSource
       def self.file?(path)
-        Markdown.file?(path) || text_file?(path)
+        Markdown.file?(path) || RDoc.file?(path) || AsciiDoc.file?(path) || text_file?(path)
       end
 
       def self.text_file?(path)