ace-lint 0.25.0

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "../atoms/pattern_matcher"
+
+module Ace
+  module Lint
+    module Molecules
+      # Resolves which validator group applies to files based on pattern matching
+      # Uses configuration groups with glob patterns to determine validators
+      class GroupResolver
+        # Default group configuration when no groups are defined
+        DEFAULT_GROUPS = {
+          default: {
+            patterns: ["**/*.rb"],
+            validators: [:standardrb],
+            fallback_validators: [:rubocop]
+          }
+        }.freeze
+
+        attr_reader :groups
+
+        # Initialize with groups configuration
+        # @param groups [Hash] Groups configuration from ruby.yml
+        def initialize(groups = nil)
+          @groups = normalize_groups(groups || DEFAULT_GROUPS)
+        end
+
+        # Resolve validator group for a single file
+        # @param file_path [String] File path to resolve
+        # @return [Hash] { group_name:, validators:, fallback_validators:, config: }
+        def resolve(file_path)
+          match = Atoms::PatternMatcher.best_group_match(file_path, @groups)
+
+          if match
+            group_name, config = match
+            build_result(group_name, config)
+          else
+            # No match - use default group if available, otherwise return nil
+            default = @groups[:default]
+            if default
+              build_result(:default, default)
+            end
+          end
+        end
+
+        # Resolve validator groups for multiple files, grouping them by matched group
+        # @param file_paths [Array<String>] File paths to resolve
+        # @return [Hash<Symbol, Hash>] Map of group_name => { files:, validators:, ... }
+        def resolve_batch(file_paths)
+          result = Hash.new { |h, k| h[k] = {files: []} }
+
+          file_paths.each do |file_path|
+            resolution = resolve(file_path)
+
+            if resolution
+              group_name = resolution[:group_name]
+              result[group_name][:files] << file_path
+              # Store group config (only once per group)
+              result[group_name].merge!(resolution) { |_k, old, _new| old }
+            else
+              # Unmatched files go to :_unmatched_ group
+              result[:_unmatched_][:files] << file_path
+              result[:_unmatched_][:validators] ||= []
+              result[:_unmatched_][:group_name] ||= :_unmatched_
+            end
+          end
+
+          result
+        end
+
+        private
+
+        # Normalize groups configuration to use symbols and arrays
+        # @param groups [Hash] Raw groups configuration
+        # @return [Hash] Normalized groups
+        def normalize_groups(groups)
+          return {} if groups.nil?
+
+          groups.each_with_object({}) do |(name, config), result|
+            result[name.to_sym] = {
+              patterns: normalize_array(config[:patterns] || config["patterns"]),
+              validators: normalize_validators(config[:validators] || config["validators"]),
+              fallback_validators: normalize_validators(config[:fallback_validators] || config["fallback_validators"]),
+              config_path: config[:config_path] || config["config_path"]
+            }
+          end
+        end
+
+        # Normalize array values
+        # @param value [Array, String, nil] Value to normalize
+        # @return [Array] Normalized array
+        def normalize_array(value)
+          return [] if value.nil?
+
+          Array(value)
+        end
+
+        # Normalize validators to symbols
+        # @param validators [Array, String, Symbol, nil] Validators to normalize
+        # @return [Array<Symbol>] Normalized validators
+        def normalize_validators(validators)
+          return [] if validators.nil?
+
+          Array(validators).map { |v| v.to_s.downcase.to_sym }
+        end
+
+        # Build result hash for a matched group
+        # @param group_name [Symbol] Group name
+        # @param config [Hash] Group configuration
+        # @return [Hash] Resolution result
+        def build_result(group_name, config)
+          {
+            group_name: group_name,
+            validators: config[:validators] || [],
+            fallback_validators: config[:fallback_validators] || [],
+            config_path: config[:config_path]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../atoms/kramdown_parser"
+
+module Ace
+  module Lint
+    module Molecules
+      # Formats markdown with kramdown
+      class KramdownFormatter
+        # Format markdown file in place
+        # @param file_path [String] Path to markdown file
+        # @param options [Hash] Kramdown options
+        # @return [Hash] Result with :success, :formatted, :errors
+        def self.format_file(file_path, options: {})
+          content = File.read(file_path)
+          result = format_content(content, options: options)
+
+          if result[:success] && result[:formatted_content]
+            File.write(file_path, result[:formatted_content])
+            {success: true, formatted: true, errors: []}
+          else
+            {success: false, formatted: false, errors: result[:errors]}
+          end
+        rescue Errno::ENOENT
+          {success: false, formatted: false, errors: ["File not found: #{file_path}"]}
+        rescue => e
+          {success: false, formatted: false, errors: ["Error formatting file: #{e.message}"]}
+        end
+
+        # Format markdown content
+        # @param content [String] Markdown content
+        # @param options [Hash] Kramdown options
+        # @return [Hash] Result with :success, :formatted_content, :errors
+        def self.format_content(content, options: {})
+          # Load kramdown configuration from ace-core config cascade
+          # Config location: .ace/lint/kramdown.yml
+          kramdown_config = Ace::Lint.kramdown_config
+
+          # Convert string keys to symbols (kramdown expects symbols)
+          kramdown_opts = kramdown_config.transform_keys(&:to_sym)
+
+          # Merge: config file < formatting defaults < CLI options
+          default_options = {
+            line_width: kramdown_opts[:line_width] || 120,
+            remove_block_html_tags: false,
+            remove_span_html_tags: false
+          }
+
+          merged_options = kramdown_opts.merge(default_options).merge(options)
+          Atoms::KramdownParser.format(content, options: merged_options)
+        end
+
+        # Check if content would change after formatting
+        # @param content [String] Markdown content
+        # @param options [Hash] Kramdown options
+        # @return [Boolean] True if formatting would change content
+        def self.needs_formatting?(content, options: {})
+          result = format_content(content, options: options)
+          return false unless result[:success]
+
+          result[:formatted_content] != content
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require_relative "../atoms/kramdown_parser"
+require_relative "../atoms/frontmatter_extractor"
+require_relative "../models/lint_result"
+require_relative "../models/validation_error"
+
+module Ace
+  module Lint
+    module Molecules
+      # Validates markdown syntax via kramdown
+      class MarkdownLinter
+        # Typography characters to detect
+        EM_DASH = "\u2014"
+        SMART_QUOTES = [
+          "\u201C", # Left double quotation mark "
+          "\u201D", # Right double quotation mark "
+          "\u2018", # Left single quotation mark '
+          "\u2019"  # Right single quotation mark '
+        ].freeze
+
+        # 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 = /``[^`]+``|`[^`]+`/
+        # Validate markdown file
+        # @param file_path [String] Path to markdown file
+        # @param options [Hash] Kramdown options
+        # @return [Models::LintResult] Validation result
+        def self.lint(file_path, options: {})
+          content = File.read(file_path)
+          lint_content(file_path, content, options: options)
+        rescue Errno::ENOENT
+          Models::LintResult.new(
+            file_path: file_path,
+            success: false,
+            errors: [Models::ValidationError.new(message: "File not found: #{file_path}")]
+          )
+        rescue => e
+          Models::LintResult.new(
+            file_path: file_path,
+            success: false,
+            errors: [Models::ValidationError.new(message: "Error reading file: #{e.message}")]
+          )
+        end
+
+        # Validate markdown content
+        # @param file_path [String] Path for reference
+        # @param content [String] Markdown content
+        # @param options [Hash] Kramdown options
+        # @return [Models::LintResult] Validation result
+        def self.lint_content(file_path, content, options: {})
+          markdown_content = strip_frontmatter(content)
+          result = Atoms::KramdownParser.parse(markdown_content, options: options)
+
+          errors = result[:errors].map do |msg|
+            Models::ValidationError.new(message: msg, severity: :error)
+          end
+
+          warnings = result[:warnings].map do |msg|
+            Models::ValidationError.new(message: msg, severity: :warning)
+          end
+
+          # Add style checks
+          style_warnings = check_markdown_style(markdown_content)
+          warnings.concat(style_warnings)
+
+          # Add typography checks
+          config = Ace::Lint.markdown_config
+          typography_issues = check_typography(markdown_content, config)
+          typography_issues.each do |issue|
+            if issue.severity == :error
+              errors << issue
+            else
+              warnings << issue
+            end
+          end
+
+          Models::LintResult.new(
+            file_path: file_path,
+            success: result[:success] && errors.empty?,
+            errors: errors,
+            warnings: warnings
+          )
+        end
+
+        # Check markdown style best practices
+        # @param content [String] Markdown content
+        # @return [Array<Models::ValidationError>] Style warnings
+        def self.check_markdown_style(content)
+          warnings = []
+          lines = content.lines
+
+          lines.each_with_index do |line, idx|
+            line_num = idx + 1
+            next_line = lines[idx + 1]
+
+            # Check: blank line after headers
+            if line.match?(/^\#{1,6}\s+\S/) && next_line && !next_line.strip.empty?
+              warnings << Models::ValidationError.new(
+                line: line_num,
+                message: "Missing blank line after heading",
+                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/)
+              warnings << Models::ValidationError.new(
+                line: line_num,
+                message: "Missing blank line before list",
+                severity: :warning
+              )
+            end
+
+            # Check: blank line after lists
+            if prev_line&.match?(/^[*-]\s+\S/) && !line.match?(/^[*-]\s+\S/) && !line.strip.empty?
+              warnings << Models::ValidationError.new(
+                line: line_num,
+                message: "Missing blank line after list",
+                severity: :warning
+              )
+            end
+
+            # Check: blank line before code blocks
+            if line.match?(/^```/) && prev_line && !prev_line.strip.empty?
+              warnings << Models::ValidationError.new(
+                line: line_num,
+                message: "Missing blank line before code block",
+                severity: :warning
+              )
+            end
+
+            # Check: blank line after code blocks (closing ```)
+            if prev_line&.match?(/^```$/) && !line.strip.empty?
+              warnings << Models::ValidationError.new(
+                line: line_num,
+                message: "Missing blank line after code block",
+                severity: :warning
+              )
+            end
+          end
+
+          # Check: file should end with newline
+          unless content.end_with?("\n")
+            warnings << Models::ValidationError.new(
+              message: "Missing trailing newline at end of file",
+              severity: :warning
+            )
+          end
+
+          warnings
+        end
+
+        def self.strip_frontmatter(content)
+          extraction = Atoms::FrontmatterExtractor.extract(content)
+          return content unless extraction[:has_frontmatter]
+
+          frontmatter_lines = extraction[:frontmatter].to_s.lines.count + 2
+          ("\n" * frontmatter_lines) + extraction[:body].to_s
+        end
+
+        # Check typography issues (em-dashes, smart quotes)
+        # Skips content inside fenced code blocks and inline code
+        # @param content [String] Markdown content
+        # @param config [Hash] Markdown configuration with typography settings
+        # @return [Array<Models::ValidationError>] Typography issues
+        def self.check_typography(content, config)
+          issues = []
+          typography_config = config["typography"] || {}
+          em_dash_severity = typography_config["em_dash"] || "warn"
+          smart_quotes_severity = typography_config["smart_quotes"] || "warn"
+
+          # Return early if both checks are disabled
+          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
+
+            # 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
+
+            # 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')
+
+            # Check for em-dashes
+            if em_dash_severity != "off" && line_without_code.include?(EM_DASH)
+              severity = (em_dash_severity == "error") ? :error : :warning
+              issues << Models::ValidationError.new(
+                line: line_num,
+                message: "Em-dash character found; use double hyphens (--) instead",
+                severity: severity
+              )
+            end
+
+            # Check for smart quotes
+            if smart_quotes_severity != "off"
+              SMART_QUOTES.each do |quote|
+                if line_without_code.include?(quote)
+                  severity = (smart_quotes_severity == "error") ? :error : :warning
+                  quote_type = ["\u201C", "\u201D"].include?(quote) ? "double" : "single"
+                  issues << Models::ValidationError.new(
+                    line: line_num,
+                    message: "Smart #{quote_type} quote (#{quote}) found; use ASCII quotes instead",
+                    severity: severity
+                  )
+                end
+              end
+            end
+          end
+
+          issues
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Ace
+  module Lint
+    module Molecules
+      # Deduplicates linting offenses from multiple validators
+      # Handles offenses from StandardRB, RuboCop, and other Ruby linters
+      class OffenseDeduplicator
+        # Deduplicate offenses by file:line:column:normalized_message
+        # Keeps the offense with the most detailed message when duplicates found
+        # @param offenses [Array<Hash>] Offenses to deduplicate
+        # @return [Array<Hash>] Deduplicated offenses
+        def self.deduplicate(offenses)
+          return [] if offenses.empty?
+
+          seen = {}
+
+          offenses.each do |offense|
+            key = offense_key(offense)
+            if seen[key]
+              # Keep the offense with the longer/more detailed message
+              existing_len = seen[key][:message]&.length || 0
+              new_len = offense[:message]&.length || 0
+              seen[key] = offense if new_len > existing_len
+            else
+              seen[key] = offense
+            end
+          end
+
+          seen.values
+        end
+
+        # Generate unique key for an offense
+        # @param offense [Hash] Offense data
+        # @return [String] Unique key
+        def self.offense_key(offense)
+          file = offense[:file] || ""
+          line = offense[:line] || 0
+          column = offense[:column] || 0
+          # Normalize message: strip cop name prefix, downcase, remove extra whitespace
+          message = normalize_message(offense[:message] || "")
+
+          "#{file}:#{line}:#{column}:#{message}"
+        end
+        private_class_method :offense_key
+
+        # Normalize message for comparison
+        # @param message [String] Original message
+        # @return [String] Normalized message
+        def self.normalize_message(message)
+          # Remove cop name prefix with various formats (e.g., "Style/StringLiterals: ", "Layout/TrailingWhitespace - ")
+          # Updated regex handles:
+          #   - Standard: "Style/StringLiterals: "
+          #   - With numbers: "Rails/HTTPStatus: ", "Lint/BooleanSymbol: "
+          #   - Nested: "Style/HashSyntax/Compact: "
+          #   - Hyphens: "Style-Guide: "
+          normalized = message.sub(/\A[A-Za-z0-9]+(?:[\/-][A-Za-z0-9]+)+[:\s-]+/, "")
+          # Downcase and strip extra whitespace
+          normalized.downcase.gsub(/\s+/, " ").strip
+        end
+        private_class_method :normalize_message
+      end
+    end
+  end
+end