rubocop-prose 0.1.0 → 0.2.0

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ListItemPunctuation < Base
+        include RuboCop::Prose::ListRules
+
+        TERMINAL_PUNCTUATION = /[.!?…]+\z/
+        CLOSING_QUOTES = /["'’”»›]+\z/
+
+        private
+
+        def investigate_document
+          list_groups do |list, marks, _parent|
+            next unless marks.length == list.children.count { |child| child.type == :li }
+
+            items = marks.map { |mark| [mark, terminal_punctuation(mark[:item])] }
+            next if items.any? { |_mark, punctuation| punctuation.nil? }
+
+            style = cop_config.fetch('Style', 'consistent')
+            expected = style == 'consistent' ? items.first.last != false : style == 'always'
+            items.each do |mark, punctuation|
+              message = item_message(style, punctuation, expected)
+              next unless message
+
+              prose_offense(document.range(mark[:line], mark[:column], mark[:line],
+                                           mark[:column] + mark[:marker].length),
+                            message: message)
+            end
+          end
+        end
+
+        def item_message(style, punctuation, expected)
+          return punctuation_message(style) if (punctuation != false) != expected
+          return unless punctuation
+          return if punctuation.each_char.all? { |char| cop_config['AllowedPunctuation'].include?(char) }
+
+          'Use only configured terminal punctuation.'
+        end
+
+        def punctuation_message(style)
+          case style
+          when 'always' then 'End list items with terminal punctuation.'
+          when 'never' then 'Do not end list items with terminal punctuation.'
+          else 'Use terminal punctuation consistently with sibling list items.'
+          end
+        end
+
+        def terminal_punctuation(item)
+          return unless item.children.one? && item.children.first.type == :p
+
+          paragraph = item.children.first
+          return unless paragraph.options[:prose_source]
+
+          text = document.plain_text(paragraph).rstrip.sub(CLOSING_QUOTES, '')
+          text[TERMINAL_PUNCTUATION] || false
+        end
+      end
+    end
+  end
+end

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

@@ -9,14 +9,23 @@ module RuboCop
         extend AutoCorrector
         include RuboCop::Prose::ListRules
 
+        def validate_config
+          unless %w[fixed aligned].include?(cop_config['Style'])
+            raise ValidationError, "#{cop_name}: Style must be fixed or aligned."
+          end
+          return if cop_config['MinSpaces'].is_a?(Integer) && cop_config['MinSpaces'].positive?
+
+          raise ValidationError, "#{cop_name}: MinSpaces must be a positive integer."
+        end
+
         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)
+          list_groups do |_list, marks, _parent|
+            widest = marks.map { |mark| mark[:marker].length }.max
             marks.each do |mark|
+              spaces = cop_config['MinSpaces']
+              spaces += widest - mark[:marker].length if cop_config['Style'] == 'aligned'
               next if mark[:gap].empty? || mark[:gap] == ' ' * spaces
 
               first = mark[:column] + mark[:marker].length

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

@@ -17,7 +17,7 @@ module RuboCop
 
             first = marks.first[:marker].to_i
             marks.each_with_index do |mark, index|
-              expected = cop_config.fetch('EnforcedStyle', 'sequential') == 'ones' ? 1 : first + index
+              expected = cop_config.fetch('Style', 'sequential') == 'ones' ? 1 : first + index
               digits = mark[:marker][/\A\d+/]
               next if digits == expected.to_s
 

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

@@ -23,16 +23,16 @@ module RuboCop
 
         def code_spans
           multiline = RuboCop::Prose::InlineRules.multiline_atoms(document)
-          RuboCop::Prose::InlineRules.lines(document).flat_map do |text, number, column|
+          document.inline_lines.flat_map do |_, number, column|
             line_start = document.line_range(number).begin_pos
-            RuboCop::Prose::InlineRules.spans(text).filter_map do |span|
+            document.inline_spans(number).filter_map do |span|
               next unless span.kind == :code && span.begin_pos >= column
 
               first = line_start + span.begin_pos
               last = line_start + span.end_pos
               range = ::Parser::Source::Range.new(document.buffer, first, last)
               next if multiline.any? { |atom| atom.overlaps?(range) }
-              next if protected_ranges(number, text, line_start).any? { |atom| atom.overlaps?(range) }
+              next if protected_ranges(number, line_start).any? { |atom| atom.overlaps?(range) }
 
               [first, last, first + span.delimiter.length, last - span.delimiter.length]
             end
@@ -48,7 +48,7 @@ module RuboCop
               last = closing.end_pos
               number = opening.line
               line_start = document.line_range(number).begin_pos
-              next if protected_ranges(number, document.line(number), line_start)
+              next if protected_ranges(number, line_start)
                       .any? { |atom| atom.begin_pos < last && first < atom.end_pos }
 
               [first, last, opening.end_pos, closing.begin_pos]
@@ -56,9 +56,9 @@ module RuboCop
           end
         end
 
-        def protected_ranges(number, text, line_start)
+        def protected_ranges(number, line_start)
           @protected_ranges ||= {}
-          @protected_ranges[number] ||= RuboCop::Prose::InlineRules.spans(text).filter_map do |span|
+          @protected_ranges[number] ||= document.inline_spans(number).filter_map do |span|
             next if span.kind == :code
 
             ::Parser::Source::Range.new(document.buffer, line_start + span.begin_pos, line_start + span.end_pos)

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

@@ -1,49 +1,38 @@
 # frozen_string_literal: true
 
 require_relative '../../prose/inline_rules'
+require_relative '../../prose/proper_name_rules'
 
 module RuboCop
   module Cop
     module Markdown
       class ProperNames < Base
+        include RuboCop::Prose::ProperNameRules
         extend AutoCorrector
 
-        def investigate_document
-          names = Array(cop_config['Names']).reject(&:empty?)
-          return if names.empty?
+        private
 
-          alternatives = names.sort_by { |name| -name.length }.map { |name| Regexp.escape(name) }.join('|')
-          pattern = /(?<![\p{L}\p{N}_])(?:#{alternatives})(?![\p{L}\p{N}_])/i
-          lines = RuboCop::Prose::InlineRules.lines(document)
-          if cop_config['CodeBlocks']
-            document.nodes(:codeblock).each do |node|
-              first = node.options.fetch(:code_start_line)
-              node.value.lines.each_index do |index|
-                number = first + index
-                lines << [document.line(number), number, 0] unless document.front_matter_line?(number)
-              end
-            end
+        def name_lines
+          lines = document.inline_lines.map do |text, number, column|
+            [masked_markdown_line(text, number), number, column]
           end
-          lines.each do |text, number, column|
-            masked = if document.code_line?(number)
-                       text
-                     else
-                       RuboCop::Prose::InlineRules.mask(text, include_code: cop_config['CodeBlocks'],
-                                                              document: document, number: number)
-                     end
-            masked.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
+          return lines unless cop_config['CodeBlocks']
 
-              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
+          document.nodes(:codeblock).each do |node|
+            first = node.options.fetch(:code_start_line)
+            node.value.lines.each_index do |index|
+              number = first + index
+              lines << [document.line(number), number, 0] unless document.front_matter_line?(number)
             end
           end
+          lines
+        end
+
+        def masked_markdown_line(text, number)
+          return text if document.code_line?(number)
+
+          RuboCop::Prose::InlineRules.mask(text, include_code: cop_config['CodeBlocks'],
+                                                 document: document, number: number)
         end
       end
     end

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

@@ -6,8 +6,15 @@ module RuboCop
   module Cop
     module Markdown
       class RawHtml < Base
+        OPENING_TAG = /<([A-Za-z][\w:-]*)\b(?:[^"'<>]|"[^"]*"|'[^']*')*(?:>|\z)/
+        ATTRIBUTE = /\s+([a-z_:][\w:.-]*)(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?/i
+
+        def validate_config
+          allowed_elements
+        end
+
         def investigate_document
-          allowed = Array(cop_config['AllowedElements']).map(&:downcase)
+          allowed = allowed_elements
           offsets = Hash.new(0)
           located = []
           unlocated = []
@@ -23,7 +30,7 @@ module RuboCop
 
             text = document.line(number)
             key = [number, node.value.to_s.downcase]
-            match = /<#{Regexp.escape(node.value.to_s)}\b[^>]*(?:>|\z)/i.match(text, offsets[key])
+            match = opening_tag(text, node.value, offsets[key])
             unless match
               unlocated << node.value.to_s.downcase
               next
@@ -31,15 +38,15 @@ module RuboCop
 
             offsets[key] = match.end(0)
             located << [number, match.begin(0)]
-            next if allowed.include?(node.value.to_s.downcase)
+            next if element_allowed?(node.value, match[0], allowed)
 
             prose_offense(document.range(number, match.begin(0), number, match.end(0)),
                           message: "Raw HTML element <#{node.value}> is not allowed.")
           end
           # GFM table cell span locations are relative to the cell, not the document.
-          RuboCop::Prose::InlineRules.lines(document).each do |text, number, _|
-            protected = RuboCop::Prose::InlineRules.spans(text).reject { |span| span.kind == :html }
-            text.to_enum(:scan, /<([A-Za-z][\w:-]*)\b[^>]*>/).each do
+          document.inline_lines.each do |text, number, _|
+            protected = document.inline_spans(number).reject { |span| span.kind == :html }
+            text.to_enum(:scan, OPENING_TAG).each do
               match = Regexp.last_match
               name = match[1].downcase
               next unless unlocated.include?(name)
@@ -47,13 +54,61 @@ module RuboCop
               next if protected.any? { |span| match.begin(0) >= span.begin_pos && match.begin(0) < span.end_pos }
 
               unlocated.delete_at(unlocated.index(name))
-              next if allowed.include?(name)
+              next if element_allowed?(name, match[0], allowed)
 
               prose_offense(document.range(number, match.begin(0), number, match.end(0)),
                             message: "Raw HTML element <#{match[1]}> is not allowed.")
             end
           end
         end
+
+        private
+
+        def allowed_elements
+          configured = cop_config.fetch('AllowedElements', [])
+          unless configured.is_a?(Array)
+            raise ValidationError,
+                  'Markdown/RawHtml: AllowedElements must be an array of element names or attribute rules.'
+          end
+
+          configured.map do |entry|
+            if entry.is_a?(String) && entry.match?(/\A[a-z][\w:-]*\z/i)
+              [entry.downcase, nil]
+            elsif entry.is_a?(Hash) && entry.size == 1
+              attribute_rule(*entry.first)
+            else
+              raise ValidationError, 'Markdown/RawHtml: AllowedElements entries must be element names or ' \
+                                     'single-element mappings to attribute lists.'
+            end
+          end
+        end
+
+        def attribute_rule(element, attributes)
+          unless element.is_a?(String) && element.match?(/\A[a-z][\w:-]*\z/i)
+            raise ValidationError, 'Markdown/RawHtml: AllowedElements rules must use valid element names.'
+          end
+
+          unless attributes.is_a?(Array) &&
+                 attributes.all? { |attribute| attribute.is_a?(String) && attribute.match?(/\A[a-z_:][\w:.-]*\z/i) }
+            raise ValidationError, 'Markdown/RawHtml: Attribute rules must be arrays of attribute names.'
+          end
+
+          [element.downcase, attributes.map(&:downcase)]
+        end
+
+        def opening_tag(text, name, offset)
+          pattern = /<#{Regexp.escape(name.to_s)}\b(?:[^"'<>]|"[^"]*"|'[^']*')*(?:>|\z)/i
+          pattern.match(text, offset)
+        end
+
+        def element_allowed?(name, tag, allowed)
+          present = tag.scan(ATTRIBUTE).flatten.map(&:downcase)
+          allowed.any? do |element, attributes|
+            next false unless element == name.to_s.downcase
+
+            attributes.nil? || present.all? { |attribute| attributes.include?(attribute) }
+          end
+        end
       end
     end
   end

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

@@ -6,6 +6,15 @@ module RuboCop
   module Cop
     module Markdown
       class ReferenceDefinitions < Base
+        def validate_config
+          unless %w[forbid allow_identical allow].include?(cop_config['Duplicates'])
+            raise ValidationError, "#{cop_name}: Duplicates must be forbid, allow_identical, or allow."
+          end
+          return if [true, false].include?(cop_config['Unused'])
+
+          raise ValidationError, "#{cop_name}: Unused must be true or false."
+        end
+
         private
 
         def investigate_document
@@ -16,14 +25,15 @@ module RuboCop
           scanner.definitions.each do |definition|
             first = seen[definition.reference]
             seen[definition.reference] ||= definition
-            duplicate = first && !(cop_config.fetch('AllowIdenticalDuplicates', false) &&
-              scanner.decode(first.destination) == scanner.decode(definition.destination) &&
-              first.title == definition.title)
+            duplicate = first && cop_config['Duplicates'] != 'allow' &&
+                        !(cop_config['Duplicates'] == 'allow_identical' &&
+                        scanner.decode(first.destination) == scanner.decode(definition.destination) &&
+                        first.title == definition.title)
             next if ignored.include?(definition.reference)
 
-            message = if duplicate && cop_config.fetch('CheckDuplicates', true)
+            message = if duplicate
                         'Remove or rename the duplicate reference definition.'
-                      elsif !used.include?(definition.reference) && cop_config.fetch('CheckUnused', false)
+                      elsif !used.include?(definition.reference) && cop_config['Unused']
                         'Reference definition is not used.'
                       end
             next unless message

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

@@ -8,6 +8,13 @@ module RuboCop
       class StrongStyle < Base
         extend AutoCorrector
 
+        def validate_config
+          styles = cop_config['SupportedStyles']
+          return if styles.include?(cop_config['Style'])
+
+          raise ValidationError, "#{cop_name}: Style must be one of #{styles.join(', ')}."
+        end
+
         def investigate_document
           expected = cop_config.fetch('Style', 'consistent')
           document.emphasis_ranges(:strong).each do |opening, closing, char|

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

@@ -7,12 +7,13 @@ module RuboCop
         MSG = 'Markdown source line is too long. [%<length>d/%<max>d]'
 
         def validate_config
-          %w[Max HeadingMax CodeBlockMax].each do |name|
+          %w[Headings CodeBlocks Tables].each do |name|
             value = cop_config[name]
-            next if name != 'Max' && value.nil?
+            next if value == false
             next if value.is_a?(Integer) && value.positive?
 
-            raise ValidationError, "Markdown/StructuralLineLength: #{name} must be a positive integer."
+            raise ValidationError,
+                  "Markdown/StructuralLineLength: #{name} must be a positive integer or false."
           end
         end
 
@@ -38,11 +39,11 @@ module RuboCop
 
         def structural_limit(number, headings, tables)
           if headings.include?(number) && cop_config['Headings']
-            cop_config['HeadingMax'] || cop_config['Max']
+            cop_config['Headings']
           elsif document.code_line?(number) && cop_config['CodeBlocks']
-            cop_config['CodeBlockMax'] || cop_config['Max']
+            cop_config['CodeBlocks']
           elsif tables.include?(number) && cop_config['Tables']
-            cop_config['Max']
+            cop_config['Tables']
           end
         end
       end

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

@@ -9,7 +9,7 @@ module RuboCop
         extend AutoCorrector
 
         def investigate_document
-          RuboCop::Prose::TableRules.tables(document).each do |table|
+          document.tables.each do |table|
             first = table.rows.first.number
             last = table.rows.last.number
             unless first == 1 || blank?(document.line(first - 1))

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

@@ -7,7 +7,7 @@ module RuboCop
     module Markdown
       class TableColumns < Base
         def investigate_document
-          RuboCop::Prose::TableRules.tables(document).each do |table|
+          document.tables.each do |table|
             count = table.rows.first.cells.length
             table.rows.drop(1).each do |row|
               next if row.cells.length == count

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

@@ -8,8 +8,15 @@ module RuboCop
       class TablePipes < Base
         extend AutoCorrector
 
+        def validate_config
+          styles = cop_config['SupportedStyles']
+          return if styles.include?(cop_config['Style'])
+
+          raise ValidationError, "#{cop_name}: Style must be one of #{styles.join(', ')}."
+        end
+
         def investigate_document
-          RuboCop::Prose::TableRules.tables(document).each do |table|
+          document.tables.each do |table|
             style = cop_config.fetch('Style', 'consistent')
             expected = case style
                        when 'leading_and_trailing' then [true, true]

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

@@ -8,8 +8,15 @@ module RuboCop
       class TableSpacing < Base
         extend AutoCorrector
 
+        def validate_config
+          styles = cop_config['SupportedStyles']
+          return if styles.include?(cop_config['Style'])
+
+          raise ValidationError, "#{cop_name}: Style must be one of #{styles.join(', ')}."
+        end
+
         def investigate_document
-          RuboCop::Prose::TableRules.tables(document).each do |table|
+          document.tables.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|

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

@@ -6,6 +6,10 @@ module RuboCop
       class ThematicBreakStyle < Base
         extend AutoCorrector
 
+        def validate_config
+          configured_styles(cop_config['Style'])
+        end
+
         def investigate_document
           style = cop_config.fetch('Style', 'consistent')
           styles = configured_styles(style)

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

@@ -27,6 +27,7 @@ module RuboCop
 
             match = text.match(/[ \t]+\z/)
             next unless match
+            next if allowed_empty_blockquote_space?(text, number, match[0])
 
             spaces = text[/ +\z/].to_s.length
             hard_break = !text.strip.empty? && paragraphs.include?(number) && spaces >= 2
@@ -49,6 +50,11 @@ module RuboCop
           style = config.for_cop('Markdown/HardBreakStyle')
           style if style && style['Enabled']
         end
+
+        def allowed_empty_blockquote_space?(text, number, whitespace)
+          cop_config['AllowEmptyBlockquoteSpace'] && whitespace == ' ' &&
+            !document.code_line?(number) && text.match?(/\A[ \t]*>(?:[ \t]*>)* \z/)
+        end
       end
     end
   end

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

@@ -12,7 +12,7 @@ module RuboCop
         private
 
         def investigate_document
-          style = cop_config.fetch('EnforcedStyle', 'consistent')
+          style = cop_config.fetch('Style', 'consistent')
           expected = { 'asterisk' => '*', 'plus' => '+', 'dash' => '-' }[style]
           changes = []
           list_groups do |list, marks, _parent|

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/capitalization_rules'
+
+module RuboCop
+  module Cop
+    module Prose
+      class SentenceCapitalization < Base
+        extend AutoCorrector
+        include RuboCop::Prose::CapitalizationRules
+
+        MSG = 'Capitalize or rephrase this lowercase paragraph opening without changing its literal text.'
+
+        def investigate_document
+          if document.is_a?(RuboCop::Prose::MarkdownDocument)
+            investigate_markdown
+          else
+            investigate_text
+          end
+        end
+
+        private
+
+        def investigate_markdown
+          list_openings = list_opening_paragraphs
+          table_paragraphs = paragraphs_in_tables
+          (document.paragraphs + footnote_paragraphs).uniq(&:object_id).each do |paragraph|
+            next if list_openings.include?(paragraph.object_id) || table_paragraphs.include?(paragraph.object_id)
+
+            source = paragraph.options[:prose_source]
+            opening = opening_word(source)
+            next if opening && !opening.literal && ambiguous_identifier_opening?(source, opening)
+
+            number = paragraph.options[:location]
+            investigate_opening(source, number, opening, document.content_start(paragraph, number))
+          end
+        end
+
+        def investigate_text
+          document.paragraphs.each do |paragraph|
+            number = paragraph.first_line
+            source = document.line(number)
+            opening = opening_word(source, markdown: false)
+            next if opening && !opening.literal && ambiguous_identifier_opening?(source, opening)
+
+            investigate_opening(source, number, opening)
+          end
+        end
+
+        def investigate_opening(source, number, opening, column_offset = 0)
+          return unless lowercase_opening?(opening)
+          return if source[0...opening.begin_pos].include?("\n")
+
+          column = column_offset + opening.begin_pos
+          range = document.range(number, column, number, column + 1)
+          prose_offense(range, message: MSG) do |corrector|
+            next if opening.literal
+
+            corrector.replace(processed_range(range), range.source.upcase)
+          end
+        end
+
+        def list_opening_paragraphs
+          openings = []
+          visit = lambda do |node|
+            if node.type == :li
+              first = node.children.first
+              openings << first.object_id if first&.type == :p && first.options[:prose_source]
+            end
+            node.children.each { |child| visit.call(child) }
+          end
+          visit.call(document.root)
+          openings
+        end
+
+        def paragraphs_in_tables
+          paragraphs = []
+          visit = lambda do |node|
+            paragraphs << node.object_id if node.type == :p && node.options[:prose_source]
+            node.children.each { |child| visit.call(child) }
+          end
+          document.nodes(:table).each { |table| visit.call(table) }
+          paragraphs
+        end
+
+        def footnote_paragraphs
+          paragraphs = []
+          visit = lambda do |node|
+            paragraphs << node if node.type == :p && node.options[:prose_source]
+            node.children.each { |child| visit.call(child) }
+          end
+          document.nodes(:footnote).each do |footnote|
+            visit.call(footnote.value) if footnote.value.respond_to?(:children)
+          end
+          paragraphs
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Text
+      class HardTabs < Base
+        private
+
+        def investigate_document
+          document.lines.each_with_index do |text, index|
+            text.to_enum(:scan, /\t/).each do
+              position = Regexp.last_match.begin(0)
+              prose_offense(document.range(index + 1, position, index + 1, position + 1),
+                            message: 'Use spaces instead of hard tabs.')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/proper_name_rules'
+
+module RuboCop
+  module Cop
+    module Text
+      class ProperNames < Base
+        include RuboCop::Prose::ProperNameRules
+        extend AutoCorrector
+
+        private
+
+        def name_lines
+          document.lines.each_with_index.map { |text, index| [text, index + 1, 0] }
+        end
+      end
+    end
+  end
+end