rubocop-prose 0.1.0

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/structural_blank_lines'
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Prose
+      class MultipleBlankLines < Base
+        extend AutoCorrector
+        include RuboCop::Prose::ListRules
+
+        def validate_config
+          value = cop_config['Max']
+          return if value.is_a?(Integer) && value >= 0
+
+          raise ValidationError, 'Prose/MultipleBlankLines: Max must be a non-negative integer.'
+        end
+
+        private
+
+        def investigate_document
+          consecutive = 0
+          sequence = nil
+          quote_blank_lines = markdown_quote_blank_lines
+          source_lines = document.source.lines
+          protected_lines = structural_blank_lines
+          document.lines.each_with_index do |text, index|
+            number = index + 1
+            quote = quote_blank_lines[number]
+            blank = quote || (text.strip.empty? && :root)
+            if document.ignored_line?(number) || !blank
+              consecutive = 0
+              sequence = nil
+              next
+            end
+            if sequence != blank
+              consecutive = 0
+              sequence = blank
+            end
+            consecutive += 1
+            next if consecutive <= cop_config['Max'] || protected_lines.include?(number)
+
+            first = document.buffer.line_range(number).begin_pos
+            removal = ::Parser::Source::Range.new(document.buffer, first, first + source_lines.fetch(index).length)
+            prose_offense(document.line_range(number), message: 'Too many consecutive blank lines.') do |corrector|
+              corrector.remove(processed_range(removal)) if cop_config['Max'].positive?
+            end
+          end
+        end
+
+        def structural_blank_lines
+          return Set.new unless processed_source.prose_format == :markdown
+
+          RuboCop::Prose::StructuralBlankLines.new(document, config, processed_source).protected_lines
+        end
+
+        def markdown_quote_blank_lines
+          return {} unless document.is_a?(RuboCop::Prose::MarkdownDocument)
+
+          quote_blank_lines_in(document.root, nil, 0, {})
+        end
+
+        def quote_blank_lines_in(node, quote, depth, lines)
+          if node.type == :blockquote
+            quote = node
+            depth += 1
+          end
+
+          if quote
+            node.children.each_with_index do |child, index|
+              next unless child.type == :blank
+
+              previous = node.children[0...index].reverse.find { |sibling| sibling.type != :blank }
+              following = node.children[(index + 1)..].find { |sibling| sibling.type != :blank }
+              next unless previous && following && following.options[:location]
+
+              ((node_last_line(previous) + 1)...following.options[:location]).each do |number|
+                lines[number] = quote if quoted_blank_line?(number, depth)
+              end
+            end
+          end
+
+          node.children.each { |child| quote_blank_lines_in(child, quote, depth, lines) }
+          lines
+        end
+
+        def quoted_blank_line?(number, depth)
+          text = document.line(number)
+          prefix = text[/\A[ \t]*(?:>[ \t]*)+/]
+          prefix && prefix.count('>') == depth && text[prefix.length..].strip.empty?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Prose
+      class TrailingNewline < Base
+        extend AutoCorrector
+
+        private
+
+        def investigate_document
+          source = document.source
+          return if source.empty?
+
+          suffix = source.match(/\n*\z/)
+          return if suffix[0] == "\n"
+
+          range = ::Parser::Source::Range.new(document.buffer, suffix.begin(0), source.length)
+          prose_offense(range, message: 'End the document with exactly one newline.') do |corrector|
+            corrector.replace(processed_range(range), "\n")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Text
+      class Base < Prose::Base
+        exclude_from_registry
+
+        private
+
+        def applicable_document?
+          processed_source.prose_format == :text
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Text
+      class TrailingWhitespace < Base
+        extend AutoCorrector
+
+        private
+
+        def investigate_document
+          document.lines.each_with_index do |text, index|
+            match = text.match(/[ \t]+\z/)
+            next unless match
+
+            range = document.range(index + 1, match.begin(0))
+            prose_offense(range, message: 'Remove trailing whitespace.') do |corrector|
+              corrector.remove(processed_range(range))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/prose/code_rules.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    module CodeRules
+      def code_blocks
+        document.nodes(:codeblock)
+      end
+
+      def fenced_blocks(list_items: true)
+        return enum_for(__method__, list_items: list_items) unless block_given?
+
+        code_blocks.each do |node|
+          next if !list_items && code_ancestors(node).any? { |ancestor| ancestor.type == :li }
+
+          details = fence_details(node)
+          yield details if details
+        end
+      end
+
+      def code_ancestors(target, node = document.root, parents = [])
+        return parents if node.equal?(target)
+
+        node.children.each do |child|
+          found = code_ancestors(target, child, parents + [node])
+          return found if found
+        end
+        nil
+      end
+
+      def fence_details(node)
+        return unless node.options[:fenced]
+
+        first = node.options[:location]
+        opening = fence_match(document.line(first))
+        return unless opening
+
+        last = node.options.fetch(:code_start_line) + node.value.lines.length
+        return if last > document.lines.length
+
+        closing = fence_match(document.line(last))
+        return unless closing && closing[:fence][0] == opening[:fence][0] &&
+                      closing[:fence].length >= opening[:fence].length && closing[:info].strip.empty?
+
+        { first: first, last: last, opening: opening, closing: closing }
+      end
+
+      def fence_match(text)
+        /
+          \A(?<prefix>(?:[ \t]*>[ \t]?|[ \t]*[-+*][ \t]+|[ \t]*\d+[.)][ \t]+|[ \t]+)*)
+          (?<fence>`{3,}|~{3,})(?<info>.*)\z
+        /x.match(text)
+      end
+
+      def fence_range(number, match)
+        document.range(number, match.begin(:fence), number, match.end(:fence))
+      end
+
+      def code_blank?(number)
+        number < 1 || number > document.lines.length ||
+          document.line(number).match?(/\A[ \t]*(?:>[ \t]*)*\z/)
+      end
+
+      def code_continuation_prefix(prefix)
+        prefix.gsub(/[-+*]|\d+[.)]/) { |marker| ' ' * marker.length }
+      end
+
+      def code_content_range(node, index, length)
+        number = node.options.fetch(:code_start_line) + index
+        content = node.value.lines[index].chomp
+        raw = document.line(number)
+        return unless raw.end_with?(content)
+
+        first = raw.length - content.length
+        document.range(number, first, number, first + length)
+      end
+    end
+  end
+end

data/lib/rubocop/prose/document.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    class Document
+      attr_reader :buffer, :lines
+
+      def self.format(path, configuration = nil)
+        (configuration ? configuration.prose_file_types : FileTypes.default).format(path)
+      end
+
+      def self.file?(path, configuration = nil)
+        !format(path, configuration).nil?
+      end
+
+      def self.build(path, buffer, configuration: nil, format: self.format(path, configuration))
+        case format
+        when :markdown then MarkdownDocument.new(buffer, configuration: configuration || {})
+        when :text then TextDocument.new(buffer)
+        else raise ArgumentError, "Unsupported prose document: #{path.inspect}"
+        end
+      end
+
+      def initialize(buffer)
+        @buffer = buffer
+        @lines = source.lines(chomp: true)
+      end
+
+      def source
+        buffer.source
+      end
+
+      def line(number)
+        lines.fetch(number - 1)
+      end
+
+      def range(first_line, first_column = 0, last_line = first_line, last_column = nil)
+        last_column ||= line(last_line).length
+        ::Parser::Source::Range.new(
+          buffer, buffer.line_range(first_line).begin_pos + first_column,
+          buffer.line_range(last_line).begin_pos + last_column
+        )
+      end
+
+      def line_range(number)
+        range(number)
+      end
+
+      def ignored_line?(_number)
+        false
+      end
+
+      def reflowable?(_paragraph)
+        true
+      end
+
+      def breakable_space?(_text, _first, _last)
+        true
+      end
+    end
+  end
+end

data/lib/rubocop/prose/file_types.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    class FileTypes
+      attr_reader :patterns
+
+      def self.default
+        @default ||= new(Prose.default_configuration)
+      end
+
+      def initialize(configuration)
+        @patterns = %i[markdown text].to_h do |format|
+          name = format.to_s.capitalize
+          settings = configuration.fetch(name, {})
+          raise ValidationError, "#{name} must be a mapping." unless settings.is_a?(Hash)
+
+          values = settings.fetch('Include') { self.class.default.patterns.fetch(format) }
+          [format, validate(name, values)]
+        end.freeze
+        loaded_path = configuration.loaded_path if configuration.respond_to?(:loaded_path)
+        @matchers = patterns.transform_values do |values|
+          RuboCop::Config.new({ 'AllCops' => { 'Include' => values } }, loaded_path)
+        end
+      end
+
+      def format(path)
+        return unless path
+
+        matches = @matchers.select { |_, matcher| matcher.file_to_include?(path.to_s) }.keys
+        raise ValidationError, "#{path.inspect} matches both Markdown/Include and Text/Include." if matches.length > 1
+
+        matches.first
+      end
+
+      private
+
+      def validate(name, values)
+        valid = values.is_a?(Array) && values.all? do |value|
+          value.is_a?(Regexp) || (value.is_a?(String) && !value.empty?)
+        end
+        raise ValidationError, "#{name}/Include must be an array of nonempty file patterns." unless valid
+
+        values.map { |value| value.dup.freeze }.uniq.freeze
+      end
+    end
+
+    module Configuration
+      def prose_file_types
+        @prose_file_types ||= FileTypes.new(self)
+      end
+    end
+  end
+end
+
+RuboCop::Config.prepend(RuboCop::Prose::Configuration)

data/lib/rubocop/prose/heading_rules.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    module HeadingRules
+      # Container markers are retained so source columns refer to the original line.
+      ATX = /\A(?<prefix>(?: {0,3}>[ \t]?| {0,3}(?:[-+*]|\d+[.)])[ \t]+)* {0,3})(?<marks>\#{1,6})(?!#)(?<rest>.*)\z/
+
+      def heading_entries
+        document.nodes(:header).map do |node|
+          number = node.options.fetch(:location)
+          text = document.line(number)
+          opening = ATX.match(text)
+          closing = opening && closing_heading_match(opening[:rest])
+          {
+            level: node.options.fetch(:level), text: document.plain_text(node), line: number,
+            last_line: opening ? number : number + 1, opening: opening, closing: closing,
+            style: if opening
+                     closing ? 'atx_closed' : 'atx'
+                   else
+                     'setext'
+                   end
+          }
+        end
+      end
+
+      def closing_heading_match(rest)
+        match = /(?<space>[ \t]+)(?<marks>#+)[ \t]*\z/.match(rest)
+        return match if match
+
+        /\A(?<space>)(?<marks>#+)[ \t]*\z/.match(rest)
+      end
+
+      def heading_candidates
+        document.prose_lines.filter_map do |text, number|
+          match = ATX.match(text)
+          [match, number] if match
+        end
+      end
+
+      def heading_range(entry)
+        document.line_range(entry.fetch(:line))
+      end
+
+      def heading_blank?(number)
+        document.line(number).match?(/\A(?: {0,3}>[ \t]?)*[ \t]*\z/)
+      end
+
+      def heading_end_range
+        ::Parser::Source::Range.new(document.buffer, document.source.length, document.source.length)
+      end
+    end
+  end
+end

data/lib/rubocop/prose/inline_rules.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    # Source positions are character offsets, like Document#range.
+    module InlineRules
+      Span = Struct.new(:begin_pos, :end_pos, :kind, :delimiter, keyword_init: true)
+
+      class PositionedParser < Parser
+        protected
+
+        def parse_emphasis
+          scanner = @src
+          parent = @tree
+          count = parent.children.length
+          first = scanner.pos
+          number = scanner.current_line_number
+          super
+          node = parent.children.last
+          return unless parent.children.length > count && %i[em strong].include?(node.type)
+
+          node.options[:prose_delimiters] = [scanner.string, first, scanner.pos, number]
+        end
+      end
+
+      def self.lines(document)
+        found = {}
+        document.paragraphs.each do |paragraph|
+          document.line_numbers(paragraph).each do |number|
+            found[number] = document.content_start(paragraph, number)
+          end
+        end
+        document.nodes(:header).each { |node| found[node.options[:location]] = 0 }
+        document.nodes(:table).each do |node|
+          number = node.options[:location]
+          while number <= document.lines.length && !document.line(number).strip.empty?
+            found[number] = 0
+            number += 1
+          end
+        end
+        found.sort.filter_map do |number, column|
+          next if document.code_line?(number) || document.front_matter_line?(number)
+
+          [document.line(number), number, column]
+        end
+      end
+
+      def self.escaped?(text, index)
+        count = 0
+        index -= 1
+        while index >= 0 && text[index] == '\\'
+          count += 1
+          index -= 1
+        end
+        count.odd?
+      end
+
+      def self.spans(text, links: true, html: true)
+        result = []
+        index = 0
+        while index < text.length
+          if text[index] == '\\' && text[index + 1]&.match?(/[[:punct:]]/)
+            result << Span.new(begin_pos: index, end_pos: [index + 2, text.length].min, kind: :escape)
+            index += 2
+            next
+          end
+          if text[index] == '`'
+            delimiter = text[index..][/\A`+/]
+            finish = index + delimiter.length
+            closed = false
+            while (match = /`+/.match(text, finish))
+              if match[0] == delimiter
+                result << Span.new(begin_pos: index, end_pos: match.end(0), kind: :code, delimiter: delimiter)
+                index = match.end(0)
+                closed = true
+                break
+              end
+              finish = match.end(0)
+            end
+            next if closed
+
+            index += delimiter.length
+            next
+          elsif html && text[index] == '<'
+            rest = text[index..]
+            html = %r{\A<([A-Za-z][\w:-]*)\b[^>]*>.*?</\1\s*>}i.match(rest) ||
+                   /\A(?:<!--.*?-->|<[^>]+>)/.match(rest)
+            if html
+              result << Span.new(begin_pos: index, end_pos: index + html[0].length, kind: :html)
+              index += html[0].length
+              next
+            end
+          elsif links && (text[index] == '[' || (text[index] == '!' && text[index + 1] == '['))
+            finish = link_end(text, index)
+            if finish
+              result << Span.new(begin_pos: index, end_pos: finish, kind: :link)
+              index = finish
+              next
+            end
+          end
+          index += 1
+        end
+        result
+      end
+
+      def self.link_end(text, index)
+        index += 1 if text[index] == '!'
+        close = balanced_end(text, index, '[', ']')
+        return unless close
+        return balanced_end(text, close, '(', ')') if text[close] == '('
+        return balanced_end(text, close, '[', ']') if text[close] == '['
+
+        # A shortcut reference may resolve elsewhere in the document.
+        close
+      end
+
+      def self.balanced_end(text, index, opening, closing)
+        depth = 0
+        (index...text.length).each do |position|
+          next if escaped?(text, position)
+
+          depth += 1 if text[position] == opening
+          depth -= 1 if text[position] == closing
+          return position + 1 if depth.zero?
+        end
+        nil
+      end
+
+      def self.multiline_atoms(document)
+        document.multiline_atoms
+      end
+
+      def self.mask(text, include_code: false, document: nil, number: nil)
+        result = text.dup
+        spans(text).each do |span|
+          next if include_code && span.kind == :code
+
+          result[span.begin_pos...span.end_pos] = ' ' * (span.end_pos - span.begin_pos)
+        end
+        if document
+          line = document.line_range(number)
+          multiline_atoms(document).each do |range|
+            next if include_code && range.source.start_with?('`')
+            next unless range.overlaps?(line)
+
+            first = [range.begin_pos, line.begin_pos].max - line.begin_pos
+            last = [range.end_pos, line.end_pos].min - line.begin_pos
+            result[first...last] = ' ' * (last - first)
+          end
+        end
+        result
+      end
+
+      def self.emphasis(document)
+        source = document.source.dup
+        document.lines.each_with_index do |_, index|
+          next unless document.front_matter_line?(index + 1)
+
+          range = document.buffer.line_range(index + 1)
+          source[range.begin_pos...range.end_pos] = ' ' * range.size
+        end
+        root = PositionedParser.parse(source, hard_wrap: false, gfm_quirks: %i[paragraph_end no_auto_typographic]).first
+        nodes = lambda do |node|
+          [node] + (node.type == :table ? [] : node.children.flat_map { |child| nodes.call(child) })
+        end
+        records = nodes.call(root).map { |node| [node, 0, nil] }
+        document.nodes(:table).each do |table|
+          number = table.options[:location]
+          while number <= document.lines.length && !document.line(number).strip.empty?
+            # Cell locations are not document-relative; parsing the row as inline prose
+            # recovers offsets without changing the table parser or its AST.
+            row = PositionedParser.parse("prose #{document.line(number).tr('|', ';')}",
+                                         hard_wrap: false, gfm_quirks: %i[paragraph_end no_auto_typographic]).first
+            records.concat(nodes.call(row).map { |node| [node, number - 1, -6] })
+            number += 1
+          end
+        end
+        ranges = { em: [], strong: [] }
+        records.each do |node, line_offset, column_offset|
+          next unless ranges.key?(node.type) && node.options[:prose_delimiters]
+
+          text, first, last, number = node.options[:prose_delimiters]
+          next unless number
+
+          number += line_offset
+          before = text.byteslice(0, first)
+          through = text.byteslice(0, last)
+          local_line = before.count("\n")
+          last_number = number + through.count("\n") - local_line
+          first_text = text.lines(chomp: true)[local_line]
+          last_text = text.lines(chomp: true)[through.count("\n")]
+          first_prefix = column_offset || document.line(number).rindex(first_text)
+          last_prefix = column_offset || document.line(last_number).rindex(last_text)
+          next unless first_prefix && last_prefix
+
+          column = first_prefix + before.rpartition("\n").last.length
+          last_column = last_prefix + through.rpartition("\n").last.length
+          next if spans(document.line(number)).any? { |span| span.begin_pos <= column && span.end_pos > column }
+
+          position = document.range(number, column, number, column + 1)
+          next if multiline_atoms(document).any? { |range| range.contains?(position) }
+
+          width = node.type == :strong ? 2 : 1
+          ranges.fetch(node.type) << [
+            document.range(number, column, number, column + width),
+            document.range(last_number, last_column - width, last_number, last_column), node.options[:char]
+          ]
+        end
+        ranges.transform_values { |entries| entries.sort_by { |opening, _, _| opening.begin_pos } }
+      end
+    end
+  end
+end