rubocop-prose 0.1.0

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/table_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class TableSpacing < Base
+        extend AutoCorrector
+
+        def investigate_document
+          RuboCop::Prose::TableRules.tables(document).each do |table|
+            style = cop_config.fetch('Style', 'aligned')
+            widths = table.rows.each_with_object({}) do |row, sizes|
+              row.cells.each_with_index do |cell, index|
+                sizes[index] = [sizes.fetch(index, 0), cell.text.strip.length].max
+              end
+            end
+            table.rows.each do |row|
+              row.cells.each_with_index do |cell, index|
+                content = cell.text.strip
+                left = row.leading || index.positive?
+                right = row.trailing || index < row.cells.length - 1
+                if content.empty?
+                  padding = case style
+                            when 'tight' then ''
+                            when 'aligned' then ' ' * (widths[index] + (left ? 1 : 0) + (right ? 1 : 0))
+                            else ' '
+                            end
+                  next if cell.text == padding
+
+                  range = document.range(row.number, cell.begin_pos, row.number, cell.end_pos)
+                  prose_offense(range, message: "Use #{style} table cell spacing.") do |corrector|
+                    corrector.replace(processed_range(range), padding)
+                  end
+                  next
+                end
+
+                before = cell.text[/\A[ \t]*/]
+                after = cell.text[/[ \t]*\z/]
+                expected_before = left ? ' ' : ''
+                padding = style == 'aligned' ? widths[index] - content.length + 1 : 1
+                expected_after = right ? ' ' * padding : ''
+                valid = case style
+                        when 'tight' then before.empty? && after.empty?
+                        else before == expected_before && after == expected_after
+                        end
+                next if valid
+
+                replacement = style == 'tight' ? content : "#{expected_before}#{content}#{expected_after}"
+                range = document.range(row.number, cell.begin_pos, row.number, cell.end_pos)
+                prose_offense(range, message: "Use #{style} table cell spacing.") do |corrector|
+                  corrector.replace(processed_range(range), replacement)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ThematicBreakBlankLines < Base
+        extend AutoCorrector
+        include RuboCop::Prose::ListRules
+
+        THEMATIC_BREAK = /(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,}/
+
+        def validate_config
+          %w[LinesAbove LinesBelow].each do |name|
+            next unless cop_config.key?(name)
+
+            value = cop_config[name]
+            next if value.is_a?(Integer) && value >= 0
+
+            raise ValidationError, "Markdown/ThematicBreakBlankLines: #{name} must be a nonnegative integer."
+          end
+        end
+
+        private
+
+        def investigate_document
+          @insertions = {}
+          document.nodes(:hr).each do |node|
+            number = node.options.fetch(:location)
+            next if document.front_matter_line?(number)
+
+            marker = THEMATIC_BREAK.match(document.line(number))
+            next unless marker
+
+            ancestors = node_path(node)
+            prefix = document.line(number)[0...marker.begin(0)]
+            in_list = ancestors.any? { |ancestor| ancestor.type == :li }
+            prefix = if in_list
+                       continuation_prefix(prefix)
+                     else
+                       prefix.rstrip
+                     end
+            range = document.line_range(number)
+            require_blanks(number - 1, -1, prefix, cop_config.fetch('LinesAbove', 1), range)
+            require_blanks(number + 1, 1, prefix, cop_config.fetch('LinesBelow', 1), range)
+          end
+
+          @insertions.values.group_by { |insertion| insertion[:offense_range] }.each do |offense_range, insertions|
+            if insertions.all? { |insertion| insertion[:safe] }
+              prose_offense(offense_range, message: 'Surround thematic breaks with blank lines.') do |corrector|
+                insertions.each do |insertion|
+                  range = document.line_range(insertion[:line])
+                  corrector.insert_before(processed_range(range), "#{insertion[:prefix]}#{newline}" * insertion[:count])
+                end
+              end
+            else
+              prose_offense(offense_range, message: 'Surround thematic breaks with blank lines.')
+            end
+          end
+        end
+
+        def require_blanks(number, direction, prefix, required, offense_range)
+          return if required.zero?
+
+          existing = blank_count(number, direction, prefix)
+          missing = required - existing
+          return unless missing.positive?
+
+          insertion_line = direction.negative? ? number - existing + 1 : number
+          insertion = @insertions[insertion_line] ||= {
+            line: insertion_line, prefix: prefix, count: 0, offense_range: offense_range, safe: true
+          }
+          insertion[:count] = [insertion[:count], missing].max
+          insertion[:safe] = false unless prefix == insertion[:prefix]
+        end
+
+        def blank_count(number, direction, prefix)
+          count = 0
+          while number.between?(1, document.lines.length)
+            return Float::INFINITY if direction.negative? && document.front_matter_line?(number)
+            break unless blank_line?(number, prefix)
+
+            count += 1
+            number += direction
+          end
+          number.between?(1, document.lines.length) ? count : Float::INFINITY
+        end
+
+        def blank_line?(number, prefix)
+          text = document.line(number)
+          return text.match?(/\A[ \t]*\z/) if prefix.empty?
+
+          pattern = /\A#{Regexp.escape(prefix)}[ \t]*\z/
+          text.match?(pattern)
+        end
+
+        def node_path(target, node = document.root, path = [])
+          current_path = path + [node]
+          return current_path if node.equal?(target)
+
+          node.children.each do |child|
+            found = node_path(target, child, current_path)
+            return found if found
+          end
+          []
+        end
+
+        def newline
+          document.source.include?("\r\n") ? "\r\n" : "\n"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ThematicBreakStyle < Base
+        extend AutoCorrector
+
+        def investigate_document
+          style = cop_config.fetch('Style', 'consistent')
+          styles = configured_styles(style)
+          consistent = style == 'consistent'
+          expected = nil
+
+          document.nodes(:hr).each do |node|
+            number = node.options[:location]
+            next if document.front_matter_line?(number)
+
+            text = document.line(number)
+            match = /(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,}/.match(text)
+            next unless match
+
+            actual = match[0].rstrip
+            expected ||= actual if consistent
+            next if consistent ? actual == expected : styles.include?(actual)
+
+            range = document.range(number, match.begin(0), number, match.begin(0) + actual.length)
+            replacement = if consistent
+                            expected
+                          elsif styles.one?
+                            styles.first
+                          end
+            message = if consistent || styles.one?
+                        "Use `#{replacement}` for thematic breaks."
+                      else
+                        "Use one of #{styles.map { |value| "`#{value}`" }.join(' or ')} for thematic breaks."
+                      end
+            if replacement
+              prose_offense(range, message: message) do |corrector|
+                corrector.replace(processed_range(range), replacement)
+              end
+            else
+              prose_offense(range, message: message)
+            end
+          end
+        end
+
+        private
+
+        def configured_styles(style)
+          return [] if style == 'consistent'
+
+          styles = style.is_a?(Array) ? style : [style]
+          valid = !styles.empty? && styles.all? do |value|
+            value.is_a?(String) && thematic_break?(value)
+          end
+          unless valid
+            raise ValidationError, [
+              'Markdown/ThematicBreakStyle: Style must be `consistent`,',
+              'a literal break, or a nonempty array of valid breaks.'
+            ].join(' ')
+          end
+
+          styles.uniq
+        end
+
+        def thematic_break?(value)
+          match = /\A(?:(?:\*[ \t]*){3,}|(?:-[ \t]*){3,}|(?:_[ \t]*){3,})\z/.match(value)
+          match && match[0].rstrip == value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Markdown
+      class TrailingWhitespace < Base
+        extend AutoCorrector
+
+        MSG = 'Remove unexpected trailing whitespace; preserve Markdown hard breaks.'
+
+        def validate_config
+          value = cop_config['HardBreakSpaces']
+          return if value.is_a?(Integer) && value >= 2
+
+          raise ValidationError, 'Markdown/TrailingWhitespace: HardBreakSpaces must be an integer of at least two.'
+        end
+
+        private
+
+        def investigate_document
+          paragraphs = document.paragraphs.flat_map { |paragraph| document.line_numbers(paragraph).to_a }.to_set
+          hard_break_lines = document.hard_breaks.to_set { |node| node.options[:location] }
+          document.lines.each_with_index do |text, index|
+            number = index + 1
+            next if document.front_matter_line?(number)
+            next if document.code_line?(number) && !cop_config['CodeBlocks']
+
+            match = text.match(/[ \t]+\z/)
+            next unless match
+
+            spaces = text[/ +\z/].to_s.length
+            hard_break = !text.strip.empty? && paragraphs.include?(number) && spaces >= 2
+            style = hard_break_style
+            handled_by_style = hard_break_lines.include?(number) && hard_break &&
+                               style && (style['Style'] == 'backslash' || text[0...-spaces].end_with?('\\'))
+            next if handled_by_style
+
+            keep = hard_break ? ' ' * cop_config['HardBreakSpaces'] : ''
+            next if match[0] == keep
+
+            range = document.range(number, match.begin(0))
+            prose_offense(range) do |corrector|
+              corrector.replace(processed_range(range), keep) unless document.code_line?(number)
+            end
+          end
+        end
+
+        def hard_break_style
+          style = config.for_cop('Markdown/HardBreakStyle')
+          style if style && style['Enabled']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Markdown
+      class UnclosedFencedCodeBlock < Base
+        private
+
+        def investigate_document
+          opening = nil
+          document.lines.each_with_index do |line, index|
+            number = index + 1
+            next if document.front_matter_line?(number)
+
+            match = fence_line(line)
+            next unless match
+
+            if opening
+              opening = nil if closing_fence?(match, opening)
+            elsif opening_fence?(match)
+              opening = match.merge(line: number)
+            end
+          end
+          report_unclosed(opening) if opening
+        end
+
+        def fence_line(line)
+          index = 0
+          quote_depth = 0
+          list_indent = 0
+          loop do
+            start = index
+            index += line[index..].to_s[/\A {0,3}/].length
+            if line[index] == '>'
+              quote_depth += 1
+              index += 1
+              index += 1 if [' ', "\t"].include?(line[index])
+            elsif (list = /\A([-+*]|\d{1,9}[.)])([ \t]+)/.match(line[index..].to_s)) && list[2].length <= 4
+              list_indent += index - start + list[1].length + list[2].length
+              index += list[0].length
+            else
+              index = start
+              break
+            end
+          end
+
+          indent = line[index..].to_s[/\A {0,3}/].length
+          index += indent
+          fence = /\A(?<fence>`{3,}|~{3,})(?<info>.*)\z/.match(line[index..].to_s)
+          return unless fence
+
+          { column: index, fence: fence[:fence], info: fence[:info],
+            quote_depth: quote_depth, list_indent: list_indent, indent: indent }
+        end
+
+        def opening_fence?(match)
+          match[:fence][0] != '`' || !match[:info].include?('`')
+        end
+
+        def closing_fence?(match, opening)
+          indent = match[:list_indent] + match[:indent]
+          container_matches = if opening[:list_indent].zero?
+                                match[:list_indent].zero? && indent <= 3
+                              else
+                                indent.between?(opening[:list_indent], opening[:list_indent] + 3)
+                              end
+          match[:fence][0] == opening[:fence][0] &&
+            match[:fence].length >= opening[:fence].length &&
+            match[:info].match?(/\A[ \t]*\z/) &&
+            match[:quote_depth] == opening[:quote_depth] &&
+            container_matches
+        end
+
+        def report_unclosed(opening)
+          range = document.range(opening[:line], opening[:column],
+                                 opening[:line], opening[:column] + opening[:fence].length)
+          prose_offense(range, message: 'Close this fenced code block explicitly before end of file.')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/link_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class UndefinedReference < Base
+        MSG = 'Define the link or image reference.'
+
+        private
+
+        def investigate_document
+          scanner = document.link_rules
+          scanner.links.each do |link|
+            next unless link.reference && !scanner.resolved?(link)
+            next if link.style == 'shortcut_reference' && !cop_config.fetch('ShortcutSyntax', false)
+
+            prose_offense(scanner.link_range(link))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class UnorderedListIndentation < Base
+        include RuboCop::Prose::ListRules
+
+        private
+
+        def investigate_document
+          width = cop_config.fetch('Indent', 2)
+          list_groups do |list, marks, parent|
+            next unless list.type == :ul
+
+            expected = expected_indentation(parent, marks.first, width)
+            marks.each do |mark|
+              next if mark[:indent] == expected
+
+              prose_offense(document.range(mark[:line], mark[:column], mark[:line], mark[:column] + 1),
+                            message: "Use #{expected} spaces of unordered list indentation.")
+            end
+          end
+        end
+
+        def expected_indentation(parent, mark, width)
+          return 0 unless parent && parent[:quote_depth] == mark[:quote_depth]
+
+          width = [width, parent[:content_column] - parent[:column]].max if parent[:marker].length > 1
+          parent[:indent] + width
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class UnorderedListMarker < Base
+        extend AutoCorrector
+        include RuboCop::Prose::ListRules
+
+        private
+
+        def investigate_document
+          style = cop_config.fetch('EnforcedStyle', 'consistent')
+          expected = { 'asterisk' => '*', 'plus' => '+', 'dash' => '-' }[style]
+          changes = []
+          list_groups do |list, marks, _parent|
+            next unless list.type == :ul
+
+            expected ||= marks.first[:marker]
+            marks.each do |mark|
+              next if mark[:marker] == expected
+
+              changes << [mark, expected]
+            end
+          end
+          candidates = changes.group_by { |mark, _target| mark[:line] }.transform_values do |entries|
+            text = document.line(entries.first.first[:line]).dup
+            entries.each { |mark, target| text[mark[:column]] = target }
+            text
+          end
+          changes.each do |mark, target|
+            range = document.range(mark[:line], mark[:column], mark[:line], mark[:column] + 1)
+            prose_offense(range, message: "Use `#{target}` for unordered list markers.") do |corrector|
+              next if candidates.fetch(mark[:line]).match?(/(?:\A|[> \t])([*-])(?:[ \t]*\1){2,}[ \t]*\z/)
+
+              corrector.replace(processed_range(range), target)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/prose/base.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Prose
+      class Base < RuboCop::Cop::Base
+        exclude_from_registry
+
+        def on_new_investigation
+          super
+          @document = nil
+          investigate_document if applicable_document?
+        end
+
+        def on_other_file
+          on_new_investigation
+        end
+
+        def current_corrector
+          return super unless processed_source.prose_format
+
+          @current_corrector ||= Corrector.new(processed_source)
+        end
+
+        private
+
+        def applicable_document?
+          !processed_source.prose_format.nil?
+        end
+
+        def document
+          @document ||= processed_source.prose_document(configuration: config)
+        end
+
+        def investigate_document
+          document.paragraphs.each { |paragraph| investigate_paragraph(paragraph) }
+        end
+
+        def range_for_original(range)
+          mapping = processed_source.prose_markdown_document
+          mapping ? mapping.original_range(range) : range
+        end
+
+        def processed_range(range)
+          mapping = processed_source.prose_markdown_document
+          mapping ? mapping.processed_range(range) : range
+        end
+
+        def prose_offense(range, **, &)
+          add_offense(processed_range(range), **, &)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/prose/max_length.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Prose
+      class MaxLength < Base
+        extend AutoCorrector
+
+        MSG = 'Prose line is too long. [%<length>d/%<max>d]'
+        UNWRAP_MSG = 'Keep paragraph text on a single source line.'
+
+        def validate_config
+          value = cop_config['Max']
+          return if value == false || (value.is_a?(Integer) && value.positive?)
+
+          raise ValidationError, 'Prose/MaxLength: Max must be a positive integer or false.'
+        end
+
+        private
+
+        def investigate_paragraph(paragraph)
+          return unwrap_paragraph(paragraph) if cop_config['Max'] == false
+
+          document.line_numbers(paragraph).each { |number| inspect_line(paragraph, number) }
+        end
+
+        def unwrap_paragraph(paragraph)
+          document.soft_breaks(paragraph).each do |number|
+            previous = document.line(number)
+            column = document.content_start(paragraph, number + 1)
+
+            join = document.range(number, previous.rstrip.length, number + 1, column)
+            offense = document.range(number + 1, column)
+            prose_offense(offense, message: UNWRAP_MSG) do |corrector|
+              corrector.replace(processed_range(join), ' ') if document.reflowable?(paragraph)
+            end
+          end
+        end
+
+        def inspect_line(paragraph, number)
+          text = document.line(number)
+          max = cop_config['Max']
+          return if text.length <= max
+
+          first = document.content_start(paragraph, number)
+          return if cop_config['IgnoreURLs'] && text[first..].strip.match?(%r{\A<?https?://\S+>?\z})
+
+          range = document.range(number, [first, max].max, number, text.length)
+          prefix = document.continuation_prefix(paragraph)
+          breaks = if document.reflowable?(paragraph)
+                     wrap_points(text, number, first, prefix, document.atomic_ranges(paragraph))
+                   else
+                     []
+                   end
+          prose_offense(range, message: format(MSG, length: text.length, max: max)) do |corrector|
+            breaks.each { |space| corrector.replace(processed_range(space), "\n#{prefix}") }
+          end
+        end
+
+        def wrap_points(text, number, first, prefix, atomic)
+          spaces = breakable_spaces(text, number, first, atomic)
+          breaks = []
+          start = 0
+          width = cop_config['Max']
+          while text.length - start > width
+            candidates = spaces.select { |space| space.column > start }
+            chosen = candidates.reverse.find { |space| space.column - start <= width }
+            chosen ||= candidates.first
+            break unless chosen
+
+            breaks << chosen
+            start = chosen.last_column
+            width = cop_config['Max'] - prefix.length
+          end
+          breaks
+        end
+
+        def breakable_spaces(text, number, first, atomic)
+          spaces = []
+          text.to_enum(:scan, /[ \t]+/).each do
+            match = Regexp.last_match
+            next if match.begin(0) <= first || match.end(0) == text.length
+            next unless document.breakable_space?(text, match.begin(0), match.end(0))
+
+            range = document.range(number, match.begin(0), number, match.end(0))
+            spaces << range unless atomic.any? { |protected| protected.overlaps?(range) }
+          end
+          spaces
+        end
+      end
+    end
+  end
+end