ace-test-runner 0.18.0

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Molecules
+      class PatternResolver
+        attr_reader :using_catch_all
+
+        def initialize(config)
+          @config = config
+          @patterns = normalize_keys(config.patterns || {})
+          @groups = normalize_keys(config.groups || {})
+          @using_catch_all = false
+        end
+
+        def resolve_target(target)
+          return resolve_all_files if target.nil? || target == "all"
+          return [target] if File.exist?(target)
+
+          # Normalize target to string for consistent lookup
+          target_key = target.to_s
+
+          if @groups.key?(target_key)
+            resolve_group(target_key)
+          elsif @patterns.key?(target_key)
+            expand_pattern(@patterns[target_key])
+          elsif looks_like_file_path?(target)
+            raise ArgumentError, "File not found: #{target}. " \
+              "Make sure you're running from the correct directory or use an absolute path."
+          else
+            raise ArgumentError, "Unknown target: #{target}. Available targets: #{available_targets.join(", ")}"
+          end
+        end
+
+        def resolve_multiple_targets(targets)
+          targets.flat_map { |target| resolve_target(target) }.uniq
+        end
+
+        def resolve_group_sequential(group_name)
+          group_key = group_name.to_s
+          group_members = @groups[group_key]
+          return [] unless group_members
+
+          group_members.flat_map do |member|
+            member_key = member.to_s
+
+            if @groups.key?(member_key)
+              # Recursively expand nested groups
+              resolve_group_sequential(member_key)
+            elsif @patterns.key?(member_key)
+              # Pattern found - return as a group
+              files = expand_pattern(@patterns[member_key])
+              files.empty? ? [] : [{name: member_key, files: files}]
+            else
+              # Direct pattern - expand and wrap
+              files = expand_pattern(member)
+              files.empty? ? [] : [{name: "other", files: files}]
+            end
+          end
+        end
+
+        def available_targets
+          (@groups.keys + @patterns.keys).map(&:to_s).sort
+        end
+
+        def classify_file(file_path)
+          @patterns.each do |name, pattern|
+            # Use File::FNM_PATHNAME to handle ** correctly
+            return name.to_s if File.fnmatch?(pattern, file_path, File::FNM_PATHNAME)
+          end
+          "other"
+        end
+
+        private
+
+        def looks_like_file_path?(target)
+          target.include?("/") || target.end_with?(".rb")
+        end
+
+        def normalize_keys(hash)
+          hash.transform_keys(&:to_s)
+        end
+
+        def resolve_group(group_name)
+          # Normalize to string
+          group_key = group_name.to_s
+          group_members = @groups[group_key]
+          return [] unless group_members
+
+          group_members.flat_map do |member|
+            member_key = member.to_s
+
+            if @groups.key?(member_key)
+              resolve_group(member_key) # Recursive expansion
+            elsif @patterns.key?(member_key)
+              expand_pattern(@patterns[member_key])
+            else
+              # Direct pattern or file
+              expand_pattern(member)
+            end
+          end.uniq
+        end
+
+        def expand_pattern(pattern)
+          Dir.glob(pattern).select { |f| File.file?(f) }
+        end
+
+        def resolve_all_files
+          # Always start by finding ALL test files that exist
+          all_test_files = expand_pattern("test/**/*_test.rb")
+          @using_catch_all = false
+
+          # First check if "all" group is defined
+          if @groups.key?("all")
+            pattern_files = resolve_group("all")
+            # If patterns miss any files, use the complete scan
+            if pattern_files.size < all_test_files.size
+              @using_catch_all = true
+              return all_test_files
+            end
+            return pattern_files
+          end
+
+          # If no "all" group, try all defined patterns
+          if @patterns && !@patterns.empty?
+            pattern_files = []
+            @patterns.each_value do |pattern|
+              pattern_files.concat(expand_pattern(pattern))
+            end
+            pattern_files = pattern_files.uniq
+            # If patterns miss any files, use the complete scan
+            if pattern_files.size < all_test_files.size
+              @using_catch_all = true
+              return all_test_files
+            end
+            return pattern_files
+          end
+
+          # No configuration - using catch-all pattern
+          @using_catch_all = true
+          all_test_files
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "erb"
+
+module Ace
+  module TestRunner
+    module Molecules
+      # Manages Rakefile integration for ace-test
+      class RakeIntegration
+        BACKUP_EXTENSION = ".ace-backup"
+        MARKER_COMMENT = "# ace-test-runner integration"
+
+        def initialize(rakefile_path = "Rakefile")
+          @rakefile_path = rakefile_path
+        end
+
+        # Set ace-test as the default rake test runner
+        def set_default
+          validate_environment!
+
+          if already_integrated?
+            return {success: true, message: "ace-test is already set as default rake test runner"}
+          end
+
+          backup_rakefile
+          inject_ace_test_config
+
+          {success: true, message: "Successfully set ace-test as default rake test runner"}
+        rescue => e
+          restore_from_backup if backup_exists?
+          {success: false, message: "Failed to set ace-test as default: #{e.message}"}
+        end
+
+        # Remove ace-test as the default rake test runner
+        def unset_default
+          unless already_integrated?
+            return {success: true, message: "ace-test is not currently set as default"}
+          end
+
+          if backup_exists?
+            restore_from_backup
+            {success: true, message: "Successfully restored original Rakefile"}
+          else
+            remove_ace_test_config
+            {success: true, message: "Successfully removed ace-test configuration"}
+          end
+        rescue => e
+          {success: false, message: "Failed to unset ace-test as default: #{e.message}"}
+        end
+
+        # Check if ace-test is currently set as default
+        def check_status
+          if !rakefile_exists?
+            {
+              integrated: false,
+              message: "No Rakefile found in current directory",
+              rakefile_exists: false
+            }
+          elsif already_integrated?
+            {
+              integrated: true,
+              message: "ace-test is currently set as default rake test runner",
+              rakefile_exists: true,
+              backup_exists: backup_exists?
+            }
+          else
+            {
+              integrated: false,
+              message: "ace-test is not set as default rake test runner",
+              rakefile_exists: true,
+              has_test_task: has_test_task?
+            }
+          end
+        end
+
+        private
+
+        def validate_environment!
+          unless rakefile_exists?
+            # Create a basic Rakefile if it doesn't exist
+            create_basic_rakefile
+          end
+        end
+
+        def rakefile_exists?
+          File.exist?(@rakefile_path)
+        end
+
+        def backup_exists?
+          File.exist?(backup_path)
+        end
+
+        def backup_path
+          "#{@rakefile_path}#{BACKUP_EXTENSION}"
+        end
+
+        def already_integrated?
+          return false unless rakefile_exists?
+
+          content = File.read(@rakefile_path)
+          content.include?(MARKER_COMMENT) && content.include?("Ace::TestRunner::RakeTask")
+        end
+
+        def has_test_task?
+          return false unless rakefile_exists?
+
+          content = File.read(@rakefile_path)
+          content.match?(/task\s+:test|Rake::TestTask\.new/)
+        end
+
+        def backup_rakefile
+          FileUtils.cp(@rakefile_path, backup_path)
+        end
+
+        def restore_from_backup
+          FileUtils.mv(backup_path, @rakefile_path, force: true)
+        end
+
+        def inject_ace_test_config
+          original_content = File.read(@rakefile_path)
+
+          # Check if there's an existing test task
+          if has_test_task?
+            # Comment out existing test task and add ace-test task
+            modified_content = comment_out_existing_test_task(original_content)
+            modified_content += "\n\n" + ace_test_rake_config
+          else
+            # Just append ace-test configuration
+            modified_content = original_content + "\n\n" + ace_test_rake_config
+          end
+
+          File.write(@rakefile_path, modified_content)
+        end
+
+        def remove_ace_test_config
+          content = File.read(@rakefile_path)
+
+          # Remove ace-test configuration block
+          content = content.gsub(/#{Regexp.escape(MARKER_COMMENT)}.*?# End of ace-test-runner integration/mo, "")
+
+          # Uncomment original test task if it was commented
+          content = uncomment_original_test_task(content)
+
+          File.write(@rakefile_path, content.strip + "\n")
+        end
+
+        def comment_out_existing_test_task(content)
+          # Comment out existing Rake::TestTask
+          content = content.gsub(/^(require\s+["']rake\/testtask["'])/, '# \1 # Commented by ace-test')
+          content = content.gsub(/^(Rake::TestTask\.new.*?)^end/m) do |match|
+            match.split("\n").map { |line| "# #{line}" }.join("\n")
+          end
+
+          # Comment out simple task :test definitions
+          content.gsub(/^(task\s+:test\s+do.*?)^end/m) do |match|
+            match.split("\n").map { |line| "# #{line}" }.join("\n")
+          end
+        end
+
+        def uncomment_original_test_task(content)
+          # Uncomment lines that were commented by ace-test
+          content.gsub(/^# (.*) # Commented by ace-test$/, '\1')
+
+          # Uncomment task blocks (more complex - would need proper parsing)
+          # For now, just leave them commented as user can manually uncomment if needed
+        end
+
+        def create_basic_rakefile
+          File.write(@rakefile_path, basic_rakefile_template)
+        end
+
+        def basic_rakefile_template
+          <<~RAKEFILE
+            # frozen_string_literal: true
+
+            require "bundler/gem_tasks" if File.exist?("Gemfile")
+
+            # Default task
+            task default: :test
+          RAKEFILE
+        end
+
+        def ace_test_rake_config
+          <<~CONFIG
+            #{MARKER_COMMENT}
+            begin
+              require "ace/test_runner/rake_task"
+
+              # Use ace-test as the default test runner
+              Ace::TestRunner::RakeTask.new(:test) do |t|
+                t.description = "Run tests with ace-test"
+                t.libs << "test" << "lib"
+                t.pattern = ENV["PATTERN"] || "test/**/*_test.rb"
+                t.verbose = ENV["VERBOSE"] == "true"
+                t.format = ENV["FORMAT"] || ENV["ACE_TEST_FORMAT"]
+              end
+            rescue LoadError
+              # Fallback to standard Rake::TestTask if ace-test-runner is not available
+              require "rake/testtask"
+
+              Rake::TestTask.new(:test) do |t|
+                t.libs << "test" << "lib"
+                t.test_files = FileList[ENV["PATTERN"] || "test/**/*_test.rb"]
+                t.verbose = ENV["VERBOSE"] == "true"
+                t.warning = ENV["WARNING"] == "true"
+              end
+
+              puts "Warning: ace-test-runner not found. Using standard Rake::TestTask."
+              puts "Install ace-test-runner gem to use advanced test features."
+            end
+            # End of ace-test-runner integration
+          CONFIG
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Molecules
+      # Handles storage of test reports to filesystem
+      class ReportStorage
+        def initialize(base_dir: ".ace-local/test/reports", timestamp_generator: nil)
+          @base_dir = base_dir
+          @timestamp_generator = timestamp_generator || Atoms::TimestampGenerator.new
+        end
+
+        def save_report(report, format: :json)
+          ensure_base_directory
+          report_dir = create_report_directory
+
+          case format
+          when :json
+            save_json_report(report, report_dir)
+          when :markdown
+            save_markdown_report(report, report_dir)
+          when :all
+            save_all_formats(report, report_dir)
+          else
+            raise ArgumentError, "Unknown report format: #{format}"
+          end
+
+          create_latest_symlink(report_dir)
+          report_dir
+        end
+
+        def save_raw_output(output, report_dir)
+          ensure_directory(report_dir)
+          output_file = File.join(report_dir, "raw_output.txt")
+          File.write(output_file, output)
+          output_file
+        end
+
+        def save_stderr(stderr, report_dir)
+          return nil if stderr.nil? || stderr.empty?
+
+          ensure_directory(report_dir)
+          stderr_file = File.join(report_dir, "raw_stderr.txt")
+          File.write(stderr_file, stderr)
+          stderr_file
+        end
+
+        def save_summary(result, report_dir)
+          ensure_directory(report_dir)
+          summary_file = File.join(report_dir, "summary.json")
+
+          summary_data = {
+            passed: result.passed,
+            failed: result.failed,
+            errors: result.errors,
+            skipped: result.skipped,
+            total: result.total_tests,
+            pass_rate: result.pass_rate,
+            duration: result.duration,
+            success: result.success?,
+            timestamp: Time.now.iso8601
+          }
+
+          File.write(summary_file, JSON.pretty_generate(summary_data))
+          summary_file
+        end
+
+        def save_failures(failures, report_dir)
+          return nil if failures.empty?
+
+          ensure_directory(report_dir)
+          failures_file = File.join(report_dir, "failures.json")
+
+          failures_data = failures.map(&:to_h)
+          File.write(failures_file, JSON.pretty_generate(failures_data))
+          failures_file
+        end
+
+        def save_individual_failure_reports(failures, report_dir, formatter, max_display: nil)
+          return [] if failures.empty?
+
+          failures_dir = File.join(report_dir, "failures")
+          ensure_directory(failures_dir)
+
+          # Limit number of individual .md files to max_display if specified
+          failures_to_save = max_display ? failures.take(max_display) : failures
+
+          report_files = []
+          failures_to_save.each_with_index do |failure, index|
+            filename = generate_failure_filename(failure, index + 1)
+            filepath = File.join(failures_dir, filename)
+
+            content = formatter.generate_failure_report(failure, index + 1)
+            File.write(filepath, content)
+            report_files << filepath
+          end
+
+          # Create an index file for ALL failures (not just the limited ones)
+          create_failure_index(failures, failures_dir)
+
+          report_files
+        end
+
+        def list_reports(limit: 10)
+          ensure_base_directory
+
+          report_directories
+            .map { |d| report_info(d) }
+            .compact
+            .sort_by { |r| r[:timestamp] }
+            .reverse
+            .take(limit)
+        end
+
+        def latest_report_path
+          latest_link = File.join(@base_dir, "latest")
+          return nil unless File.exist?(latest_link) && File.symlink?(latest_link)
+
+          File.readlink(latest_link)
+        end
+
+        def load_report(report_dir)
+          return nil unless Dir.exist?(report_dir)
+
+          summary_file = File.join(report_dir, "summary.json")
+          return nil unless File.exist?(summary_file)
+
+          summary = JSON.parse(File.read(summary_file), symbolize_names: true)
+
+          # Load additional data if available
+          failures_file = File.join(report_dir, "failures.json")
+          failures = if File.exist?(failures_file)
+            JSON.parse(File.read(failures_file), symbolize_names: true)
+          else
+            []
+          end
+
+          {
+            summary: summary,
+            failures: failures,
+            report_dir: report_dir
+          }
+        end
+
+        def cleanup_old_reports(keep: 10, max_age_days: 30)
+          ensure_base_directory
+
+          cutoff_time = Time.now - (max_age_days * 24 * 60 * 60)
+          deleted = []
+
+          # In centralized mode, base_dir contains package subfolders; in legacy mode it may contain reports directly.
+          reports_by_scope = report_directories
+            .map { |d| report_info(d) }
+            .compact
+            .group_by { |r| File.dirname(r[:path]) }
+
+          reports_by_scope.each_value do |reports|
+            sorted = reports.sort_by { |r| r[:timestamp] }.reverse
+
+            to_keep = sorted.take(keep)
+            to_keep += sorted.select { |r| r[:timestamp] > cutoff_time }
+            to_keep_paths = to_keep.map { |r| r[:path] }.uniq
+
+            sorted.each do |report|
+              next if to_keep_paths.include?(report[:path])
+
+              FileUtils.rm_rf(report[:path])
+              deleted << report[:path]
+            end
+          end
+
+          deleted
+        end
+
+        private
+
+        def generate_failure_filename(failure, index)
+          # Create a safe filename from the test name
+          test_name = failure.full_test_name.gsub(/\W+/, "_").downcase
+          test_name = test_name[0...50] if test_name.length > 50
+          format("%03d-%s.md", index, test_name)
+        end
+
+        def create_failure_index(failures, failures_dir)
+          index_file = File.join(failures_dir, "index.md")
+
+          lines = []
+          lines << "# Test Failures Index"
+          lines << ""
+          lines << "Total failures: #{failures.size}"
+          lines << ""
+          lines << "## Failures"
+          lines << ""
+
+          failures.each_with_index do |failure, index|
+            filename = generate_failure_filename(failure, index + 1)
+            lines << "#{index + 1}. [#{failure.full_test_name}](./#{filename})"
+            lines << "   - **Type:** #{failure.type}"
+            lines << "   - **Location:** `#{failure.location}`"
+            lines << ""
+          end
+
+          File.write(index_file, lines.join("\n"))
+        end
+
+        def ensure_base_directory
+          FileUtils.mkdir_p(@base_dir) unless Dir.exist?(@base_dir)
+        end
+
+        def ensure_directory(dir)
+          FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+        end
+
+        def create_report_directory
+          ensure_base_directory
+          timestamp = @timestamp_generator.directory_name
+          report_dir = File.join(@base_dir, timestamp)
+          FileUtils.mkdir_p(report_dir)
+          report_dir
+        end
+
+        def create_latest_symlink(report_dir)
+          latest_link = File.join(@base_dir, "latest")
+
+          # Remove existing symlink if present
+          FileUtils.rm_f(latest_link) if File.exist?(latest_link)
+
+          # Create new symlink to the latest report
+          FileUtils.ln_s(File.basename(report_dir), latest_link)
+        end
+
+        def save_json_report(report, report_dir)
+          report_file = File.join(report_dir, "report.json")
+          File.write(report_file, report.to_json)
+          report_file
+        end
+
+        def save_markdown_report(report, report_dir)
+          report_file = File.join(report_dir, "report.md")
+          File.write(report_file, report.to_markdown)
+          report_file
+        end
+
+        def save_all_formats(report, report_dir)
+          files = [
+            save_json_report(report, report_dir),
+            save_markdown_report(report, report_dir),
+            save_summary(report.result, report_dir)
+          ]
+
+          if report.result.has_failures?
+            files << save_failures(report.result.failures_detail, report_dir)
+          end
+
+          files.compact
+        end
+
+        def report_info(dir)
+          return nil unless Dir.exist?(dir)
+
+          summary_file = File.join(dir, "summary.json")
+          return nil unless File.exist?(summary_file)
+
+          summary = JSON.parse(File.read(summary_file), symbolize_names: true)
+
+          {
+            path: dir,
+            name: File.basename(dir),
+            timestamp: Time.parse(summary[:timestamp]),
+            success: summary[:success],
+            stats: {
+              passed: summary[:passed],
+              failed: summary[:failed],
+              total: summary[:total]
+            }
+          }
+        rescue JSON::ParserError, ArgumentError
+          nil
+        end
+
+        def report_directories
+          top_level = Dir.glob(File.join(@base_dir, "*"))
+            .select { |d| File.directory?(d) && !File.symlink?(d) }
+
+          dirs = []
+          top_level.each do |entry|
+            if File.exist?(File.join(entry, "summary.json"))
+              dirs << entry
+              next
+            end
+
+            nested = Dir.glob(File.join(entry, "*"))
+              .select { |d| File.directory?(d) && !File.symlink?(d) }
+              .select { |d| File.exist?(File.join(d, "summary.json")) }
+            dirs.concat(nested)
+          end
+
+          dirs
+        end
+      end
+    end
+  end
+end