ace-lint 0.25.0 → 0.27.4

data/lib/ace/lint/molecules/markdown_linter.rb

@@ -22,10 +22,10 @@ module Ace
         # Fenced code block pattern (``` or ~~~, with optional up to 3 leading spaces per CommonMark)
         # Captures the fence character and length for proper matching
         FENCE_PATTERN = /^(\s{0,3})(`{3,}|~{3,})/
-        # Markdown link pattern [text](url) - captures link text for typography checking
-        LINK_PATTERN = /\[([^\]]*)\]\([^)]*\)/
         # Inline code pattern - handles single and double backtick spans
         INLINE_CODE_PATTERN = /``[^`]+``|`[^`]+`/
+        HEADING_PATTERN = /^\#{1,6}\s+\S/
+        UNORDERED_LIST_PATTERN = /^[*-]\s+\S/
         # Validate markdown file
         # @param file_path [String] Path to markdown file
         # @param options [Hash] Kramdown options
@@ -93,53 +93,77 @@ module Ace
         def self.check_markdown_style(content)
           warnings = []
           lines = content.lines
-
-          lines.each_with_index do |line, idx|
+          each_fence_aware_line(lines) do |line:, index:, in_code_block:, transition:|
+            idx = index
             line_num = idx + 1
+            prev_line = idx.positive? ? lines[idx - 1] : nil
             next_line = lines[idx + 1]
 
-            # Check: blank line after headers
-            if line.match?(/^\#{1,6}\s+\S/) && next_line && !next_line.strip.empty?
+            case transition
+            when :open
+              if prev_line && !prev_line.strip.empty?
+                warnings << Models::ValidationError.new(
+                  line: line_num,
+                  message: "Missing blank line before code block",
+                  severity: :warning
+                )
+              end
+              next
+            when :close
+              if next_line && !next_line.strip.empty?
+                warnings << Models::ValidationError.new(
+                  line: line_num + 1,
+                  message: "Missing blank line after code block",
+                  severity: :warning
+                )
+              end
+              next
+            end
+
+            # Skip style checks inside fenced code blocks.
+            next if in_code_block
+
+            # Check: trailing whitespace
+            if line_has_trailing_whitespace?(line)
               warnings << Models::ValidationError.new(
                 line: line_num,
-                message: "Missing blank line after heading",
+                message: "Trailing whitespace found",
                 severity: :warning
               )
             end
 
-            # Check: blank line before lists (unless first line or after another list item)
-            prev_line = idx.positive? ? lines[idx - 1] : nil
-            if line.match?(/^[*-]\s+\S/) && prev_line && !prev_line.strip.empty? && !prev_line.match?(/^[*-]\s+\S/)
+            # Check: blank line before headers
+            if line.match?(HEADING_PATTERN) && prev_line && !prev_line.strip.empty?
               warnings << Models::ValidationError.new(
                 line: line_num,
-                message: "Missing blank line before list",
+                message: "Missing blank line before heading",
                 severity: :warning
               )
             end
 
-            # Check: blank line after lists
-            if prev_line&.match?(/^[*-]\s+\S/) && !line.match?(/^[*-]\s+\S/) && !line.strip.empty?
+            # Check: blank line after headers
+            if line.match?(HEADING_PATTERN) && next_line && !next_line.strip.empty?
               warnings << Models::ValidationError.new(
                 line: line_num,
-                message: "Missing blank line after list",
+                message: "Missing blank line after heading",
                 severity: :warning
               )
             end
 
-            # Check: blank line before code blocks
-            if line.match?(/^```/) && prev_line && !prev_line.strip.empty?
+            # Check: blank line before lists (unless first line or after another list item)
+            if line.match?(UNORDERED_LIST_PATTERN) && prev_line && !prev_line.strip.empty? && !prev_line.match?(UNORDERED_LIST_PATTERN)
               warnings << Models::ValidationError.new(
                 line: line_num,
-                message: "Missing blank line before code block",
+                message: "Missing blank line before list",
                 severity: :warning
               )
             end
 
-            # Check: blank line after code blocks (closing ```)
-            if prev_line&.match?(/^```$/) && !line.strip.empty?
+            # Check: blank line after lists
+            if prev_line&.match?(UNORDERED_LIST_PATTERN) && !line.match?(UNORDERED_LIST_PATTERN) && !line.strip.empty?
               warnings << Models::ValidationError.new(
                 line: line_num,
-                message: "Missing blank line after code block",
+                message: "Missing blank line after list",
                 severity: :warning
               )
             end
@@ -156,6 +180,11 @@ module Ace
           warnings
         end
 
+        def self.line_has_trailing_whitespace?(line)
+          line_without_newline = line.sub(/\r?\n\z/, "")
+          line_without_newline.match?(/[ \t]+\z/)
+        end
+
         def self.strip_frontmatter(content)
           extraction = Atoms::FrontmatterExtractor.extract(content)
           return content unless extraction[:has_frontmatter]
@@ -164,6 +193,44 @@ module Ace
           ("\n" * frontmatter_lines) + extraction[:body].to_s
         end
 
+        def self.each_markdown_link(text)
+          return enum_for(:each_markdown_link, text) unless block_given?
+
+          cursor = 0
+          while (open_bracket = text.index("[", cursor))
+            close_bracket = find_matching_closer(text, open_bracket, "[", "]")
+            if close_bracket && text[close_bracket + 1] == "("
+              close_paren = find_matching_closer(text, close_bracket + 1, "(", ")")
+              if close_paren
+                yield(
+                  start: open_bracket,
+                  end_exclusive: close_paren + 1,
+                  link_text: text[(open_bracket + 1)...close_bracket],
+                  destination: text[(close_bracket + 2)...close_paren]
+                )
+                cursor = close_paren + 1
+                next
+              end
+            end
+
+            cursor = open_bracket + 1
+          end
+        end
+
+        def self.strip_link_markup(text)
+          output = +""
+          cursor = 0
+
+          each_markdown_link(text) do |link|
+            output << text[cursor...link[:start]]
+            output << link[:link_text]
+            cursor = link[:end_exclusive]
+          end
+
+          output << (text[cursor..] || "")
+          output
+        end
+
         # Check typography issues (em-dashes, smart quotes)
         # Skips content inside fenced code blocks and inline code
         # @param content [String] Markdown content
@@ -179,41 +246,15 @@ module Ace
           return issues if em_dash_severity == "off" && smart_quotes_severity == "off"
 
           lines = content.lines
-          in_code_block = false
-          fence_char = nil
-          fence_length = 0
 
-          lines.each_with_index do |line, idx|
-            line_num = idx + 1
+          each_fence_aware_line(lines) do |line:, index:, in_code_block:, transition:|
+            line_num = index + 1
 
-            # Track fenced code block state with proper fence matching
-            if (match = line.match(FENCE_PATTERN))
-              current_fence_char = match[2][0] # First char (` or ~)
-              current_fence_length = match[2].length
-
-              if in_code_block
-                # Only close if same char and at least same length
-                if current_fence_char == fence_char && current_fence_length >= fence_length
-                  in_code_block = false
-                  fence_char = nil
-                  fence_length = 0
-                end
-              else
-                # Opening fence
-                in_code_block = true
-                fence_char = current_fence_char
-                fence_length = current_fence_length
-              end
-              next
-            end
-
-            # Skip lines inside code blocks
-            next if in_code_block
+            next if transition || in_code_block
 
             # Remove inline code spans (handles both single and double backticks)
             # Then remove link markup but keep link text for checking
-            line_without_code = line.gsub(INLINE_CODE_PATTERN, "")
-              .gsub(LINK_PATTERN, '\1')
+            line_without_code = strip_link_markup(line.gsub(INLINE_CODE_PATTERN, ""))
 
             # Check for em-dashes
             if em_dash_severity != "off" && line_without_code.include?(EM_DASH)
@@ -243,6 +284,86 @@ module Ace
 
           issues
         end
+
+        def self.each_fence_aware_line(lines)
+          return enum_for(:each_fence_aware_line, lines) unless block_given?
+
+          in_code_block = false
+          fence_char = nil
+          fence_length = 0
+
+          lines.each_with_index do |line, idx|
+            transition = nil
+            opened_fence_char = nil
+            opened_fence_length = nil
+
+            if (match = line.match(FENCE_PATTERN))
+              current_fence_char = match[2][0]
+              current_fence_length = match[2].length
+
+              if in_code_block
+                transition = :close if current_fence_char == fence_char && current_fence_length >= fence_length
+              else
+                transition = :open
+                opened_fence_char = current_fence_char
+                opened_fence_length = current_fence_length
+              end
+            end
+
+            yield(
+              line: line,
+              index: idx,
+              in_code_block: in_code_block,
+              transition: transition
+            )
+
+            case transition
+            when :open
+              in_code_block = true
+              fence_char = opened_fence_char
+              fence_length = opened_fence_length
+            when :close
+              in_code_block = false
+              fence_char = nil
+              fence_length = 0
+            end
+          end
+        end
+
+        def self.find_matching_closer(text, opener_index, opener_char, closer_char)
+          depth = 0
+          idx = opener_index
+
+          while idx < text.length
+            char = text[idx]
+            if escaped_character?(text, idx)
+              idx += 1
+              next
+            end
+
+            if char == opener_char
+              depth += 1
+            elsif char == closer_char
+              depth -= 1
+              return idx if depth.zero?
+            end
+            idx += 1
+          end
+
+          nil
+        end
+
+        def self.escaped_character?(text, index)
+          backslashes = 0
+          idx = index - 1
+
+          while idx >= 0 && text[idx] == "\\"
+            backslashes += 1
+            idx -= 1
+          end
+
+          backslashes.odd?
+        end
       end
     end
   end

data/lib/ace/lint/molecules/markdown_surgical_fixer.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+require_relative "../atoms/frontmatter_extractor"
+require_relative "markdown_linter"
+
+module Ace
+  module Lint
+    module Molecules
+      # Applies low-risk, line-level markdown fixes without re-serializing the document.
+      class MarkdownSurgicalFixer
+        SMART_QUOTE_REPLACEMENTS = {
+          "\u201C" => '"',
+          "\u201D" => '"',
+          "\u2018" => "'",
+          "\u2019" => "'"
+        }.freeze
+
+        class << self
+          def fix_file(file_path)
+            content = File.binread(file_path).dup.force_encoding(Encoding::UTF_8)
+            unless content.valid_encoding?
+              return {
+                success: true,
+                formatted: false,
+                errors: [],
+                warnings: ["Skipped non-UTF8 file: #{file_path}"]
+              }
+            end
+
+            result = fix_content(content)
+            return {success: false, formatted: false, errors: result[:errors], warnings: result[:warnings]} unless result[:success]
+
+            File.write(file_path, result[:formatted_content]) if result[:formatted]
+
+            {
+              success: true,
+              formatted: result[:formatted],
+              errors: [],
+              warnings: result[:warnings]
+            }
+          rescue Errno::ENOENT
+            {success: false, formatted: false, errors: ["File not found: #{file_path}"], warnings: []}
+          rescue => e
+            {success: false, formatted: false, errors: ["Error fixing file: #{e.message}"], warnings: []}
+          end
+
+          def fix_content(content)
+            extraction = Atoms::FrontmatterExtractor.extract(content)
+            if extraction[:has_frontmatter]
+              body = extraction[:body].to_s
+              # FrontmatterExtractor returns body as the exact suffix after frontmatter delimiters.
+              frontmatter_prefix = content[0...(content.length - body.length)]
+            else
+              body = content
+              frontmatter_prefix = ""
+            end
+
+            fixed_body = apply_body_fixes(body)
+            formatted_content = frontmatter_prefix + fixed_body
+
+            {
+              success: true,
+              formatted: formatted_content != content,
+              formatted_content: formatted_content,
+              errors: [],
+              warnings: []
+            }
+          rescue => e
+            {
+              success: false,
+              formatted: false,
+              formatted_content: content,
+              errors: ["Error fixing markdown content: #{e.message}"],
+              warnings: []
+            }
+          end
+
+          private
+
+          def apply_body_fixes(body)
+            return body if body.empty?
+
+            lines = body.lines
+            transformed = transform_lines(lines)
+            with_spacing_fixes = apply_spacing_rules(transformed)
+            fixed_body = with_spacing_fixes.join
+            ensure_trailing_newline(fixed_body)
+          end
+
+          def transform_lines(lines)
+            transformed = []
+            MarkdownLinter.each_fence_aware_line(lines) do |line:, in_code_block:, transition:, **|
+              case transition
+              when :open
+                transformed << trim_trailing_whitespace(line)
+                next
+              when :close
+                transformed << line
+                next
+              end
+
+              if in_code_block
+                transformed << line
+                next
+              end
+
+              normalized_line = trim_trailing_whitespace(line)
+              transformed << replace_typography_outside_inline_code(normalized_line)
+            end
+
+            transformed
+          end
+
+          def apply_spacing_rules(lines)
+            output = []
+            MarkdownLinter.each_fence_aware_line(lines) do |line:, index:, in_code_block:, transition:|
+              idx = index
+              next_line = lines[idx + 1]
+              previous_line = output.last
+
+              case transition
+              when :open
+                ensure_blank_line_before(output, previous_line || line)
+                output << line
+                next
+              when :close
+                output << line
+                ensure_blank_line_after(output, line) if next_line && !blank_line?(next_line)
+                next
+              end
+
+              if in_code_block
+                output << line
+                next
+              end
+
+              if line.match?(MarkdownLinter::HEADING_PATTERN)
+                ensure_blank_line_before(output, previous_line || line)
+              end
+
+              if line.match?(MarkdownLinter::UNORDERED_LIST_PATTERN) &&
+                  previous_line &&
+                  !blank_line?(previous_line) &&
+                  !previous_line.match?(MarkdownLinter::UNORDERED_LIST_PATTERN)
+                ensure_blank_line_before(output, previous_line)
+              end
+
+              if previous_line&.match?(MarkdownLinter::UNORDERED_LIST_PATTERN) &&
+                  !line.match?(MarkdownLinter::UNORDERED_LIST_PATTERN) &&
+                  !blank_line?(line)
+                ensure_blank_line_before(output, previous_line)
+              end
+
+              output << line
+
+              if line.match?(MarkdownLinter::HEADING_PATTERN) && next_line && !blank_line?(next_line)
+                ensure_blank_line_after(output, line)
+              end
+            end
+
+            output
+          end
+
+          def replace_typography_outside_inline_code(line)
+            body, line_ending = split_line_ending(line)
+            result = +""
+            cursor = 0
+
+            body.to_enum(:scan, MarkdownLinter::INLINE_CODE_PATTERN).each do
+              match = Regexp.last_match
+              result << replace_typography_outside_links(body[cursor...match.begin(0)])
+              result << match[0]
+              cursor = match.end(0)
+            end
+            result << replace_typography_outside_links(body[cursor..] || "")
+
+            result + line_ending
+          end
+
+          def replace_typography_outside_links(text)
+            result = +""
+            cursor = 0
+
+            MarkdownLinter.each_markdown_link(text) do |link|
+              result << normalize_typography(text[cursor...link[:start]])
+              link_text = normalize_typography(link[:link_text])
+              result << "[#{link_text}](#{link[:destination]})"
+              cursor = link[:end_exclusive]
+            end
+            result << normalize_typography(text[cursor..] || "")
+
+            result
+          end
+
+          def normalize_typography(text)
+            normalized = text.gsub(MarkdownLinter::EM_DASH, "--")
+            SMART_QUOTE_REPLACEMENTS.each do |source, target|
+              normalized = normalized.gsub(source, target)
+            end
+            normalized
+          end
+
+          def trim_trailing_whitespace(line)
+            body, line_ending = split_line_ending(line)
+            body.sub(/[ \t]+\z/, "") + line_ending
+          end
+
+          def split_line_ending(line)
+            if line.end_with?("\r\n")
+              [line[0...-2], "\r\n"]
+            elsif line.end_with?("\n")
+              [line[0...-1], "\n"]
+            else
+              [line, ""]
+            end
+          end
+
+          def blank_line?(line)
+            line.nil? || line.strip.empty?
+          end
+
+          def ensure_blank_line_before(lines, reference_line)
+            return if lines.empty? || blank_line?(lines.last)
+
+            lines << blank_line_for(reference_line)
+          end
+
+          def ensure_blank_line_after(lines, reference_line)
+            return if lines.empty? || blank_line?(lines.last)
+
+            lines << blank_line_for(reference_line)
+          end
+
+          def blank_line_for(reference_line)
+            reference_line&.end_with?("\r\n") ? "\r\n" : "\n"
+          end
+
+          def ensure_trailing_newline(content)
+            return content if content.empty? || content.end_with?("\n")
+
+            "#{content}\n"
+          end
+        end
+      end
+    end
+  end
+end