rubocop-prose 0.1.0

data/lib/rubocop/prose/markdown_document.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    class MarkdownDocument < Document
+      FRONT_MATTER = /\A(?:\uFEFF)?---[ \t]*\r?\n.*?^(?:---|\.\.\.)[ \t]*(?:\r?\n|\z)/m
+      BLOCK_START = /\A(?:[>#]|[-+*](?:\s|\z)|\d+[.)](?:\s|\z)|`{3}|~{3}|[=-]+[\t ]*\z)/
+
+      attr_reader :front_matter
+
+      def self.file?(path, configuration = nil)
+        Document.format(path, configuration) == :markdown
+      end
+
+      def initialize(buffer, ignore_front_matter: true, configuration: {})
+        ignore_front_matter = configuration.fetch('Markdown', {}).fetch('IgnoreFrontMatter', ignore_front_matter)
+        unless [true, false].include?(ignore_front_matter)
+          raise ValidationError, 'Markdown: IgnoreFrontMatter must be true or false.'
+        end
+
+        super(buffer)
+        @front_matter = source[FRONT_MATTER]
+        @ignore_front_matter = ignore_front_matter
+      end
+
+      def root
+        parsed.first
+      end
+
+      def warnings
+        parsed.last
+      end
+
+      def nodes(type)
+        @nodes ||= walk(root).group_by(&:type)
+        @nodes.fetch(type, [])
+      end
+
+      def paragraphs
+        @paragraphs ||= nodes(:p).select { |node| node.options[:prose_source] }
+      end
+
+      def hard_breaks
+        @hard_breaks ||= paragraphs.flat_map { |paragraph| find_hard_breaks(paragraph) }
+      end
+
+      def link_rules
+        @link_rules ||= LinkRules.new(self)
+      end
+
+      def emphasis_ranges(type)
+        @emphasis_ranges ||= InlineRules.emphasis(self)
+        @emphasis_ranges.fetch(type, [])
+      end
+
+      def multiline_atoms
+        @multiline_atoms ||= paragraphs.flat_map { |paragraph| atomic_ranges(paragraph) }
+                                       .reject { |range| range.line == range.last_line }
+      end
+
+      def headings
+        nodes(:header).map { |node| [node.options[:level], plain_text(node), node.options[:location]] }
+      end
+
+      def plain_text(node)
+        return node.value.to_s if %i[text codespan].include?(node.type)
+        return node.value.char if node.type == :entity
+
+        node.children.map { |child| plain_text(child) }.join
+      end
+
+      def front_matter_line?(number)
+        @ignore_front_matter && front_matter && number <= front_matter.lines.length
+      end
+
+      def code_line?(number)
+        @code_lines ||= nodes(:codeblock).flat_map do |node|
+          first = node.options.fetch(:location)
+          length = node.value.lines.length + (node.options[:fenced] ? 2 : 0)
+          (first...(first + length)).to_a
+        end.to_set
+        @code_lines.include?(number)
+      end
+
+      def ignored_line?(number)
+        code_line?(number) || front_matter_line?(number)
+      end
+
+      def breakable_space?(text, first, last)
+        !text[last..].match?(BLOCK_START) && text[0...first][/\\+\z/].to_s.length.even?
+      end
+
+      def prose_lines
+        return enum_for(__method__) unless block_given?
+
+        lines.each_with_index do |text, index|
+          number = index + 1
+          yield text, number unless code_line?(number) || front_matter_line?(number)
+        end
+      end
+
+      def content_start(paragraph, number)
+        text = source_lines(paragraph).fetch(number - paragraph.options[:location])
+        line(number).rindex(text) || raise("Cannot map Markdown paragraph on line #{number}")
+      end
+
+      def line_numbers(paragraph)
+        first = paragraph.options[:location]
+        first...(first + source_lines(paragraph).length)
+      end
+
+      def continuation_prefix(paragraph)
+        number = paragraph.options[:location]
+        prefix = line(number)[0...content_start(paragraph, number)]
+        prefix.gsub(/[-+*]|\d+[.)]/) { |marker| ' ' * marker.length }
+      end
+
+      def soft_breaks(paragraph)
+        line_numbers(paragraph).to_a[0...-1].reject do |number|
+          text = line(number)
+          join = range(number, text.rstrip.length, number + 1, content_start(paragraph, number + 1))
+          following = line(number + 1)[content_start(paragraph, number + 1)..]
+          text.end_with?('  ') || text[/\\+\z/].to_s.length.odd? ||
+            text.match?(/<br\b[^>]*>\s*\z/i) || following.match?(/\A<br\b[^>]*>/i) ||
+            atomic_ranges(paragraph).any? { |atom| atom.overlaps?(join) }
+        end
+      end
+
+      def atomic_ranges(paragraph)
+        paragraph.options[:original_ranges] ||= begin
+          inline = ::Parser::Source::Buffer.new('(paragraph)', source: paragraph.options[:prose_source])
+          paragraph.options[:prose_atoms].map do |first, last|
+            start_line, start_column = inline.decompose_position(first)
+            end_line, end_column = inline.decompose_position(last)
+            first_line = paragraph.options[:location] + start_line - 1
+            last_line = paragraph.options[:location] + end_line - 1
+            range(first_line, content_start(paragraph, first_line) + start_column,
+                  last_line, content_start(paragraph, last_line) + end_column)
+          end
+        end
+      end
+
+      private
+
+      def source_lines(paragraph)
+        paragraph.options[:prose_lines] ||= paragraph.options[:prose_source].split("\n", -1)
+      end
+
+      def parsed
+        @parsed ||= begin
+          text = @ignore_front_matter ? source.sub(FRONT_MATTER) { |header| header.gsub(/[^\r\n]/, ' ') } : source
+          Parser.parse(text, hard_wrap: false, gfm_quirks: %i[paragraph_end no_auto_typographic])
+        end
+      end
+
+      def walk(node)
+        [node] + node.children.flat_map { |child| walk(child) }
+      end
+
+      def find_hard_breaks(node)
+        node.children.flat_map do |child|
+          child.type == :br ? [child] : find_hard_breaks(child)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/prose/parser.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'kramdown'
+require 'kramdown-parser-gfm'
+
+module RuboCop
+  module Prose
+    class Parser < Kramdown::Parser::GFM
+      protected
+
+      def parse_codeblock_fenced
+        result = super
+        if result
+          block = @tree.children.last
+          block.options[:fenced] = true
+          block.options[:code_start_line] = block.options[:location] + 1
+        end
+        result
+      end
+
+      def parse_codeblock
+        result = super
+        @tree.children.last.options[:code_start_line] = @tree.children.last.options[:location] if result
+        result
+      end
+
+      def update_tree(element)
+        if element.type == :p && (raw = element.children.find { |child| child.type == :raw_text })
+          raw.value.sub!(/\n+\z/, '')
+          element.options[:prose_source] = raw.value.dup
+          element.options[:prose_atoms] = raw.options[:prose_atoms] = []
+          raw.options[:prose_atoms] << [0, 3] if raw.value.match?(/\A\[[ xX]\]/)
+        end
+        result = super
+        if element.type == :p && element.children.all? do |child|
+          child.type == :html_element || (child.type == :text && child.value.strip.empty?)
+        end
+          element.options.delete(:prose_source)
+        end
+        result
+      end
+
+      def parse_spans(element, *args, &)
+        previous = @prose_atoms
+        @prose_atoms = element.options[:prose_atoms] if element.type == :raw_text
+        super
+      ensure
+        @prose_atoms = previous
+      end
+
+      def parse_list
+        Kramdown::Parser::Kramdown.instance_method(:parse_list).bind_call(self)
+      end
+
+      def parse_link
+        if @src.pos.zero? && @src.check(/\[[ xX]\]/)
+          add_text(@src.scan(/\[[ xX]\]/))
+        else
+          capture_atom { super }
+        end
+      end
+
+      %i[parse_codespan parse_autolink parse_span_html].each do |method|
+        define_method(method) { capture_atom { super() } }
+      end
+
+      def capture_atom
+        scanner = @src
+        first = scanner.pos
+        atoms = @prose_atoms
+        result = yield
+        if atoms
+          atoms << [scanner.string.byteslice(0, first).length,
+                    scanner.string.byteslice(0, scanner.pos).length]
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rubocop/prose/plugin.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'lint_roller'
+require 'tempfile'
+
+module RuboCop
+  module Prose
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-prose', version: VERSION,
+          homepage: 'https://github.com/dblock/rubocop-prose',
+          description: 'Lint prose in Markdown and plain-text documents.'
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        @configuration ||= Tempfile.new(['rubocop-prose', '.yml']).tap do |file|
+          file.write(Prose.default_configuration.to_yaml)
+          file.flush
+        end
+        LintRoller::Rules.new(type: :path, config_format: :rubocop, value: Pathname.new(@configuration.path))
+      end
+    end
+  end
+end

data/lib/rubocop/prose/runner.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    module Runner
+      private
+
+      def get_processed_source(file, *arguments, **keywords)
+        configuration = @config_store.for_file(file)
+        format = configuration.prose_file_types.format(file)
+        return super if format == Document.format(file)
+
+        # The native factory normally initializes this optional preprocessor context.
+        if defined?(RuboCop::Markdown) && RuboCop::Markdown.respond_to?(:config_store=)
+          RuboCop::Markdown.config_store = @config_store
+        end
+
+        source = if keywords[:source]
+                   RuboCop::Util.emulate_write_read_cycle(keywords[:source])
+                 else
+                   prose_source(file)
+                 end
+        processed = ProcessedSource.new(
+          source, configuration.target_ruby_version, file,
+          parser_engine: configuration.parser_engine, prose_configuration: configuration
+        )
+        processed.config = configuration
+        processed.registry = mobilized_cop_classes(configuration)
+        processed
+      end
+
+      def prose_source(file)
+        @options[:stdin] || File.binread(file)
+      rescue Errno::ENOENT
+        raise RuboCop::Error, "No such file or directory: #{file}"
+      end
+    end
+
+    module TargetFinder
+      def find(...)
+        @config_store.for_pwd.prose_file_types
+        super
+      end
+
+      private
+
+      def ruby_file?(file, ...)
+        types = @config_store.for_file(file).prose_file_types
+        super || !types.format(file).nil?
+      end
+
+      def to_inspect?(file, ...)
+        configuration = @config_store.for_file(file)
+        return false if configuration.prose_file_types.format(file) && configuration.file_to_exclude?(file)
+
+        super
+      end
+    end
+  end
+end
+
+RuboCop::Runner.prepend(RuboCop::Prose::Runner)
+RuboCop::TargetFinder.prepend(RuboCop::Prose::TargetFinder)

data/lib/rubocop/prose/source.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    module Source
+      DIRECTIVE = %r{(?:<!--|<span\b[^>]*>)\s*(#\s*rubocop:[^\n]*?)\s*(?:-->|</span>)}
+
+      module MarkdownMapping
+        def markdown_document
+          super unless prose_format == :text
+        end
+      end
+
+      module Parsing
+        private
+
+        def parse(source, *)
+          return super unless prose_format
+
+          if prose_format == :markdown && respond_to?(:markdown_document)
+            super
+            return if prose_markdown_document
+
+            @diagnostics.clear
+            @parser_error = @tokens = nil
+          end
+
+          super('', *)
+          @buffer = ::Parser::Source::Buffer.new(path, source: raw_source)
+          @prose_documents = @prose_comments = nil
+        end
+      end
+
+      attr_reader :prose_format
+
+      def initialize(source, ruby_version, path = nil, prose_configuration: nil, **)
+        @prose_format = Document.format(path, prose_configuration)
+        extend Parsing if prose_format
+        extend MarkdownMapping if prose_format == :text && respond_to?(:markdown_document)
+        super(source, ruby_version, path, **)
+      end
+
+      def prose_document(configuration: nil)
+        @prose_documents ||= {}.compare_by_identity
+        @prose_documents[configuration] ||= Document.build(
+          path,
+          prose_markdown_document ? prose_markdown_document.buffer : buffer,
+          configuration: configuration, format: prose_format
+        )
+      end
+
+      def valid_syntax?
+        prose_format && !prose_markdown_document ? false : super
+      end
+
+      def comments
+        return [] if prose_format == :text
+        return super unless prose_format && !prose_markdown_document
+
+        prose_comments
+      end
+
+      def prose_markdown_document
+        markdown_document if prose_format == :markdown && respond_to?(:markdown_document)
+      end
+
+      private
+
+      def prose_comments
+        @prose_comments ||= buffer.source.to_enum(:scan, DIRECTIVE).filter_map do
+          match = Regexp.last_match
+          range = ::Parser::Source::Range.new(buffer, match.begin(1), match.end(1))
+          next if prose_document.code_line?(range.first_line) || prose_document.front_matter_line?(range.first_line)
+
+          ::Parser::Source::Comment.new(range)
+        end
+      end
+    end
+  end
+end
+
+RuboCop::ProcessedSource.prepend(RuboCop::Prose::Source)

data/lib/rubocop/prose/structural_blank_lines.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative 'heading_rules'
+require_relative 'code_rules'
+require_relative 'list_rules'
+require_relative 'table_rules'
+
+module RuboCop
+  module Prose
+    class StructuralBlankLines
+      include HeadingRules
+      include CodeRules
+      include ListRules
+
+      def initialize(document, configuration, processed_source)
+        @document = document
+        @configuration = configuration
+        @processed_source = processed_source
+      end
+
+      def protected_lines
+        @protected_lines = Set.new
+        heading_boundaries if enabled?(Cop::Markdown::HeadingBlankLines)
+        fence_boundaries if enabled?(Cop::Markdown::FenceBlankLines)
+        list_boundaries if enabled?(Cop::Markdown::ListBlankLines)
+        table_boundaries if enabled?(Cop::Markdown::TableBlankLines)
+        @protected_lines
+      end
+
+      private
+
+      attr_reader :document
+
+      def enabled?(cop)
+        @configuration.cop_enabled?(cop.cop_name) &&
+          cop.new(@configuration).relevant_file?(@processed_source.file_path)
+      end
+
+      def heading_boundaries
+        settings = @configuration.for_cop('Markdown/HeadingBlankLines')
+        heading_entries.each do |heading|
+          protect(heading[:line] - 1, -1, settings.fetch('LinesAbove', 1), blank: method(:heading_blank?))
+          protect(heading[:last_line] + 1, 1, settings.fetch('LinesBelow', 1), blank: method(:heading_blank?))
+        end
+      end
+
+      def fence_boundaries
+        settings = @configuration.for_cop('Markdown/FenceBlankLines')
+        fenced_blocks(list_items: settings.fetch('ListItems', true)) do |details|
+          unless details[:opening][:prefix].match?(/[-+*]|\d+[.)]/)
+            protect(details[:first] - 1, -1, settings.fetch('LinesAbove', 1))
+          end
+          protect(details[:last] + 1, 1, settings.fetch('LinesBelow', 1))
+        end
+      end
+
+      def list_boundaries
+        list_groups do |list, marks, parent|
+          next if parent
+
+          protect(marks.first[:line] - 1, -1, 1)
+          protect(node_last_line(list) + 1, 1, 1)
+        end
+      end
+
+      def table_boundaries
+        TableRules.tables(document).each do |table|
+          protect(table.rows.first.number - 1, -1, 1, front_matter: false)
+          protect(table.rows.last.number + 1, 1, 1)
+        end
+      end
+
+      def protect(number, direction, required, blank: method(:container_blank?), front_matter: true)
+        return if required.zero?
+
+        blanks = []
+        while number.between?(1, document.lines.length)
+          return if front_matter && direction.negative? && document.front_matter_line?(number)
+          break unless blank.call(number)
+
+          blanks << number
+          number += direction
+        end
+        return unless number.between?(1, document.lines.length)
+
+        @protected_lines.merge(blanks.sort.first(required))
+      end
+    end
+  end
+end

data/lib/rubocop/prose/table_rules.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'inline_rules'
+
+module RuboCop
+  module Prose
+    module TableRules
+      Row = Struct.new(:number, :text, :begin_pos, :end_pos, :pipes, :cells, :leading, :trailing, keyword_init: true)
+      Cell = Struct.new(:begin_pos, :end_pos, :text, keyword_init: true)
+      Table = Struct.new(:rows, keyword_init: true)
+
+      def self.row(document, number)
+        return if number > document.lines.length || document.code_line?(number) || document.front_matter_line?(number)
+
+        text = document.line(number)
+        first = text[/\A[ \t]*(?:>[ \t]*)*/].length
+        last = text.rstrip.length
+        return if first >= last
+
+        protected = InlineRules.spans(text, links: false, html: false)
+        pipes = (first...last).select do |index|
+          text[index] == '|' && protected.none? { |span| index >= span.begin_pos && index < span.end_pos }
+        end
+        leading = pipes.first == first
+        trailing = pipes.last == last - 1
+        boundaries = pipes.dup
+        boundaries.shift if leading
+        boundaries.pop if trailing
+        start = leading ? first + 1 : first
+        finish = trailing ? last - 1 : last
+        cells = []
+        boundaries.each do |position|
+          cells << Cell.new(begin_pos: start, end_pos: position, text: text[start...position])
+          start = position + 1
+        end
+        cells << Cell.new(begin_pos: start, end_pos: finish, text: text[start...finish])
+        Row.new(number: number, text: text, begin_pos: first, end_pos: last, pipes: pipes, cells: cells,
+                leading: leading, trailing: trailing)
+      end
+
+      def self.tables(document)
+        # A malformed body can make GFM reject the entire table. Its header and delimiter
+        # still identify the intended table, but only inside parser-recognized prose.
+        eligible = InlineRules.lines(document).to_set { |_, number, _| number }
+        result = []
+        number = 1
+        while number < document.lines.length
+          header = row(document, number) if eligible.include?(number)
+          separator = row(document, number + 1) if header && !header.pipes.empty?
+          if separator&.cells&.all? { |cell| cell.text.strip.match?(/\A:?-{3,}:?\z/) }
+            rows = [header, separator]
+            cursor = number + 2
+            while cursor <= document.lines.length && eligible.include?(cursor)
+              body = row(document, cursor)
+              break unless body && !body.pipes.empty?
+
+              rows << body
+              cursor += 1
+            end
+            result << Table.new(rows: rows)
+            number = cursor
+          else
+            number += 1
+          end
+          header = separator = nil
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rubocop/prose/text_document.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    class TextDocument < Document
+      Paragraph = Struct.new(:first_line, :last_line)
+
+      def self.file?(path, configuration = nil)
+        Document.format(path, configuration) == :text
+      end
+
+      def paragraphs
+        @paragraphs ||= begin
+          result = []
+          lines.each_with_index do |text, index|
+            next if text.strip.empty?
+
+            number = index + 1
+            if result.last && result.last.last_line == number - 1
+              result.last.last_line = number
+            else
+              result << Paragraph.new(number, number)
+            end
+          end
+          result
+        end
+      end
+
+      def line_numbers(paragraph)
+        paragraph.first_line..paragraph.last_line
+      end
+
+      def content_start(_paragraph, _number)
+        0
+      end
+
+      def continuation_prefix(_paragraph)
+        ''
+      end
+
+      def atomic_ranges(_paragraph)
+        []
+      end
+
+      def soft_breaks(paragraph)
+        (paragraph.first_line...paragraph.last_line).to_a
+      end
+
+      def reflowable?(paragraph)
+        line_numbers(paragraph).none? { |number| line(number).match?(/\A[ \t]/) }
+      end
+    end
+  end
+end

data/lib/rubocop/prose/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    VERSION = '0.1.0'
+  end
+end

data/lib/rubocop-prose.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+require 'yaml'
+require_relative 'rubocop/prose/version'
+require_relative 'rubocop/prose/parser'
+require_relative 'rubocop/prose/file_types'
+require_relative 'rubocop/prose/document'
+require_relative 'rubocop/prose/markdown_document'
+require_relative 'rubocop/prose/text_document'
+require_relative 'rubocop/prose/source'
+require_relative 'rubocop/prose/runner'
+require_relative 'rubocop/prose/plugin'
+require_relative 'rubocop/cop/prose/base'
+require_relative 'rubocop/cop/markdown/base'
+require_relative 'rubocop/cop/text/base'
+
+Dir[File.join(__dir__, 'rubocop/cop/{prose,markdown,text}/*.rb')].each { |path| require path }
+
+module RuboCop
+  module Prose
+    def self.default_configuration
+      paths = Dir[File.expand_path('../config/default.yml', __dir__),
+                  File.expand_path('../config/cops/**/*.yml', __dir__)]
+      paths.each_with_object({}) do |path, config|
+        config.merge!(YAML.safe_load_file(path)) { |_, previous, current| previous.merge(current) }
+      end
+    end
+  end
+end