kaisoku 0.1.0

data/lib/kaisoku/rails/integration.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Rails
+    class Integration
+      DB_PATTERNS = %w[db/schema.rb db/structure.sql db/migrate/**].freeze
+      ROUTE_PATTERNS = %w[config/routes.rb config/routes/**].freeze
+      DB_DEPENDENCY_PREFIXES = %w[app/models db/ config/database].freeze
+
+      def initialize(configuration: Configuration.new)
+        @configuration = configuration
+      end
+
+      def rails_project?
+        File.file?(@configuration.absolute_path('config/application.rb'))
+      end
+
+      def boot_impact_file?(path)
+        relative = @configuration.relative_path(path)
+        patterns.any? { |pattern| File.fnmatch?(pattern, relative, File::FNM_PATHNAME) }
+      end
+
+      def database_change?(path)
+        relative = @configuration.relative_path(path)
+        DB_PATTERNS.any? { |pattern| File.fnmatch?(pattern, relative, File::FNM_PATHNAME) }
+      end
+
+      def route_change?(path)
+        relative = @configuration.relative_path(path)
+        ROUTE_PATTERNS.any? { |pattern| File.fnmatch?(pattern, relative, File::FNM_PATHNAME) }
+      end
+
+      def db_dependency_prefixes
+        DB_DEPENDENCY_PREFIXES
+      end
+
+      def database_name(base_name, worker_index)
+        return base_name if worker_index.to_i <= 0
+
+        "#{base_name}_#{worker_index}"
+      end
+
+      def wrap_reloader(&)
+        return yield unless defined?(::Rails) && ::Rails.respond_to?(:application)
+
+        ::Rails.application.reloader.wrap(&)
+      end
+
+      private
+
+      def patterns
+        DB_PATTERNS + ROUTE_PATTERNS
+      end
+    end
+  end
+end

data/lib/kaisoku/reporters/console.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Reporters
+    class Console
+      def initialize(output: $stdout)
+        @output = output
+      end
+
+      def selection(selection, selected_count:, total_count:)
+        safety = selection.safe? ? 'safe' : 'unsafe'
+        fallback = selection.fallback? ? ' fallback' : ''
+        @output.puts "selected #{selected_count}/#{total_count} test entities (reason: #{selection.reason}) [#{safety}#{fallback}]"
+        selection.warnings.each { |warning| @output.puts "warning: #{warning}" }
+      end
+
+      def results(results)
+        failed = results.values.count { |payload| payload[:status] == 'failed' || payload[:error] }
+        total = results.length
+        @output.puts "finished #{total} test entities, #{failed} failed"
+      end
+    end
+  end
+end

data/lib/kaisoku/reporters/factory.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Reporters
+    module Factory
+      module_function
+
+      def build(format, output: $stdout)
+        case format.to_s
+        when 'console'
+          Console.new(output: output)
+        when 'json'
+          JSON.new(output: output)
+        when 'junit'
+          JUnit.new(output: output)
+        when 'tui'
+          TUI.new(output: output)
+        else
+          raise Error, "unknown reporter: #{format}"
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/reporters/json.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kaisoku
+  module Reporters
+    class JSON
+      def initialize(output: $stdout)
+        @output = output
+      end
+
+      def selection(selection, selected_count:, total_count:)
+        @selection = {
+          selected: selected_count,
+          total: total_count,
+          reason: selection.reason,
+          safe: selection.safe?,
+          fallback: selection.fallback?,
+          warnings: selection.warnings
+        }
+      end
+
+      def results(results)
+        @output.puts ::JSON.pretty_generate(selection: @selection, results: results)
+      end
+    end
+  end
+end

data/lib/kaisoku/reporters/junit.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module Kaisoku
+  module Reporters
+    class JUnit
+      def initialize(output: $stdout)
+        @output = output
+      end
+
+      def selection(_selection, selected_count:, total_count:)
+        @selected_count = selected_count
+        @total_count = total_count
+      end
+
+      def results(results)
+        failures = results.values.count { |payload| payload[:status] == 'failed' || payload[:error] }
+        @output.puts %(<?xml version="1.0" encoding="UTF-8"?>)
+        @output.puts %(<testsuite name="kaisoku" tests="#{@selected_count || results.length}" failures="#{failures}" skipped="#{skipped_count}">)
+        results.each { |id, payload| testcase(id, payload) }
+        @output.puts '</testsuite>'
+      end
+
+      private
+
+      def testcase(id, payload)
+        duration = (payload[:duration_ms] || 0).to_f / 1000.0
+        @output.puts %(<testcase classname="kaisoku" name="#{escape(id)}" time="#{format('%.3f', duration)}">)
+        failure(payload) if payload[:status] == 'failed' || payload[:error]
+        @output.puts '</testcase>'
+      end
+
+      def failure(payload)
+        message = payload[:error] || payload[:status]
+        @output.puts %(<failure message="#{escape(message)}">#{escape(message)}</failure>)
+      end
+
+      def skipped_count
+        return 0 unless @total_count && @selected_count
+
+        @total_count - @selected_count
+      end
+
+      def escape(value)
+        CGI.escapeHTML(value.to_s)
+      end
+    end
+  end
+end

data/lib/kaisoku/reporters/tui.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Reporters
+    class TUI < Console
+      def selection(selection, selected_count:, total_count:)
+        clear
+        @started_at = Time.now
+        super
+      end
+
+      def results(results)
+        failed = results.values.count { |payload| payload[:status] == 'failed' || payload[:error] }
+        elapsed = Time.now - (@started_at || Time.now)
+        @output.puts "status: #{failed.zero? ? 'passed' : 'failed'}"
+        @output.puts "elapsed: #{format('%.2fs', elapsed)}"
+        super
+      end
+
+      private
+
+      def clear
+        return unless @output.tty?
+
+        @output.print "\e[2J\e[H"
+      end
+    end
+  end
+end

data/lib/kaisoku/runner.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'rails/integration'
+
+module Kaisoku
+  class Runner
+    def initialize(adapter:, test_map:, collector: CoverageCollector.new, reporter: nil, rails_integration: nil)
+      @adapter = adapter
+      @test_map = test_map
+      @collector = collector
+      @reporter = reporter
+      @rails_integration = rails_integration || Rails::Integration.new(configuration: adapter.configuration)
+    end
+
+    def run(entities)
+      results = []
+
+      @rails_integration.wrap_reloader do
+        @adapter.run(entities, reporter: @reporter) do |event, entity, payload = {}|
+          case event
+          when :entity_started
+            @collector.start_entity
+          when :entity_finished
+            collection = @collector.finish_entity
+            result = EntityResult.new(
+              entity: entity,
+              payload: payload,
+              dependencies: collection.dependencies,
+              collection_skipped: collection.skipped?
+            )
+            persist_result(result)
+            results << result
+          end
+        end
+      end
+
+      results.to_h do |result|
+        [result.entity.id, result.payload]
+      end
+    end
+
+    private
+
+    def persist_result(result)
+      Scheduler::ResultPersister.new(test_map: @test_map).persist([result])
+    end
+  end
+end

data/lib/kaisoku/runtime_context.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  class RuntimeContext
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def configuration
+      @configuration ||= Configuration.new(
+        project_root: options[:project_root],
+        map_path: options[:map_path],
+        adapter: options[:adapter],
+        method_level_threshold: options[:method_level_threshold] || 20
+      )
+    end
+
+    def test_map
+      @test_map ||= TestMap.new(configuration: configuration)
+    end
+
+    def adapter
+      @adapter ||= Adapters::Factory.build(options[:adapter], configuration: configuration)
+    end
+  end
+end

data/lib/kaisoku/scheduler/fork_pool.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'etc'
+
+module Kaisoku
+  module Scheduler
+    class ForkPool
+      def initialize(configuration:, workers: Etc.nprocessors)
+        @configuration = configuration
+        @workers = [workers.to_i, 1].max
+      end
+
+      def run(entities)
+        pending = Array(entities).dup
+        running = {}
+        results = []
+        before_fork
+
+        until pending.empty? && running.empty?
+          start_available_workers(pending, running)
+          pid, status = Process.wait2
+          reader, entity, index = running.delete(pid)
+          results << read_result(reader, entity, status)
+          @available_indexes << index
+        end
+
+        results
+      end
+
+      private
+
+      def start_available_workers(pending, running)
+        while running.length < @workers && !pending.empty?
+          entity = pending.shift
+          reader, writer = IO.pipe
+          index = @available_indexes.shift || running.length
+          pid = fork_worker(entity, writer, index)
+          writer.close
+          running[pid] = [reader, entity, index]
+        end
+      end
+
+      def fork_worker(entity, writer, index)
+        fork do
+          begin
+            reader = nil
+            run_child(entity, writer, index)
+          ensure
+            reader&.close
+            writer.close
+          end
+          exit! 0
+        end
+      end
+
+      def run_child(entity, writer, index)
+        configure_worker_environment(index)
+        configuration = Configuration.new(
+          project_root: @configuration.project_root,
+          map_path: @configuration.map_path,
+          adapter: @configuration.adapter
+        )
+        adapter = Adapters::Factory.build(configuration.adapter, configuration: configuration)
+        adapter.after_fork(index)
+        collector = CoverageCollector.new(configuration: configuration)
+        result = Worker.new(adapter: adapter, collector: collector).run(entity)
+        Marshal.dump(result, writer)
+      end
+
+      def before_fork
+        @available_indexes = (0...@workers).to_a
+        adapter = Adapters::Factory.build(@configuration.adapter, configuration: @configuration)
+        adapter.before_fork(workers: @workers)
+      end
+
+      def configure_worker_environment(index)
+        ENV['KAISOKU_WORKER_INDEX'] = index.to_s
+        ENV['TEST_ENV_NUMBER'] = index.zero? ? '' : (index + 1).to_s
+      end
+
+      def read_result(reader, entity, status)
+        result = Marshal.load(reader)
+        return result if status.success?
+
+        EntityResult.new(
+          entity: entity,
+          payload: { status: 'failed', duration_ms: 0 },
+          dependencies: result.dependencies,
+          collection_skipped: true,
+          error: "worker exited with status #{status.exitstatus}"
+        )
+      rescue StandardError => e
+        EntityResult.new(
+          entity: entity,
+          payload: { status: 'failed', duration_ms: 0 },
+          dependencies: {},
+          collection_skipped: true,
+          error: "#{e.class}: #{e.message}"
+        )
+      ensure
+        reader.close
+      end
+    end
+  end
+end

data/lib/kaisoku/scheduler/result_persister.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Scheduler
+    class ResultPersister
+      def initialize(test_map:)
+        @test_map = test_map
+      end
+
+      def persist(results)
+        results.each_with_object({}) do |result, payloads|
+          runtime_entity = runtime_entity(result)
+          @test_map.upsert_entity(runtime_entity)
+          persist_dependencies(runtime_entity, result)
+          payloads[runtime_entity.id] = result.payload.merge(error: result.error).compact
+        end
+      end
+
+      private
+
+      def runtime_entity(result)
+        result.entity.with_runtime(
+          avg_duration_ms: result.payload[:duration_ms],
+          last_status: result.status == 'passed' ? 'passed' : 'failed',
+          last_failed_at: result.failed? ? Time.now.to_i : result.entity.last_failed_at,
+          failure_count: failure_count(result)
+        )
+      end
+
+      def failure_count(result)
+        return result.entity.failure_count unless result.failed?
+
+        result.entity.failure_count.to_i + 1
+      end
+
+      def persist_dependencies(entity, result)
+        return if result.collection_skipped
+
+        @test_map.replace_dependencies(entity, result.dependencies)
+      end
+    end
+  end
+end

data/lib/kaisoku/selection.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  Selection = Struct.new(
+    :entities,
+    :safe,
+    :fallback,
+    :invalidate_map,
+    :reason,
+    :warnings,
+    :ignored_files,
+    keyword_init: true
+  ) do
+    def initialize(
+      reason:, entities: [],
+      safe: true,
+      fallback: false,
+      invalidate_map: false,
+      warnings: [],
+      ignored_files: []
+    )
+      super
+    end
+
+    def self.none(ignored_files: [], reason: 'checksums unchanged')
+      new(entities: [], reason: reason, ignored_files: ignored_files)
+    end
+
+    def self.all(entities:, reason:, invalidate_map: false, warnings: [])
+      new(
+        entities: entities,
+        fallback: true,
+        invalidate_map: invalidate_map,
+        reason: reason,
+        warnings: warnings
+      )
+    end
+
+    def count
+      entities.length
+    end
+
+    def safe?
+      safe
+    end
+
+    def fallback?
+      fallback
+    end
+  end
+end

data/lib/kaisoku/selector.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  class Selector
+    def initialize(
+      test_map:,
+      configuration: Configuration.new,
+      checksum: Checksum.new,
+      static_analyzer: StaticAnalysis::Analyzer.new(configuration: configuration),
+      rails_integration: Rails::Integration.new(configuration: configuration),
+      hybrid_policy: nil
+    )
+      @test_map = test_map
+      @configuration = configuration
+      @checksum = checksum
+      @static_analyzer = static_analyzer
+      @method_map = MethodMap.new(configuration: configuration)
+      @rails_integration = rails_integration
+      @hybrid_policy = hybrid_policy || HybridPolicy.new(test_map: test_map, configuration: configuration)
+    end
+
+    def select(changed_paths:, all_entities:)
+      entities = Array(all_entities)
+      paths = Array(changed_paths).map { |path| @configuration.relative_path(path) }.uniq
+
+      return Selection.all(entities: entities, reason: 'test map is empty') if @test_map.empty?
+
+      invalidating = paths.select { |path| @configuration.invalidates_map?(path) }
+      unless invalidating.empty?
+        return Selection.all(
+          entities: entities,
+          reason: "map invalidating file changed: #{invalidating.join(', ')}",
+          invalidate_map: true
+        )
+      end
+
+      boot_files = paths.select { |path| @configuration.boot_impact_file?(path) }
+      unless boot_files.empty?
+        rails_selection = rails_boot_selection(boot_files, entities)
+        return rails_selection if rails_selection
+
+        return Selection.all(
+          entities: entities,
+          reason: "boot-impact file changed: #{boot_files.join(', ')}"
+        )
+      end
+
+      select_from_known_changes(paths, entities)
+    end
+
+    private
+
+    def select_from_known_changes(paths, all_entities)
+      selected = []
+      ignored = []
+      reasons = []
+
+      paths.each do |path|
+        if @configuration.test_file?(path)
+          direct = direct_test_entities(path, all_entities)
+          selected.concat(direct)
+          reasons << "#{path} directly selected #{direct.length} test entities"
+          next
+        end
+
+        unless @test_map.known_file?(path)
+          return Selection.all(
+            entities: all_entities,
+            reason: "unknown changed file: #{path}",
+            warnings: static_warnings(path)
+          )
+        end
+
+        if checksum_unchanged?(path)
+          ignored << path
+          next
+        end
+
+        affected = affected_entities(path)
+        conventional = conventional_test_entities(path, all_entities) - affected
+        selected.concat(affected)
+        selected.concat(conventional)
+        reasons << selection_reason(path, affected, conventional)
+      end
+
+      unique = selected.uniq
+      return Selection.none(ignored_files: ignored) if unique.empty?
+
+      Selection.new(
+        entities: unique,
+        reason: reasons.join('; '),
+        ignored_files: ignored
+      )
+    end
+
+    def direct_test_entities(path, all_entities)
+      from_map = @test_map.entities_for_test_files([path], adapter: @configuration.adapter)
+      return from_map unless from_map.empty?
+
+      all_entities.select { |entity| entity.adapter == @configuration.adapter && entity.file == path }
+    end
+
+    def checksum_unchanged?(path)
+      stored = @test_map.checksums_for_file(path)
+      return false if stored.empty?
+
+      current = @checksum.digest(@configuration.absolute_path(path))
+      return false unless current
+
+      stored.all? { |checksum| checksum == current }
+    end
+
+    def affected_entities(path)
+      method_keys = changed_method_keys(path)
+      if !method_keys.empty? && @hybrid_policy.method_level?(path)
+        entities = @test_map.entities_for_dependency_keys(method_keys, adapter: @configuration.adapter)
+        return entities unless entities.empty?
+      end
+
+      @test_map.entities_for_changed_files([path], adapter: @configuration.adapter)
+    end
+
+    def conventional_test_entities(path, all_entities)
+      @static_analyzer.conventional_tests_for(path).flat_map do |test_path|
+        direct_test_entities(test_path, all_entities)
+      end
+    end
+
+    def selection_reason(path, affected, conventional)
+      reason = "#{path} selected #{affected.length} dependent test entities"
+      return reason if conventional.empty?
+
+      "#{reason} and #{conventional.length} conventional test entities"
+    end
+
+    def changed_method_keys(path)
+      stored = @test_map.method_checksums_for_file(path)
+      return [] if stored.empty?
+
+      current = @method_map.checksums(path)
+      changed = stored.keys.reject { |key| current[key] == stored[key] }
+      return [top_level_key(path)] if changed.empty? && !checksum_unchanged?(path)
+
+      changed
+    end
+
+    def top_level_key(path)
+      "#{@configuration.relative_path(path)}##{MethodMap::TOP_LEVEL}"
+    end
+
+    def static_warnings(path)
+      tests = @static_analyzer.conventional_tests_for(path)
+      return [] if tests.empty?
+
+      ["static analysis found conventional tests: #{tests.join(', ')}; falling back to all tests for safety"]
+    end
+
+    def rails_boot_selection(paths, all_entities)
+      return nil unless paths.any? { |path| @rails_integration.database_change?(path) }
+
+      db_entities = @test_map.entities_with_dependency_prefixes(
+        @rails_integration.db_dependency_prefixes,
+        adapter: @configuration.adapter
+      )
+      return nil if db_entities.empty?
+
+      Selection.new(
+        entities: db_entities & all_entities,
+        reason: "Rails database-impact file changed: #{paths.join(', ')}"
+      )
+    end
+  end
+end