makit 0.0.138 → 0.0.140

data/lib/makit/examples/runner.rb

@@ -1,370 +1,370 @@
-# frozen_string_literal: true
-
-require "fileutils"
-require "parallel"
-
-module Makit
-  module Examples
-    # Centralized management of example discovery, execution, and verification
-    #
-    # This class provides a clean interface for running all examples in the
-    # examples directory, with support for different execution strategies,
-    # artifact verification, and comprehensive reporting.
-    #
-    # @example Basic usage
-    #   runner = Makit::Examples::Runner.new
-    #   runner.run_all
-    #
-    # @example Custom configuration
-    #   runner = Makit::Examples::Runner.new(
-    #     strategy: :parallel,
-    #     verify_artifacts: true,
-    #     cleanup_after: false
-    #   )
-    #   runner.run_all
-    class Runner
-      # Configuration options
-      attr_reader :examples_dir, :execution_strategy, :verify_artifacts, :cleanup_after, :filter, :timeout, :verbose
-
-      # Execution results
-      attr_reader :results, :failed_examples, :passed_examples, :examples
-
-      # Initialize the examples runner
-      #
-      # @param options [Hash] configuration options
-      # @option options [String] :examples_dir directory containing examples (default: "examples")
-      # @option options [Symbol] :strategy execution strategy (:sequential, :parallel, :filtered)
-      # @option options [Boolean] :verify_artifacts whether to verify expected artifacts (default: true)
-      # @option options [Boolean] :cleanup_after whether to clean up artifacts after testing (default: true)
-      # @option options [Regexp] :filter pattern to filter examples (default: nil)
-      # @option options [Integer] :timeout timeout per example in seconds (default: 30)
-      # @option options [Boolean] :verbose whether to show detailed output (default: false)
-      def initialize(options = {})
-        @examples_dir = options[:examples_dir] || "examples"
-        @execution_strategy = options[:strategy] || :sequential
-        @verify_artifacts = options[:verify_artifacts] || true
-        @cleanup_after = options[:cleanup_after] || true
-        @filter = options[:filter]
-        @timeout = options[:timeout] || 30
-        @verbose = options[:verbose] || false
-
-        @results = []
-        @failed_examples = []
-        @passed_examples = []
-        @examples = []
-      end
-
-      # Run all discovered examples
-      #
-      # @return [Boolean] true if all examples passed, false otherwise
-      def run_all
-        discover_examples
-        execute_examples
-        verify_results
-        report_results
-        cleanup_if_needed
-
-        @failed_examples.empty?
-      end
-
-      # Run a specific example
-      #
-      # @param example_path [String] path to the example directory
-      # @return [Hash] result hash with success status and details
-      def run_example(example_path)
-        discover_examples if @examples.empty?
-        example = @examples.find { |ex| ex[:name] == example_path }
-        return { success: false, error: "Example not found: #{example_path}" } unless example
-
-        execute_single_example(example)
-      end
-
-      # Discover all examples in the examples directory
-      def discover_examples
-        @examples = Dir.glob("#{@examples_dir}/**/Rakefile").map do |rakefile|
-          example_dir = File.dirname(rakefile)
-          example_name = example_dir.gsub("#{@examples_dir}/", "")
-
-          {
-            path: example_dir,
-            name: example_name,
-            rakefile: rakefile,
-            expected_artifacts: determine_expected_artifacts(example_name),
-          }
-        end
-
-        # Apply filter if specified
-        @examples = @examples.select { |ex| ex[:name].match?(@filter) } if @filter
-
-        log "Discovered #{@examples.count} examples" if @verbose
-      end
-
-      private
-
-      # Execute all examples based on the configured strategy
-      def execute_examples
-        case @execution_strategy
-        when :sequential
-          execute_sequential
-        when :parallel
-          execute_parallel
-        when :filtered
-          execute_filtered
-        else
-          execute_sequential
-        end
-      end
-
-      # Execute examples sequentially
-      def execute_sequential
-        @examples.each do |example|
-          result = execute_single_example(example)
-
-          # Verify artifacts immediately after execution if enabled
-          verify_example_artifacts(example, result) if @verify_artifacts && result[:success]
-
-          @results << result
-
-          if result[:success]
-            @passed_examples << example
-            log "  ✅ #{example[:name]} passed".colorize(:green) if @verbose
-          else
-            @failed_examples << example
-            log "  ❌ #{example[:name]} failed: #{result[:error]}".colorize(:red) if @verbose
-          end
-        end
-      end
-
-      # Execute examples in parallel
-      def execute_parallel
-        results = Parallel.map(@examples, in_threads: 4) do |example|
-          result = execute_single_example(example)
-
-          # Verify artifacts immediately after execution if enabled
-          verify_example_artifacts(example, result) if @verify_artifacts && result[:success]
-
-          result
-        end
-
-        results.each_with_index do |result, index|
-          @results << result
-          example = @examples[index]
-
-          if result[:success]
-            @passed_examples << example
-            log "  ✅ #{example[:name]} passed".colorize(:green) if @verbose
-          else
-            @failed_examples << example
-            log "  ❌ #{example[:name]} failed: #{result[:error]}".colorize(:red) if @verbose
-          end
-        end
-      end
-
-      # Execute examples with filtering (same as sequential for now)
-      def execute_filtered
-        execute_sequential
-      end
-
-      # Execute a single example
-      #
-      # @param example [Hash] example configuration
-      # @return [Hash] result hash
-      def execute_single_example(example)
-        # Display separator and example path
-        puts "=" * 80
-        # puts example[:name]
-        puts example[:rakefile]
-
-        log "  Testing example: #{example[:name]}" if @verbose
-
-        # Store current directory
-        original_dir = Dir.pwd
-
-        begin
-          Dir.chdir(example[:path]) do
-            # Use the default runner with middleware for consistent behavior
-            runner = Makit::DEFAULT_COMMANDS_RUNNER
-            Makit::Logging::Logger.new(
-              Makit::Logging::Sinks::Console.new,
-              Makit::Logging::Sinks::FileSink.new(log_file: "artifacts/command_examples.log")
-            )
-
-            begin
-              request = Makit::Commands::Request.from_string("rake default")
-              result = runner.execute(request)
-
-              # Log success or error for each example
-              if result.success?
-                Makit::Logging.success(example[:name])
-              else
-                Makit::Logging.error(example[:name])
-              end
-
-              {
-                example: example,
-                success: result.success?,
-                exit_code: result.exit_code,
-                output: result.stdout,
-                error: result.stderr,
-                duration: result.duration,
-              }
-            rescue StandardError => e
-              # Log error for exceptions
-              Makit::Logging.error(example[:name])
-
-              {
-                example: example,
-                success: false,
-                exit_code: -1,
-                output: "",
-                error: e.message,
-                duration: 0,
-              }
-            end
-          end
-        rescue StandardError => e
-          # Log error for directory change failures
-          Makit::Logging.error(example[:name])
-
-          {
-            example: example,
-            success: false,
-            exit_code: -1,
-            output: "",
-            error: "Failed to change directory: #{e.message}",
-            duration: 0,
-          }
-        ensure
-          # Always return to original directory
-          begin
-            Dir.chdir(original_dir)
-          rescue StandardError
-            nil
-          end
-        end
-      end
-
-      # Determine expected artifacts for an example
-      #
-      # @param example_name [String] name of the example
-      # @return [Array<String>] list of expected artifact paths
-      def determine_expected_artifacts(example_name)
-        case example_name
-        when %r{commands/(default_runner|runner)}
-          ["artifacts/commands/git_version.log", "artifacts/commands/git_version.txt"]
-        when "protoc"
-          ["artifacts/makit.v1_pb.rb"]
-        when "rake_default"
-          [".makit.project.json"]
-        when "run_mp"
-          [] # No expected artifacts
-        when "tasks/simple"
-          [] # No expected artifacts
-        when "rubygem-foo"
-          [] # No expected artifacts
-        else
-          [] # Default to no expected artifacts
-        end
-      end
-
-      # Verify artifacts for a single example immediately after execution
-      #
-      # @param example [Hash] example configuration
-      # @param result [Hash] execution result
-      def verify_example_artifacts(example, result)
-        return unless @verify_artifacts
-
-        # Check artifacts in the example directory context
-        missing_artifacts = example[:expected_artifacts].reject do |artifact|
-          artifact_path = File.join(example[:path], artifact)
-          File.exist?(artifact_path)
-        end
-
-        return unless missing_artifacts.any?
-
-        result[:success] = false
-        result[:error] = "Missing expected artifacts: #{missing_artifacts.join(", ")}"
-      end
-
-      # Verify that all results meet expectations
-      def verify_results
-        return unless @verify_artifacts
-
-        @results.each do |result|
-          next unless result[:success]
-
-          example = result[:example]
-
-          # Check artifacts in the example directory context
-          missing_artifacts = example[:expected_artifacts].reject do |artifact|
-            artifact_path = File.join(example[:path], artifact)
-            File.exist?(artifact_path)
-          end
-
-          next unless missing_artifacts.any?
-
-          result[:success] = false
-          result[:error] = "Missing expected artifacts: #{missing_artifacts.join(", ")}"
-
-          # Move from passed to failed
-          @passed_examples.delete(example)
-          @failed_examples << example
-        end
-      end
-
-      # Clean up artifacts if configured
-      def cleanup_if_needed
-        return unless @cleanup_after
-
-        @examples.each do |example|
-          cleanup_example(example)
-        end
-      end
-
-      # Clean up artifacts for a specific example
-      #
-      # @param example [Hash] example configuration
-      def cleanup_example(example)
-        Dir.chdir(example[:path]) do
-          # Remove artifacts directory if it exists
-          FileUtils.rm_rf("artifacts")
-
-          # Remove project file if it exists
-          FileUtils.rm_f(".makit.project.json")
-        end
-      rescue StandardError => e
-        log "  Warning: Failed to cleanup #{example[:name]}: #{e.message}" if @verbose
-      end
-
-      # Report the results of example execution
-      def report_results
-        puts "📊 Example Test Results:".colorize(:blue)
-        puts "  ✅ Passed: #{@passed_examples.count}".colorize(:green)
-        puts "  ❌ Failed: #{@failed_examples.count}".colorize(:red)
-
-        if @failed_examples.any?
-          puts "  Failed examples:".colorize(:red)
-          @failed_examples.each do |example|
-            result = @results.find { |r| r[:example] == example }
-            error_msg = result ? result[:error] : "Unknown error"
-            puts "    - #{example[:name]}: #{error_msg}".colorize(:red)
-          end
-        end
-
-        return unless @passed_examples.any? && @verbose
-
-        puts "  Passed examples:".colorize(:green)
-        @passed_examples.each do |example|
-          puts "    - #{example[:name]}".colorize(:green)
-        end
-      end
-
-      # Log a message if verbose mode is enabled
-      #
-      # @param message [String] message to log
-      def log(message)
-        puts message if @verbose
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "fileutils"
+require "parallel"
+
+module Makit
+  module Examples
+    # Centralized management of example discovery, execution, and verification
+    #
+    # This class provides a clean interface for running all examples in the
+    # examples directory, with support for different execution strategies,
+    # artifact verification, and comprehensive reporting.
+    #
+    # @example Basic usage
+    #   runner = Makit::Examples::Runner.new
+    #   runner.run_all
+    #
+    # @example Custom configuration
+    #   runner = Makit::Examples::Runner.new(
+    #     strategy: :parallel,
+    #     verify_artifacts: true,
+    #     cleanup_after: false
+    #   )
+    #   runner.run_all
+    class Runner
+      # Configuration options
+      attr_reader :examples_dir, :execution_strategy, :verify_artifacts, :cleanup_after, :filter, :timeout, :verbose
+
+      # Execution results
+      attr_reader :results, :failed_examples, :passed_examples, :examples
+
+      # Initialize the examples runner
+      #
+      # @param options [Hash] configuration options
+      # @option options [String] :examples_dir directory containing examples (default: "examples")
+      # @option options [Symbol] :strategy execution strategy (:sequential, :parallel, :filtered)
+      # @option options [Boolean] :verify_artifacts whether to verify expected artifacts (default: true)
+      # @option options [Boolean] :cleanup_after whether to clean up artifacts after testing (default: true)
+      # @option options [Regexp] :filter pattern to filter examples (default: nil)
+      # @option options [Integer] :timeout timeout per example in seconds (default: 30)
+      # @option options [Boolean] :verbose whether to show detailed output (default: false)
+      def initialize(options = {})
+        @examples_dir = options[:examples_dir] || "examples"
+        @execution_strategy = options[:strategy] || :sequential
+        @verify_artifacts = options[:verify_artifacts] || true
+        @cleanup_after = options[:cleanup_after] || true
+        @filter = options[:filter]
+        @timeout = options[:timeout] || 30
+        @verbose = options[:verbose] || false
+
+        @results = []
+        @failed_examples = []
+        @passed_examples = []
+        @examples = []
+      end
+
+      # Run all discovered examples
+      #
+      # @return [Boolean] true if all examples passed, false otherwise
+      def run_all
+        discover_examples
+        execute_examples
+        verify_results
+        report_results
+        cleanup_if_needed
+
+        @failed_examples.empty?
+      end
+
+      # Run a specific example
+      #
+      # @param example_path [String] path to the example directory
+      # @return [Hash] result hash with success status and details
+      def run_example(example_path)
+        discover_examples if @examples.empty?
+        example = @examples.find { |ex| ex[:name] == example_path }
+        return { success: false, error: "Example not found: #{example_path}" } unless example
+
+        execute_single_example(example)
+      end
+
+      # Discover all examples in the examples directory
+      def discover_examples
+        @examples = Dir.glob("#{@examples_dir}/**/Rakefile").map do |rakefile|
+          example_dir = File.dirname(rakefile)
+          example_name = example_dir.gsub("#{@examples_dir}/", "")
+
+          {
+            path: example_dir,
+            name: example_name,
+            rakefile: rakefile,
+            expected_artifacts: determine_expected_artifacts(example_name),
+          }
+        end
+
+        # Apply filter if specified
+        @examples = @examples.select { |ex| ex[:name].match?(@filter) } if @filter
+
+        log "Discovered #{@examples.count} examples" if @verbose
+      end
+
+      private
+
+      # Execute all examples based on the configured strategy
+      def execute_examples
+        case @execution_strategy
+        when :sequential
+          execute_sequential
+        when :parallel
+          execute_parallel
+        when :filtered
+          execute_filtered
+        else
+          execute_sequential
+        end
+      end
+
+      # Execute examples sequentially
+      def execute_sequential
+        @examples.each do |example|
+          result = execute_single_example(example)
+
+          # Verify artifacts immediately after execution if enabled
+          verify_example_artifacts(example, result) if @verify_artifacts && result[:success]
+
+          @results << result
+
+          if result[:success]
+            @passed_examples << example
+            log "  ✅ #{example[:name]} passed".colorize(:green) if @verbose
+          else
+            @failed_examples << example
+            log "  ❌ #{example[:name]} failed: #{result[:error]}".colorize(:red) if @verbose
+          end
+        end
+      end
+
+      # Execute examples in parallel
+      def execute_parallel
+        results = Parallel.map(@examples, in_threads: 4) do |example|
+          result = execute_single_example(example)
+
+          # Verify artifacts immediately after execution if enabled
+          verify_example_artifacts(example, result) if @verify_artifacts && result[:success]
+
+          result
+        end
+
+        results.each_with_index do |result, index|
+          @results << result
+          example = @examples[index]
+
+          if result[:success]
+            @passed_examples << example
+            log "  ✅ #{example[:name]} passed".colorize(:green) if @verbose
+          else
+            @failed_examples << example
+            log "  ❌ #{example[:name]} failed: #{result[:error]}".colorize(:red) if @verbose
+          end
+        end
+      end
+
+      # Execute examples with filtering (same as sequential for now)
+      def execute_filtered
+        execute_sequential
+      end
+
+      # Execute a single example
+      #
+      # @param example [Hash] example configuration
+      # @return [Hash] result hash
+      def execute_single_example(example)
+        # Display separator and example path
+        puts "=" * 80
+        # puts example[:name]
+        puts example[:rakefile]
+
+        log "  Testing example: #{example[:name]}" if @verbose
+
+        # Store current directory
+        original_dir = Dir.pwd
+
+        begin
+          Dir.chdir(example[:path]) do
+            # Use the default runner with middleware for consistent behavior
+            runner = Makit::DEFAULT_COMMANDS_RUNNER
+            Makit::Logging::Logger.new(
+              Makit::Logging::Sinks::Console.new,
+              Makit::Logging::Sinks::FileSink.new(log_file: "artifacts/command_examples.log")
+            )
+
+            begin
+              request = Makit::Commands::Request.from_string("rake default")
+              result = runner.execute(request)
+
+              # Log success or error for each example
+              if result.success?
+                Makit::Logging.success(example[:name])
+              else
+                Makit::Logging.error(example[:name])
+              end
+
+              {
+                example: example,
+                success: result.success?,
+                exit_code: result.exit_code,
+                output: result.stdout,
+                error: result.stderr,
+                duration: result.duration,
+              }
+            rescue StandardError => e
+              # Log error for exceptions
+              Makit::Logging.error(example[:name])
+
+              {
+                example: example,
+                success: false,
+                exit_code: -1,
+                output: "",
+                error: e.message,
+                duration: 0,
+              }
+            end
+          end
+        rescue StandardError => e
+          # Log error for directory change failures
+          Makit::Logging.error(example[:name])
+
+          {
+            example: example,
+            success: false,
+            exit_code: -1,
+            output: "",
+            error: "Failed to change directory: #{e.message}",
+            duration: 0,
+          }
+        ensure
+          # Always return to original directory
+          begin
+            Dir.chdir(original_dir)
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      # Determine expected artifacts for an example
+      #
+      # @param example_name [String] name of the example
+      # @return [Array<String>] list of expected artifact paths
+      def determine_expected_artifacts(example_name)
+        case example_name
+        when %r{commands/(default_runner|runner)}
+          ["artifacts/commands/git_version.log", "artifacts/commands/git_version.txt"]
+        when "protoc"
+          ["artifacts/makit.v1_pb.rb"]
+        when "rake_default"
+          [".makit.project.json"]
+        when "run_mp"
+          [] # No expected artifacts
+        when "tasks/simple"
+          [] # No expected artifacts
+        when "rubygem-foo"
+          [] # No expected artifacts
+        else
+          [] # Default to no expected artifacts
+        end
+      end
+
+      # Verify artifacts for a single example immediately after execution
+      #
+      # @param example [Hash] example configuration
+      # @param result [Hash] execution result
+      def verify_example_artifacts(example, result)
+        return unless @verify_artifacts
+
+        # Check artifacts in the example directory context
+        missing_artifacts = example[:expected_artifacts].reject do |artifact|
+          artifact_path = File.join(example[:path], artifact)
+          File.exist?(artifact_path)
+        end
+
+        return unless missing_artifacts.any?
+
+        result[:success] = false
+        result[:error] = "Missing expected artifacts: #{missing_artifacts.join(", ")}"
+      end
+
+      # Verify that all results meet expectations
+      def verify_results
+        return unless @verify_artifacts
+
+        @results.each do |result|
+          next unless result[:success]
+
+          example = result[:example]
+
+          # Check artifacts in the example directory context
+          missing_artifacts = example[:expected_artifacts].reject do |artifact|
+            artifact_path = File.join(example[:path], artifact)
+            File.exist?(artifact_path)
+          end
+
+          next unless missing_artifacts.any?
+
+          result[:success] = false
+          result[:error] = "Missing expected artifacts: #{missing_artifacts.join(", ")}"
+
+          # Move from passed to failed
+          @passed_examples.delete(example)
+          @failed_examples << example
+        end
+      end
+
+      # Clean up artifacts if configured
+      def cleanup_if_needed
+        return unless @cleanup_after
+
+        @examples.each do |example|
+          cleanup_example(example)
+        end
+      end
+
+      # Clean up artifacts for a specific example
+      #
+      # @param example [Hash] example configuration
+      def cleanup_example(example)
+        Dir.chdir(example[:path]) do
+          # Remove artifacts directory if it exists
+          FileUtils.rm_rf("artifacts")
+
+          # Remove project file if it exists
+          FileUtils.rm_f(".makit.project.json")
+        end
+      rescue StandardError => e
+        log "  Warning: Failed to cleanup #{example[:name]}: #{e.message}" if @verbose
+      end
+
+      # Report the results of example execution
+      def report_results
+        puts "📊 Example Test Results:".colorize(:blue)
+        puts "  ✅ Passed: #{@passed_examples.count}".colorize(:green)
+        puts "  ❌ Failed: #{@failed_examples.count}".colorize(:red)
+
+        if @failed_examples.any?
+          puts "  Failed examples:".colorize(:red)
+          @failed_examples.each do |example|
+            result = @results.find { |r| r[:example] == example }
+            error_msg = result ? result[:error] : "Unknown error"
+            puts "    - #{example[:name]}: #{error_msg}".colorize(:red)
+          end
+        end
+
+        return unless @passed_examples.any? && @verbose
+
+        puts "  Passed examples:".colorize(:green)
+        @passed_examples.each do |example|
+          puts "    - #{example[:name]}".colorize(:green)
+        end
+      end
+
+      # Log a message if verbose mode is enabled
+      #
+      # @param message [String] message to log
+      def log(message)
+        puts message if @verbose
+      end
+    end
+  end
+end