mdl 0.15.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b0bf6bf60ca7328cdc7b7c979b1c7f9eea59f99c35a219da0eddf8c73e529cc
-  data.tar.gz: 954a6871342a9137babebe806cab333bbf883d835cdc1ff867731145fb52d85f
+  metadata.gz: 5f3b2d8b702d0c1f3e4401b5c0a997d76f13368f57fc1be5d52acd2ca9ea35c2
+  data.tar.gz: f65a08dd97130930b44e93cb65cc318f218210b99d74ff915cd5842e17dca188
 SHA512:
-  metadata.gz: 987343bbcf9c9a260e205970c1ea1bba1c5eb8dc5e0d2f3ed03013126efdf58a65085275f24081019d27fe63c02ce0ebbe0dded59e265392833f19cd00b582dd
-  data.tar.gz: aa09c154c250f31e0f0ad9cefc8b1e243562a836c9d2c1d740aa7d5d20eac38ea91f56dd73c7a6d1d8aa5ab57b0ba41143013372a65eb208411d3b8ebe4b53bf
+  metadata.gz: 0a63864cdb9583963ff12d78ccfd5d304b8162c464842140ceae23d5b14afab9d8f4fd60e473634bb0fdf3f2580a68ca8aca451559df058276fc3cb235dc8290
+  data.tar.gz: d381798b1c293e45a237368232429e0ab1e9812c1963b674383c61b0301fdcd72f3f34c285bcd58ea5ed1695fa5fd0fbf01514929aa49ded6a4df74472ce1822

data/Gemfile

@@ -3,7 +3,7 @@ gemspec
 
 group :development, :test do
   gem 'base64'
-  gem 'bundler', '>= 1.12', '< 3'
+  gem 'bundler', '>= 1.12', '< 5'
   gem 'minitest', '~> 5.26', '>= 5.26.2'
   gem 'pry', '~> 0.15.2'
   gem 'rake', '~> 13.3', '>= 13.3.1'

data/lib/mdl/cli.rb

@@ -101,6 +101,12 @@ module MarkdownLint
            :proc => proc { puts MarkdownLint::VERSION },
            :exit => 0
 
+    option :fix,
+           :short => '-f',
+           :long => '--fix',
+           :description => 'Automatically fix what can be fixed',
+           :boolean => true
+
     option :json,
            :short => '-j',
            :long => '--json',
@@ -122,6 +128,9 @@ module MarkdownLint
       # Only fall back to ~/.mdlrc if we are using the default value for -c
       if filename.nil? && (config[:config_file] == CONFIG_FILE)
         filename = File.expand_path("~/#{CONFIG_FILE}")
+      elsif filename.nil? && config[:config_file] != CONFIG_FILE
+        warn "Config file '#{config[:config_file]}' not found"
+        exit 3
       end
 
       if !filename.nil? && File.exist?(filename)

data/lib/mdl/doc.rb

@@ -11,7 +11,7 @@ module MarkdownLint
     # subtract 1 from a line number to get the correct line. The element_line*
     # methods take care of this for you.
 
-    attr_reader :lines, :parsed, :elements, :offset
+    attr_reader :lines, :parsed, :elements, :offset, :front_matter
 
     ##
     # A Kramdown::Document object containing the parsed markdown document.
@@ -27,11 +27,13 @@ module MarkdownLint
     # Create a new document given a string containing the markdown source
 
     def initialize(text, ignore_front_matter = false)
-      regex = /^---\n(.*?)---\n\n?/m
+      regex = /\A---\n(.*?)---\n\n?/m
       if ignore_front_matter && regex.match(text)
-        @offset = regex.match(text).to_s.split("\n").length
+        @front_matter = regex.match(text).to_s
+        @offset = @front_matter.count("\n")
         text.sub!(regex, '')
       else
+        @front_matter = ''
         @offset = 0
       end
       # The -1 is to cause split to preserve an extra entry in the array so we
@@ -47,9 +49,12 @@ module MarkdownLint
 
     def self.new_from_file(filename, ignore_front_matter = false)
       if filename == '-'
-        new($stdin.read, ignore_front_matter)
+        new($stdin.read.scrub, ignore_front_matter)
       else
-        new(File.read(filename, :encoding => 'UTF-8'), ignore_front_matter)
+        new(
+          File.read(filename, :encoding => 'UTF-8').scrub,
+          ignore_front_matter,
+        )
       end
     end
 
@@ -211,7 +216,8 @@ module MarkdownLint
     # Returns line numbers for lines that match the given regular expression
 
     def matching_lines(regex)
-      @lines.each_with_index.select { |text, _linenum| regex.match(text) }
+      @lines.each_with_index
+            .select { |text, _linenum| regex.match(text) }
             .map do |i|
               i[1] + 1
             end
@@ -292,6 +298,12 @@ module MarkdownLint
       end.join.split("\n")
     end
 
+    ##
+    # Reconstruct the full file content from front matter and lines
+    def to_s
+      @front_matter + @lines.join("\n")
+    end
+
     private
 
     ##

data/lib/mdl/kramdown_parser.rb

@@ -16,6 +16,14 @@ module Kramdown
 
       # Regular kramdown parser, but with GFM style fenced code blocks
       FENCED_CODEBLOCK_MATCH = Kramdown::Parser::GFM::FENCED_CODEBLOCK_MATCH
+
+      # End paragraphs when a fenced code block starts, matching GFM
+      # behavior. Without this, fenced code blocks without a preceding
+      # blank line are swallowed into the paragraph.
+      PARAGRAPH_END = Regexp.union(
+        Kramdown::Parser::Kramdown::PARAGRAPH_END,
+        Kramdown::Parser::GFM::FENCED_CODEBLOCK_START,
+      )
     end
   end
 end

data/lib/mdl/rules.rb

@@ -111,15 +111,13 @@ rule 'MD005', 'Inconsistent indentation for list items at the same level' do
   check do |doc|
     bullets = doc.find_type(:li)
     errors = []
-    indent_levels = []
+    indent_levels = {}
     bullets.each do |b|
       indent_level = doc.indent_for(doc.element_line(b))
-      if indent_levels[b[:element_level]].nil?
-        indent_levels[b[:element_level]] = indent_level
-      end
-      if indent_level != indent_levels[b[:element_level]]
-        errors << doc.element_linenumber(b)
-      end
+      list_type = b[:parent].type
+      key = [b[:element_level], list_type]
+      indent_levels[key] = indent_level if indent_levels[key].nil?
+      errors << doc.element_linenumber(b) if indent_level != indent_levels[key]
     end
     errors
   end
@@ -144,16 +142,24 @@ rule 'MD007', 'Unordered list indentation' do
   params :indent => 3
   check do |doc|
     errors = []
-    indents = doc.find_type(:ul).map do |e|
-      [doc.indent_for(doc.element_line(e)), doc.element_linenumber(e)]
-    end
-    curr_indent = indents[0][0] unless indents.empty?
-    indents.each do |indent, linenum|
-      if (indent > curr_indent) && (indent - curr_indent != @params[:indent])
-        errors << linenum
+    # Check indentation of nested ul elements relative to their parent ul.
+    # Only compare parent-child ul pairs to avoid false positives when
+    # unrelated lists appear at different indent levels.
+    def check_ul_indent(doc, elements, parent_indent, errors, indent)
+      elements.each do |e|
+        if e.type == :ul
+          el_indent = doc.indent_for(doc.element_line(e))
+          if parent_indent && (el_indent > parent_indent) &&
+             (el_indent - parent_indent != indent)
+            errors << doc.element_linenumber(e)
+          end
+          check_ul_indent(doc, e.children, el_indent, errors, indent)
+        else
+          check_ul_indent(doc, e.children, parent_indent, errors, indent)
+        end
       end
-      curr_indent = indent
     end
+    check_ul_indent(doc, doc.elements, nil, errors, @params[:indent])
     errors
   end
 end
@@ -169,6 +175,11 @@ rule 'MD009', 'Trailing spaces' do
     end
     errors
   end
+  fix do |doc, lines|
+    lines.each do |linenum|
+      doc.lines[linenum - 1] = doc.lines[linenum - 1].rstrip
+    end
+  end
 end
 
 rule 'MD010', 'Hard tabs' do
@@ -189,13 +200,18 @@ rule 'MD010', 'Hard tabs' do
     hard_tab_lines -= codeblock_lines if params[:ignore_code_blocks]
     hard_tab_lines
   end
+  fix do |doc, lines|
+    lines.each do |linenum|
+      doc.lines[linenum - 1] = doc.lines[linenum - 1].gsub("\t", '    ')
+    end
+  end
 end
 
 rule 'MD011', 'Reversed link syntax' do
   tags :links
   aliases 'no-reversed-links'
   check do |doc|
-    doc.matching_text_element_lines(/\([^)]+\)\[[^\]]+\]/)
+    doc.matching_text_element_lines(/\([^)]+\)\[[^\]\^]+\]/)
   end
 end
 
@@ -215,13 +231,19 @@ rule 'MD012', 'Multiple consecutive blank lines' do
                        end.map { |_p, n| n }
     cons_blank_lines - codeblock_lines
   end
+  fix do |doc, lines|
+    lines.reverse_each do |linenum|
+      doc.lines.delete_at(linenum - 1)
+    end
+  end
 end
 
 rule 'MD013', 'Line length' do
   tags :line_length
   aliases 'line-length'
   params :line_length => 80, :ignore_code_blocks => false, :code_blocks => true,
-         :tables => true
+         :tables => true, :headings => true,
+         :treat_links_as_single_words => false
 
   check do |doc|
     # Every line in the document that is part of a code block.
@@ -242,7 +264,32 @@ rule 'MD013', 'Line length' do
         end
       end
     end.flatten
-    overlines = doc.matching_lines(/^.{#{@params[:line_length]}}.*\s/)
+    # Fallback: detect table-like lines not recognized by kramdown
+    # (e.g. tables without surrounding blank lines are parsed as paragraphs)
+    unless params[:tables]
+      doc.lines.each_with_index do |line, i|
+        linenum = i + 1
+        next if table_lines.include?(linenum)
+        next if codeblock_lines.include?(linenum)
+
+        table_lines << linenum if line.match?(/^\s*\|.*\|/)
+      end
+    end
+    single_word_lines = doc.matching_lines(/^\s*\S+$/) +
+                        doc.matching_lines(/^\s*(?:[-*+]|\d+[.)])\s+\S+$/)
+    if params[:treat_links_as_single_words]
+      link_re = /\[.*\]\([^)]*\)/
+      list_re = /^\s*(?:[-*+]|\d+[.)])\s+#{link_re.source}$/
+      single_word_lines +=
+        doc.matching_lines(/^\s*#{link_re.source}$/) +
+        doc.matching_lines(list_re)
+    end
+    # Every line in the document that is a header.
+    header_lines = doc.find_type_elements(:header).map do |e|
+      doc.element_linenumber(e)
+    end
+    overlines = doc.matching_lines(/^.{#{@params[:line_length]}}.+/)
+    overlines -= single_word_lines
     if !params[:code_blocks] || params[:ignore_code_blocks]
       overlines -= codeblock_lines
       unless params[:code_blocks]
@@ -252,6 +299,7 @@ rule 'MD013', 'Line length' do
       end
     end
     overlines -= table_lines unless params[:tables]
+    overlines -= header_lines unless params[:headings]
     overlines
   end
 end
@@ -261,8 +309,9 @@ rule 'MD014', 'Dollar signs used before commands without showing output' do
   aliases 'commands-show-output'
   check do |doc|
     doc.find_type_elements(:codeblock).select do |e|
-      !e.value.empty? &&
-        !e.value.split(/\n+/).map { |l| l.match(/^\$\s/) }.include?(nil)
+      lines = e.value.split(/\n+/)
+      !lines.empty? &&
+        !lines.map { |l| l.match(/^\$\s/) }.include?(nil)
     end.map { |e| doc.element_linenumber(e) }
   end
 end
@@ -275,6 +324,11 @@ rule 'MD018', 'No space after hash on atx style header' do
       doc.header_style(h) == :atx && doc.element_line(h).match(/^#+[^#\s]/)
     end.map { |h| doc.element_linenumber(h) }
   end
+  fix do |doc, lines|
+    lines.each do |linenum|
+      doc.lines[linenum - 1] = doc.lines[linenum - 1].sub(/^(#+)/, '\1 ')
+    end
+  end
 end
 
 rule 'MD019', 'Multiple spaces after hash on atx style header' do
@@ -285,6 +339,11 @@ rule 'MD019', 'Multiple spaces after hash on atx style header' do
       doc.header_style(h) == :atx && doc.element_line(h).match(/^#+\s\s/)
     end.map { |h| doc.element_linenumber(h) }
   end
+  fix do |doc, lines|
+    lines.each do |linenum|
+      doc.lines[linenum - 1] = doc.lines[linenum - 1].sub(/^(#+)\s+/, '\1 ')
+    end
+  end
 end
 
 rule 'MD020', 'No space inside hashes on closed atx style header' do
@@ -309,6 +368,13 @@ rule 'MD021', 'Multiple spaces inside hashes on closed atx style header' do
              || doc.element_line(h).match(/\s\s#+$/))
     end.map { |h| doc.element_linenumber(h) }
   end
+  fix do |doc, lines|
+    lines.each do |linenum|
+      doc.lines[linenum - 1] = doc.lines[linenum - 1]
+                                  .sub(/^(#+)\s+/, '\1 ')
+                                  .sub(/\s+(#+)$/, ' \1')
+    end
+  end
 end
 
 rule 'MD022', 'Headers should be surrounded by blank lines' do
@@ -380,6 +446,16 @@ rule 'MD023', 'Headers must start at the beginning of the line' do
     end
     errors.sort
   end
+  fix do |doc, lines|
+    lines.each do |linenum|
+      doc.lines[linenum - 1] = doc.lines[linenum - 1].lstrip
+      # For setext headers, also lstrip the underline on the next line
+      next_line = doc.lines[linenum]
+      if next_line&.match?(/^\s+(-+|=+)\s*$/)
+        doc.lines[linenum] = next_line.lstrip
+      end
+    end
+  end
 end
 
 rule 'MD024', 'Multiple headers with the same content' do
@@ -444,7 +520,8 @@ rule 'MD026', 'Trailing punctuation in header' do
   params :punctuation => '.,;:!?'
   check do |doc|
     doc.find_type(:header).select do |h|
-      h[:raw_text].match(/[#{params[:punctuation]}]$/)
+      h[:raw_text].match(/[#{params[:punctuation]}]$/) &&
+        !h[:raw_text].match(/:[a-zA-Z0-9_+-]+:\s*$/)
     end.map do |h|
       doc.element_linenumber(h)
     end
@@ -463,12 +540,24 @@ rule 'MD027', 'Multiple spaces after blockquote symbol' do
       # element
       errors << linenum if doc.element_line(e).match(/^\s*>  /)
       lines.each do |line|
-        errors << linenum if line.start_with?(' ')
+        # Check extracted text for leading spaces, but verify against the
+        # source line to avoid false positives from kramdown text processing
+        # (e.g. em-dash conversion creating leading spaces).
+        src = doc.lines[linenum - 1]
+        if line.start_with?(' ') && src&.match?(/^\s*(?:>\s?)+\s{2,}\S/)
+          errors << linenum
+        end
         linenum += 1
       end
     end
     errors
   end
+  fix do |doc, lines|
+    lines.each do |linenum|
+      doc.lines[linenum - 1] = doc.lines[linenum - 1].sub(/(>\s*>) +/, '\1 ')
+                                  .sub(/^> +/, '> ')
+    end
+  end
 end
 
 rule 'MD028', 'Blank line inside blockquote' do
@@ -506,18 +595,16 @@ rule 'MD029', 'Ordered list item prefix' do
       doc.find_type_elements(:ol).map do |l|
         doc.find_type_elements(:li, false, l.children)
            .map.with_index do |i, idx|
-          unless doc.element_line(i).strip.start_with?("#{idx + 1}. ")
-            doc.element_linenumber(i)
-          end
+          line = doc.element_line(i).gsub(/^[\s>]+/, '')
+          doc.element_linenumber(i) unless line.start_with?("#{idx + 1}. ")
         end
       end.flatten.compact
     when :one
       doc.find_type_elements(:ol).map do |l|
         doc.find_type_elements(:li, false, l.children)
       end.flatten.map do |i|
-        unless doc.element_line(i).strip.start_with?('1. ')
-          doc.element_linenumber(i)
-        end
+        line = doc.element_line(i).gsub(/^[\s>]+/, '')
+        doc.element_linenumber(i) unless line.start_with?('1. ')
       end.compact
     end
   end
@@ -571,7 +658,15 @@ rule 'MD031', 'Fenced code blocks should be surrounded by blank lines' do
         next
       end
 
-      fence = in_code ? nil : Regexp.last_match(1)
+      marker = Regexp.last_match(1)
+      # Backtick info strings cannot contain backticks (CommonMark spec),
+      # so a line like ```test``` is inline code, not a fence opener.
+      if marker[0] == '`' && !in_code
+        rest = line.strip[marker.length..]
+        next if rest&.include?('`')
+      end
+
+      fence = in_code ? nil : marker
       in_code = !in_code
       if (in_code && !lines[linenum - 1].empty?) ||
          (!in_code && !lines[linenum + 1].empty?)
@@ -591,12 +686,22 @@ rule 'MD032', 'Lists should be surrounded by blank lines' do
     # without surrounding whitespace, so examine the lines directly.
     in_list = false
     in_code = false
+    in_comment = false
     fence = nil
     prev_line = ''
     doc.lines.each_with_index do |line, linenum|
       next if line.strip == '{:toc}'
 
-      unless in_code
+      # Track HTML comments
+      if !in_comment && line.match?(/<!--/) && !line.match?(/-->/)
+        in_comment = true
+      elsif in_comment && line.match?(/-->/)
+        in_comment = false
+        prev_line = ''
+        next
+      end
+
+      unless in_code || in_comment
         list_marker = line.strip.match(/^([*+-]|(\d+\.))\s/)
         if list_marker && !in_list && !prev_line.match(/^($|\s)/)
           errors << (linenum + 1)
@@ -637,7 +742,40 @@ rule 'MD034', 'Bare URL used' do
   tags :links, :url
   aliases 'no-bare-urls'
   check do |doc|
-    doc.matching_text_element_lines(%r{https?://})
+    errors = doc.matching_text_element_lines(
+      %r{https?://}, %i{a html_element}
+    )
+    # Text elements inside tables lack location info, so check table
+    # text elements separately using the table's location.
+    doc.find_type_elements(:table).each do |t|
+      table_start = doc.element_linenumber(t)
+      next if table_start.nil?
+
+      doc.find_type_elements_except(:text, [:a], t.children).each do |e|
+        next unless e.value.match?(%r{https?://})
+
+        # Find this text in the table's source lines
+        doc.lines[(table_start - 1)..].each_with_index do |line, i|
+          linenum = table_start + i
+          break unless line&.match?(/^\s*\|/)
+
+          if line.include?(e.value.strip)
+            errors << linenum
+            break
+          end
+        end
+      end
+    end
+    # Filter out false positives where the source line doesn't actually
+    # contain a bare URL (kramdown can misparse links containing pipes
+    # as tables, reporting wrong line numbers)
+    errors.uniq.sort.select do |linenum|
+      line = doc.lines[linenum - 1]
+      next false if line.nil?
+
+      # Strip URLs inside markdown links, then check if a bare URL remains
+      line.gsub(%r{\]\(https?://[^)]*\)}, '').match?(%r{https?://})
+    end
   end
 end
 
@@ -691,9 +829,12 @@ rule 'MD037', 'Spaces inside emphasis markers' do
   check do |doc|
     # Kramdown doesn't parse emphasis with spaces, which means we can just
     # look for emphasis patterns inside regular text with spaces just inside
-    # them.
+    # them. Exclude lines with escaped emphasis markers (\* or \_) since
+    # kramdown resolves escapes in text element values.
     (doc.matching_text_element_lines(/\s(\*\*?|__?)\s.+\1/) |
-      doc.matching_text_element_lines(/(\*\*?|__?).+\s\1\s/)).sort
+      doc.matching_text_element_lines(/(\*\*?|__?).+\s\1\s/))
+      .reject { |linenum| doc.lines[linenum - 1]&.match?(/\\[*_]/) }
+      .sort
   end
 end
 
@@ -733,7 +874,8 @@ rule 'MD040', 'Fenced code blocks should have a language specified' do
     # the class attribute set to language-languagename.
     doc.element_linenumbers(doc.find_type_elements(:codeblock).select do |i|
                               !i.attr['class'].to_s.start_with?('language-') &&
-                                !doc.element_line(i).start_with?('    ')
+                                !doc.element_line(i).start_with?('    ') &&
+                                !doc.element_line(i).start_with?("\t")
                             end)
   end
 end
@@ -798,4 +940,7 @@ rule 'MD047', 'File should end with a single newline character' do
     error_lines.push(doc.lines.length) unless last_line.nil? || last_line.empty?
     error_lines
   end
+  fix do |doc, _lines|
+    doc.lines << '' unless doc.lines[-1] && doc.lines[-1].empty?
+  end
 end

data/lib/mdl/ruleset.rb

@@ -19,6 +19,11 @@ module MarkdownLint
       @check
     end
 
+    def fix(&block)
+      @fix = block unless block.nil?
+      @fix
+    end
+
     def tags(*tags)
       @tags = tags.flatten.map(&:to_sym) unless tags.empty?
       @tags
@@ -30,7 +35,21 @@ module MarkdownLint
     end
 
     def params(params = nil)
-      @params.update(params) unless params.nil?
+      unless params.nil?
+        # Normalize string values to symbols where the rule's default is
+        # a symbol AND the string looks like a simple identifier, so that
+        # style files can use either :atx or "atx". Values like "---"
+        # (MD035 hr style) are left as strings.
+        params = params.each_with_object({}) do |(k, v), h|
+          h[k] = if v.is_a?(String) && @params[k].is_a?(Symbol) &&
+                    v.match?(/\A[a-z][a-z_]*\z/)
+                   v.to_sym
+                 else
+                   v
+                 end
+        end
+        @params.update(params)
+      end
       @params
     end
 

data/lib/mdl/style.rb

@@ -38,6 +38,7 @@ module MarkdownLint
 
     def exclude_rule(id)
       id = @aliases[id] if @aliases[id]
+      all if @rules.empty?
       @rules.delete(id)
     end
 
@@ -46,6 +47,7 @@ module MarkdownLint
     end
 
     def exclude_tag(tag)
+      all if @rules.empty?
       @rules.subtract(@tagged_rules[tag])
     end
 

data/lib/mdl/version.rb

@@ -1,3 +1,3 @@
 module MarkdownLint
-  VERSION = '0.15.0'.freeze
+  VERSION = '0.17.0'.freeze
 end

data/lib/mdl.rb

@@ -62,6 +62,7 @@ module MarkdownLint
 
     # Recurse into directories
     cli.cli_arguments.each_with_index do |filename, i|
+      filename = filename.chomp('/') if filename.end_with?('/')
       if Dir.exist?(filename)
         if Config[:git_recurse]
           Dir.chdir(filename) do
@@ -88,6 +89,12 @@ module MarkdownLint
         )
         exit 3
       end
+
+      if Config[:fix] && filename != '-'
+        original_text = File.read(filename, :encoding => 'UTF-8').scrub
+        text = original_text.dup
+      end
+
       doc = Doc.new_from_file(filename, Config[:ignore_front_matter])
       filename = '(stdin)' if filename == '-'
       if Config[:show_kramdown_warnings]
@@ -102,10 +109,19 @@ module MarkdownLint
         next if error_lines.nil? || error_lines.empty?
 
         status = 1
+        corrected = false
+        if Config[:fix] && filename != '(stdin)' && rule.fix
+          rule.fix.call(doc, error_lines)
+          text = doc.to_s
+          doc = Doc.new(text.dup, Config[:ignore_front_matter])
+          corrected = true
+        end
+
+        suffix = corrected ? ' (corrected)' : ''
         error_lines.each do |line|
           line += doc.offset # Correct line numbers for any yaml front matter
           if Config[:json] || Config[:sarif]
-            results << {
+            result = {
               'filename' => filename,
               'line' => line,
               'rule' => id,
@@ -113,9 +129,12 @@ module MarkdownLint
               'description' => rule.description,
               'docs' => rule.docs_url,
             }
+            result['corrected'] = corrected if Config[:fix]
+            results << result
           else
             linked_id = linkify(printable_id(rule), rule.docs_url)
-            puts "#{filename}:#{line}: #{linked_id} " + rule.description.to_s
+            puts "#{filename}:#{line}: #{linked_id} " \
+                 "#{rule.description}#{suffix}"
           end
         end
 
@@ -124,10 +143,15 @@ module MarkdownLint
         # for that) then, instead of making the output ugly with long URLs, we
         # print them at the end. And of course we only want to print each URL
         # once.
-        if !Config[:json] && !Config[:sarif] &&
-           !$stdout.tty? && !docs_to_print.include?(rule)
-          docs_to_print << rule
-        end
+        next unless !Config[:json] && !Config[:sarif] &&
+                    !$stdout.tty? && rule.docs_url &&
+                    !docs_to_print.include?(rule)
+
+        docs_to_print << rule
+      end
+
+      if Config[:fix] && filename != '(stdin)' && text != original_text
+        File.write(filename, text)
       end
     end
 

data/mdl.gemspec

@@ -5,8 +5,8 @@ require 'mdl/version'
 Gem::Specification.new do |spec|
   spec.name = 'mdl'
   spec.version = MarkdownLint::VERSION
-  spec.authors = ['Mark Harrison']
-  spec.email = ['mark@mivok.net']
+  spec.authors = ['Phil Dibowitz']
+  spec.email = ['phil@ipom.com']
   spec.summary = 'Markdown lint tool'
   spec.description = 'Style checker/lint tool for markdown files'
   spec.homepage = 'https://github.com/markdownlint/markdownlint'
@@ -21,7 +21,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 3.2'
 
-  spec.add_dependency 'kramdown', '~> 2.3'
+  spec.add_dependency 'kramdown', '~> 2.5'
   spec.add_dependency 'kramdown-parser-gfm', '~> 1.1'
   spec.add_dependency 'mixlib-cli'
   spec.add_dependency 'mixlib-config'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mdl
 version: !ruby/object:Gem::Version
-  version: 0.15.0
+  version: 0.17.0
 platform: ruby
 authors:
-- Mark Harrison
+- Phil Dibowitz
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-26 00:00:00.000000000 Z
+date: 2026-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kramdown
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: kramdown-parser-gfm
   requirement: !ruby/object:Gem::Requirement
@@ -82,7 +82,7 @@ dependencies:
         version: '0'
 description: Style checker/lint tool for markdown files
 email:
-- mark@mivok.net
+- phil@ipom.com
 executables:
 - mdl
 extensions: []