rubocop-prose 0.1.0 → 0.2.0

data/lib/rubocop/prose/capitalization_rules.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative 'inline_rules'
+
+module RuboCop
+  module Prose
+    module CapitalizationRules
+      WORD = /[\p{L}\p{N}][\p{L}\p{M}\p{N}_]*(?:['’][\p{L}\p{M}\p{N}_]+)*/
+      OpeningWord = Struct.new(:word, :begin_pos, :end_pos, :literal, :code, keyword_init: true)
+      QUOTES = { '"' => '"', "'" => "'", '“' => '”', '‘' => '’', '«' => '»', '‹' => '›',
+                 '「' => '」', '『' => '』' }.freeze
+
+      def opening_word(source, offset = 0, literal: false, depth: 0, base: 0, markdown: true)
+        return if depth > 8
+
+        index = offset
+        index += 1 while source[index]&.match?(/[ \t]/)
+        character = source[index]
+
+        if (closing = QUOTES[character]) && source.index(closing, index + 1)
+          return opening_word(source, index + 1, literal: true, depth: depth + 1, base: base, markdown: markdown)
+        end
+
+        if markdown && character == '`'
+          span = InlineRules.spans(source, links: false, html: false).find do |item|
+            item.kind == :code && item.begin_pos == index
+          end
+          if span
+            delimiter = span.delimiter.length
+            content_start = index + delimiter
+            content_end = span.end_pos - delimiter
+            content = source[content_start...content_end]
+            padding = content[/\A[ \t]*/].to_s.length
+            match = WORD.match(content, padding)
+            if match && match.begin(0) == padding && match[0].match?(/\p{L}/)
+              return opening_match(match, base + content_start, true, true)
+            end
+          end
+        end
+
+        if markdown && character == '[' && source[index - 1] != '!'
+          close = InlineRules.balanced_end(source, index, '[', ']')
+          if close
+            return opening_word(source, index + 1, literal: literal, depth: depth + 1, base: base, markdown: markdown)
+          end
+        end
+
+        if markdown && ['*', '_'].include?(character)
+          delimiter = source[index..][/\A(?:\*{1,3}|_{1,3})/]
+          closing = delimiter && source.index(delimiter, index + delimiter.length)
+          if closing
+            content_start = index + delimiter.length
+            inside = source[content_start...closing]
+            return opening_word(inside, literal: literal, depth: depth + 1, base: base + content_start,
+                                        markdown: markdown)
+          end
+        end
+
+        match = WORD.match(source, index)
+        return unless match && match.begin(0) == index && match[0].match?(/\p{L}/)
+
+        opening_match(match, base, literal, false)
+      end
+
+      def opening_match(match, offset, literal, code)
+        OpeningWord.new(word: match[0], begin_pos: offset + match.begin(0), end_pos: offset + match.end(0),
+                        literal: literal, code: code)
+      end
+
+      def lowercase_opening?(opening)
+        return false unless opening&.word&.match?(/\A\p{Ll}/)
+        return false if ignored_word?(opening.word)
+
+        !cop_config['PreserveMixedCase'] || !opening.word.match?(/\A\p{Ll}[\p{L}\p{M}\p{N}_]*[\p{Lu}\p{Lt}]/)
+      end
+
+      def ambiguous_identifier_opening?(source, opening)
+        opening.word.include?('_') ||
+          source[opening.end_pos..].match?(%r{\A(?:[.:/@=][\p{L}\p{N}]|://)})
+      end
+
+      def identifier_source?(source)
+        source.match?(%r{
+          https?://
+          | www\.
+          | [\p{L}\p{N}_]+_[\p{L}\p{N}_]+
+          | [\p{L}\p{N}_]+/[\p{L}\p{N}_]+
+          | \b[\p{L}\p{N}_]+\.[A-Za-z0-9]{2,}\b
+        }ix)
+      end
+
+      def validate_config
+        styles = cop_config['SupportedStyles']
+        unless styles.include?(cop_config['Style'])
+          raise RuboCop::ValidationError, "#{cop_name}: Style must be one of #{styles.join(', ')}."
+        end
+
+        options = %w[IgnoredWords]
+        options << 'MinorWords' if cop_config.key?('MinorWords')
+        options.each do |option|
+          words = cop_config[option]
+          next if words.is_a?(Array) && words.all? { |word| word.is_a?(String) && word.match?(/\A#{WORD}\z/) }
+
+          raise RuboCop::ValidationError, "#{cop_name}: #{option} must be an array of individual words."
+        end
+        return if [true, false].include?(cop_config['PreserveMixedCase'])
+
+        raise RuboCop::ValidationError, "#{cop_name}: PreserveMixedCase must be true or false."
+      end
+
+      private
+
+      def correction_range(text, number)
+        return if text.empty? || text.include?("\n") || text.include?("\0")
+
+        source = document.line(number)
+        first = source.index(text)
+        return unless first && !source.index(text, first + 1)
+
+        last = first + text.length
+        protected = InlineRules.spans(source)
+        return if protected.any? { |span| first < span.end_pos && last > span.begin_pos }
+
+        document.range(number, first, number, last)
+      end
+
+      def capitalized_text(text, title_case)
+        words = text.scan(WORD).grep(/\p{L}/)
+        minor_words = cop_config['MinorWords'].map(&:downcase)
+        index = -1
+        text.gsub(WORD) do |word|
+          next word unless word.match?(/\p{L}/)
+
+          index += 1
+          next word if ignored_word?(word) || (!title_case && index.positive?)
+
+          if title_case && index.positive? && index < words.size - 1 && minor_words.include?(word.downcase)
+            word.downcase
+          elsif invalid_initial?(word)
+            word.sub(/\p{L}/, &:upcase)
+          else
+            word
+          end
+        end
+      end
+
+      def invalid_initial?(text)
+        first = /[\p{L}\0]/.match(text)
+        return false unless first && first[0].match?(/\p{Ll}/)
+        return false if ignored_word?(text.scan(WORD).find { |word| word.match?(/\p{L}/) })
+
+        word = text[first.begin(0)..][/\A[\p{L}\p{N}_]+/]
+        !cop_config['PreserveMixedCase'] || !word&.match?(/\p{Lu}|\p{Lt}/)
+      end
+
+      def invalid_title?(text)
+        return false if text.include?("\0")
+
+        words = text.scan(WORD).grep(/\p{L}/)
+        minor_words = cop_config['MinorWords'].map(&:downcase)
+        words.each_with_index.any? do |word, index|
+          next false if ignored_word?(word)
+
+          if index.positive? && index < words.size - 1 && minor_words.include?(word.downcase)
+            word != word.downcase
+          else
+            invalid_initial?(word)
+          end
+        end
+      end
+
+      def ignored_word?(word)
+        cop_config['IgnoredWords'].include?(word)
+      end
+
+      def prose_text(node)
+        case node.type
+        when :text then node.value.to_s
+        when :entity then node.value.char
+        when :header, :p, :em, :strong, :a
+          node.children.map { |child| prose_text(child) }.join
+        else
+          # Do not check a later word after opaque leading content.
+          "\0"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/prose/inline_rules.rb

@@ -58,7 +58,7 @@ module RuboCop
       def self.spans(text, links: true, html: true)
         result = []
         index = 0
-        while index < text.length
+        while (index = text.index(/[\\`<!\[]/, index))
           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
@@ -132,7 +132,8 @@ module RuboCop
 
       def self.mask(text, include_code: false, document: nil, number: nil)
         result = text.dup
-        spans(text).each do |span|
+        protected = document && text == document.line(number) ? document.inline_spans(number) : spans(text)
+        protected.each do |span|
           next if include_code && span.kind == :code
 
           result[span.begin_pos...span.end_pos] = ' ' * (span.end_pos - span.begin_pos)
@@ -160,8 +161,10 @@ module RuboCop
           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) })
+        nodes = lambda do |node, found = []|
+          found << node
+          node.children.each { |child| nodes.call(child, found) } unless node.type == :table
+          found
         end
         records = nodes.call(root).map { |node| [node, 0, nil] }
         document.nodes(:table).each do |table|
@@ -169,13 +172,16 @@ module RuboCop
           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] })
+            if document.line(number).match?(/[*_]/)
+              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] })
+            end
             number += 1
           end
         end
         ranges = { em: [], strong: [] }
+        source_lines = {}.compare_by_identity
         records.each do |node, line_offset, column_offset|
           next unless ranges.key?(node.type) && node.options[:prose_delimiters]
 
@@ -187,15 +193,16 @@ module RuboCop
           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")]
+          lines = source_lines[text] ||= text.lines(chomp: true)
+          first_text = lines[local_line]
+          last_text = lines[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 }
+          next if document.inline_spans(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) }

data/lib/rubocop/prose/link_rules.rb

@@ -22,6 +22,9 @@ module RuboCop
         @links = []
         @definitions = []
         @html_anchors = []
+        @inline_destinations = {}
+        @definition_destinations = {}
+        @display_text = {}
         exclude_blocks
         exclude_spans
         scan_definitions
@@ -93,8 +96,10 @@ module RuboCop
       def display_text(link)
         return link.destination if link.style == 'autolink'
 
-        root = Parser.parse(link.label).first
-        self.class.plain_text(root).gsub(/[[:space:]]+/, ' ').strip
+        @display_text.fetch(link.label) do
+          root = Parser.parse(link.label).first
+          @display_text[link.label] = self.class.plain_text(root).gsub(/[[:space:]]+/, ' ').strip
+        end
       end
 
       def self.plain_text(node)
@@ -281,7 +286,7 @@ module RuboCop
       end
 
       def codespan_end(index)
-        run = @text[index..][/\A`+/]
+        run = /\G`+/.match(@text, index)[0]
         cursor = index + run.length
         while (match = /`+/.match(@text, cursor))
           return match.end(0) if match[0].length == run.length
@@ -373,8 +378,9 @@ module RuboCop
 
         depth = 1
         cursor = index + 1
-        while cursor < text.length
-          return if text[cursor] == "\n" && text[cursor..].match?(/\A\n[ \t\r]*\n/)
+        candidates = opening == '[' ? /[\[\]\n]/ : /[()\n]/
+        while (cursor = text.index(candidates, cursor))
+          return if text[cursor] == "\n" && /\G\n[ \t\r]*\n/.match?(text, cursor)
 
           unless escaped?(cursor)
             depth += 1 if text[cursor] == opening
@@ -391,8 +397,9 @@ module RuboCop
 
         depth = 1
         cursor = ending - 1
-        while cursor >= 0
-          return if @text[cursor] == "\n" && @text[cursor..ending].match?(/\A\n[ \t\r]*\n/)
+        while cursor >= 0 && (cursor = @text.rindex(/[\[\]\n]/, cursor))
+          return if @text[cursor] == "\n" && (blank = /\G\n[ \t\r]*\n/.match(@text, cursor)) &&
+                    blank.end(0) <= ending + 1
 
           unless escaped?(cursor)
             depth += 1 if @text[cursor] == ']'
@@ -405,7 +412,13 @@ module RuboCop
       end
 
       def unescaped_brackets?(first, last)
-        (first...last).any? { |index| ['[', ']'].include?(@source[index]) && !escaped?(index) }
+        cursor = first
+        while (cursor = @source.index(/[\[\]]/, cursor)) && cursor < last
+          return true unless escaped?(cursor)
+
+          cursor += 1
+        end
+        false
       end
 
       def whitespace(index, text = @text)
@@ -413,7 +426,7 @@ module RuboCop
         while text[cursor]&.match?(/[ \t\r\n]/)
           newline = text[cursor] == "\n"
           cursor += 1
-          cursor += text[cursor..][/\A[ \t]*(?:>[ \t]*)+/].to_s.length if newline
+          cursor += /\G[ \t]*(?:>[ \t]*)+/.match(text, cursor).to_s.length if newline
         end
         return if text[index...cursor].count("\n") > 1
 
@@ -469,6 +482,10 @@ module RuboCop
       end
 
       def inline_destination(index)
+        @inline_destinations.fetch(index) { @inline_destinations[index] = read_inline_destination(index) }
+      end
+
+      def read_inline_destination(index)
         first = whitespace(index + 1, @source)
         return unless first
 
@@ -490,6 +507,10 @@ module RuboCop
       end
 
       def definition_destination(index)
+        @definition_destinations.fetch(index) { @definition_destinations[index] = read_definition_destination(index) }
+      end
+
+      def read_definition_destination(index)
         start = whitespace(index, @source)
         result = read_destination(start) if start
         return unless result
@@ -497,8 +518,8 @@ module RuboCop
         value, finish, destination_first, destination_last = result
         gap = whitespace(finish, @source)
         title = title_end(gap) if gap && gap > finish
-        finish = title if title && @source[title..].match?(/\A[ \t]*(?:\r?\n|\z)/)
-        return unless @source[finish..].match?(/\A[ \t]*(?:\r?\n|\z)/)
+        finish = title if title && /\G[ \t]*(?:\r?\n|\z)/.match?(@source, title)
+        return unless /\G[ \t]*(?:\r?\n|\z)/.match?(@source, finish)
         return if value.empty? && @source[start] != '<'
 
         [value, finish, title && @source[(gap + 1)...(title - 1)], destination_first, destination_last]
@@ -549,7 +570,7 @@ module RuboCop
           links << link
           # Images may supply the accessible text of an outer link.
           nested = cursor + 1
-          while !link.image && nested < link.label_end_pos
+          while !link.image && (nested = @text.index('[', nested)) && nested < link.label_end_pos
             if @text[nested] == '[' && @text[nested - 1] == '!' && !escaped?(nested - 1)
               image = parse_link(nested)
               links << image if image&.image && image.end_pos <= link.label_end_pos
@@ -607,7 +628,7 @@ module RuboCop
         end
 
         cursor = outer.label_begin_pos
-        while cursor < outer.label_end_pos
+        while (cursor = @text.index('[', cursor)) && cursor < outer.label_end_pos
           if @text[cursor] == '[' && !escaped?(cursor)
             inner = parse_link(cursor)
             return true if inner && !inner.image && resolved?(inner) && inner.end_pos <= outer.label_end_pos

data/lib/rubocop/prose/markdown_document.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'table_rules'
+
 module RuboCop
   module Prose
     class MarkdownDocument < Document
@@ -20,6 +22,7 @@ module RuboCop
 
         super(buffer)
         @front_matter = source[FRONT_MATTER]
+        @front_matter_lines = @front_matter&.lines&.length
         @ignore_front_matter = ignore_front_matter
       end
 
@@ -48,6 +51,19 @@ module RuboCop
         @link_rules ||= LinkRules.new(self)
       end
 
+      def tables
+        @tables ||= TableRules.tables(self)
+      end
+
+      def inline_lines
+        @inline_lines ||= InlineRules.lines(self)
+      end
+
+      def inline_spans(number)
+        @inline_spans ||= {}
+        @inline_spans[number] ||= InlineRules.spans(line(number))
+      end
+
       def emphasis_ranges(type)
         @emphasis_ranges ||= InlineRules.emphasis(self)
         @emphasis_ranges.fetch(type, [])
@@ -70,7 +86,7 @@ module RuboCop
       end
 
       def front_matter_line?(number)
-        @ignore_front_matter && front_matter && number <= front_matter.lines.length
+        @ignore_front_matter && @front_matter_lines && number <= @front_matter_lines
       end
 
       def code_line?(number)
@@ -128,8 +144,11 @@ module RuboCop
 
       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|
+          atoms = paragraph.options[:prose_atoms]
+          unless atoms.empty?
+            inline = ::Parser::Source::Buffer.new('(paragraph)', source: paragraph.options[:prose_source])
+          end
+          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
@@ -153,14 +172,17 @@ module RuboCop
         end
       end
 
-      def walk(node)
-        [node] + node.children.flat_map { |child| walk(child) }
+      def walk(node, found = [])
+        found << node
+        node.children.each { |child| walk(child, found) }
+        found
       end
 
-      def find_hard_breaks(node)
-        node.children.flat_map do |child|
-          child.type == :br ? [child] : find_hard_breaks(child)
+      def find_hard_breaks(node, found = [])
+        node.children.each do |child|
+          child.type == :br ? found << child : find_hard_breaks(child, found)
         end
+        found
       end
     end
   end

data/lib/rubocop/prose/proper_name_rules.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Prose
+    module ProperNameRules
+      private
+
+      def investigate_document
+        names = Array(cop_config['Names']).reject(&:empty?)
+        return if names.empty?
+
+        alternatives = names.sort_by { |name| -name.length }.map { |name| Regexp.escape(name) }.join('|')
+        pattern = /(?<![\p{L}\p{N}_])(?:#{alternatives})(?![\p{L}\p{N}_])/i
+        name_lines.each do |text, number, column|
+          text.to_enum(:scan, pattern).each do
+            match = Regexp.last_match
+            next if match.begin(0) < column
+
+            expected = names.find { |name| name.casecmp?(match[0]) }
+            next if match[0] == expected
+
+            range = document.range(number, match.begin(0), number, match.end(0))
+            prose_offense(range, message: "Use the capitalization `#{expected}`.") do |corrector|
+              corrector.replace(processed_range(range), expected)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/prose/structural_blank_lines.rb

@@ -64,7 +64,7 @@ module RuboCop
       end
 
       def table_boundaries
-        TableRules.tables(document).each do |table|
+        document.tables.each do |table|
           protect(table.rows.first.number - 1, -1, 1, front_matter: false)
           protect(table.rows.last.number + 1, 1, 1)
         end

data/lib/rubocop/prose/table_rules.rb

@@ -41,7 +41,7 @@ module RuboCop
       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 }
+        eligible = document.inline_lines.to_set { |_, number, _| number }
         result = []
         number = 1
         while number < document.lines.length

data/lib/rubocop/prose/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Prose
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/lib/rubocop-prose.rb

@@ -2,6 +2,9 @@
 
 require 'rubocop'
 require 'yaml'
+
+RuboCop::ConfigObsoletion.files << File.expand_path('../config/obsoletion.yml', __dir__)
+
 require_relative 'rubocop/prose/version'
 require_relative 'rubocop/prose/parser'
 require_relative 'rubocop/prose/file_types'