mdlint 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f620c8c00a85c39a41cc1f81a4708ead9496071dd6cf984cd64eb7749bf646f
-  data.tar.gz: 76c8f42560a6b98b8007b05911825017d34cc09dad59ee0545f2a87b863bfd01
+  metadata.gz: 25d6971b46664870bcf318a6013fe69079a6e8208f061d22e39ec18cce41d15a
+  data.tar.gz: 471f942064bb9944fd5344766811f32b9ab28e15112c873399e5fb034fa52770
 SHA512:
-  metadata.gz: 202ea22fc2617cce04c03a0785ee64dfd64e62e306de58a6cf50257668b0992b2de1fa953cbe8d7374db4de0aeb99940c8dd98e936b34b47022316058a34f8cd
-  data.tar.gz: b987544c415e6bfa021d7472080284c07a9f179b1ad46dddcc53944faa4e14a3f3a27db7202f72d8208deac05a95234a8f9b1eab5b3d40907cbd98aa0210eee0
+  metadata.gz: 241b2426e28d513cc63daccc62dc22ae264d0269d12301ae324ba8318ebe0a08c90f6a9523e421ee3e577dcedf694ae957c68034ec8bcd266db78502ca7e281d
+  data.tar.gz: a5e7d1800c8ec2c090b5de2d3605dafc66bf0ed087565dd97db4136b680b4a0464e70c603ed23960a54e395c92e7e1a14408898cdc90446887d204a65bc64ad6

data/.pre-commit-hooks.yaml

@@ -0,0 +1,6 @@
+- id: mdlint
+  name: mdlint
+  description: Check Markdown formatting and lint violations
+  entry: mdlint --check
+  language: system
+  files: \\.md$

data/CHANGELOG.md

@@ -7,6 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+## 0.2.0 - 2026-08-12
+
+### Added
+
+- Added `lint`, `fix`, and `lsp` CLI commands while keeping formatting as the default command.
+- Added lint fixes with `--fix`, `--fix-only`, and `--dry-run`.
+- Added inline directives for disabling and enabling rules, including file-level and next-line controls.
+- Added rule discovery and guidance through `--list-rules` and `--explain`, with Markdownlint-compatible rule IDs and aliases.
+- Added configurable severities, fail levels, and text, JSON, SARIF, GitHub, Checkstyle, JUnit, and reviewdog output formats.
+- Added YAML, TOML, and JSON front matter preservation during parsing and formatting.
+- Added GFM tables, task lists, strikethrough, bare URL autolinks, and selectable Markdown dialects.
+- Added HTML rendering through `Mdlint.html`.
+- Added `--auto-gen-config`, parallel file processing, and content/configuration-hash caching.
+- Added GitHub Action, reviewdog integration, and a pre-commit hook.
+- Added LSP diagnostics, formatting, and quick fixes.
+- Added the Japanese technical-writing preset (`JA001`–`JA007`), CJK-aware wrapping, link and anchor checks, and table-of-contents updates.
+- Added optional fenced-code validation and formatting commands with configurable timeouts.
+- Added 29 built-in lint rules and a stable plugin API for custom rules and dialect feature sets.
+
+### Changed
+
+- `Mdlint.lint` now honors rule selections, disabled rules, aliases, severity settings, and configuration-file options from `.mdlint.yml`.
+- `Mdlint.fix` and rule fixes now consistently return formatted source strings.
+- Markdown parsing and HTML rendering now handle nested lists, loose list items, reference links and images, entities, code spans, block quotes, directives, and common URI autolinks more consistently.
+- GFM behavior is enabled explicitly with `dialect: :gfm` or `--dialect gfm`; CommonMark remains the default dialect.
+
+### Fixed
+
+- Fixed front matter being interpreted as thematic breaks, headings, or ordinary Markdown content.
+- Fixed configured rules and disabled rules being ignored by the linter.
+- Fixed inline links, reference links, images, escaped destinations, and nested link destinations being parsed or rendered incorrectly.
+- Fixed formatter output changing document meaning in supported Markdown cases and added idempotence and HTML meaning-preservation checks.
+
 ## 0.1.0 - 2025-01-23
 
 - Initial release

data/README.md

@@ -24,7 +24,18 @@
 - Linting with configurable rules and clear violations
 - Auto-formatting that follows mdformat conventions
 - CLI for CI-friendly workflows and local formatting
-- Simple YAML configuration file
+- YAML/TOML/JSON front matter preservation
+- GFM tables, task lists, strikethrough, and configurable dialects
+- Text, JSON, SARIF, Checkstyle, JUnit, and GitHub diagnostic output
+- Optional HTML rendering through the Ruby API
+- GitHub Action and RBS/Steep signatures for integration and tooling
+- reviewdog-compatible RDJSON output through the CLI and GitHub Action
+- Language Server Protocol diagnostics, formatting, and quick fixes
+- Parallel linting with a content/configuration-hash cache
+- Japanese technical-writing preset, code-block syntax checks, link/anchor checks, and TOC updates
+- Optional language commands for code-block validation and formatting
+- 29 built-in lint rules with Markdownlint-compatible IDs and aliases
+- Stable plugin registration for custom rules and dialect feature sets
 
 ## Quickstart
 
@@ -39,6 +50,12 @@ mdlint --check README.md
 
 # show diffs
 mdlint --diff README.md
+
+# lint and report violations
+mdlint lint docs/
+
+# fix fixable lint violations
+mdlint fix --dry-run docs/
 ```
 
 ## Installation
@@ -63,12 +80,16 @@ Command line:
 mdlint README.md docs/
 mdlint --check README.md
 mdlint --diff README.md
+mdlint lint README.md
+mdlint fix README.md
 ```
 
 Options:
 
 ```
-Usage: mdlint [options] [paths...]
+Usage: mdlint [command] [options] [paths...]
+
+Commands: format (default), lint, fix, lsp
 
 Options:
     -c, --check              Check if files are formatted, exit with error if not
@@ -77,7 +98,34 @@ Options:
     -e, --exclude PATTERN    Exclude files matching pattern
     -w, --wrap MODE          Paragraph wrapping: keep (default), no, or INTEGER
         --number             Use consecutive numbering for ordered lists
-        --end-of-line MODE   End of line: lf (default), crlf, keep
+    --end-of-line MODE   End of line: lf (default), crlf, keep
+        --fix                 Fix fixable lint violations
+        --fix-only            Apply fixes without reporting remaining violations
+        --dry-run             Do not write fixes to files
+        --disable RULES       Disable comma-separated rules
+        --rule RULES          Run only comma-separated rules
+        --severity LEVEL      Default severity: error, warning, or info
+        --fail-level LEVEL    Fail at severity: error, warning, or info
+        --format FORMAT       Lint output: text, json, sarif, github, checkstyle, junit, reviewdog
+        --stdin-filename NAME Filename to use for stdin diagnostics
+        --dialect DIALECT     Markdown dialect: commonmark or gfm
+        --preset NAME          Enable a rule preset, such as japanese
+        --check-links          Check relative link, image, and anchor targets
+        --check-external-links Check external HTTP(S) links
+        --check-code-blocks    Validate supported fenced code blocks
+        --code-block-command SPEC Validate a language block with LANG=COMMAND
+        --code-block-formatter SPEC Format a language block with LANG=COMMAND
+        --code-block-timeout SECONDS Timeout for external code-block commands
+        --toc                  Update table-of-contents markers
+        --no-table-align       Do not pad GFM table columns
+        --jobs N               Process files concurrently
+        --cache                Cache lint diagnostics
+        --cache-path PATH      Path for the lint cache
+        --lsp                  Run the Language Server Protocol server
+        --list-rules           List available lint rules
+        --explain RULE        Explain a lint rule
+        --require PATH        Load a custom rule file
+        --auto-gen-config     Write a config disabling current violations
     -v, --version            Show version
     -h, --help               Show help
 ```
@@ -96,6 +144,11 @@ violations = Mdlint.lint("# Heading\n\n\n\nParagraph")
 violations.each { |v| puts v }
 
 violations = Mdlint.lint_file("README.md")
+
+fixed = Mdlint.fix("Line  \n")
+html = Mdlint.html("# Hello\n\n**world**\n")
+gfm_tokens = Mdlint.parse("- [x] Done\n", dialect: :gfm)
+toc_updated = Mdlint.update_toc("# Hello\n\n<!-- toc -->\nold\n<!-- toc -->\n")
 ```
 
 ## Configuration
@@ -113,6 +166,39 @@ quiet: false
 exclude:
   - "vendor/**/*.md"
   - "node_modules/**/*.md"
+
+# Markdown dialect
+dialect: commonmark # or gfm
+
+# Optional integrations
+preset: japanese
+toc: false
+check_links: false
+check_external_links: false
+check_code_blocks: false
+code_block_timeout: 10
+jobs: 2
+cache: true
+cache_path: .mdlint_cache
+
+# Rule configuration (markdownlint-compatible IDs and aliases are accepted)
+rules:
+  MD013:
+    enabled: true
+    line_length: 120
+    ignore_code_blocks: true
+  MD009: false
+
+# Severity and CI threshold
+severity: warning
+fail_level: error
+
+# Custom rule files
+plugins:
+  - "./rules/my_rule.rb"
+
+# A plugin may register a feature subset for a project-specific dialect.
+# Mdlint::Plugin.register_dialect(:docs, features: [:tables])
 ```
 
 ## Lint Rules
@@ -124,13 +210,44 @@ Key rules:
 - No trailing spaces
 - No multiple consecutive blank lines
 - First line should be a top-level heading
+- Lines should respect MD013's configured length
+- Relative links, images, and anchors can be checked with `mdlint lint --check-links`.
+- External HTTP(S) links are opt-in with `--check-external-links`.
+- `--preset japanese` enables JA001–JA007 writing checks; options include `sentence_length` and `max_commas`.
+- `--check-code-blocks` validates JSON and Ruby fenced blocks.
+- `--code-block-command python='python -m py_compile -'` adds opt-in validation for another language; commands receive block content on stdin.
+- `--code-block-formatter python='black -'` can rewrite an external language block; commands are bounded by `code_block_timeout` (10 seconds by default).
+- `--toc` regenerates content between paired `<!-- toc -->` or `<!-- toc:start -->` / `<!-- toc:end -->` markers.
+
+Plugins can use the stable API from a required Ruby file:
+
+```ruby
+class MyRule < Mdlint::Linter::Rule
+  self.rule_id = "PL001"
+  self.aliases = ["my-rule"]
+  self.description = "Project-specific Markdown rule"
+end
+
+Mdlint::Plugin.register_rule(MyRule)
+Mdlint::Plugin.register_dialect(:docs, features: [:tables, :task_lists])
+```
+
+Inline directives can suppress diagnostics for a section or one line:
+
+```markdown
+<!-- mdlint-disable MD013 -->
+long content is allowed here
+<!-- mdlint-enable MD013 -->
+<!-- mdlint-disable-next-line MD001 -->
+### Intentional jump
+```
 
 ## Formatting Style
 
 | Element | Style |
 |---------|-------|
 | Headings | ATX style only (`#`) |
-| Bullet lists | Hyphen (`-`), alternating for nested |
+| Bullet lists | Hyphen (`-`) at every nesting level |
 | Ordered lists | All items use `1.` (minimizes diffs) |
 | Code blocks | Fenced style (`` ``` ``) |
 | Horizontal rules | 70 underscores |
@@ -153,6 +270,7 @@ Block elements:
 - Horizontal rules (`---`, `***`, `___`)
 - HTML blocks
 - Reference definitions
+- Footnotes, fenced math blocks, GitHub alerts, and MDX/JSX component blocks
 
 Inline elements:
 
@@ -165,11 +283,25 @@ Inline elements:
 - Autolinks (`<https://example.com>`)
 - Hard breaks (backslash + newline)
 
+With `dialect: gfm`, tables, task lists, strikethrough, and bare URL autolinks are supported. Footnote definitions/references, fenced math blocks, GitHub alerts, and MDX/JSX blocks are preserved and included in HTML output.
+
 ## Development
 
 ```bash
 bin/setup
 bundle exec rspec
+rbs validate
+steep check --no-daemon --severity-level error
+
+# Optional quality tools
+ruby script/fetch_commonmark_spec.rb
+bundle exec rspec spec/commonmark_spec.rb
+ITERATIONS=100 ruby benchmark/format.rb README.md
+ruby script/commonmark_compatibility.rb spec/fixtures/commonmark_smoke.json
+ITERATIONS=100 ruby benchmark/compare.rb README.md
+# Property tests cover formatter idempotence and HTML meaning preservation.
+bundle exec rspec spec/mdlint/property_spec.rb
+bundle exec rake property
 ```
 
 ## Contributing

data/Rakefile

@@ -4,5 +4,19 @@ require "bundler/gem_tasks"
 require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:property) do |task|
+  task.pattern = "spec/mdlint/property_spec.rb"
+end
+
+namespace :commonmark do
+  task :fetch do
+    sh "ruby script/fetch_commonmark_spec.rb"
+  end
+
+  task :compatibility do
+    sh "ruby script/fetch_commonmark_spec.rb spec/fixtures/commonmark.json"
+    sh "ruby script/commonmark_compatibility.rb spec/fixtures/commonmark.json"
+  end
+end
 
 task default: :spec

data/Steepfile

@@ -0,0 +1,17 @@
+target :lib do
+  signature "sig"
+  library "cgi"
+  library "digest"
+  library "fileutils"
+  library "json"
+  library "net-http"
+  library "open3"
+  library "optparse"
+  library "ripper"
+  library "shellwords"
+  library "stringio"
+  library "timeout"
+  library "uri"
+  library "yaml"
+  check "lib"
+end

data/action.yml

@@ -0,0 +1,54 @@
+name: mdlint
+description: Lint and format Markdown files with mdlint
+branding:
+  icon: check-circle
+  color: blue
+inputs:
+  args:
+    description: Arguments passed to mdlint
+    required: false
+    default: lint --format github
+  ruby-version:
+    description: Ruby version used by the action
+    required: false
+    default: '3.2'
+  reviewdog:
+    description: Run diagnostics through reviewdog
+    required: false
+    default: 'false'
+  reviewdog-reporter:
+    description: reviewdog reporter name
+    required: false
+    default: github-pr-check
+  reviewdog-filter-mode:
+    description: reviewdog filter mode
+    required: false
+    default: added
+runs:
+  using: composite
+  steps:
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@95ef2b042f9d7a56d8268cba8559e2842e2ad01b # v1
+      with:
+        ruby-version: ${{ inputs.ruby-version }}
+    - name: Install mdlint
+      shell: bash
+      run: gem install mdlint --no-document # zizmor: ignore[adhoc-packages]
+    - name: Set up reviewdog
+      if: inputs.reviewdog == 'true'
+      uses: reviewdog/action-setup@d8a7baabd7f3e8544ee4dbde3ee41d0011c3a93f # v1
+      with:
+        reviewdog_version: latest
+    - name: Run mdlint
+      shell: bash
+      env:
+        MDLINT_ARGS: ${{ inputs.args }}
+        REVIEWDOG_ENABLED: ${{ inputs.reviewdog }}
+        REVIEWDOG_REPORTER: ${{ inputs.reviewdog-reporter }}
+        REVIEWDOG_FILTER_MODE: ${{ inputs.reviewdog-filter-mode }}
+      run: |
+        if [ "$REVIEWDOG_ENABLED" = "true" ]; then
+          mdlint $MDLINT_ARGS --format reviewdog | reviewdog -f=rdjson "-reporter=$REVIEWDOG_REPORTER" "-filter-mode=$REVIEWDOG_FILTER_MODE"
+        else
+          mdlint $MDLINT_ARGS
+        fi

data/benchmark/compare.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "../lib/mdlint"
+
+path = ARGV.first
+source = path && File.file?(path) ? File.read(path) : <<~MARKDOWN
+  # Benchmark document
+
+  A paragraph with **strong text**, `inline code`, and a [link](https://example.com).
+
+  - one
+  - two
+
+  ```ruby
+  puts "hello"
+  ```
+MARKDOWN
+iterations = Integer(ENV.fetch("ITERATIONS", "100"))
+
+adapters = { "mdlint" => -> { Mdlint.html(source) } }
+
+begin
+  require "kramdown"
+  adapters["kramdown"] = -> { Kramdown::Document.new(source).to_html }
+rescue LoadError
+  warn "kramdown: unavailable (install it to include this adapter)"
+end
+
+begin
+  require "commonmarker"
+  adapters["commonmarker"] = lambda do
+    if Commonmarker.respond_to?(:to_html)
+      Commonmarker.to_html(source)
+    elsif Commonmarker.respond_to?(:render_doc)
+      Commonmarker.render_doc(source).to_html
+    else
+      raise "unsupported commonmarker API"
+    end
+  end
+rescue LoadError
+  warn "commonmarker: unavailable (install it to include this adapter)"
+end
+
+adapters.each do |name, formatter|
+  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  iterations.times { formatter.call }
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+  puts format("%-14s %.6fs (%.2f ops/s)", name, elapsed, iterations / elapsed)
+end

data/benchmark/format.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../lib/mdlint"
+
+path = ARGV.first
+source = path && File.file?(path) ? File.read(path) : <<~MARKDOWN
+  # Benchmark document
+
+  This is a representative paragraph with **strong text**, `inline code`, and a [link](https://example.com).
+
+  - one
+  - two
+
+  ```ruby
+  puts "hello"
+  ```
+MARKDOWN
+
+iterations = Integer(ENV.fetch("ITERATIONS", "100"))
+measure = lambda do |label, &block|
+  started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  iterations.times(&block)
+  elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+  puts format("%-16s %.6fs (%.2f ops/s)", label, elapsed, iterations / elapsed)
+end
+
+measure.call("format x#{iterations}") { Mdlint.format(source) }
+measure.call("html x#{iterations}") { Mdlint.html(source) }
+measure.call("lint x#{iterations}") { Mdlint.lint(source) }

data/lib/mdlint/cache_store.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "digest"
+require "fileutils"
+require "json"
+
+module Mdlint
+  class CacheStore
+    def initialize(path)
+      @path = path
+      @mutex = Mutex.new
+      @data = load_data
+      @dirty = false
+    end
+
+    def key(source, options)
+      Digest::SHA256.hexdigest(JSON.generate([source, canonicalize(options)]))
+    end
+
+    def fetch(key)
+      @mutex.synchronize do
+        values = @data[key]
+        values&.map do |value|
+          attributes = symbolize(value)
+          Linter::Violation.new(
+            rule_id: attributes[:rule_id].to_s,
+            message: attributes[:message].to_s,
+            line: attributes[:line].to_i,
+            column: attributes[:column],
+            severity: (attributes[:severity] || :warning).to_sym,
+            fixable: attributes[:fixable] == true
+          )
+        end
+      end
+    end
+
+    def store(key, violations)
+      @mutex.synchronize do
+        @data[key] = violations.map(&:to_h)
+        @dirty = true
+      end
+    end
+
+    def save
+      @mutex.synchronize do
+        return unless @dirty
+
+        parent = File.dirname(@path)
+        FileUtils.mkdir_p(parent) unless parent == "."
+        File.write(@path, JSON.pretty_generate(@data) + "\n")
+        @dirty = false
+      end
+    end
+
+    private
+
+    def load_data
+      return {} unless File.file?(@path)
+
+      JSON.parse(File.read(@path))
+    rescue JSON::ParserError, SystemCallError
+      {}
+    end
+
+    def canonicalize(value)
+      case value
+      when Hash
+        value.keys.map(&:to_s).sort.to_h do |key|
+          original_key = value.keys.find { |candidate| candidate.to_s == key }
+          [key, canonicalize(value[original_key])]
+        end
+      when Array
+        value.map { |item| canonicalize(item) }
+      when Symbol
+        value.to_s
+      else
+        value
+      end
+    end
+
+    def symbolize(value)
+      value.each_with_object({}) { |(key, item), result| result[key.to_sym] = item }
+    end
+  end
+end

data/lib/mdlint/cli/output_formatter.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Mdlint
+  class CLI
+    class OutputFormatter
+      LEVELS = { error: "error", warning: "warning", info: "note" }.freeze
+
+      def initialize(format)
+        @format = format.to_s.downcase
+      end
+
+      def render(entries)
+        return "" if entries.empty? && @format == "text"
+
+        case @format
+        when "json"
+          json(entries)
+        when "sarif"
+          sarif(entries)
+        when "github"
+          github(entries)
+        when "checkstyle"
+          checkstyle(entries)
+        when "junit"
+          junit(entries)
+        when "reviewdog", "rdjson"
+          reviewdog(entries)
+        else
+          text(entries)
+        end
+      end
+
+      private
+
+      def text(entries)
+        entries.map { |entry| "#{entry[:filename]}:#{entry[:violation]}" }.join("\n") + "\n"
+      end
+
+      def json(entries)
+        JSON.generate(entries.map do |entry|
+          entry[:violation].to_h.merge(file: entry[:filename])
+        end) + "\n"
+      end
+
+      def github(entries)
+        entries.map do |entry|
+          violation = entry[:violation]
+          command = violation.error? ? "error" : violation.info? ? "notice" : "warning"
+          location = "file=#{entry[:filename]},line=#{violation.line}"
+          location += ",col=#{violation.column}" if violation.column
+          "::#{command} #{location}::[#{violation.rule_id}] #{violation.message}"
+        end.join("\n") + "\n"
+      end
+
+      def sarif(entries)
+        rules = entries.map { |entry| entry[:violation].rule_id }.uniq.filter_map do |rule_id|
+          rule = Mdlint::Linter::RuleRegistry.find(rule_id)
+          next unless rule
+
+          {
+            id: rule.rule_id,
+            shortDescription: { text: rule.description.to_s }
+          }
+        end
+        rule_indexes = rules.each_with_index.to_h { |rule, index| [rule[:id], index] }
+
+        document = {
+          version: "2.1.0",
+          "$schema": "https://json.schemastore.org/sarif-2.1.0.json",
+          runs: [{
+            tool: { driver: { name: "mdlint", rules: rules } },
+            results: entries.map do |entry|
+              violation = entry[:violation]
+              location = {
+                physicalLocation: {
+                  artifactLocation: { uri: entry[:filename] },
+                  region: { startLine: violation.line }
+                }
+              }
+              location[:physicalLocation][:region][:startColumn] = violation.column if violation.column
+              {
+                ruleId: violation.rule_id,
+                ruleIndex: rule_indexes[violation.rule_id],
+                level: LEVELS.fetch(violation.severity, "warning"),
+                message: { text: violation.message },
+                locations: [location]
+              }
+            end
+          }]
+        }
+        JSON.generate(document) + "\n"
+      end
+
+      def checkstyle(entries)
+        files = entries.group_by { |entry| entry[:filename] }.map do |filename, file_entries|
+          errors = file_entries.map do |entry|
+            violation = entry[:violation]
+            attributes = {
+              line: violation.line,
+              column: violation.column,
+              severity: violation.severity,
+              message: "[#{violation.rule_id}] #{violation.message}",
+              source: violation.rule_id
+            }.compact.map { |key, value| "#{key}=\"#{xml_escape(value)}\"" }.join(" ")
+            "    <error #{attributes}/>"
+          end
+          "  <file name=\"#{xml_escape(filename)}\">\n#{errors.join("\n")}\n  </file>"
+        end
+        "<checkstyle version=\"1.0\">\n#{files.join("\n")}\n</checkstyle>\n"
+      end
+
+      def junit(entries)
+        cases = entries.map do |entry|
+          violation = entry[:violation]
+          name = "#{entry[:filename]}:#{violation.line}:#{violation.rule_id}"
+          "    <testcase name=\"#{xml_escape(name)}\"><failure message=\"#{xml_escape(violation.message)}\"/></testcase>"
+        end
+        "<testsuite name=\"mdlint\" tests=\"#{entries.length}\" failures=\"#{entries.length}\">\n#{cases.join("\n")}\n</testsuite>\n"
+      end
+
+      def reviewdog(entries)
+        document = {
+          source: { name: "mdlint" },
+          diagnostics: entries.map do |entry|
+            violation = entry[:violation]
+            column = violation.column || 1
+            {
+              message: "[#{violation.rule_id}] #{violation.message}",
+              location: {
+                path: entry[:filename],
+                range: {
+                  start: { line: violation.line, column: column },
+                  end: { line: violation.line, column: column + 1 }
+                }
+              },
+              severity: violation.severity.to_s.upcase
+            }
+          end
+        }
+        JSON.generate(document) + "\n"
+      end
+
+      def xml_escape(value)
+        value.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;").gsub("'", "&apos;")
+      end
+    end
+  end
+end