rubocop-prose 0.1.0 → 0.2.0

data/docs/cops/markdown/trailing_whitespace.md

@@ -4,12 +4,17 @@ Trims trailing whitespace while preserving paragraph hard breaks at the configur
 
 When [Markdown/HardBreakStyle](hard_break_style.md) is enabled, that cop selects the hard-break syntax and this cop avoids overlapping corrections.
 
+Set `AllowEmptyBlockquoteSpace: true` to permit exactly one trailing ASCII space on an otherwise-empty blockquote line, including nested quotes. Bare quote markers remain valid. Two or more trailing spaces, tabs, and mixed trailing whitespace are still rejected; paragraph hard breaks and code-block handling are unchanged.
+
+[Markdown/BlockquoteSpacing](blockquote_spacing.md) leaves empty quote markers alone, and [Markdown/BlockquoteBlankLines](blockquote_blank_lines.md) adds bare markers without requiring a trailing space. [Prose/MultipleBlankLines](../prose/multiple_blank_lines.md) still counts empty quote lines toward `Max`, whether they have the allowed space or not.
+
 ## Configuration
 
 ```yaml
 Markdown/TrailingWhitespace:
   Enabled: true
   HardBreakSpaces: 2 # Must be an integer of at least 2.
+  AllowEmptyBlockquoteSpace: false
   CodeBlocks: false # When true, code whitespace is report-only to preserve embedded strings.
 ```
 
@@ -28,3 +33,27 @@ Inputs are shown as Ruby strings so tabs, trailing spaces, and newline character
 ```ruby
 "A paragraph.\n"
 ```
+
+## Empty Blockquote Lines
+
+For this configuration:
+
+```yaml
+Markdown/TrailingWhitespace:
+  AllowEmptyBlockquoteSpace: true
+```
+
+### Bad
+
+```ruby
+"> First paragraph.\n>  \n> Second paragraph.\n"
+"> First paragraph.\n>\t\n> Second paragraph.\n"
+```
+
+### Good
+
+```ruby
+"> First paragraph.\n> \n> Second paragraph.\n"
+"> > First paragraph.\n> > \n> > Second paragraph.\n"
+"> First paragraph.\n>\n> Second paragraph.\n"
+```

data/docs/cops/markdown/unordered_list_marker.md

@@ -9,7 +9,7 @@ Autocorrection changes only the marker and is withheld if it could create a them
 ```yaml
 Markdown/UnorderedListMarker:
   Enabled: true
-  EnforcedStyle: consistent # consistent, asterisk, plus or dash.
+  Style: consistent # consistent, asterisk, plus or dash.
 ```
 
 ## Example
@@ -18,7 +18,7 @@ For this configuration:
 
 ```yaml
 Markdown/UnorderedListMarker:
-  EnforcedStyle: dash
+  Style: dash
 ```
 
 ### Bad
@@ -34,3 +34,12 @@ Markdown/UnorderedListMarker:
 - one
 - two
 ```
+
+## Migrating From 0.1.0
+
+Replace `EnforcedStyle` with `Style`:
+
+```yaml
+Markdown/UnorderedListMarker:
+  Style: dash
+```

data/docs/cops/prose/multiple_blank_lines.md

@@ -4,6 +4,8 @@ Removes excess consecutive blank lines while preserving paragraph separation. In
 
 [Markdown/BlockquoteBlankLines](../markdown/blockquote_blank_lines.md) handles the separate case of adding markers between adjacent blockquotes.
 
+Empty quote lines with the single trailing space permitted by [Markdown/TrailingWhitespace](../markdown/trailing_whitespace.md)'s `AllowEmptyBlockquoteSpace` option still count toward `Max`; retained lines keep their original spelling.
+
 At Markdown structural boundaries, the effective limit is at least the minimum required by the enabled [heading](../markdown/heading_blank_lines.md), [fence](../markdown/fence_blank_lines.md), [list](../markdown/list_blank_lines.md), or [table](../markdown/table_blank_lines.md) spacing cop in that file's configuration. Shared boundaries use the largest minimum, not their sum. `Max` still applies elsewhere, including document edges where no structural padding is required.
 
 ## Configuration

data/docs/cops/prose/sentence_capitalization.md

@@ -0,0 +1,46 @@
+# Prose/SentenceCapitalization
+
+Checks lowercase words at paragraph openings in Markdown and plain-text files using the single `initial_capital` style. It is an opt-in editorial rule. It checks ordinary prose and reports lowercase openings inside inline code or quoted terms in Markdown, but never changes quoted or code contents. For literal terms, rewrite the sentence around the term rather than changing the literal spelling.
+
+The cop checks paragraph openings only; it does not split paragraphs into sentences. In Markdown, it handles paragraphs in blockquotes, footnotes, and list items, but leaves each list item's opening paragraph to [Markdown/ListItemCapitalization](../markdown/list_item_capitalization.md) so consistent lowercase lists remain possible. Subsequent paragraphs in list items are checked.
+
+In plain-text files, paragraphs are literal groups of nonblank lines. The cop does not interpret Markdown-like code, emphasis, links, or containers in text files. A quoted paragraph opening is still reported without correction. Plain-text list-item capitalization is not inferred.
+
+Headings, tables, code blocks, and ignored front matter are not Markdown paragraphs for this rule. Mixed-case brands such as `eBay` pass by default. `IgnoredWords` exempts exact, case-sensitive words. Native RuboCop suppression directives can silence intentional Markdown exceptions; plain-text files use `IgnoredWords`.
+
+Supports unsafe autocorrection with `rubocop -A` for a mapped ordinary prose opening only. A lowercase opening in code, quotation marks, or ambiguous source mapping is report-only. Abbreviations, URLs, decimals, and later sentence boundaries are not analyzed.
+
+## Configuration
+
+```yaml
+Prose/SentenceCapitalization:
+  Enabled: false
+  SafeAutoCorrect: false
+  Style: initial_capital
+  PreserveMixedCase: true
+  IgnoredWords: []
+  SupportedStyles:
+    - initial_capital
+```
+
+## Examples
+
+### Bad
+
+```markdown
+lowercase prose starts this paragraph.
+
+`fixed` requires exactly one space after every marker.
+
+"aligned" adds padding after shorter markers.
+```
+
+### Good
+
+```markdown
+Lowercase prose starts this paragraph.
+
+The `fixed` style requires exactly one space after every marker.
+
+The "aligned" style adds padding after shorter markers.
+```

data/docs/cops/text/hard_tabs.md

@@ -0,0 +1,28 @@
+# Text/HardTabs
+
+Reports every hard tab in plain-text files without correction. Markdown-like fences, code, and metadata are literal text and receive no exemptions.
+
+Use [Markdown/HardTabs](../markdown/hard_tabs.md) for Markdown code-block and language exceptions.
+
+## Configuration
+
+```yaml
+Text/HardTabs:
+  Enabled: true
+```
+
+## Example
+
+Inputs are shown as Ruby strings so tabs and newline characters are visible.
+
+### Bad
+
+```ruby
+"A\tparagraph.\n"
+```
+
+### Good
+
+```ruby
+"A paragraph.\n"
+```

data/docs/cops/text/proper_names.md

@@ -0,0 +1,36 @@
+# Text/ProperNames
+
+Corrects configured names to their canonical capitalization in literal plain text. Matching is case-insensitive, uses whole-word boundaries, and treats punctuation in names literally. Markdown-like code, links, URLs, and fences receive no special treatment.
+
+Use [Markdown/ProperNames](../markdown/proper_names.md) for Markdown syntax exclusions and code-content options.
+
+## Configuration
+
+```yaml
+Text/ProperNames:
+  Enabled: false
+  Names: [] # Canonical spellings; an empty list disables checks.
+```
+
+## Example
+
+For this configuration:
+
+```yaml
+Text/ProperNames:
+  Enabled: true
+  Names:
+    - GitHub
+```
+
+### Bad
+
+```text
+`github` https://github.com
+```
+
+### Good
+
+```text
+`GitHub` https://GitHub.com
+```

data/docs/settings/files.md

@@ -1,4 +1,4 @@
-# File selection
+# File Selection
 
 `Markdown/Include` and `Text/Include` select files using RuboCop's normal filename and glob patterns.
 

data/docs/settings/front_matter.md

@@ -1,8 +1,8 @@
-# Front matter
+# Front Matter
 
 By default, Markdown checks ignore a leading header opened with `---` and closed with `---` or `...`. Unclosed headers and delimiters elsewhere remain ordinary Markdown.
 
-Set `IgnoreFrontMatter: false` to inspect the header as Markdown, not validate its YAML. RuboCop directives inside metadata remain ignored, and this setting does not change Ruby snippet extraction.
+Set `IgnoreFrontMatter: false` to inspect the header as Markdown, not validate its YAML. Use the opt-in [Markdown/FrontMatterSyntax](../cops/markdown/front_matter_syntax.md) cop to report YAML syntax errors independently of this setting. RuboCop directives inside metadata remain ignored, and this setting does not change Ruby snippet extraction.
 
 ## Example
 

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

@@ -12,7 +12,7 @@ module RuboCop
         private
 
         def investigate_document
-          expected = cop_config.fetch('EnforcedStyle', 'consistent')
+          expected = cop_config.fetch('Style', 'consistent')
           code_blocks.each do |node|
             actual = node.options[:fenced] ? 'fenced' : 'indented'
             expected = actual if expected == 'consistent'

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

@@ -11,8 +11,8 @@ module RuboCop
         def investigate_document
           multiline = RuboCop::Prose::InlineRules.multiline_atoms(document)
                                                  .select { |range| range.source.start_with?('`') }
-          RuboCop::Prose::InlineRules.lines(document).each do |text, number, column|
-            RuboCop::Prose::InlineRules.spans(text).each do |span|
+          document.inline_lines.each do |text, number, column|
+            document.inline_spans(number).each do |span|
               next unless span.kind == :code && span.begin_pos >= column
 
               position = document.range(number, span.begin_pos, number, span.end_pos)

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

@@ -8,20 +8,70 @@ module RuboCop
       class DuplicateHeadings < Base
         include RuboCop::Prose::HeadingRules
 
+        def validate_config
+          scopes = ['siblings', 'document', false]
+          value = cop_config['Scope']
+          return if scopes.include?(value)
+
+          if value.is_a?(Hash) && value.key?('Default') && scopes.include?(value['Default'])
+            covered = []
+            valid = value.except('Default').all? do |selector, scope|
+              levels = selector_levels(selector)
+              next false unless levels && scopes.include?(scope) && !covered.intersect?(levels)
+
+              covered.concat(levels)
+              true
+            end
+            return if valid
+          end
+
+          raise ValidationError, "#{cop_name}: Scope must be siblings, document, false, or a mapping with Default " \
+                                 'and nonoverlapping levels (1-6), ranges (4-6), or comparisons (>4), ' \
+                                 'set to siblings, document, or false.'
+        end
+
         def investigate_document
-          seen = Set.new
+          document_seen = Set.new
+          sibling_seen = Set.new
           parents = []
           heading_entries.each do |heading|
             parents.pop while parents.any? && parents.last[:level] >= heading[:level]
-            scope = cop_config.fetch('Scope', 'siblings') == 'siblings' ? parents.last&.fetch(:line) : nil
-            key = [scope, heading[:text]]
-            if seen.include?(key)
+            key = [parents.last&.fetch(:line), heading[:text]]
+            setting = cop_config['Scope']
+            scope = effective_scope(setting, heading[:level])
+            duplicate = scope == 'document' ? document_seen.include?(heading[:text]) : sibling_seen.include?(key)
+            if scope != false && duplicate
               prose_offense(heading_range(heading), message: 'Use unique heading text within the configured scope.')
             end
-            seen.add(key)
+            document_seen.add(heading[:text])
+            sibling_seen.add(key)
             parents << heading
           end
         end
+
+        private
+
+        def effective_scope(setting, level)
+          return setting unless setting.is_a?(Hash)
+
+          selected = setting.find do |selector, _scope|
+            selector != 'Default' && selector_levels(selector).include?(level)
+          end
+          selected ? selected.last : setting.fetch('Default')
+        end
+
+        def selector_levels(selector)
+          return [selector] if selector.is_a?(Integer) && selector.between?(1, 6)
+          return unless selector.is_a?(String)
+
+          if (match = /\A([1-6])-([1-6])\z/.match(selector))
+            first, last = match.captures.map(&:to_i)
+            (first..last).to_a if first <= last
+          elsif (match = /\A([<>])([1-6])\z/.match(selector))
+            levels = (1..6).select { |level| match[1] == '>' ? level > match[2].to_i : level < match[2].to_i }
+            levels unless levels.empty?
+          end
+        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module RuboCop
         extend AutoCorrector
 
         def investigate_document
-          RuboCop::Prose::InlineRules.lines(document).each do |text, number, column|
+          document.inline_lines.each do |text, number, column|
             masked = RuboCop::Prose::InlineRules.mask(text, document: document, number: number)
             masked.to_enum(:scan, /(?<![\w*_])(\*{1,3}|_{1,3})(?![*_])(.+?)\1(?![\w*_])/).each do
               match = Regexp.last_match

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

@@ -8,6 +8,13 @@ module RuboCop
       class EmphasisStyle < 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(:em).each do |opening, closing, char|

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

@@ -12,7 +12,7 @@ module RuboCop
         private
 
         def investigate_document
-          expected = { 'backtick' => '`', 'tilde' => '~' }[cop_config.fetch('EnforcedStyle', 'consistent')]
+          expected = { 'backtick' => '`', 'tilde' => '~' }[cop_config.fetch('Style', 'consistent')]
           code_blocks.each do |node|
             details = fence_details(node)
             next unless details

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

@@ -24,16 +24,27 @@ module RuboCop
                         message: 'Start the document with a heading at the configured level.')
         end
 
+        def validate_config
+          title_key = cop_config['FrontMatterTitle']
+          return if title_key == false || (title_key.is_a?(String) && !title_key.strip.empty?)
+
+          raise ValidationError,
+                "#{cop_name}: FrontMatterTitle must be a nonempty metadata key or false; " \
+                'replace `FrontMatterTitle: true` and `TitleKey` with the metadata key, or use false to disable.'
+        end
+
         private
 
         def front_matter_title?
-          return false unless cop_config.fetch('FrontMatterTitle', true) && document.front_matter
+          title_key = cop_config['FrontMatterTitle']
+          return false if title_key == false
+          return false unless document.front_matter
 
           lines = document.front_matter.lines
           metadata = YAML.safe_load(lines[1...-1].join)
           return false unless metadata.is_a?(Hash)
 
-          title = metadata[cop_config.fetch('TitleKey', 'title')]
+          title = metadata[title_key]
           title.is_a?(String) && !title.strip.empty?
         rescue Psych::Exception
           false

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'psych'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class FrontMatterKeys < Base
+        def validate_config
+          %w[AllowedKeys RequiredKeys].each do |option|
+            keys = cop_config[option]
+            next if option == 'AllowedKeys' && keys.nil?
+            next if keys.is_a?(Array) && keys.all? { |key| key.is_a?(String) && !key.empty? }
+
+            raise ValidationError, "#{cop_name}: #{option} must be an array of nonempty key names."
+          end
+          allowed = cop_config['AllowedKeys']
+          return if allowed.nil? || (cop_config['RequiredKeys'] - allowed).empty?
+
+          raise ValidationError, "#{cop_name}: RequiredKeys must be included in AllowedKeys."
+        end
+
+        private
+
+        def investigate_document
+          return unless document.front_matter
+
+          parsed = parse_front_matter
+          return if parsed == :invalid
+
+          root = parsed&.root
+          if root && !root.is_a?(Psych::Nodes::Mapping)
+            prose_offense(node_range(root), message: 'Front matter must be a mapping of metadata keys.')
+            return
+          end
+
+          keys = root ? root.children.each_slice(2).map(&:first) : []
+          names = keys.filter_map do |key|
+            unless key.is_a?(Psych::Nodes::Scalar)
+              prose_offense(node_range(key), message: 'Front matter keys must be scalar names.')
+              next
+            end
+
+            allowed = cop_config['AllowedKeys']
+            if allowed && !allowed.include?(key.value)
+              prose_offense(node_range(key), message: "Front matter key `#{key.value}` is not allowed.")
+            end
+            key.value
+          end
+          (cop_config['RequiredKeys'] - names).each do |key|
+            prose_offense(document.line_range(1), message: "Missing required front matter key `#{key}`.")
+          end
+        end
+
+        def parse_front_matter
+          Psych.parse(document.front_matter.lines[1...-1].join) || nil
+        rescue Psych::SyntaxError
+          # Syntax diagnostics belong to Markdown/FrontMatterSyntax.
+          :invalid
+        end
+
+        def node_range(node)
+          first = node.start_line + 2
+          last = node.end_line + 2
+          document.range(first, node.start_column, last, node.end_column)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'psych'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class FrontMatterSyntax < Base
+        private
+
+        def investigate_document
+          return unless document.front_matter
+
+          Psych.parse(document.front_matter.lines[1...-1].join)
+        rescue Psych::SyntaxError => e
+          line = (e.line + 1).clamp(1, document.lines.length)
+          column = (e.column - 1).clamp(0, document.line(line).length)
+          prose_offense(
+            document.range(line, column, line, [column + 1, document.line(line).length].min),
+            message: "Invalid YAML front matter: #{e.problem}."
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -7,13 +7,7 @@ module RuboCop
         private
 
         def investigate_document
-          allowed = cop_config['AllowedCodeLanguages'].map(&:downcase)
-          exempt = document.nodes(:codeblock).flat_map do |block|
-            next [] unless allowed.include?(block.options[:lang].to_s.split.first.to_s.downcase)
-
-            first = block.options.fetch(:code_start_line)
-            (first...(first + block.value.lines.length)).to_a
-          end.to_set
+          exempt = allowed_code_lines
           document.lines.each_with_index do |text, index|
             number = index + 1
             next if document.front_matter_line?(number) || exempt.include?(number)
@@ -26,6 +20,16 @@ module RuboCop
             end
           end
         end
+
+        def allowed_code_lines
+          allowed = cop_config['AllowedCodeLanguages'].map(&:downcase)
+          document.nodes(:codeblock).flat_map do |block|
+            next [] unless allowed.include?(block.options[:lang].to_s.split.first.to_s.downcase)
+
+            first = block.options.fetch(:code_start_line)
+            (first...(first + block.value.lines.length)).to_a
+          end.to_set
+        end
       end
     end
   end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/capitalization_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class HeadingCapitalization < Base
+        extend AutoCorrector
+        include RuboCop::Prose::CapitalizationRules
+
+        MSG = 'Capitalize the first prose letter of the heading.'
+        TITLE_MSG = 'Use title case: capitalize major words and lowercase internal minor words.'
+
+        def investigate_document
+          document.nodes(:header).each do |node|
+            text = prose_text(node)
+            title_case = cop_config['Style'] == 'title_case'
+            number = node.options.fetch(:location)
+            opening = heading_opening(number)
+            literal_lowercase = opening&.literal && lowercase_opening?(opening)
+            invalid = title_case ? invalid_title?(text) || literal_lowercase : lowercase_opening?(opening)
+            invalid ||= !title_case && !opening && invalid_initial?(text)
+            next unless invalid
+
+            range = opening&.literal || identifier_source?(document.line(number)) ? nil : correction_range(text, number)
+            replacement = capitalized_text(text, title_case)
+            prose_offense(document.line_range(number), message: title_case ? TITLE_MSG : MSG) do |corrector|
+              corrector.replace(processed_range(range), replacement) if range
+            end
+          end
+        end
+
+        def heading_opening(number)
+          source = document.line(number)
+          text = source.sub(/\A(?:[ \t]*>[ \t]?)*[ \t]*(?:[-+*]|\d+[.)])?[ \t]*/, '')
+          text = text.sub(/\A\#{1,6}[ \t]+/, '').sub(/[ \t]+\#{1,}[ \t]*\z/, '')
+          opening_word(text)
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module RuboCop
 
         def investigate_document
           headings = heading_entries
-          style = cop_config.fetch('EnforcedStyle', 'consistent')
+          style = cop_config.fetch('Style', 'consistent')
           style = headings.first&.fetch(:style) if style == 'consistent'
           headings.each do |heading|
             next if heading[:style] == style

data/lib/rubocop/cop/markdown/{syntax.rb → kramdown_syntax.rb}

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Markdown
-      class Syntax < Base
+      class KramdownSyntax < Base
         private
 
         def investigate_document

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../../prose/list_rules'
+require_relative '../../prose/capitalization_rules'
+
+module RuboCop
+  module Cop
+    module Markdown
+      class ListItemCapitalization < Base
+        extend AutoCorrector
+        include RuboCop::Prose::ListRules
+        include RuboCop::Prose::CapitalizationRules
+
+        private
+
+        def investigate_document
+          list_groups do |_list, marks, _parent|
+            expected = nil
+            marks.each do |mark|
+              if cop_config['Style'] == 'title_case'
+                investigate_title(mark)
+                next
+              end
+
+              initial = prose_initial(mark)
+              next unless initial
+
+              range, style = initial
+              next if initial.last && expected.nil? && cop_config['Style'] == 'consistent'
+
+              expected ||= cop_config['Style'] == 'initial_capital' ? 'uppercase' : style
+              next if style == expected
+
+              prose_offense(range, message: "Use #{expected} initial capitalization in list items.") do |corrector|
+                next if initial.last
+
+                replacement = expected == 'uppercase' ? range.source.upcase : range.source.downcase
+                corrector.replace(processed_range(range), replacement)
+              end
+            end
+          end
+        end
+
+        def investigate_title(mark)
+          paragraph = mark[:item].children.first
+          return unless paragraph&.type == :p && paragraph.options[:prose_source]
+          return unless paragraph.options[:location] == mark[:line]
+
+          source = paragraph.options[:prose_source]
+          checkbox = source[/\A[ \t]*\[[ xX]\][ \t]+/].to_s
+          text = prose_text(paragraph).sub(/\A\[[ xX]\][ \t]+/, '')
+          opening = opening_word(source[checkbox.length..])
+          return unless invalid_title?(text) || (opening&.literal && lowercase_opening?(opening))
+
+          range = opening&.literal || identifier_source?(source) ? nil : correction_range(text, mark[:line])
+          prose_offense(document.line_range(mark[:line]), message: 'Use title case in list items.') do |corrector|
+            corrector.replace(processed_range(range), capitalized_text(text, true)) if range
+          end
+        end
+
+        def prose_initial(mark)
+          paragraph = mark[:item].children.first
+          return unless paragraph&.type == :p && paragraph.options[:prose_source]
+          return unless paragraph.options[:location] == mark[:line]
+
+          source = paragraph.options[:prose_source]
+          checkbox = source[/\A[ \t]*\[[ xX]\][ \t]+/].to_s
+          text = source[checkbox.length..]
+          opening = opening_word(text)
+          word = opening&.word
+          return unless word&.match?(/\A[\p{L}\p{M}]+\z/) ||
+                        (opening&.code && word&.match?(/\A[\p{L}\p{M}][\p{L}\p{M}\p{N}_]*\z/))
+
+          return if ignored_word?(opening.word)
+          return if cop_config['PreserveMixedCase'] && opening.word[1..].match?(/[\p{Lu}\p{Lt}]/)
+
+          after = text[opening.end_pos..].sub(/\A(?:\*+|_+|`+|["'“”‘’»›\]]+)+/, '')
+          return if after.match?(%r{\A(?:[\p{L}\p{M}_]|[._/:-])})
+
+          offset = checkbox.length + opening.begin_pos
+          return if source[0...offset].include?("\n")
+
+          column = document.content_start(paragraph, mark[:line]) + offset
+          range = document.range(mark[:line], column, mark[:line], column + 1)
+          [range, opening.word[0].match?(/\p{Ll}/) ? 'lowercase' : 'uppercase', opening.literal]
+        end
+      end
+    end
+  end
+end