rubocop-prose 0.1.0

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class FirstHeading < Base
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          return if front_matter_title?
+
+          first = document.lines.each_with_index.find do |text, index|
+            !document.front_matter_line?(index + 1) && !text.strip.empty?
+          end
+          return unless first
+
+          number = first.last + 1
+          heading = heading_entries.first
+          return if heading && heading[:line] == number && heading[:level] == cop_config.fetch('Level', 1)
+
+          prose_offense(document.line_range(number),
+                        message: 'Start the document with a heading at the configured level.')
+        end
+
+        private
+
+        def front_matter_title?
+          return false unless cop_config.fetch('FrontMatterTitle', true) && document.front_matter
+
+          lines = document.front_matter.lines
+          metadata = YAML.safe_load(lines[1...-1].join)
+          return false unless metadata.is_a?(Hash)
+
+          title = metadata[cop_config.fetch('TitleKey', 'title')]
+          title.is_a?(String) && !title.strip.empty?
+        rescue Psych::Exception
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Markdown
+      class HardBreakStyle < Base
+        extend AutoCorrector
+
+        MSG = 'Use the configured Markdown hard-break style.'
+        STYLES = %w[backslash spaces].freeze
+
+        def validate_config
+          style = cop_config['Style']
+          return if STYLES.include?(style)
+
+          raise ValidationError, 'Markdown/HardBreakStyle: Style must be backslash or spaces.'
+        end
+
+        private
+
+        def investigate_document
+          document.hard_breaks.each { |node| investigate_break(node) }
+        end
+
+        def investigate_break(node)
+          number = node.options[:location]
+          text = document.line(number)
+          marker = marker_for(text)
+          return unless marker
+
+          style, first_column, last_column = marker
+          return if style.to_s == cop_config.fetch('Style', 'backslash')
+
+          range = document.range(number, first_column, number, last_column)
+          prose_offense(range) do |corrector|
+            next unless safe_to_correct?(style, text, first_column)
+
+            replacement = cop_config['Style'] == 'backslash' ? '\\' : '  '
+            correction_range = if style == :backslash
+                                 document.range(number, last_column - 1, number, last_column)
+                               else
+                                 range
+                               end
+            corrector.replace(processed_range(correction_range), replacement)
+          end
+        end
+
+        def marker_for(text)
+          if (spaces = / {2,}\z/.match(text))
+            [:spaces, spaces.begin(0), spaces.end(0)]
+          elsif (slashes = /\\+\z/.match(text))
+            [:backslash, slashes.begin(0), slashes.end(0)]
+          end
+        end
+
+        def safe_to_correct?(style, text, first_column)
+          return false unless processed_source.raw_source == processed_source.buffer.source
+          return true if style == :backslash
+
+          !text[...first_column].end_with?('\\')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Markdown
+      class HardTabs < Base
+        private
+
+        def investigate_document
+          allowed = cop_config['AllowedCodeLanguages'].map(&:downcase)
+          exempt = document.nodes(:codeblock).flat_map do |block|
+            next [] unless allowed.include?(block.options[:lang].to_s.split.first.to_s.downcase)
+
+            first = block.options.fetch(:code_start_line)
+            (first...(first + block.value.lines.length)).to_a
+          end.to_set
+          document.lines.each_with_index do |text, index|
+            number = index + 1
+            next if document.front_matter_line?(number) || exempt.include?(number)
+            next if document.code_line?(number) && !cop_config['CodeBlocks']
+
+            text.to_enum(:scan, /\t/).each do
+              position = Regexp.last_match.begin(0)
+              prose_offense(document.range(number, position, number, position + 1),
+                            message: 'Use spaces instead of hard tabs.')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class HeadingBlankLines < Base
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          heading_entries.each do |heading|
+            before = blank_count(heading[:line] - 1, -1)
+            after = blank_count(heading[:last_line] + 1, 1)
+            next unless before < cop_config.fetch('LinesAbove', 1) || after < cop_config.fetch('LinesBelow', 1)
+
+            prose_offense(heading_range(heading), message: 'Surround headings with the configured blank lines.')
+          end
+        end
+
+        private
+
+        def blank_count(number, direction)
+          count = 0
+          while number.between?(1, document.lines.length)
+            return Float::INFINITY if document.front_matter_line?(number) && direction.negative?
+            break unless heading_blank?(number)
+
+            count += 1
+            number += direction
+          end
+          number.between?(1, document.lines.length) ? count : Float::INFINITY
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class HeadingIncrement < Base
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          previous = nil
+          heading_entries.each do |heading|
+            if previous && heading[:level] > previous + 1
+              prose_offense(heading_range(heading), message: 'Increase heading levels by at most one.')
+            end
+            previous = heading[:level]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class HeadingIndentation < Base
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          parsed_lines = heading_entries.to_set { |heading| heading[:line] }
+          document.prose_lines.each do |text, number|
+            next unless text.match?(/\A[ \t]+\S/)
+            next unless parsed_lines.include?(number) || dedented_heading?(text, number)
+
+            prose_offense(document.line_range(number), message: 'Start headings without leading indentation.')
+          end
+        end
+
+        private
+
+        def dedented_heading?(text, number)
+          return false unless text.match?(/\A {1,3}\S/)
+
+          source = "#{text.lstrip}\n"
+          following = document.lines[number]
+          if following&.match?(/\A {0,3}(?:=+|-+)[ \t]*\z/) && !document.code_line?(number + 1)
+            source += "#{following.lstrip}\n"
+          end
+          root = RuboCop::Prose::Parser.parse(source).first
+          root.children.any? { |node| node.type == :header }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class HeadingPunctuation < Base
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          punctuation = cop_config.fetch('Punctuation', '.,;:!?')
+          heading_entries.each do |heading|
+            ending = heading[:text].rstrip[-1]
+            next unless ending && punctuation.include?(ending)
+
+            prose_offense(heading_range(heading), message: 'Do not end headings with configured punctuation.')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class HeadingStructure < Base
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          expected = cop_config.fetch('Headings', []).map do |heading|
+            match = /\A(\#{1,6}) (.*)\z/.match(heading)
+            raise ArgumentError, 'Headings must contain ATX outline strings such as "# Title".' unless match
+
+            [match[1].length, match[2]]
+          end
+          return if expected.empty?
+
+          headings = heading_entries
+          headings.each_with_index do |heading, index|
+            next if expected[index] == [heading[:level], heading[:text]]
+
+            prose_offense(heading_range(heading), message: 'Match the configured exact heading outline.')
+          end
+          return unless expected.length > headings.length
+
+          prose_offense(heading_end_range, message: 'Add the missing headings from the configured exact outline.')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/heading_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class HeadingStyle < Base
+        include RuboCop::Prose::HeadingRules
+
+        def investigate_document
+          headings = heading_entries
+          style = cop_config.fetch('EnforcedStyle', 'consistent')
+          style = headings.first&.fetch(:style) if style == 'consistent'
+          headings.each do |heading|
+            next if heading[:style] == style
+
+            prose_offense(heading_range(heading), message: "Use #{style} headings.")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/link_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ImageAltText < Base
+        MSG = 'Provide alternative text for the image.'
+
+        private
+
+        def investigate_document
+          scanner = document.link_rules
+          scanner.links.each do |link|
+            next unless link.image && scanner.resolved?(link) && scanner.display_text(link).empty?
+
+            prose_offense(scanner.link_range(link))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/link_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ImagePathSeparators < Base
+        extend AutoCorrector
+
+        MSG = 'Use forward slashes in local image destinations.'
+
+        private
+
+        def investigate_document
+          scanner = document.link_rules
+          reported = Set.new
+          scanner.links.each do |link|
+            scanner.image_path_separators(link).each do |position, ambiguous|
+              next unless reported.add?(position)
+
+              range = scanner.range(position, position + 1)
+              prose_offense(range) do |corrector|
+                corrector.replace(processed_range(range), '/') unless ambiguous
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/link_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class LinkFragment < Base
+        MSG = 'Link fragment does not identify a heading or HTML anchor in this document.'
+
+        private
+
+        def investigate_document
+          renderer = cop_config.fetch('Renderer', 'github')
+          raise ArgumentError, "Unknown anchor renderer: #{renderer}" unless %w[github gitlab
+                                                                                kramdown].include?(renderer)
+
+          scanner = document.link_rules
+          anchors = scanner.anchors(renderer, cop_config.fetch('AdditionalAnchors', []))
+          scanner.links.each do |link|
+            next if link.image || !scanner.resolved?(link)
+
+            target = scanner.destination(link)
+            next unless target&.start_with?('#')
+            next if target == '#' && cop_config.fetch('AllowEmptyFragment', true)
+
+            fragment = URI::DEFAULT_PARSER.unescape(target[1..])
+            next if anchors.include?(fragment)
+
+            prose_offense(scanner.link_range(link))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/link_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class LinkStyle < Base
+        MSG = 'Use an allowed %<kind>s style instead of %<style>s.'
+
+        private
+
+        def investigate_document
+          scanner = document.link_rules
+          scanner.links.each do |link|
+            next unless scanner.resolved?(link)
+
+            key = link.image ? 'AllowedImageStyles' : 'AllowedLinkStyles'
+            allowed = cop_config.fetch(key, %w[inline reference autolink])
+            next if allowed.include?(link.style) || (link.reference && allowed.include?('reference'))
+
+            prose_offense(scanner.link_range(link),
+                          message: format(MSG, kind: link.image ? 'image' : 'link', style: link.style))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/link_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class LinkTextSpacing < Base
+        extend AutoCorrector
+
+        MSG = 'Remove whitespace at the edges of link text.'
+
+        private
+
+        def investigate_document
+          scanner = document.link_rules
+          scanner.links.each do |link|
+            next if link.image || link.style == 'autolink' || !scanner.resolved?(link)
+            next if link.label == link.label.strip
+
+            original = scanner.label_range(link)
+            if link.label.strip.empty?
+              prose_offense(original)
+              next
+            end
+            prose_offense(original) do |corrector|
+              corrector.replace(processed_range(original), link.label.strip)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ListBlankLines < Base
+        extend AutoCorrector
+        include RuboCop::Prose::ListRules
+
+        private
+
+        def investigate_document
+          @insertions = Set.new
+          list_groups do |list, marks, parent|
+            next if parent
+
+            first = marks.first[:line]
+            last = node_last_line(list)
+            prefix = continuation_prefix(document.line(first)[0...marks.first[:column]])
+            add_boundary(first, prefix) unless container_blank?(first - 1) || document.front_matter_line?(first - 1)
+            add_boundary(last + 1, prefix) unless container_blank?(last + 1)
+          end
+        end
+
+        def add_boundary(number, prefix)
+          return unless @insertions.add?(number)
+
+          range = document.line_range(number)
+          prose_offense(range, message: 'Surround lists with blank lines.') do |corrector|
+            corrector.insert_before(processed_range(range), "#{prefix.rstrip}\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ListContinuationIndentation < Base
+        include RuboCop::Prose::ListRules
+
+        private
+
+        def investigate_document
+          list_groups do |_list, marks, _parent|
+            marks.each do |mark|
+              item_paragraphs(mark[:item]).each do |paragraph|
+                investigate_continuations(mark, paragraph)
+              end
+            end
+          end
+        end
+
+        def item_paragraphs(node)
+          return [] if %i[ul ol].include?(node.type)
+          return [node] if node.type == :p && node.options[:prose_source]
+
+          node.children.flat_map { |child| item_paragraphs(child) }
+        end
+
+        def investigate_continuations(mark, paragraph)
+          lines = document.line_numbers(paragraph).to_a
+          return if lines.length < 2
+
+          first_line = lines.first
+          expected = [mark[:content_column], paragraph_content_column(paragraph, first_line)].max
+          lines.drop(1).each do |number|
+            next if multiline_atom_line?(number)
+
+            actual = paragraph_content_column(paragraph, number)
+            next unless actual < expected
+            next if document.line(number)[actual..].empty?
+
+            range = document.range(number, actual, number, actual + 1)
+            prose_offense(range, message: "Indent list continuation text to column #{expected}.")
+          end
+        end
+
+        def paragraph_content_column(paragraph, number)
+          source_line = paragraph.options[:prose_source].split("\n", -1).fetch(number - paragraph.options[:location])
+          document.content_start(paragraph, number) + source_line[/\A[ \t]*/].length
+        end
+
+        def multiline_atom_line?(number)
+          document.multiline_atoms.any? { |atom| number.between?(atom.line, atom.last_line) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ListIndentation < Base
+        include RuboCop::Prose::ListRules
+
+        private
+
+        def investigate_document
+          list_groups do |_list, marks, _parent|
+            expected = marks.first[:indent]
+            marks.drop(1).each do |mark|
+              next if mark[:indent] == expected
+
+              prose_offense(document.range(mark[:line], mark[:column], mark[:line],
+                                           mark[:column] + mark[:marker].length),
+                            message: "Align sibling list markers at indentation #{expected}.")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ListMarkerSpacing < Base
+        extend AutoCorrector
+        include RuboCop::Prose::ListRules
+
+        private
+
+        def investigate_document
+          list_groups do |list, marks, _parent|
+            multiline = marks.any? { |mark| node_last_line(mark[:item]) > mark[:line] }
+            key = "#{list.type == :ul ? 'Unordered' : 'Ordered'}#{multiline ? 'Multi' : 'Single'}"
+            spaces = cop_config.fetch(key, 1)
+            marks.each do |mark|
+              next if mark[:gap].empty? || mark[:gap] == ' ' * spaces
+
+              first = mark[:column] + mark[:marker].length
+              range = document.range(mark[:line], first, mark[:line], mark[:content_column])
+              prose_offense(range, message: "Use #{spaces} spaces after this list marker.") do |corrector|
+                next unless spacing_correction_safe?(mark, spaces)
+
+                corrector.replace(processed_range(range), ' ' * spaces)
+              end
+            end
+          end
+        end
+
+        def spacing_correction_safe?(mark, spaces)
+          item = mark[:item]
+          return false unless node_last_line(item) == mark[:line]
+          return false unless item.children.all? { |child| child.type == :p }
+
+          content = document.line(mark[:line])[mark[:content_column]..]
+          spaces.between?(1, 4) && !content.match?(/\A(?:[-+*]|\d+[.)]|>|`{3,}|~{3,}| {4})/)
+        end
+      end
+    end
+  end
+end