rubocop-prose 0.1.0

data/lib/rubocop/cop/markdown/blockquote_blank_lines.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class BlockquoteBlankLines < Base
+        extend AutoCorrector
+        include RuboCop::Prose::ListRules
+
+        private
+
+        def investigate_document
+          inspect_children(document.root)
+        end
+
+        def inspect_children(parent)
+          previous = nil
+          parent.children.each do |child|
+            if child.type == :blockquote
+              connect_quotes(previous, child) if previous
+              previous = child
+            elsif child.type != :blank
+              previous = nil
+            end
+            inspect_children(child)
+          end
+        end
+
+        def connect_quotes(first, last)
+          start = last.options[:location]
+          prefix = document.line(start)[/\A[ \t]*(?:>[ \t]*)+/]
+          return unless prefix
+
+          ((node_last_line(first) + 1)...start).each do |number|
+            next unless container_blank?(number)
+
+            range = document.line_range(number)
+            prose_offense(range,
+                          message: 'Keep blockquote markers on blank lines between quoted blocks.') do |corrector|
+              corrector.replace(processed_range(range), prefix.rstrip)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/blockquote_spacing.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class BlockquoteSpacing < Base
+        extend AutoCorrector
+        include RuboCop::Prose::ListRules
+
+        private
+
+        def investigate_document
+          quote_depths = Hash.new(0)
+          document.nodes(:blockquote).each do |node|
+            (node.options[:location]..node_last_line(node)).each { |number| quote_depths[number] += 1 }
+          end
+          list_lines = []
+          list_groups do |_list, marks, _parent|
+            marks.each { |mark| list_lines.concat((mark[:line]..node_last_line(mark[:item])).to_a) }
+          end
+          document.prose_lines do |text, number|
+            next unless quote_depths[number].positive?
+
+            prefix = text[/\A[ \t]*(?:>[ \t]*)+/]
+            next unless prefix
+
+            markers = prefix.to_enum(:scan, />/).map { Regexp.last_match.begin(0) }
+            prefix.to_enum(:scan, />[ \t]{2,}/).each do
+              match = Regexp.last_match
+              next if match.end(0) == prefix.length && (list_lines.include?(number) || text[prefix.length..].empty?)
+
+              range = document.range(number, match.begin(0) + 1, number, match.end(0))
+              prose_offense(range, message: 'Use one space after a blockquote marker.') do |corrector|
+                corrector.replace(processed_range(range), ' ')
+              end
+            end
+
+            next unless markers.length == quote_depths[number]
+
+            markers.each do |column|
+              next if text[column + 1]&.match?(/[ \t]/)
+              next if text[(column + 1)..].sub(/\A(?:[ \t]*>)*[ \t]*/, '').empty?
+
+              range = document.range(number, column, number, column + 1)
+              prose_offense(range, message: 'Use one space after a blockquote marker.') do |corrector|
+                next unless correction_preserves_structure?(number, column)
+
+                corrector.insert_after(processed_range(range), ' ')
+              end
+            end
+          end
+        end
+
+        def correction_preserves_structure?(number, column)
+          source = document.source.dup
+          line_start = document.buffer.line_range(number).begin_pos
+          position = source.byteslice(0, line_start).length + column + 1
+          source.insert(position, ' ')
+          candidate = RuboCop::Prose::MarkdownDocument.new(
+            ::Parser::Source::Buffer.new(document.buffer.name, source: source),
+            configuration: config
+          )
+          tree_signature(document.root) == tree_signature(candidate.root) &&
+            document.warnings == candidate.warnings
+        end
+
+        def tree_signature(node)
+          options = node.options.except(:prose_lines, :original_ranges)
+          [node.type, node.value, options, node.children.map { |child| tree_signature(child) }]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/closed_heading_space.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ClosedHeadingSpace < Base
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          heading_entries.each do |heading|
+            opening = heading[:opening]
+            next unless opening && !heading[:closing]
+
+            # An escaped final hash is text, not an intended closing marker.
+            ending = /(?<slashes>\\*)(?<hashes>#+)[ \t]*\z/.match(opening[:rest])
+            next unless ending && ending[:slashes].length.even?
+
+            prose_offense(heading_range(heading), message: 'Separate closing heading hashes from text with a space.')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/closed_heading_spacing.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ClosedHeadingSpacing < Base
+        extend AutoCorrector
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          heading_entries.each do |heading|
+            closing = heading[:closing]
+            next unless closing && closing[:space].length > 1
+
+            column = heading[:opening].begin(:rest) + closing.begin(:space)
+            range = document.range(heading[:line], column, heading[:line], column + closing[:space].length)
+            prose_offense(range, message: 'Use one space before closing heading hashes.') do |corrector|
+              corrector.replace(processed_range(range), ' ')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/code_block_style.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/code_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class CodeBlockStyle < Base
+        extend AutoCorrector
+        include RuboCop::Prose::CodeRules
+
+        private
+
+        def investigate_document
+          expected = cop_config.fetch('EnforcedStyle', 'consistent')
+          code_blocks.each do |node|
+            actual = node.options[:fenced] ? 'fenced' : 'indented'
+            expected = actual if expected == 'consistent'
+            next if actual == expected
+
+            range = document.line_range(node.options[:location])
+            prose_offense(range, message: "Use #{expected} code blocks.") do |corrector|
+              conversion = safe_conversion(node, expected)
+              corrector.replace(processed_range(conversion.first), conversion.last) if conversion
+            end
+          end
+        end
+
+        def safe_conversion(node, expected)
+          return unless code_ancestors(node).all? { |ancestor| ancestor.type == :root }
+
+          expected == 'fenced' ? to_fenced(node) : to_indented(node)
+        end
+
+        def to_fenced(node)
+          first = node.options.fetch(:code_start_line)
+          last = first + node.value.lines.length - 1
+          return if last < first || !code_blank?(first - 1) || !code_blank?(last + 1)
+
+          raw = document.lines[(first - 1)..(last - 1)]
+          return unless raw.all? { |line| line.start_with?('    ') || line.empty? }
+          return unless "#{raw.map { |line| line.delete_prefix('    ') }.join("\n")}\n" == node.value
+
+          length = [3, node.value.scan(/`+/).map(&:length).max.to_i + 1].max
+          fence = '`' * length
+          [document.range(first, 0, last), "#{fence}\n#{node.value}#{fence}"]
+        end
+
+        def to_indented(node)
+          details = fence_details(node)
+          return unless details && details[:opening][:prefix].empty? && details[:opening][:info].strip.empty?
+          return unless details[:closing][:prefix].empty?
+          return unless code_blank?(details[:first] - 1) && code_blank?(details[:last] + 1)
+          return if adjacent_code_block?(node, details)
+
+          body = document.lines[details[:first]...(details[:last] - 1)]
+          return if body.empty? || body.first.strip.empty? || body.last.strip.empty?
+          return unless "#{body.join("\n")}\n" == node.value
+
+          [document.range(details[:first], 0, details[:last]),
+           body.map { |line| line.empty? ? '' : "    #{line}" }.join("\n")]
+        end
+
+        def adjacent_code_block?(node, details)
+          blocks = code_blocks
+          index = blocks.index(node)
+          neighbors = []
+          neighbors << blocks[index - 1] if index.positive?
+          neighbors << blocks[index + 1] if index + 1 < blocks.length
+          neighbors.any? do |other|
+            first = other.options[:location]
+            last = other.options[:code_start_line] + other.value.lines.length - (other.options[:fenced] ? 0 : 1)
+            gap = last < details[:first] ? ((last + 1)...details[:first]) : ((details[:last] + 1)...first)
+            gap.all? { |number| document.line(number).strip.empty? }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/code_span_spacing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/inline_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class CodeSpanSpacing < Base
+        extend AutoCorrector
+
+        def investigate_document
+          multiline = RuboCop::Prose::InlineRules.multiline_atoms(document)
+                                                 .select { |range| range.source.start_with?('`') }
+          RuboCop::Prose::InlineRules.lines(document).each do |text, number, column|
+            RuboCop::Prose::InlineRules.spans(text).each do |span|
+              next unless span.kind == :code && span.begin_pos >= column
+
+              position = document.range(number, span.begin_pos, number, span.end_pos)
+              next if multiline.any? { |range| range.overlaps?(position) }
+
+              width = span.delimiter.length
+              content = text[(span.begin_pos + width)...(span.end_pos - width)]
+              next if content.strip.empty? || content == content.strip
+              # One space on each side is the Markdown escape for literal edge backticks.
+              next if content.start_with?(' ') && content.end_with?(' ') &&
+                      (content[1] == '`' || content[-2] == '`')
+
+              range = document.range(number, span.begin_pos, number, span.end_pos)
+              prose_offense(range, message: 'Avoid unnecessary padding inside code spans.') do |corrector|
+                # Only symmetric single-space padding can be removed without changing the value.
+                next unless content.start_with?(' ') && content.end_with?(' ')
+                next if content[1] == ' ' || content[-2] == ' '
+
+                corrector.replace(processed_range(range), "#{span.delimiter}#{content[1...-1]}#{span.delimiter}")
+              end
+            end
+            multiline.each do |range|
+              delimiter = range.source[/\A`+/]
+              content = range.source[delimiter.length...-delimiter.length]
+              next if content.strip.empty? || content == content.strip
+              next if content.start_with?(' ') && content.end_with?(' ') &&
+                      (content[1] == '`' || content[-2] == '`')
+
+              prose_offense(range, message: 'Avoid unnecessary padding inside code spans.')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/compact_lists.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class CompactLists < Base
+        extend AutoCorrector
+        include RuboCop::Prose::ListRules
+
+        private
+
+        def investigate_document
+          list_groups do |list, marks, _parent|
+            items = list.children.select { |child| child.type == :li }
+            next unless marks.length == items.length
+
+            marks.each_cons(2) do |previous, following|
+              first_blank = node_last_line(previous[:item]) + 1
+              last_blank = following[:line] - 1
+              next unless first_blank <= last_blank
+
+              blank_lines = (first_blank..last_blank).to_a
+              next unless blank_lines.all? { |number| container_blank?(number) }
+
+              range = document.range(first_blank, 0, following[:line], 0)
+              prose_offense(range, message: 'Avoid blank lines between list items.') do |corrector|
+                next unless simple_list_item?(previous[:item]) && simple_list_item?(following[:item])
+
+                corrector.remove(processed_range(range))
+              end
+            end
+          end
+        end
+
+        def simple_list_item?(item)
+          item.children.one? && item.children.first.type == :p
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/descriptive_link_text.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/link_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class DescriptiveLinkText < Base
+        MSG = 'Use descriptive link text instead of a generic label.'
+
+        private
+
+        def investigate_document
+          scanner = document.link_rules
+          generic = cop_config.fetch('GenericLabels', ['click here', 'here', 'link', 'more'])
+                              .map { |label| scanner.normalize_text(label) }
+          scanner.links.each do |link|
+            next if link.image || link.style == 'autolink' || !scanner.resolved?(link)
+            next unless generic.include?(scanner.normalize_text(scanner.display_text(link)))
+
+            prose_offense(scanner.label_range(link))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/duplicate_headings.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class DuplicateHeadings < Base
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          seen = Set.new
+          parents = []
+          heading_entries.each do |heading|
+            parents.pop while parents.any? && parents.last[:level] >= heading[:level]
+            scope = cop_config.fetch('Scope', 'siblings') == 'siblings' ? parents.last&.fetch(:line) : nil
+            key = [scope, heading[:text]]
+            if seen.include?(key)
+              prose_offense(heading_range(heading), message: 'Use unique heading text within the configured scope.')
+            end
+            seen.add(key)
+            parents << heading
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/emphasis_heading.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Markdown
+      class EmphasisHeading < Base
+        def investigate_paragraph(paragraph)
+          children = paragraph.children.reject { |child| child.type == :text && child.value.strip.empty? }
+          return unless children.one? && %i[em strong].include?(children.first.type)
+          return unless document.line_numbers(paragraph).size == 1
+
+          number = paragraph.options.fetch(:location)
+          prose_offense(document.line_range(number), message: 'Use a heading instead of an emphasis-only paragraph.')
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/emphasis_spacing.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/inline_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class EmphasisSpacing < Base
+        extend AutoCorrector
+
+        def investigate_document
+          RuboCop::Prose::InlineRules.lines(document).each do |text, number, column|
+            masked = RuboCop::Prose::InlineRules.mask(text, document: document, number: number)
+            masked.to_enum(:scan, /(?<![\w*_])(\*{1,3}|_{1,3})(?![*_])(.+?)\1(?![\w*_])/).each do
+              match = Regexp.last_match
+              content = text[match.begin(2)...match.end(2)]
+              next if match.begin(0) < column || content.strip.empty? || content == content.strip
+
+              range = document.range(number, match.begin(0), number, match.end(0))
+              replacement = "#{match[1]}#{text[match.begin(2)...match.end(2)].strip}#{match[1]}"
+              prose_offense(range, message: 'Remove spaces inside emphasis delimiters.') do |corrector|
+                corrector.replace(processed_range(range), replacement)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/emphasis_style.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/inline_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class EmphasisStyle < Base
+        extend AutoCorrector
+
+        def investigate_document
+          expected = cop_config.fetch('Style', 'consistent')
+          document.emphasis_ranges(:em).each do |opening, closing, char|
+            actual = char == '*' ? 'asterisk' : 'underscore'
+            expected = actual if expected == 'consistent'
+            next if actual == expected
+
+            replacement = expected == 'asterisk' ? '*' : '_'
+            # Underscores cannot delimit intraword emphasis.
+            before = opening.begin_pos.positive? ? document.source[opening.begin_pos - 1] : nil
+            after = document.source[closing.end_pos]
+
+            prose_offense(opening, message: "Use #{expected} emphasis.") do |corrector|
+              next if replacement == '_' && (before&.match?(/[[:alnum:]_]/) || after&.match?(/[[:alnum:]_]/))
+
+              corrector.replace(processed_range(opening), replacement)
+              corrector.replace(processed_range(closing), replacement)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/empty_link.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/link_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class EmptyLink < Base
+        MSG = 'Provide a nonempty link destination.'
+
+        private
+
+        def investigate_document
+          scanner = document.link_rules
+          scanner.links.each do |link|
+            next if link.image || !scanner.resolved?(link)
+            next unless ['', '#'].include?(scanner.destination(link))
+
+            prose_offense(scanner.link_range(link))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/fence_blank_lines.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/code_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class FenceBlankLines < Base
+        extend AutoCorrector
+        include RuboCop::Prose::CodeRules
+
+        def validate_config
+          %w[LinesAbove LinesBelow].each do |name|
+            value = cop_config[name]
+            next if value.is_a?(Integer) && value >= 0
+
+            raise ValidationError, "Markdown/FenceBlankLines: #{name} must be a nonnegative integer."
+          end
+        end
+
+        private
+
+        def investigate_document
+          @insertions = {}
+          fenced_blocks(list_items: cop_config.fetch('ListItems', true)) do |details|
+            first = details[:first]
+            last = details[:last]
+            prefix = code_continuation_prefix(details[:opening][:prefix]).rstrip
+            inline_item = details[:opening][:prefix].match?(/[-+*]|\d+[.)]/)
+            require_blanks(first, prefix, cop_config.fetch('LinesAbove', 1), -1) unless inline_item
+            require_blanks(last + 1, prefix, cop_config.fetch('LinesBelow', 1), 1)
+          end
+          @insertions.each do |number, insertion|
+            add_blank(number, insertion[:prefix], insertion[:count])
+          end
+        end
+
+        def require_blanks(number, prefix, required, direction)
+          return if required.zero?
+
+          existing = blank_count(direction.negative? ? number - 1 : number, direction)
+          missing = required - existing
+          return unless missing.positive?
+
+          # Adjacent fences must share one insertion, even when some padding already exists.
+          number -= existing if direction.negative?
+          insertion = @insertions[number] ||= { prefix: prefix, count: missing }
+          insertion[:count] = [insertion[:count], missing].max
+        end
+
+        def blank_count(number, direction)
+          count = 0
+          while number.between?(1, document.lines.length)
+            return Float::INFINITY if direction.negative? && document.front_matter_line?(number)
+            break unless code_blank?(number)
+
+            count += 1
+            number += direction
+          end
+          number.between?(1, document.lines.length) ? count : Float::INFINITY
+        end
+
+        def add_blank(number, prefix, count)
+          range = document.line_range(number)
+          prose_offense(range, message: 'Surround fenced code blocks with blank lines.') do |corrector|
+            corrector.insert_before(processed_range(range), "#{prefix}\n" * count)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/fence_language.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/code_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class FenceLanguage < Base
+        include RuboCop::Prose::CodeRules
+
+        private
+
+        def investigate_document
+          allowed = cop_config.fetch('AllowedLanguages', [])
+          code_blocks.each do |node|
+            next unless node.options[:fenced]
+
+            language = node.options[:lang].to_s
+            next unless language.empty? || (!allowed.empty? && !allowed.include?(language))
+
+            message = if language.empty?
+                        'Specify a language for this fenced code block.'
+                      else
+                        "Use an allowed fence language (#{allowed.join(', ')})."
+                      end
+            prose_offense(document.line_range(node.options[:location]), message: message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/markdown/fence_style.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/code_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class FenceStyle < Base
+        extend AutoCorrector
+        include RuboCop::Prose::CodeRules
+
+        private
+
+        def investigate_document
+          expected = { 'backtick' => '`', 'tilde' => '~' }[cop_config.fetch('EnforcedStyle', 'consistent')]
+          code_blocks.each do |node|
+            details = fence_details(node)
+            next unless details
+
+            expected ||= details[:opening][:fence][0]
+            next if details[:opening][:fence][0] == expected
+
+            range = fence_range(details[:first], details[:opening])
+            prose_offense(range, message: "Use #{expected == '`' ? 'backtick' : 'tilde'} fences.") do |corrector|
+              next if expected == '`' && details[:opening][:info].include?('`')
+
+              length = [details[:opening][:fence].length, details[:closing][:fence].length,
+                        node.value.scan(/#{Regexp.escape(expected)}+/).map(&:length).max.to_i + 1].max
+              replacement = expected * length
+              corrector.replace(processed_range(range), replacement)
+              closing = fence_range(details[:last], details[:closing])
+              corrector.replace(processed_range(closing), replacement)
+            end
+          end
+        end
+      end
+    end
+  end
+end