mdlint 0.1.0 → 0.2.0

data/lib/mdlint/cli.rb

@@ -1,76 +1,108 @@
 # frozen_string_literal: true
 
 require "optparse"
-require "pathname"
+require "yaml"
+require_relative "../mdlint"
 require_relative "config"
+require_relative "cli/output_formatter"
 
 module Mdlint
   class CLI
+    FAIL_LEVELS = { info: 0, warning: 1, error: 2 }.freeze
+    COMMANDS = %w[format lint fix lsp].freeze
+
     def initialize(argv)
       @argv = argv.dup
+      @command = extract_command
       @cli_options = { exclude: [] }
     end
 
     def run
       parse_options
       load_config
-      paths = @argv
+      load_plugins
+      @cache_store = CacheStore.new(@options[:cache_path]) if @options[:cache]
+      return show_rule_list if @options[:list_rules]
+      return show_rule_explanation(@options[:explain]) if @options[:explain]
 
-      if paths.empty?
-        process_stdin
-      else
-        process_paths(paths)
-      end
+      return Mdlint::Lsp::Server.new.run if @command == :lsp
+
+      @command == :format ? process_format : process_lint
     end
 
     private
 
+    def extract_command
+      command = @argv.first
+      return :format unless COMMANDS.include?(command)
+
+      @argv.shift.to_sym
+    end
+
     def load_config
       config = Config.new
       config.load
       @options = config.merge(@cli_options)
+      @options[:format] ||= "text" if @command != :format
     end
 
     def parse_options
       parser = OptionParser.new do |opts|
-        opts.banner = "Usage: mdlint [options] [paths...]"
+        opts.banner = "Usage: mdlint [command] [options] [paths...]"
+        opts.separator ""
+        opts.separator "Commands: format (default), lint, fix, lsp"
         opts.separator ""
         opts.separator "Options:"
 
-        opts.on("-c", "--check", "Check if files are formatted, exit with error if not") do
-          @cli_options[:check] = true
-        end
-
-        opts.on("-d", "--diff", "Show diff of changes") do
-          @cli_options[:diff] = true
-        end
-
-        opts.on("-q", "--quiet", "Suppress output") do
-          @cli_options[:quiet] = true
-        end
-
-        opts.on("-e", "--exclude PATTERN", "Exclude files matching pattern") do |pattern|
-          @cli_options[:exclude] << pattern
+        opts.on("-c", "--check", "Check if files are formatted, exit with error if not") { @cli_options[:check] = true }
+        opts.on("-d", "--diff", "Show diff of changes") { @cli_options[:diff] = true }
+        opts.on("-q", "--quiet", "Suppress output") { @cli_options[:quiet] = true }
+        opts.on("-e", "--exclude PATTERN", "Exclude files matching pattern") { |pattern| @cli_options[:exclude] << pattern }
+        opts.on("-w", "--wrap MODE", "Paragraph wrapping: keep, no, or INTEGER") { |mode| @cli_options[:wrap] = parse_wrap_mode(mode) }
+        opts.on("--number", "Use consecutive numbering for ordered lists") { @cli_options[:number] = true }
+        opts.on("--end-of-line MODE", "End of line: lf, crlf, keep") { |mode| @cli_options[:end_of_line] = mode.downcase.to_sym }
+        opts.on("--fix", "Fix fixable lint violations") do
+          @cli_options[:fix] = true
+          @command = :lint if @command == :format
         end
-
-        opts.on("-w", "--wrap MODE", "Paragraph wrapping mode: keep (default), no, or INTEGER") do |mode|
-          @cli_options[:wrap] = parse_wrap_mode(mode)
+        opts.on("--fix-only", "Apply fixes without reporting remaining violations") do
+          @cli_options[:fix] = true
+          @cli_options[:fix_only] = true
+          @command = :fix
         end
-
-        opts.on("--number", "Use consecutive numbering for ordered lists") do
-          @cli_options[:number] = true
+        opts.on("--dry-run", "Do not write fixes to files") { @cli_options[:dry_run] = true }
+        opts.on("--disable RULES", "Disable comma-separated rules") { |rules| @cli_options[:disable] = split_rules(rules) }
+        opts.on("--rule RULES", "Run only comma-separated rules") { |rules| @cli_options[:rules] = split_rules(rules) }
+        opts.on("--severity LEVEL", "Default severity: error, warning, or info") { |level| @cli_options[:severity] = parse_level(level) }
+        opts.on("--fail-level LEVEL", "Fail at severity: error, warning, or info") { |level| @cli_options[:fail_level] = parse_level(level) }
+        opts.on("--format FORMAT", "Lint output: text, json, sarif, github, checkstyle, junit, reviewdog") { |format| @cli_options[:format] = format }
+        opts.on("--stdin-filename NAME", "Filename to use for stdin diagnostics") { |name| @cli_options[:stdin_filename] = name }
+        opts.on("--dialect DIALECT", "Markdown dialect: commonmark or gfm") { |dialect| @cli_options[:dialect] = dialect.to_sym }
+        opts.on("--preset NAME", "Enable a rule preset, such as japanese") { |preset| @cli_options[:preset] = preset.to_sym }
+        opts.on("--check-links", "Check relative link, image, and anchor targets") { @cli_options[:check_links] = true }
+        opts.on("--check-external-links", "Check external HTTP(S) links") { @cli_options[:check_external_links] = true }
+        opts.on("--check-code-blocks", "Validate supported fenced code blocks") { @cli_options[:check_code_blocks] = true }
+        opts.on("--code-block-command SPEC", "Validate a language block with LANG=COMMAND") { |spec| add_code_block_command(:code_block_commands, spec) }
+        opts.on("--code-block-formatter SPEC", "Format a language block with LANG=COMMAND") { |spec| add_code_block_command(:code_block_format_commands, spec) }
+        opts.on("--code-block-timeout SECONDS", Integer, "Timeout for external code-block commands") { |seconds| @cli_options[:code_block_timeout] = [seconds, 1].max }
+        opts.on("--toc", "Update table-of-contents markers while formatting") { @cli_options[:toc] = true }
+        opts.on("--no-table-align", "Do not pad GFM table columns") { @cli_options[:table_align] = false }
+        opts.on("--jobs N", Integer, "Process files concurrently") { |jobs| @cli_options[:jobs] = [jobs, 1].max }
+        opts.on("--cache", "Cache lint diagnostics") { @cli_options[:cache] = true }
+        opts.on("--cache-path PATH", "Path for the lint cache") { |path| @cli_options[:cache_path] = path; @cli_options[:cache] = true }
+        opts.on("--no-cache", "Disable diagnostic cache") { @cli_options[:cache] = false }
+        opts.on("--lsp", "Run the Language Server Protocol server") { @command = :lsp }
+        opts.on("--list-rules", "List available lint rules") { @cli_options[:list_rules] = true }
+        opts.on("--explain RULE", "Explain a lint rule") { |rule| @cli_options[:explain] = rule }
+        opts.on("--require PATH", "Load a custom rule file") { |path| (@cli_options[:require] ||= []) << path }
+        opts.on("--auto-gen-config [PATH]", "Write a config disabling current violations") do |path|
+          @cli_options[:auto_gen_config] = path || ".mdlint_todo.yml"
         end
-
-        opts.on("--end-of-line MODE", "End of line: lf (default), crlf, keep") do |mode|
-          @cli_options[:end_of_line] = mode.downcase.to_sym
-        end
-
         opts.on("-v", "--version", "Show version") do
           puts "mdlint #{Mdlint::VERSION}"
           exit 0
         end
-
-        opts.on("-h", "--help", "Show this help") do
+        opts.on("-h", "--help", "Show help") do
           puts opts
           exit 0
         end
@@ -79,7 +111,23 @@ module Mdlint
       parser.parse!(@argv)
     end
 
-    def process_stdin
+    def process_format
+      return process_format_stdin if @argv.empty?
+
+      files = collect_files(@argv)
+      changed_files = ParallelRunner.map(files, jobs: @options[:jobs]) { |file| file if process_format_file(file) }.compact
+
+      if @options[:check]
+        exit(changed_files.empty? ? 0 : 1)
+      end
+
+      unless @options[:quiet] || @options[:diff]
+        puts(changed_files.empty? ? "All files are formatted correctly" : "#{changed_files.length} file(s) reformatted")
+      end
+      @options[:diff] && changed_files.any? ? 1 : 0
+    end
+
+    def process_format_stdin
       input = $stdin.read
       output = Mdlint.format(input, format_options)
 
@@ -94,113 +142,227 @@ module Mdlint
       end
     end
 
-    def process_paths(paths)
-      files = collect_files(paths)
-      changed_files = []
+    def process_format_file(file)
+      original = File.read(file)
+      formatted = Mdlint.format(original, format_options)
+      changed = original != formatted
+      return false unless changed
 
-      files.each do |file|
-        result = process_file(file)
-        changed_files << file if result
+      if @options[:diff]
+        show_diff(file, original, formatted)
+      elsif @options[:check]
+        puts "Would reformat: #{file}" unless @options[:quiet]
+      else
+        File.write(file, formatted)
+        puts "Reformatted: #{file}" unless @options[:quiet]
       end
+      true
+    end
 
-      if @options[:check]
-        exit(changed_files.empty? ? 0 : 1)
+    def process_lint
+      entries = if @argv.empty?
+                  process_lint_stdin
+                else
+                  ParallelRunner.map(collect_files(@argv), jobs: @options[:jobs]) { |file| process_lint_file(file) }.flatten
+                end
+
+      print lint_output(entries) unless @options[:quiet]
+      @cache_store&.save
+      return write_auto_gen_config(entries) if @options[:auto_gen_config]
+
+      fail_for?(entries) ? exit(1) : 0
+    end
+
+    def load_plugins
+      paths = Array(@options[:plugins]) + Array(@options[:require])
+      paths.each do |path|
+        Mdlint::Plugin.load(path)
+      rescue Mdlint::Plugin::Error => error
+        warn "Warning: Could not load rule file #{path}: #{error.message}"
+        exit 2
       end
+    end
 
-      unless @options[:quiet]
-        if changed_files.any?
-          puts "#{changed_files.length} file(s) reformatted" unless @options[:diff]
-        else
-          puts "All files are formatted correctly" unless @options[:diff]
-        end
+    def write_auto_gen_config(entries)
+      rules = entries.to_h { |entry| [entry[:violation].rule_id, false] }
+      path = @options[:auto_gen_config]
+      File.write(path, YAML.dump({ "rules" => rules }))
+      puts "Wrote #{path}" unless @options[:quiet]
+      0
+    end
+
+    def process_lint_stdin
+      filename = @options[:stdin_filename] || "stdin"
+      source = $stdin.read
+      fixed_source = apply_lint_fix(filename, source, nil)
+      return [] if @options[:fix_only]
+
+      Mdlint.lint(fixed_source, lint_options(filename)).map { |violation| { filename: filename, violation: violation } }
+    end
+
+    def process_lint_file(file)
+      source = File.read(file)
+      fixed_source = apply_lint_fix(file, source, file)
+      return [] if @options[:fix_only]
+
+      violations = cached_lint(file, fixed_source)
+      violations.map { |violation| { filename: file, violation: violation } }
+    end
+
+    def cached_lint(file, source)
+      options = lint_options(file)
+      return Mdlint.lint(source, options) unless @cache_store && !fix_requested?
+
+      key = @cache_store.key(source, options)
+      cached = @cache_store.fetch(key)
+      return cached if cached
+
+      violations = Mdlint.lint(source, options)
+      @cache_store.store(key, violations)
+      violations
+    end
+
+    def apply_lint_fix(filename, source, path)
+      return source unless fix_requested?
+
+      fixed = Mdlint.fix(source, lint_options(filename))
+      return source if fixed == source
+
+      if path && !@options[:dry_run]
+        File.write(path, fixed)
+        puts "Fixed: #{filename}" unless @options[:quiet]
+      elsif path.nil? && !@options[:dry_run] && !@options[:quiet]
+        print fixed
       end
+      fixed
+    end
 
-      changed_files.empty? ? 0 : 1
+    def fix_requested?
+      @cli_options[:fix] || @command == :fix
     end
 
-    def collect_files(paths)
-      files = []
+    def lint_output(entries)
+      format = @options[:format] || "text"
+      OutputFormatter.new(format).render(entries)
+    end
 
-      paths.each do |path|
+    def fail_for?(entries)
+      threshold = FAIL_LEVELS.fetch(@options[:fail_level].to_sym, FAIL_LEVELS[:warning])
+      entries.any? { |entry| FAIL_LEVELS.fetch(entry[:violation].severity, FAIL_LEVELS[:warning]) >= threshold }
+    end
+
+    def show_rule_list
+      Mdlint::Linter::RuleRegistry.all.each do |rule|
+        aliases = Array(rule.aliases)
+        alias_text = aliases.empty? ? "" : " (#{aliases.join(", ")})"
+        puts "#{rule.rule_id}#{alias_text}: #{rule.description}"
+      end
+      exit 0
+    end
+
+    def show_rule_explanation(rule_id)
+      rule = Mdlint::Linter::RuleRegistry.find(rule_id)
+      unless rule
+        warn "Unknown rule: #{rule_id}"
+        exit 2
+      end
+
+      puts rule.rule_id
+      puts "Aliases: #{Array(rule.aliases).join(", ")}" unless Array(rule.aliases).empty?
+      puts rule.description
+      exit 0
+    end
+
+    def collect_files(paths)
+      paths.flat_map do |path|
         if File.directory?(path)
-          Dir.glob(File.join(path, "**", "*.md")).each do |file|
-            files << file unless excluded?(file)
-          end
+          Dir.glob(File.join(path, "**", "*.md")).reject { |file| excluded?(file) }
         elsif File.file?(path)
-          files << path unless excluded?(path)
+          excluded?(path) ? [] : [path]
         else
           warn "Warning: #{path} does not exist"
+          []
         end
-      end
-
-      files.sort
+      end.sort
     end
 
     def excluded?(file)
-      @options[:exclude].any? do |pattern|
-        File.fnmatch?(pattern, file, File::FNM_PATHNAME)
-      end
+      @options[:exclude].any? { |pattern| File.fnmatch?(pattern, file, File::FNM_PATHNAME) }
     end
 
-    def process_file(file)
-      original = File.read(file)
-      formatted = Mdlint.format(original, format_options)
-      changed = original != formatted
+    def show_diff(filename, original, formatted)
+      require "tempfile"
 
-      if changed
-        if @options[:diff]
-          show_diff(file, original, formatted)
-        elsif !@options[:check]
-          File.write(file, formatted)
-          puts "Reformatted: #{file}" unless @options[:quiet]
-        elsif !@options[:quiet]
-          puts "Would reformat: #{file}"
+      Tempfile.create("mdlint-original") do |original_file|
+        Tempfile.create("mdlint-formatted") do |formatted_file|
+          original_file.write(original)
+          original_file.flush
+          formatted_file.write(formatted)
+          formatted_file.flush
+          diff_output = `diff -u "#{original_file.path}" "#{formatted_file.path}" 2>&1`
+          puts diff_output.gsub(original_file.path, "#{filename} (original)")
+                          .gsub(formatted_file.path, "#{filename} (formatted)") unless diff_output.empty?
         end
       end
+    end
 
-      changed
+    def format_options
+      {
+        wrap: @options[:wrap] || :keep,
+        number: @options[:number] || false,
+        end_of_line: @options[:end_of_line] || :lf,
+        dialect: @options[:dialect] || :commonmark,
+        toc: @options[:toc],
+        table_align: @options.fetch(:table_align, true)
+      }
     end
 
-    def show_diff(filename, original, formatted)
-      require "tempfile"
+    def lint_options(filename = nil)
+      {
+        rules: @options[:rules],
+        disable: @options[:disable] || [],
+        severity: @options[:severity],
+        dialect: @options[:dialect] || :commonmark,
+        preset: @options[:preset],
+        check_links: @options[:check_links],
+        check_external_links: @options[:check_external_links],
+        check_code_blocks: @options[:check_code_blocks],
+        code_block_commands: @options[:code_block_commands],
+        code_block_format_commands: @options[:code_block_format_commands],
+        code_block_timeout: @options[:code_block_timeout],
+        filename: filename
+      }.compact
+    end
 
-      Tempfile.create("mdlint-original") do |orig_file|
-        Tempfile.create("mdlint-formatted") do |fmt_file|
-          orig_file.write(original)
-          orig_file.flush
-          fmt_file.write(formatted)
-          fmt_file.flush
-
-          diff_output = `diff -u "#{orig_file.path}" "#{fmt_file.path}" 2>&1`
-          unless diff_output.empty?
-            diff_output = diff_output.gsub(orig_file.path, "#{filename} (original)")
-                                     .gsub(fmt_file.path, "#{filename} (formatted)")
-            puts diff_output
-          end
-        end
-      end
+    def split_rules(value)
+      value.split(",").map(&:strip).reject(&:empty?)
+    end
+
+    def add_code_block_command(key, specification)
+      language, command = specification.split("=", 2)
+      raise OptionParser::InvalidArgument, "expected LANG=COMMAND" if language.to_s.empty? || command.to_s.empty?
+
+      @cli_options[key] ||= {}
+      @cli_options[key][language.downcase] = command
+      @cli_options[:check_code_blocks] = true
     end
 
     def parse_wrap_mode(mode)
       case mode.downcase
-      when "keep"
-        :keep
-      when "no"
-        :no
-      else
-        Integer(mode)
+      when "keep" then :keep
+      when "no" then :no
+      else Integer(mode)
       end
     rescue ArgumentError
       warn "Invalid wrap mode: #{mode}. Using 'keep'."
       :keep
     end
 
-    def format_options
-      {
-        wrap: @options[:wrap] || :keep,
-        number: @options[:number] || false,
-        end_of_line: @options[:end_of_line] || :lf
-      }
+    def parse_level(level)
+      value = level.downcase.to_sym
+      return value if FAIL_LEVELS.key?(value)
+
+      raise OptionParser::InvalidArgument, "invalid severity: #{level}"
     end
   end
 end

data/lib/mdlint/config.rb

@@ -15,7 +15,26 @@ module Mdlint
       check: false,
       diff: false,
       quiet: false,
-      exclude: []
+      exclude: [],
+      rules: nil,
+      disable: [],
+      severity: nil,
+      fail_level: :warning,
+      format: nil,
+      dialect: :commonmark,
+      preset: nil,
+      plugins: [],
+      check_links: false,
+      check_external_links: false,
+      check_code_blocks: false,
+      code_block_commands: {},
+      code_block_format_commands: {},
+      code_block_timeout: 10,
+      toc: false,
+      table_align: true,
+      jobs: 1,
+      cache: false,
+      cache_path: ".mdlint_cache"
     }.freeze
 
     attr_reader :options
@@ -39,6 +58,8 @@ module Mdlint
         case key
         when :exclude
           @options[:exclude] = (@options[:exclude] + value).uniq
+        when :disable, :plugins
+          @options[key] = (@options[key] + Array(value)).uniq
         else
           @options[key] = value unless value.nil?
         end
@@ -81,6 +102,32 @@ module Mdlint
       options[:check] = parsed[:check] if parsed.key?(:check)
       options[:diff] = parsed[:diff] if parsed.key?(:diff)
       options[:quiet] = parsed[:quiet] if parsed.key?(:quiet)
+      options[:wrap] = normalize_wrap(parsed[:wrap]) if parsed.key?(:wrap)
+      options[:number] = parsed[:number] if parsed.key?(:number)
+      options[:end_of_line] = parsed[:end_of_line].to_s.downcase.to_sym if parsed[:end_of_line]
+      options[:rules] = normalize_rules(parsed[:rules]) if parsed.key?(:rules)
+
+      if parsed[:disable]
+        options[:disable] = Array(parsed[:disable]).map(&:to_s)
+      end
+
+      options[:severity] = parsed[:severity].to_sym if parsed[:severity]
+      options[:fail_level] = parsed[:fail_level].to_sym if parsed[:fail_level]
+      options[:format] = parsed[:format].to_s if parsed[:format]
+      options[:dialect] = parsed[:dialect].to_sym if parsed[:dialect]
+      options[:preset] = parsed[:preset].to_sym if parsed[:preset]
+      options[:plugins] = Array(parsed[:plugins]).map(&:to_s) if parsed[:plugins]
+      options[:check_links] = parsed[:check_links] if parsed.key?(:check_links)
+      options[:check_external_links] = parsed[:check_external_links] if parsed.key?(:check_external_links)
+      options[:check_code_blocks] = parsed[:check_code_blocks] if parsed.key?(:check_code_blocks)
+      options[:code_block_commands] = normalize_command_map(parsed[:code_block_commands]) if parsed[:code_block_commands]
+      options[:code_block_format_commands] = normalize_command_map(parsed[:code_block_format_commands]) if parsed[:code_block_format_commands]
+      options[:code_block_timeout] = normalize_timeout(parsed[:code_block_timeout]) if parsed.key?(:code_block_timeout)
+      options[:toc] = parsed[:toc] if parsed.key?(:toc)
+      options[:table_align] = parsed[:table_align] if parsed.key?(:table_align)
+      options[:jobs] = parsed[:jobs].to_i if parsed[:jobs]
+      options[:cache] = parsed[:cache] if parsed.key?(:cache)
+      options[:cache_path] = parsed[:cache_path].to_s if parsed[:cache_path]
 
       if parsed[:exclude]
         options[:exclude] = Array(parsed[:exclude])
@@ -89,11 +136,50 @@ module Mdlint
       options
     end
 
+    def normalize_rules(rules)
+      return rules unless rules.is_a?(Hash)
+
+      rules.each_with_object({}) do |(rule_id, setting), normalized|
+        normalized[rule_id.to_s] = if setting.is_a?(Hash)
+                                     normalized_setting = setting.transform_keys(&:to_sym)
+                                     normalized_setting[:severity] = normalized_setting[:severity].to_sym if normalized_setting[:severity]
+                                     normalized_setting
+                                   else
+                                     setting
+                                   end
+      end
+    end
+
+    def normalize_wrap(value)
+      case value.to_s.downcase
+      when "keep" then :keep
+      when "no" then :no
+      else Integer(value)
+      end
+    rescue ArgumentError, TypeError
+      :keep
+    end
+
+    def normalize_command_map(value)
+      return {} unless value.is_a?(Hash)
+
+      value.to_h { |language, command| [language.to_s.downcase, command.to_s] }
+    end
+
+    def normalize_timeout(value)
+      timeout = Integer(value)
+      timeout.positive? ? timeout : DEFAULT_OPTIONS[:code_block_timeout]
+    rescue ArgumentError, TypeError
+      DEFAULT_OPTIONS[:code_block_timeout]
+    end
+
     def merge_options(file_options)
       file_options.each do |key, value|
         case key
         when :exclude
           @options[:exclude] = (@options[:exclude] + value).uniq
+        when :disable, :plugins
+          @options[key] = (@options[key] + Array(value)).uniq
         else
           @options[key] = value
         end

data/lib/mdlint/dialect.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Mdlint
+  class Dialect
+    BUILT_IN_FEATURES = {
+      commonmark: [],
+      gfm: %i[tables task_lists strikethrough bare_autolinks]
+    }.freeze
+
+    @features = BUILT_IN_FEATURES.dup
+
+    class << self
+      attr_reader :features
+
+      def register(name, features: [])
+        key = name.to_s.downcase.to_sym
+        raise ArgumentError, "dialect name cannot be empty" if key.to_s.empty?
+
+        @features[key] = Array(features).map(&:to_sym).uniq.freeze
+        key
+      end
+
+      def registered
+        @features.keys
+      end
+
+      def resolve(value)
+        return value if value.is_a?(self)
+
+        new(value || :commonmark)
+      end
+    end
+
+    attr_reader :name, :features
+
+    def initialize(name = :commonmark, features: nil)
+      @name = name.to_s.downcase.to_sym
+      @features = Array(features || self.class.features.fetch(@name, [])).map(&:to_sym).freeze
+    end
+
+    def gfm?
+      feature?(:tables) && feature?(:strikethrough)
+    end
+
+    def feature?(feature)
+      @features.include?(feature.to_sym)
+    end
+
+    def to_sym
+      @name
+    end
+  end
+end