mdlint 0.1.0 → 0.2.0

data/lib/mdlint/linter/directive_filter.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Mdlint
+  module Linter
+    class DirectiveFilter
+      DIRECTIVE_REGEXP = /<!--\s*mdlint-(disable-next-line|disable-file|disable|enable)(?:\s+([^>]*?))?\s*-->/i
+      FENCE_REGEXP = /\A {0,3}(`{3,}|~{3,})/
+
+      class << self
+        def apply(violations, source)
+          new(source).filter(violations)
+        end
+      end
+
+      def initialize(source)
+        @disabled_by_line = {}
+        @file_disabled = false
+        scan(source)
+      end
+
+      def filter(violations)
+        return [] if @file_disabled
+
+        violations.reject do |violation|
+          disabled = @disabled_by_line.fetch(violation.line, Set.new)
+          disabled.include?("*") || disabled.include?(RuleRegistry.normalize_id(violation.rule_id))
+        end
+      end
+
+      private
+
+      def scan(source)
+        disabled = Set.new
+        next_line = {}
+        fence = nil
+
+        source.each_line.with_index(1) do |line, line_number|
+          current_fence = line.match(FENCE_REGEXP)
+          if current_fence
+            marker = current_fence[1].to_s
+
+            if !fence.nil? && marker.to_s[0] == fence.to_s[0] && marker.to_s.length >= fence.to_s.length
+              fence = nil
+            elsif fence.nil?
+              fence = marker
+            end
+            @disabled_by_line[line_number] = disabled.dup
+            next
+          end
+
+          if fence
+            @disabled_by_line[line_number] = disabled.dup
+            next
+          end
+
+          directive = line.match(DIRECTIVE_REGEXP)
+          apply_directive(directive, disabled, next_line, line_number) if directive
+          line_disabled = disabled.dup
+          line_disabled.merge(next_line.delete(line_number) || Set.new)
+          @disabled_by_line[line_number] = line_disabled
+        end
+      end
+
+      def apply_directive(directive, disabled, next_line, line_number)
+        action = directive[1].downcase
+        ids = normalize_ids(directive[2])
+
+        case action
+        when "disable-file"
+          @file_disabled = true
+        when "disable-next-line"
+          next_line[line_number + 1] ||= Set.new
+          next_line[line_number + 1].merge(ids)
+        when "disable"
+          disabled.merge(ids)
+        when "enable"
+          ids.include?("*") ? disabled.clear : ids.each { |id| disabled.delete(id) }
+        end
+      end
+
+      def normalize_ids(value)
+        ids = value.to_s.split(/[\s,]+/).reject(&:empty?)
+        return Set["*"] if ids.empty?
+
+        Set.new(ids.map { |id| RuleRegistry.normalize_id(id) })
+      end
+    end
+  end
+end

data/lib/mdlint/linter/rule.rb

@@ -4,7 +4,7 @@ module Mdlint
   module Linter
     class Rule
       class << self
-        attr_accessor :rule_id, :description
+        attr_accessor :rule_id, :description, :aliases, :preset
 
         def inherited(subclass)
           super
@@ -14,7 +14,8 @@ module Mdlint
 
       attr_reader :violations
 
-      def initialize
+      def initialize(options = {})
+        @options = options
         @violations = []
       end
 
@@ -23,7 +24,7 @@ module Mdlint
       end
 
       def fix(_tokens, _source)
-        raise NotImplementedError, "Subclasses must implement #fix"
+        _source
       end
 
       protected
@@ -34,7 +35,8 @@ module Mdlint
           message: message,
           line: line,
           column: column,
-          fixable: fixable
+          fixable: fixable,
+          severity: @options[:severity] || :warning
         )
       end
     end
@@ -46,6 +48,9 @@ module Mdlint
         attr_reader :rules
 
         def register(rule_class)
+          return if rule_class.rule_id && @rules.any? { |existing| existing.rule_id == rule_class.rule_id }
+          return if @rules.include?(rule_class)
+
           @rules << rule_class
         end
 
@@ -54,12 +59,27 @@ module Mdlint
         end
 
         def find(rule_id)
-          @rules.find { |r| r.rule_id == rule_id }
+          normalized_id = normalize_id(rule_id)
+          @rules.find { |r| r.rule_id == normalized_id }
+        end
+
+        def normalize_id(rule_id)
+          value = rule_id.to_s
+          value = value.upcase if value.match?(/\Amd\d+\z/i)
+          rule = @rules.find do |rule_class|
+            aliases = rule_class.aliases
+            rule_class.rule_id == value || (aliases.is_a?(Array) && aliases.any? { |name| name.is_a?(String) && name.casecmp?(value.to_s) })
+          end
+          rule ? rule.rule_id : value
         end
 
         def clear
           @rules = []
         end
+
+        def unregister(rule_class)
+          @rules.delete(rule_class)
+        end
       end
     end
   end

data/lib/mdlint/linter/rule_engine.rb

@@ -7,8 +7,9 @@ module Mdlint
 
       def initialize(options = {})
         @options = options
-        @enabled_rules = options[:rules] || RuleRegistry.all.map(&:rule_id)
-        @disabled_rules = options[:disable] || []
+        @configured_rules = options[:rules]
+        @enabled_rules = Array(options[:rules]).map { |rule| RuleRegistry.normalize_id(rule) } if options[:rules].is_a?(Array)
+        @disabled_rules = Array(options[:disable]).map { |rule| RuleRegistry.normalize_id(rule) }
         @violations = []
       end
 
@@ -16,7 +17,7 @@ module Mdlint
         @violations = []
 
         active_rules.each do |rule_class|
-          rule = rule_class.new
+          rule = rule_class.new(rule_options(rule_class))
           rule.check(tokens, source)
           @violations.concat(rule.violations)
         end
@@ -26,10 +27,12 @@ module Mdlint
 
       def fix(tokens, source)
         result = source
+        current_tokens = tokens
 
         active_rules.each do |rule_class|
-          rule = rule_class.new
-          result = rule.fix(tokens, result)
+          rule = rule_class.new(rule_options(rule_class))
+          result = rule.fix(current_tokens, result)
+          current_tokens = Parser.parse(result, @options) if result != source
         end
 
         result
@@ -39,10 +42,44 @@ module Mdlint
 
       def active_rules
         RuleRegistry.all.select do |rule_class|
-          @enabled_rules.include?(rule_class.rule_id) &&
-            !@disabled_rules.include?(rule_class.rule_id)
+          configured_enabled?(rule_class) && !@disabled_rules.include?(rule_class.rule_id)
         end
       end
+
+      def configured_enabled?(rule_class)
+        if rule_class.preset && @options[:preset].to_s != rule_class.preset.to_s
+          explicitly_selected = @enabled_rules&.include?(rule_class.rule_id) || explicitly_configured?(rule_class)
+          return false unless explicitly_selected
+        end
+        return @enabled_rules.include?(rule_class.rule_id) if @enabled_rules
+        return true unless @configured_rules.is_a?(Hash)
+
+        setting = rule_setting(rule_class)
+        setting != false && (!setting.is_a?(Hash) || setting[:enabled] != false)
+      end
+
+      def explicitly_configured?(rule_class)
+        return false unless @configured_rules.is_a?(Hash)
+
+        @configured_rules.any? { |key, _value| RuleRegistry.normalize_id(key) == rule_class.rule_id }
+      end
+
+      def rule_options(rule_class)
+        setting = rule_setting(rule_class)
+        setting = {} unless setting.is_a?(Hash)
+        global_options = @options.reject { |key, _value| %i[rules disable].include?(key) }
+        setting = global_options.merge(setting.transform_keys(&:to_sym))
+        setting[:severity] ||= @options[:severity] if @options[:severity]
+        setting
+      end
+
+      def rule_setting(rule_class)
+        return nil unless @configured_rules.is_a?(Hash)
+
+        @configured_rules.find do |key, _value|
+          RuleRegistry.normalize_id(key) == rule_class.rule_id
+        end&.last
+      end
     end
   end
 end

data/lib/mdlint/linter/rules/code_block_syntax.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "ripper"
+require "shellwords"
+require "timeout"
+
+module Mdlint
+  module Linter
+    module Rules
+      class CodeBlockSyntax < Rule
+        self.rule_id = "MD040"
+        self.aliases = ["code-block-syntax"]
+        self.description = "Supported fenced code blocks should have valid syntax"
+
+        SUPPORTED_LANGUAGES = %w[json ruby].freeze
+
+        def check(tokens, _source)
+          commands = @options.fetch(:code_block_commands, {})
+          return @violations unless @options[:check_code_blocks] || !commands.empty?
+
+          tokens.each do |token|
+            next unless token.type == :fence
+
+            language = token.info.to_s.split.first.to_s.downcase
+            if language.empty?
+              add_violation(message: "Code block should specify a language", line: line_for(token), fixable: false)
+              next
+            end
+            unless SUPPORTED_LANGUAGES.include?(language) || commands.key?(language)
+              next
+            end
+
+            error = if SUPPORTED_LANGUAGES.include?(language)
+                      syntax_error(language, token.content)
+                    else
+                      command_error(commands.fetch(language), token.content)
+                    end
+            next unless error
+
+            add_violation(
+              message: "Invalid #{language} syntax: #{error}",
+              line: line_for(token),
+              fixable: false
+            )
+          end
+          @violations
+        end
+
+        def fix(tokens, source)
+          commands = @options.fetch(:code_block_format_commands, {})
+          return source if commands.empty?
+
+          lines = source.lines
+          tokens.reverse_each do |token|
+            next unless token.type == :fence
+
+            language = token.info.to_s.split.first.to_s.downcase
+            command = commands[language]
+            next unless command
+
+            formatted = command_output(command, token.content)
+            next unless formatted
+
+            start_line = token.map&.first
+            end_line = token.map&.last
+            next unless start_line && end_line
+
+            closing_line = end_line - 1
+            closing_line = end_line unless lines[closing_line].to_s.match?(/\A {0,3}(`{3,}|~{3,})\s*\r?\n?\z/)
+            replacement = formatted.end_with?("\n") ? formatted : "#{formatted}\n"
+            body_length = [closing_line - start_line - 1, 0].max
+            lines.slice!(start_line + 1, body_length)
+            lines.insert(start_line + 1, *replacement.lines)
+          end
+          lines.join
+        end
+
+        private
+
+        def line_for(token)
+          (token.map&.first || 0) + 1
+        end
+
+        def syntax_error(language, content)
+          case language
+          when "json"
+            JSON.parse(content)
+            nil
+          when "ruby"
+            Ripper.sexp(content) ? nil : "parser rejected the source"
+          end
+        rescue JSON::ParserError => error
+          error.message.lines.first.to_s.strip
+        end
+
+        def command_error(command, content)
+          result = command_result(command, content)
+          return nil if result[:status].success?
+
+          result[:stderr].lines.first.to_s.strip.empty? ? "command exited with #{result[:status].exitstatus}" : result[:stderr].lines.first.strip
+        rescue StandardError => error
+          "#{error.class}: #{error.message}"
+        end
+
+        def command_output(command, content)
+          result = command_result(command, content)
+          return result[:stdout] if result[:status].success?
+
+          nil
+        rescue StandardError
+          nil
+        end
+
+        def command_result(command, content)
+          argv = Shellwords.split(command)
+          raise ArgumentError, "empty code block command" if argv.empty?
+
+          stdout, stderr, status = Timeout.timeout(@options.fetch(:code_block_timeout, 10).to_i) do
+            Open3.capture3(*argv, stdin_data: content)
+          end
+          { stdout: stdout, stderr: stderr, status: status }
+        end
+      end
+    end
+  end
+end

data/lib/mdlint/linter/rules/first_line_heading.rb

@@ -5,12 +5,13 @@ module Mdlint
     module Rules
       class FirstLineHeading < Rule
         self.rule_id = "MD041"
+        self.aliases = ["first-line-heading"]
         self.description = "First line in file should be a top-level heading"
 
         def check(tokens, _source)
           first_content_token = tokens.find do |t|
             %i[heading_open paragraph_open bullet_list_open ordered_list_open
-               blockquote_open fence code_block hr html_block].include?(t.type)
+               blockquote_open fence code_block hr html_block].include?(t.type) && !directive?(t)
           end
 
           return @violations unless first_content_token
@@ -32,8 +33,14 @@ module Mdlint
           @violations
         end
 
-        def fix(tokens, _source)
-          tokens
+        def fix(_tokens, source)
+          source
+        end
+
+        private
+
+        def directive?(token)
+          token.type == :html_block && token.content.match?(/<!--\s*mdlint-(?:disable|enable)/i)
         end
       end
     end

data/lib/mdlint/linter/rules/heading_increment.rb

@@ -5,6 +5,7 @@ module Mdlint
     module Rules
       class HeadingIncrement < Rule
         self.rule_id = "MD001"
+        self.aliases = ["heading-increment"]
         self.description = "Heading levels should only increment by one level at a time"
 
         def check(tokens, _source)
@@ -13,7 +14,7 @@ module Mdlint
           tokens.each do |token|
             next unless token.type == :heading_open
 
-            level = token.tag[1].to_i
+            level = token.tag.to_s[1].to_i
             if last_level > 0 && level > last_level + 1
               add_violation(
                 message: "Heading level jumped from h#{last_level} to h#{level}",
@@ -27,8 +28,8 @@ module Mdlint
           @violations
         end
 
-        def fix(tokens, _source)
-          tokens
+        def fix(_tokens, source)
+          source
         end
       end
     end

data/lib/mdlint/linter/rules/heading_style.rb

@@ -5,6 +5,7 @@ module Mdlint
     module Rules
       class HeadingStyle < Rule
         self.rule_id = "MD003"
+        self.aliases = ["heading-style"]
         self.description = "Heading style should be consistent"
 
         def check(tokens, _source)
@@ -22,8 +23,29 @@ module Mdlint
           @violations
         end
 
-        def fix(tokens, _source)
-          tokens
+        def fix(tokens, source)
+          lines = source.lines
+          heading_tokens = tokens.select do |token|
+            token.type == :heading_open && token.markup && !token.markup.start_with?("#")
+          end
+
+          heading_tokens.reverse_each do |token|
+            start_line, end_line = token.map || []
+            next unless start_line && end_line && end_line == start_line + 2
+            next unless lines[start_line] && lines[start_line + 1]
+
+            match = lines[start_line].match(/\A(\s*(?:>\s*)*)(.*?)(?:\r?\n)?\z/)
+            next unless match
+
+            prefix = match[1].to_s
+            content = match[2].to_s
+            newline = lines[start_line].end_with?("\r\n") ? "\r\n" : "\n"
+            level = token.tag == "h1" ? "#" : "##"
+            lines[start_line] = "#{prefix}#{level} #{content.strip}#{newline}"
+            lines.delete_at(start_line + 1)
+          end
+
+          lines.compact.join
         end
       end
     end

data/lib/mdlint/linter/rules/japanese.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Mdlint
+  module Linter
+    module Rules
+      module JapaneseHelpers
+        CJK = /[\p{Han}\p{Hiragana}\p{Katakana}\p{Hangul}]/
+        JAPANESE = /[\p{Han}\p{Hiragana}\p{Katakana}]/
+
+        private
+
+        def each_inline(tokens)
+          tokens.each do |token|
+            yield token if token.type == :inline
+          end
+        end
+
+        def prose_content(token)
+          token.children.filter_map do |child|
+            child.content if %i[text html_inline softbreak hardbreak].include?(child.type)
+          end.join
+        end
+
+        def line_for(token)
+          (token.map&.first || 0) + 1
+        end
+      end
+
+      class JapaneseSpacing < Rule
+        include JapaneseHelpers
+
+        self.rule_id = "JA001"
+        self.aliases = ["japanese-spacing"]
+        self.description = "Japanese and ASCII text should use consistent spacing"
+        self.preset = :japanese
+
+        def check(tokens, _source)
+          each_inline(tokens) do |token|
+            content = prose_content(token)
+            next unless content.match?(JAPANESE)
+            next unless content.match?(/(?:#{JAPANESE})[A-Za-z0-9]|[A-Za-z0-9](?:#{JAPANESE})/)
+
+            add_violation(
+              message: "Add a space between Japanese and ASCII text",
+              line: line_for(token),
+              fixable: false
+            )
+          end
+          @violations
+        end
+      end
+
+      class JapanesePunctuation < Rule
+        include JapaneseHelpers
+
+        self.rule_id = "JA002"
+        self.aliases = ["japanese-punctuation"]
+        self.description = "Japanese prose should use full-width punctuation"
+        self.preset = :japanese
+
+        def check(tokens, _source)
+          each_inline(tokens) do |token|
+            content = prose_content(token)
+            next unless content.match?(JAPANESE)
+            next unless content.match?(/[、。！？] |[,:!?](?:#{JAPANESE})|(?<!\.)\.(?:#{JAPANESE})/)
+
+            add_violation(
+              message: "Use Japanese punctuation consistently in Japanese prose",
+              line: line_for(token),
+              fixable: false
+            )
+          end
+          @violations
+        end
+      end
+
+      class JapaneseStyle < Rule
+        include JapaneseHelpers
+
+        self.rule_id = "JA003"
+        self.aliases = ["japanese-style"]
+        self.description = "Japanese documents should not mix desu-masu and de-aru styles"
+        self.preset = :japanese
+
+        def check(tokens, _source)
+          prose = tokens.filter_map { |token| prose_content(token) if token.type == :inline }.join("\n")
+          has_desu_masu = prose.match?(/です(?:。|\z)|ます(?:。|\z)|でした(?:。|\z)|ません(?:。|\z)/)
+          has_de_aru = prose.match?(/である(?:。|\z)|だ(?:。|\z)|であった(?:。|\z)/)
+          return @violations unless has_desu_masu && has_de_aru
+
+          token = tokens.find { |candidate| candidate.type == :inline }
+          add_violation(
+            message: "Avoid mixing desu-masu and de-aru styles",
+            line: line_for(token),
+            fixable: false
+          )
+          @violations
+        end
+      end
+
+      class JapaneseSentenceLength < Rule
+        include JapaneseHelpers
+
+        self.rule_id = "JA004"
+        self.aliases = ["japanese-sentence-length"]
+        self.description = "Japanese sentences should stay within the configured length"
+        self.preset = :japanese
+
+        def check(tokens, _source)
+          maximum = @options.fetch(:sentence_length, 80).to_i
+          return @violations if maximum <= 0
+
+          each_inline(tokens) do |token|
+            prose_content(token).split(/(?<=[。！？!?])\s*/).each do |sentence|
+              next if sentence.empty? || sentence.each_char.count <= maximum
+
+              add_violation(
+                message: "Sentence length #{sentence.each_char.count} exceeds #{maximum}",
+                line: line_for(token),
+                fixable: false
+              )
+            end
+          end
+          @violations
+        end
+      end
+
+      class JapaneseCommaCount < Rule
+        include JapaneseHelpers
+
+        self.rule_id = "JA005"
+        self.aliases = ["japanese-comma-count"]
+        self.description = "Japanese sentences should not contain too many commas"
+        self.preset = :japanese
+
+        def check(tokens, _source)
+          maximum = @options.fetch(:max_commas, 3).to_i
+          each_inline(tokens) do |token|
+            prose_content(token).split(/(?<=[。！？!?])\s*/).each do |sentence|
+              commas = sentence.count("、,")
+              next unless commas > maximum
+
+              add_violation(
+                message: "Sentence contains #{commas} commas (maximum #{maximum})",
+                line: line_for(token),
+                fixable: false
+              )
+            end
+          end
+          @violations
+        end
+      end
+
+      class JapaneseDuplicateParticle < Rule
+        include JapaneseHelpers
+
+        self.rule_id = "JA006"
+        self.aliases = ["japanese-duplicate-particle"]
+        self.description = "Avoid repeated Japanese particles in a short phrase"
+        self.preset = :japanese
+
+        def check(tokens, _source)
+          each_inline(tokens) do |token|
+            next unless prose_content(token).match?(/の[^。！？\n]{0,12}の|に[^。！？\n]{0,12}に/)
+
+            add_violation(
+              message: "Check repeated Japanese particles such as の or に",
+              line: line_for(token),
+              fixable: false
+            )
+          end
+          @violations
+        end
+      end
+
+      class JapaneseWidth < Rule
+        include JapaneseHelpers
+
+        self.rule_id = "JA007"
+        self.aliases = ["japanese-width"]
+        self.description = "Japanese prose should use full-width brackets and punctuation"
+        self.preset = :japanese
+
+        def check(tokens, _source)
+          each_inline(tokens) do |token|
+            content = prose_content(token)
+            next unless content.match?(JAPANESE)
+            next unless content.match?(/[()\[\]{},.!?;:]/)
+
+            add_violation(
+              message: "Use full-width brackets and punctuation in Japanese prose",
+              line: line_for(token),
+              fixable: false
+            )
+          end
+          @violations
+        end
+      end
+    end
+  end
+end