ace-test-runner 0.18.0

data/lib/ace/test_runner/molecules/config_loader.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "ostruct"
+require "ace/support/config"
+
+module Ace
+  module TestRunner
+    module Molecules
+      # Load configuration using Ace::Support::Config.create() API
+      # Follows ADR-022: Configuration Default and Override Pattern
+      #
+      # Configuration priority (highest to lowest):
+      # 1. CLI options (handled by merge_with_options)
+      # 2. Explicit config_path if provided
+      # 3. Project config: .ace/test/runner.yml (nearest wins via cascade)
+      # 4. User config: ~/.ace/test/runner.yml
+      # 5. Gem defaults: ace-test-runner/.ace-defaults/test-runner/config.yml
+      class ConfigLoader
+        # Load gem defaults for direct access (used by tests)
+        # @return [Hash] Default configuration with symbol keys
+        def self.load_gem_defaults
+          gem_root = Gem.loaded_specs["ace-test-runner"]&.gem_dir ||
+            File.expand_path("../../../..", __dir__)
+
+          resolver = Ace::Support::Config.create(
+            config_dir: ".ace",
+            defaults_dir: ".ace-defaults",
+            gem_path: gem_root
+          )
+
+          config = resolver.resolve_namespace("test-runner").data
+          deep_symbolize_keys(config)
+        end
+
+        # Reset method for test isolation (no-op since we don't cache at class level)
+        def self.reset_gem_defaults!
+          # No-op: Ace::Support::Config.create() is called fresh each time
+        end
+
+        def load(config_path = nil)
+          gem_root = Gem.loaded_specs["ace-test-runner"]&.gem_dir ||
+            File.expand_path("../../../..", __dir__)
+
+          resolver = Ace::Support::Config.create(
+            config_dir: ".ace",
+            defaults_dir: ".ace-defaults",
+            gem_path: gem_root
+          )
+
+          # Get merged config from cascade
+          config = resolver.resolve_file(["test-runner/config.yml", "test/runner.yml"]).data
+
+          # If explicit config_path provided, merge it on top
+          if config_path && File.exist?(config_path)
+            user_config = load_from_file(config_path)
+            config = Ace::Support::Config::Atoms::DeepMerger.merge(config, user_config)
+          end
+
+          # Convert to symbol keys for backward compatibility
+          config = deep_symbolize_keys(config)
+
+          validate_config(config)
+          normalize_config(config)
+        rescue => e
+          warn "Warning: Could not load ace-test-runner config: #{e.message}" if ENV["DEBUG"]
+          # Return minimal valid config on error
+          normalize_config({version: 1})
+        end
+
+        def merge_with_options(config, options)
+          merged = deep_copy(config)
+
+          # Override defaults with command-line options
+          if options[:format]
+            merged[:defaults] ||= {}
+            merged[:defaults][:reporter] = options[:format]
+          end
+
+          if options.key?(:color)
+            merged[:defaults] ||= {}
+            merged[:defaults][:color] = options[:color]
+          end
+
+          if options.key?(:fail_fast)
+            merged[:defaults] ||= {}
+            merged[:defaults][:fail_fast] = options[:fail_fast]
+          end
+
+          if options[:report_dir]
+            merged[:defaults] ||= {}
+            merged[:defaults][:report_dir] = options[:report_dir]
+          end
+
+          # Override failure limits with command-line options
+          if options[:max_display]
+            merged[:failure_limits] ||= {}
+            merged[:failure_limits][:max_display] = options[:max_display]
+          end
+
+          OpenStruct.new(merged)
+        end
+
+        private
+
+        def load_from_file(path)
+          YAML.safe_load_file(path, permitted_classes: [], aliases: true) || {}
+        rescue => e
+          warn "Warning: Failed to load config from #{path}: #{e.message}"
+          {}
+        end
+
+        # Recursively convert string keys to symbols
+        def deep_symbolize_keys(obj)
+          self.class.deep_symbolize_keys(obj)
+        end
+
+        # Class method version for use in self.load_gem_defaults
+        def self.deep_symbolize_keys(obj)
+          case obj
+          when Hash
+            obj.each_with_object({}) do |(key, value), result|
+              result[key.to_sym] = deep_symbolize_keys(value)
+            end
+          when Array
+            obj.map { |item| deep_symbolize_keys(item) }
+          else
+            obj
+          end
+        end
+
+        def validate_config(config)
+          unless config[:version]
+            warn "Warning: Configuration missing version field, assuming version 1"
+            config[:version] = 1
+          end
+
+          if config[:version] > 1
+            warn "Warning: Configuration version #{config[:version]} is newer than supported version 1"
+          end
+
+          config
+        end
+
+        def normalize_config(config)
+          # Ensure all sections exist as hashes (defaults already merged in load)
+          config[:patterns] ||= {}
+          config[:groups] ||= {}
+          config[:defaults] ||= {}
+          config[:failure_limits] ||= {}
+          config[:execution] ||= {}
+
+          config
+        end
+
+        def deep_copy(obj)
+          Marshal.load(Marshal.dump(obj))
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/deprecation_fixer.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Molecules
+      # Identifies and suggests fixes for deprecated code patterns
+      class DeprecationFixer
+        DEPRECATION_PATTERNS = [
+          {
+            pattern: /must_equal/,
+            replacement: "must_be :==",
+            description: "Replace must_equal with must_be :=="
+          },
+          {
+            pattern: /wont_equal/,
+            replacement: "wont_be :==",
+            description: "Replace wont_equal with wont_be :=="
+          },
+          {
+            pattern: /must_be_nil/,
+            replacement: "must_be_nil",
+            description: "Use must_be_nil (no change needed)"
+          },
+          {
+            pattern: /\.must_be\s+:([<>]=?)/,
+            replacement: 'must_be :\1',
+            description: "Comparison operators should use symbols"
+          },
+          {
+            pattern: /assert_equal\s+nil,/,
+            replacement: "assert_nil",
+            description: "Use assert_nil instead of assert_equal nil"
+          },
+          {
+            pattern: /refute_equal\s+nil,/,
+            replacement: "refute_nil",
+            description: "Use refute_nil instead of refute_equal nil"
+          }
+        ].freeze
+
+        def find_deprecations(content)
+          deprecations = []
+
+          content.lines.each_with_index do |line, index|
+            DEPRECATION_PATTERNS.each do |pattern_info|
+              if line.match?(pattern_info[:pattern])
+                deprecations << {
+                  line_number: index + 1,
+                  line_content: line.strip,
+                  pattern: pattern_info[:pattern].source,
+                  suggestion: pattern_info[:description],
+                  replacement: pattern_info[:replacement]
+                }
+              end
+            end
+          end
+
+          deprecations
+        end
+
+        def fix_file(file_path, dry_run: false)
+          unless File.exist?(file_path)
+            return {success: false, error: "File not found: #{file_path}"}
+          end
+
+          original_content = File.read(file_path)
+          fixed_content = apply_fixes(original_content)
+
+          if original_content == fixed_content
+            return {
+              success: true,
+              changes: 0,
+              message: "No deprecations found"
+            }
+          end
+
+          unless dry_run
+            File.write(file_path, fixed_content)
+          end
+
+          {
+            success: true,
+            changes: count_changes(original_content, fixed_content),
+            message: dry_run ? "Would fix deprecations (dry run)" : "Fixed deprecations",
+            diff: generate_diff(original_content, fixed_content)
+          }
+        end
+
+        def fix_deprecations_in_output(test_output)
+          fixes = []
+
+          # Look for deprecation warnings in test output
+          test_output.scan(/DEPRECATION WARNING: (.+)/) do |warning|
+            fix = analyze_warning(warning.first)
+            fixes << fix if fix
+          end
+
+          fixes.uniq
+        end
+
+        def generate_fix_report(deprecations)
+          return "No deprecations found." if deprecations.empty?
+
+          lines = ["# Deprecation Fixes Required", ""]
+
+          grouped = deprecations.group_by { |d| d[:file] || "Unknown" }
+
+          grouped.each do |file, file_deprecations|
+            lines << "## File: #{file}"
+            lines << ""
+
+            file_deprecations.each do |dep|
+              lines << "- Line #{dep[:line_number]}: #{dep[:suggestion]}"
+              if dep[:replacement]
+                lines << "  Replace: `#{dep[:line_content]}`"
+                lines << "  With: `#{apply_single_fix(dep[:line_content], dep)}`"
+              end
+            end
+
+            lines << ""
+          end
+
+          lines.join("\n")
+        end
+
+        private
+
+        def apply_fixes(content)
+          fixed_content = content.dup
+
+          DEPRECATION_PATTERNS.each do |pattern_info|
+            fixed_content.gsub!(pattern_info[:pattern], pattern_info[:replacement])
+          end
+
+          fixed_content
+        end
+
+        def apply_single_fix(line, deprecation_info)
+          return line unless deprecation_info[:replacement]
+
+          pattern = Regexp.new(deprecation_info[:pattern])
+          line.gsub(pattern, deprecation_info[:replacement])
+        end
+
+        def count_changes(original, fixed)
+          original_lines = original.lines
+          fixed_lines = fixed.lines
+
+          changes = 0
+          [original_lines.length, fixed_lines.length].max.times do |i|
+            if original_lines[i] != fixed_lines[i]
+              changes += 1
+            end
+          end
+
+          changes
+        end
+
+        def generate_diff(original, fixed)
+          # Simple diff generation
+          diff_lines = []
+          original_lines = original.lines
+          fixed_lines = fixed.lines
+
+          [original_lines.length, fixed_lines.length].max.times do |i|
+            if original_lines[i] != fixed_lines[i]
+              diff_lines << "- #{original_lines[i]}" if original_lines[i]
+              diff_lines << "+ #{fixed_lines[i]}" if fixed_lines[i]
+            end
+          end
+
+          diff_lines.join
+        end
+
+        def analyze_warning(warning_text)
+          # Extract file and line information from warning if available
+          if warning_text =~ /(.+):(\d+):\s*(.+)/
+            {
+              file: $1,
+              line: $2.to_i,
+              message: $3,
+              suggestion: find_fix_for_warning($3)
+            }
+          else
+            {
+              message: warning_text,
+              suggestion: find_fix_for_warning(warning_text)
+            }
+          end
+        end
+
+        def find_fix_for_warning(warning_text)
+          DEPRECATION_PATTERNS.each do |pattern_info|
+            if warning_text.match?(pattern_info[:pattern])
+              return pattern_info[:description]
+            end
+          end
+
+          "Review deprecation warning and update code accordingly"
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/failed_package_reporter.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "pathname"
+require_relative "../atoms/report_path_resolver"
+
+module Ace
+  module TestRunner
+    module Molecules
+      module FailedPackageReporter
+        module_function
+
+        def format_for_display(package)
+          path = extract_path(package)
+          report_root = extract_report_root(package)
+          package_name = extract_name(package) || File.basename(path)
+          report_path = Atoms::ReportPathResolver.call(
+            path,
+            report_root: report_root,
+            package_name: package_name
+          )
+
+          if report_path
+            begin
+              relative_path = Pathname.new(report_path).relative_path_from(Dir.pwd)
+              "    → See #{relative_path}"
+            rescue => e
+              warn "Failed to calculate relative path: #{e.message}" if debug_mode?
+              "    → See #{report_path}"
+            end
+          else
+            reports_path = fallback_reports_path(path, report_root, package_name)
+            begin
+              relative_path = Pathname.new(reports_path).relative_path_from(Dir.pwd)
+              "    → Check #{relative_path}/ for details"
+            rescue => e
+              warn "Failed to calculate relative path: #{e.message}" if debug_mode?
+              "    → Check #{reports_path}/ for details"
+            end
+          end
+        end
+
+        def format_for_markdown(package)
+          path = extract_path(package)
+          report_root = extract_report_root(package)
+          package_name = extract_name(package) || File.basename(path)
+          report_path = Atoms::ReportPathResolver.call(
+            path,
+            report_root: report_root,
+            package_name: package_name
+          )
+
+          if report_path
+            relative_report_path = relative_or_absolute(report_path)
+            "- Report: `#{relative_report_path}`"
+          else
+            reports_path = fallback_reports_path(path, report_root, package_name)
+            relative_reports_path = relative_or_absolute(reports_path)
+            "- Report: Check `#{relative_reports_path}/` for details"
+          end
+        end
+
+        class << self
+          private
+
+          def extract_path(package)
+            package[:path] || package["path"]
+          end
+
+          def extract_name(package)
+            package[:name] || package["name"]
+          end
+
+          def extract_report_root(package)
+            package[:report_root] || package["report_root"]
+          end
+
+          def fallback_reports_path(path, report_root, package_name)
+            if report_root
+              short_name = package_name.to_s.sub(/\Aace-/, "")
+              return File.join(report_root, short_name) unless short_name.empty?
+            end
+
+            File.join(path, "test-reports")
+          end
+
+          def debug_mode?
+            ENV["DEBUG"]
+          end
+
+          def relative_or_absolute(path)
+            Pathname.new(path).relative_path_from(Dir.pwd).to_s
+          rescue => e
+            warn "Failed to calculate relative path: #{e.message}" if debug_mode?
+            path
+          end
+        end
+      end
+    end
+  end
+end