kaisoku 0.1.0

data/lib/kaisoku/cli.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Kaisoku
+  class CLI
+    def self.start(argv)
+      new(argv).call
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+    end
+
+    def call
+      command = @argv.shift || 'help'
+
+      case command
+      when 'run'
+        run_command(@argv)
+      when 'watch'
+        watch_command(@argv)
+      when 'map'
+        map_command(@argv)
+      when 'doctor'
+        doctor_command(@argv)
+      when 'eval'
+        eval_command(@argv)
+      when 'daemon'
+        daemon_command(@argv)
+      when 'preload'
+        preload_command(@argv)
+      when 'lsp'
+        lsp_command(@argv)
+      when 'help', '--help', '-h'
+        puts usage
+        0
+      else
+        warn "unknown command: #{command}"
+        warn usage
+        1
+      end
+    rescue Error => e
+      warn "kaisoku: #{e.message}"
+      1
+    end
+
+    private
+
+    def run_command(argv)
+      options = parse_common_options(argv)
+      Commands::RunCommand.new(argv, options).call
+    end
+
+    def watch_command(argv)
+      options = parse_common_options(argv) do |opts, parsed|
+        opts.on('--interval SECONDS', Float) { |value| parsed[:interval] = value }
+        opts.on('--watcher KIND') { |value| parsed[:watcher] = value }
+      end
+
+      Commands::WatchCommand.new(argv, options).call
+    end
+
+    def map_command(argv)
+      options = parse_common_options(argv)
+      Commands::MapCommand.new(argv, options).call
+    end
+
+    def doctor_command(argv)
+      options = parse_common_options(argv)
+      context = RuntimeContext.new(options)
+      preload = Preload::Server.new(configuration: context.configuration) if options[:preload]
+
+      puts Doctor.new(test_map: context.test_map, preload_server: preload).report
+      0
+    end
+
+    def eval_command(argv)
+      Evaluator::CLI.new(argv).call
+    end
+
+    def daemon_command(argv)
+      options = parse_daemon_options(argv)
+      subcommand = argv.shift
+      Commands::DaemonCommand.new([subcommand] + argv, options).call
+    end
+
+    def preload_command(argv)
+      options = parse_daemon_options(argv)
+      subcommand = argv.shift
+      Commands::PreloadCommand.new([subcommand] + argv, options).call
+    end
+
+    def lsp_command(argv)
+      options = parse_common_options(argv)
+      context = RuntimeContext.new(options)
+      LSP::Server.new(configuration: context.configuration).start
+    end
+
+    def parse_daemon_options(argv)
+      options = default_options
+      parser = OptionParser.new do |opts|
+        opts.on('--adapter NAME') { |value| options[:adapter] = value }
+        opts.on('--map PATH') { |value| options[:map_path] = value }
+        opts.on('--root PATH') { |value| options[:project_root] = value }
+        opts.on('--socket PATH') { |value| options[:socket_path] = value }
+      end
+      parser.order!(argv)
+      options
+    end
+
+    def parse_common_options(argv)
+      options = default_options
+      parser = OptionParser.new do |opts|
+        opts.on('--adapter NAME') { |value| options[:adapter] = value }
+        opts.on('--map PATH') { |value| options[:map_path] = value }
+        opts.on('--root PATH') { |value| options[:project_root] = value }
+        opts.on('--all') { options[:all] = true }
+        opts.on('--failed') { options[:failed] = true }
+        opts.on('--predictive') { options[:predictive] = true }
+        opts.on('--reporter FORMAT') { |value| options[:reporter] = value }
+        opts.on('--workers N', Integer) { |value| options[:workers] = value }
+        opts.on('--method-threshold N', Integer) { |value| options[:method_level_threshold] = value }
+        opts.on('--socket PATH') { |value| options[:socket_path] = value }
+        opts.on('--preload') { options[:preload] = true }
+        yield opts, options if block_given?
+      end
+
+      parser.parse!(argv)
+      options
+    end
+
+    def default_options
+      {
+        adapter: 'rspec',
+        project_root: Dir.pwd,
+        all: false,
+        failed: false,
+        predictive: false,
+        reporter: 'console',
+        workers: 1
+      }
+    end
+
+    def usage
+      <<~USAGE
+        Usage:
+          kaisoku run [changed paths] [--all] [--failed] [--adapter rspec|minitest|test-unit|cucumber] [--workers N] [--method-threshold N]
+          kaisoku watch [paths] [--adapter rspec|minitest|test-unit|cucumber] [--interval SECONDS] [--watcher listen|poll]
+          kaisoku map build|export|import|hot [paths] [--adapter rspec|minitest|test-unit|cucumber]
+          kaisoku doctor [--map PATH]
+          kaisoku eval --total N --selected N [--ci]
+          kaisoku preload start|status|refresh [paths]
+          kaisoku lsp
+      USAGE
+    end
+  end
+end

data/lib/kaisoku/commands/daemon_command.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Commands
+    class DaemonCommand
+      def initialize(argv, options)
+        @argv = argv
+        @options = options
+        @context = RuntimeContext.new(options)
+      end
+
+      def call
+        subcommand = @argv.shift
+        socket_path = @options[:socket_path] || Daemon::SocketPath.default(@context.configuration)
+        return Daemon::Server.new(socket_path: socket_path).start if subcommand == 'start'
+        return request(socket_path) if subcommand == 'request'
+
+        warn 'usage: kaisoku daemon start|request [--socket PATH]'
+        1
+      end
+
+      private
+
+      def request(socket_path)
+        response = Daemon::Client.new(socket_path: socket_path).request(@argv)
+        warn response['error'] if response['error']
+        response.fetch('status', 1)
+      end
+    end
+  end
+end

data/lib/kaisoku/commands/map_command.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Kaisoku
+  module Commands
+    class MapCommand
+      def initialize(argv, options)
+        @argv = argv
+        @context = RuntimeContext.new(options)
+        @options = options
+      end
+
+      def call
+        subcommand = @argv.shift
+        return build if subcommand == 'build'
+        return export if subcommand == 'export'
+        return import if subcommand == 'import'
+        return hot if subcommand == 'hot'
+
+        warn 'usage: kaisoku map build|export|import|hot [--adapter NAME] [--map PATH]'
+        1
+      end
+
+      private
+
+      def build
+        entities = @context.adapter.discover(@argv)
+        seed_static_dependencies(entities)
+        puts "building map for #{entities.length} #{@options[:adapter]} entities"
+        results = Runner.new(
+          adapter: @context.adapter,
+          test_map: @context.test_map,
+          collector: CoverageCollector.new(configuration: @context.configuration),
+          reporter: nil
+        ).run(entities)
+
+        results.values.any? { |result| result[:status] == 'failed' } ? 1 : 0
+      end
+
+      def export
+        puts @context.test_map.export_json
+        0
+      end
+
+      def import
+        path = @argv.shift
+        payload = path ? File.read(path) : $stdin.read
+        @context.test_map.import_json(payload)
+        0
+      end
+
+      def hot
+        options = { threshold: 20, limit: 20 }
+        OptionParser.new do |opts|
+          opts.on('--threshold N', Integer) { |value| options[:threshold] = value }
+          opts.on('--limit N', Integer) { |value| options[:limit] = value }
+        end.parse!(@argv)
+
+        rows = @context.test_map.hot_files(
+          threshold: options[:threshold],
+          limit: options[:limit],
+          adapter: @options[:adapter]
+        )
+        return puts("no hot files at threshold #{options[:threshold]}") || 0 if rows.empty?
+
+        rows.each { |row| puts "#{row[:file]}\t#{row[:entity_count]} entities" }
+        0
+      end
+
+      def seed_static_dependencies(entities)
+        analyzer = StaticAnalysis::Analyzer.new(configuration: @context.configuration)
+        checksum = Checksum.new
+
+        entities.each do |entity|
+          deps = analyzer.inferred_dependencies_for_test(entity.file).to_h do |path|
+            [path, checksum.digest(@context.configuration.absolute_path(path))]
+          end.compact
+          next if deps.empty?
+
+          @context.test_map.replace_dependencies(entity, deps)
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/commands/preload_command.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Commands
+    class PreloadCommand
+      def initialize(argv, options)
+        @argv = argv
+        @options = options
+        @context = RuntimeContext.new(options)
+      end
+
+      def call
+        subcommand = @argv.shift
+        return start if subcommand == 'start'
+        return request('status') if subcommand == 'status'
+        return request('refresh', 'changed_paths' => @argv) if subcommand == 'refresh'
+
+        warn 'usage: kaisoku preload start|status|refresh [paths]'
+        1
+      end
+
+      private
+
+      def start
+        server = Preload::Server.new(configuration: @context.configuration)
+        Preload::Daemon.new(socket_path: socket_path, server: server).start
+      end
+
+      def request(command, payload = {})
+        response = Preload::Client.new(socket_path: socket_path).request(command, payload)
+        puts response
+        response['ok'] ? 0 : 1
+      end
+
+      def socket_path
+        @options[:socket_path] || Preload::SocketPath.default(@context.configuration)
+      end
+    end
+  end
+end

data/lib/kaisoku/commands/run_command.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Commands
+    class RunCommand
+      def initialize(paths, options)
+        @paths = paths
+        @options = options
+        @context = RuntimeContext.new(options)
+      end
+
+      def call
+        all_entities = @context.adapter.discover
+        selection = build_run_selection(@paths, all_entities)
+        @context.test_map.clear! if selection.invalidate_map
+        entities = Prioritizer.new.order(selection.entities)
+        reporter.selection(selection, selected_count: entities.length, total_count: all_entities.length)
+        return 0 if entities.empty?
+
+        results = execute_entities(entities)
+        reporter.results(results)
+        results.values.any? { |result| result[:status] == 'failed' } ? 1 : 0
+      end
+
+      private
+
+      def build_run_selection(paths, all_entities)
+        return Selection.new(entities: all_entities, fallback: false, reason: 'all tests requested') if @options[:all]
+        return failed_selection if @options[:failed]
+        return predictive_selection if @options[:predictive]
+        if paths.empty?
+          return Selection.new(entities: all_entities, fallback: false,
+                               reason: 'no change paths supplied')
+        end
+
+        Selector.new(test_map: @context.test_map, configuration: @context.configuration).select(
+          changed_paths: paths,
+          all_entities: all_entities
+        )
+      end
+
+      def failed_selection
+        Selection.new(
+          entities: @context.test_map.failed_entities(adapter: @options[:adapter]),
+          reason: 'previous failures'
+        )
+      end
+
+      def predictive_selection
+        Selection.new(
+          entities: @context.test_map.failed_entities(adapter: @options[:adapter]),
+          safe: false,
+          reason: 'predictive mode: previous failures only',
+          warnings: ['predictive selection is unsafe and may miss failures']
+        )
+      end
+
+      def execute_entities(entities)
+        return execute_parallel(entities) if @options[:workers].to_i > 1
+        return execute_with_preload(entities) if @options[:preload]
+
+        Runner.new(
+          adapter: @context.adapter,
+          test_map: @context.test_map,
+          collector: CoverageCollector.new(configuration: @context.configuration),
+          reporter: nil
+        ).run(entities)
+      end
+
+      def execute_parallel(entities)
+        results = Scheduler::ForkPool.new(
+          configuration: @context.configuration,
+          workers: @options[:workers]
+        ).run(entities)
+        Scheduler::ResultPersister.new(test_map: @context.test_map).persist(results)
+      end
+
+      def execute_with_preload(entities)
+        server = Preload::Server.new(configuration: @context.configuration)
+        results = Preload::FallbackRunner.new(preload_server: server).run do
+          adapter = Adapters::Factory.build(@context.configuration.adapter, configuration: @context.configuration)
+          collector = CoverageCollector.new(configuration: @context.configuration)
+          entities.map { |entity| Worker.new(adapter: adapter, collector: collector).run(entity) }
+        end
+        Scheduler::ResultPersister.new(test_map: @context.test_map).persist(results)
+      end
+
+      def reporter
+        @reporter ||= Reporters::Factory.build(@options[:reporter])
+      end
+    end
+  end
+end

data/lib/kaisoku/commands/watch_command.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Commands
+    class WatchCommand
+      def initialize(paths, options)
+        @paths = paths
+        @options = options
+        @context = RuntimeContext.new(options)
+      end
+
+      def call
+        watcher = watcher_class.new(
+          configuration: @context.configuration,
+          paths: @paths.empty? ? Watcher::DEFAULT_PATHS : @paths,
+          interval: @options[:interval] || 0.2
+        )
+
+        puts "watching #{watcher.paths.join(', ')}"
+        WatchSession.new(watcher: watcher, debounce: 0.05, runner: runner).start
+      end
+
+      private
+
+      def runner
+        proc do |changed_paths|
+          puts "changed #{changed_paths.join(', ')}"
+          RunCommand.new(changed_paths, @options.merge(all: false, failed: false)).call
+        end
+      end
+
+      def watcher_class
+        @options[:watcher] == 'poll' ? Watcher : ListenWatcher
+      end
+    end
+  end
+end

data/lib/kaisoku/configuration.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Kaisoku
+  class Configuration
+    DEFAULT_BOOT_GLOBS = [
+      'config/**',
+      'config.ru',
+      'db/schema.rb',
+      'db/migrate/**',
+      '.env',
+      '.env.*'
+    ].freeze
+
+    MAP_INVALIDATING_FILES = [
+      'Gemfile.lock',
+      '.ruby-version',
+      '.tool-versions'
+    ].freeze
+
+    attr_reader :project_root, :map_path, :adapter, :track_paths, :method_level_threshold
+
+    def initialize(project_root: Dir.pwd, map_path: nil, adapter: 'rspec', track_paths: [], method_level_threshold: 20)
+      @project_root = File.expand_path(project_root)
+      @map_path = map_path || File.join(@project_root, '.kaisoku', 'map.db')
+      @adapter = adapter.to_s
+      @track_paths = track_paths.map { |path| File.expand_path(path, @project_root) }
+      @method_level_threshold = method_level_threshold.to_i
+    end
+
+    def relative_path(path)
+      return path.to_s if path.to_s.start_with?('__')
+
+      expanded = File.expand_path(path, project_root)
+      root = Pathname.new(project_root)
+      target = Pathname.new(expanded)
+
+      target.relative_path_from(root).to_s
+    rescue ArgumentError
+      path.to_s
+    end
+
+    def absolute_path(path)
+      File.expand_path(path, project_root)
+    end
+
+    def project_file?(path)
+      expanded = File.expand_path(path)
+      expanded == project_root ||
+        expanded.start_with?("#{project_root}#{File::SEPARATOR}") ||
+        track_paths.any? { |tracked| expanded.start_with?("#{tracked}#{File::SEPARATOR}") }
+    end
+
+    def boot_impact_file?(path)
+      relative = relative_path(path)
+      DEFAULT_BOOT_GLOBS.any? { |pattern| File.fnmatch?(pattern, relative, File::FNM_PATHNAME) }
+    end
+
+    def invalidates_map?(path)
+      MAP_INVALIDATING_FILES.include?(relative_path(path))
+    end
+
+    def test_file?(path)
+      relative = relative_path(path)
+      relative.match?(%r{\A(spec/.+_spec|test/.+_test)\.rb\z})
+    end
+  end
+end

data/lib/kaisoku/coverage_collector.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'coverage'
+
+module Kaisoku
+  class CoverageCollector
+    Result = Struct.new(:dependencies, :skipped, :reason, keyword_init: true) do
+      def skipped?
+        skipped
+      end
+    end
+
+    def initialize(configuration: Configuration.new, checksum: Checksum.new)
+      @configuration = configuration
+      @checksum = checksum
+      @method_map = MethodMap.new(configuration: configuration)
+      @started_by_collector = false
+      @loaded_features_before = []
+      @conflict_reason = nil
+      @environment_tracker = EnvironmentTracker.new
+    end
+
+    def start_entity
+      @loaded_features_before = $LOADED_FEATURES.dup
+      @conflict_reason = nil
+      @environment_tracker = EnvironmentTracker.new
+
+      if Coverage.running? && !@started_by_collector
+        @conflict_reason = 'Coverage is already running; map update skipped'
+        return
+      end
+
+      return if @started_by_collector
+
+      Coverage.start(oneshot_lines: true)
+      @started_by_collector = true
+    end
+
+    def finish_entity
+      return Result.new(dependencies: {}, skipped: true, reason: @conflict_reason) if @conflict_reason
+
+      coverage = Coverage.result(stop: false, clear: true)
+      coverage_files = coverage.keys
+      loaded_files = $LOADED_FEATURES - @loaded_features_before
+      files = (coverage_files + loaded_files).uniq
+      deps = dependency_checksums(files)
+      deps.merge!(method_dependency_checksums(coverage))
+      deps[EnvironmentTracker::DEPENDENCY_KEY] = @environment_tracker.dependency.last if @environment_tracker.changed?
+
+      Result.new(dependencies: deps, skipped: false, reason: nil)
+    end
+
+    private
+
+    def dependency_checksums(files)
+      files.each_with_object({}) do |file, deps|
+        next unless tracked_file?(file)
+
+        absolute = File.expand_path(file)
+        checksum = @checksum.digest(absolute)
+        next unless checksum
+
+        deps[@configuration.relative_path(absolute)] = checksum
+      end
+    end
+
+    def tracked_file?(file)
+      absolute = File.expand_path(file)
+      @configuration.project_file?(absolute) && File.file?(absolute)
+    end
+
+    def method_dependency_checksums(coverage)
+      coverage.each_with_object({}) do |(file, data), deps|
+        next unless tracked_file?(file)
+
+        touched = data[:oneshot_lines] || data['oneshot_lines']
+        keys = @method_map.keys_for_lines(file, touched)
+        checksums = @method_map.checksums(file)
+        keys.each { |key| deps[key] = checksums[key] if checksums[key] }
+      end
+    end
+  end
+end

data/lib/kaisoku/daemon/client.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'msgpack'
+
+module Kaisoku
+  module Daemon
+    class Client
+      def initialize(socket_path:)
+        @socket_path = socket_path
+      end
+
+      def request(argv)
+        UNIXSocket.open(@socket_path) do |socket|
+          socket.write(MessagePack.pack('argv' => argv))
+          socket.close_write
+          MessagePack.unpack(socket.read)
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/daemon/server.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'socket'
+require 'msgpack'
+
+module Kaisoku
+  module Daemon
+    class Server
+      def initialize(socket_path:, cli_factory: ->(argv) { CLI.new(argv) })
+        @socket_path = socket_path
+        @cli_factory = cli_factory
+      end
+
+      def start
+        FileUtils.mkdir_p(File.dirname(@socket_path))
+        FileUtils.rm_f(@socket_path)
+
+        UNIXServer.open(@socket_path) do |server|
+          loop { handle(server.accept) }
+        end
+      ensure
+        File.unlink(@socket_path) if @socket_path && File.socket?(@socket_path)
+      end
+
+      private
+
+      def handle(socket)
+        request = MessagePack.unpack(socket.read)
+        status = @cli_factory.call(Array(request['argv'])).call
+        socket.write(MessagePack.pack('status' => status))
+      rescue StandardError => e
+        socket.write(MessagePack.pack('status' => 1, 'error' => "#{e.class}: #{e.message}"))
+      ensure
+        socket.close
+      end
+    end
+  end
+end

data/lib/kaisoku/daemon/socket_path.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Daemon
+    module SocketPath
+      module_function
+
+      def default(configuration)
+        File.join(configuration.project_root, '.kaisoku', 'daemon.sock')
+      end
+    end
+  end
+end