kaisoku 0.1.0

data/lib/kaisoku/snapshot/inline.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Snapshot
+    module Inline
+      module_function
+
+      def matches?(actual, expected, location:)
+        return update(actual, location) if update?
+
+        actual == expected
+      end
+
+      def update(actual, location)
+        return true unless location && File.file?(location.path)
+
+        lines = File.readlines(location.path)
+        index = location.lineno - 1
+        replace_in_lines(lines, index, actual)
+        File.write(location.path, lines.join)
+        true
+      end
+
+      def update?
+        ENV['KAISOKU_UPDATE_SNAPSHOTS'] == '1'
+      end
+
+      def replace_argument(line, replacement)
+        line.sub(/match_inline_snapshot\((.*)\)/, "match_inline_snapshot(#{replacement})")
+      end
+
+      def replace_in_lines(lines, index, actual)
+        line = lines[index]
+        if (match = line.match(/match_inline_snapshot\(<<~?['"]?([A-Z_]+)['"]?\)/))
+          replace_heredoc(lines, index, match[1], actual.to_s)
+        else
+          lines[index] = replace_argument(line, actual.inspect)
+        end
+      end
+
+      def replace_heredoc(lines, index, terminator, actual)
+        finish = ((index + 1)...lines.length).find { |line_index| lines[line_index].strip == terminator }
+        return unless finish
+
+        indent = lines[index + 1][/^\s*/] || ''
+        replacement = actual.lines.map { |line| "#{indent}#{line.chomp}\n" }
+        lines[(index + 1)...finish] = replacement
+      end
+    end
+  end
+end

data/lib/kaisoku/snapshot/rspec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  module Snapshot
+    module RSpec
+      def self.install
+        return unless defined?(::RSpec::Matchers)
+
+        ::RSpec::Matchers.define :match_inline_snapshot do |expected|
+          match do |actual|
+            location = caller_locations.find { |frame| frame.path.end_with?('_spec.rb') }
+            Inline.matches?(actual, expected, location: location)
+          end
+
+          failure_message do |actual|
+            "expected #{actual.inspect} to match inline snapshot #{expected.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/static_analysis/analyzer.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'prism'
+
+module Kaisoku
+  module StaticAnalysis
+    class Analyzer
+      def initialize(configuration: Configuration.new)
+        @configuration = configuration
+      end
+
+      def inferred_dependencies_for_test(path)
+        absolute = @configuration.absolute_path(path)
+        return [] unless File.file?(absolute)
+
+        result = Prism.parse_file(absolute)
+        return [] unless result.success?
+
+        program = result.value
+        (requires(program, absolute) + constants(program)).uniq
+      rescue StandardError
+        []
+      end
+
+      def conventional_tests_for(path)
+        relative = @configuration.relative_path(path)
+        stem = relative.sub(%r{\A(app|lib)/}, '').sub(/\.rb\z/, '')
+        candidates = [
+          "spec/#{stem}_spec.rb",
+          "test/#{stem}_test.rb"
+        ]
+
+        candidates.select { |candidate| File.file?(@configuration.absolute_path(candidate)) }
+      end
+
+      private
+
+      def requires(program, absolute)
+        nodes(program).filter_map do |node|
+          next unless node.is_a?(Prism::CallNode)
+          next unless %i[require require_relative].include?(node.name)
+
+          feature = first_string_argument(node)
+          next unless feature
+
+          require_path(feature, absolute, relative: node.name == :require_relative)
+        end
+      end
+
+      def require_path(feature, absolute, relative:)
+        candidate = if relative
+                      File.expand_path("#{feature}.rb", File.dirname(absolute))
+                    else
+                      require_candidates(feature).find { |path| File.file?(path) }
+                    end
+
+        return nil unless candidate && File.file?(candidate)
+
+        @configuration.relative_path(candidate)
+      end
+
+      def require_candidates(feature)
+        [
+          @configuration.absolute_path("#{feature}.rb"),
+          @configuration.absolute_path("lib/#{feature}.rb"),
+          @configuration.absolute_path("app/#{feature}.rb")
+        ]
+      end
+
+      def constants(program)
+        nodes(program).filter_map do |node|
+          constant = constant_name(node)
+          next unless constant
+
+          constant_to_path(constant)
+        end.select { |path| File.file?(@configuration.absolute_path(path)) }
+      end
+
+      def nodes(root, &block)
+        return enum_for(:nodes, root) unless block_given?
+
+        yield root
+        return unless root.respond_to?(:child_nodes)
+
+        root.child_nodes.compact.each { |child| nodes(child, &block) }
+      end
+
+      def first_string_argument(node)
+        argument = node.arguments&.arguments&.first
+        return unless argument.respond_to?(:unescaped)
+
+        argument.unescaped
+      end
+
+      def constant_name(node)
+        return node.name.to_s if node.is_a?(Prism::ConstantReadNode)
+        return constant_path_name(node) if node.is_a?(Prism::ConstantPathNode)
+
+        nil
+      end
+
+      def constant_path_name(node)
+        parent = constant_name(node.parent)
+        [parent, node.name].compact.join('::')
+      end
+
+      def constant_to_path(constant)
+        basename = constant.split('::').map { |part| underscore(part) }.join('/')
+        "app/#{basename}.rb"
+      end
+
+      def underscore(value)
+        value
+          .gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2')
+          .gsub(/([a-z\d])([A-Z])/, '\\1_\\2')
+          .downcase
+      end
+    end
+  end
+end

data/lib/kaisoku/test_map/dependency_queries.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  class TestMap
+    module DependencyQueries
+      def dependencies_for(entity)
+        id = entity_id(entity)
+        return {} unless id
+
+        @db.execute('SELECT dep_file, checksum FROM deps WHERE entity_id = ?', [id]).to_h do |row|
+          [row['dep_file'], row['checksum']]
+        end
+      end
+
+      def checksums_for_file(path)
+        file = configuration.relative_path(path)
+        @db.execute('SELECT DISTINCT checksum FROM deps WHERE dep_file = ?', [file]).map { |row| row['checksum'] }
+      end
+
+      def method_checksums_for_file(path)
+        file = configuration.relative_path(path)
+        @db.execute('SELECT dep_file, checksum FROM deps WHERE dep_file LIKE ?', ["#{file}#%"]).to_h do |row|
+          [row['dep_file'], row['checksum']]
+        end
+      end
+
+      def entities_for_changed_files(paths, adapter: nil)
+        files = paths.map { |path| configuration.relative_path(path) }.uniq
+        entities_for_dependency_keys(files, adapter: adapter)
+      end
+
+      def entities_for_dependency_keys(keys, adapter: nil)
+        return [] if keys.empty?
+
+        adapter_clause = adapter ? 'AND entities.adapter = ?' : ''
+        bind = adapter ? keys + [adapter.to_s] : keys
+        sql = <<~SQL
+          SELECT DISTINCT entities.*
+          FROM entities
+          INNER JOIN deps ON deps.entity_id = entities.id
+          WHERE deps.dep_file IN (#{placeholders(keys)})
+          #{adapter_clause}
+          ORDER BY entities.file ASC, entities.identifier ASC
+        SQL
+        @db.execute(sql, bind).map { |row| entity_from_row(row) }
+      end
+
+      def dependency_entity_count(path, adapter: nil)
+        file = configuration.relative_path(path)
+        adapter_clause = adapter ? 'AND entities.adapter = ?' : ''
+        bind = adapter ? [file, adapter.to_s] : [file]
+        sql = <<~SQL
+          SELECT COUNT(DISTINCT deps.entity_id)
+          FROM deps
+          INNER JOIN entities ON entities.id = deps.entity_id
+          WHERE deps.dep_file = ?
+          #{adapter_clause}
+        SQL
+        @db.get_first_value(sql, bind).to_i
+      end
+
+      def entities_with_dependency_prefixes(prefixes, adapter: nil)
+        return [] if prefixes.empty?
+
+        clauses = prefixes.map { 'deps.dep_file LIKE ?' }.join(' OR ')
+        bind = prefixes.map { |prefix| "#{prefix}%" }
+        adapter_clause = adapter ? 'AND entities.adapter = ?' : ''
+        bind << adapter.to_s if adapter
+        sql = <<~SQL
+          SELECT DISTINCT entities.*
+          FROM entities
+          INNER JOIN deps ON deps.entity_id = entities.id
+          WHERE (#{clauses})
+          #{adapter_clause}
+          ORDER BY entities.file ASC, entities.identifier ASC
+        SQL
+        @db.execute(sql, bind).map { |row| entity_from_row(row) }
+      end
+    end
+  end
+end

data/lib/kaisoku/test_map/health.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  class TestMap
+    module Health
+      def health_warnings
+        warnings = []
+        warnings << 'schema version mismatch' unless stats[:schema_version] == SCHEMA_VERSION
+        warnings << 'ruby version mismatch' unless stats[:ruby_version] == RUBY_VERSION
+        warnings << 'adapter mismatch' unless stats[:adapter] == configuration.adapter
+        warnings << 'Gemfile.lock hash mismatch' if gemfile_lock_changed?
+        warnings
+      end
+
+      private
+
+      def gemfile_lock_changed?
+        current = Schema.gemfile_lock_hash(configuration)
+        stored = stats[:gemfile_lock_hash]
+        !stored.to_s.empty? && current != stored
+      end
+    end
+  end
+end

data/lib/kaisoku/test_map/hot_files.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  class TestMap
+    module HotFiles
+      def hot_files(threshold: 20, limit: 20, adapter: nil)
+        adapter_clause = adapter ? 'AND entities.adapter = ?' : ''
+        bind = []
+        bind << adapter.to_s if adapter
+        bind << threshold.to_i
+        bind << limit.to_i
+
+        sql = <<~SQL
+          SELECT deps.dep_file AS file, COUNT(DISTINCT deps.entity_id) AS entity_count
+          FROM deps
+          INNER JOIN entities ON entities.id = deps.entity_id
+          WHERE substr(deps.dep_file, 1, 2) != '__'
+            AND instr(deps.dep_file, '#') = 0
+          #{adapter_clause}
+          GROUP BY deps.dep_file
+          HAVING COUNT(DISTINCT deps.entity_id) >= ?
+          ORDER BY entity_count DESC, deps.dep_file ASC
+          LIMIT ?
+        SQL
+
+        @db.execute(sql, bind).map do |row|
+          { file: row['file'], entity_count: row['entity_count'].to_i }
+        end
+      end
+    end
+  end
+end

data/lib/kaisoku/test_map/schema.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Kaisoku
+  class TestMap
+    module Schema
+      module_function
+
+      def setup(db)
+        db.execute_batch(<<~SQL)
+          PRAGMA foreign_keys = ON;
+
+          CREATE TABLE IF NOT EXISTS map_meta (
+            key TEXT PRIMARY KEY,
+            value TEXT NOT NULL
+          );
+
+          CREATE TABLE IF NOT EXISTS entities (
+            id INTEGER PRIMARY KEY,
+            adapter TEXT NOT NULL,
+            identifier TEXT NOT NULL,
+            file TEXT NOT NULL,
+            line INTEGER,
+            avg_duration_ms INTEGER,
+            last_status TEXT,
+            last_failed_at INTEGER,
+            failure_count INTEGER NOT NULL DEFAULT 0,
+            UNIQUE(adapter, identifier)
+          );
+
+          CREATE TABLE IF NOT EXISTS deps (
+            entity_id INTEGER NOT NULL,
+            dep_file TEXT NOT NULL,
+            checksum TEXT NOT NULL,
+            granularity TEXT NOT NULL DEFAULT 'file',
+            PRIMARY KEY(entity_id, dep_file, granularity),
+            FOREIGN KEY(entity_id) REFERENCES entities(id) ON DELETE CASCADE
+          );
+
+          CREATE INDEX IF NOT EXISTS idx_deps_file ON deps(dep_file);
+        SQL
+        add_column(db, 'entities', 'failure_count', 'INTEGER NOT NULL DEFAULT 0')
+      end
+
+      def write_runtime_metadata(db, adapter:, configuration:)
+        write_meta(db, 'schema_version', TestMap::SCHEMA_VERSION)
+        write_meta(db, 'ruby_version', RUBY_VERSION)
+        write_meta(db, 'adapter', adapter)
+        write_meta(db, 'gemfile_lock_hash', gemfile_lock_hash(configuration))
+        write_meta(db, 'created_at', Time.now.to_i) unless meta(db, 'created_at')
+      end
+
+      def meta(db, key)
+        db.get_first_value('SELECT value FROM map_meta WHERE key = ?', [key])
+      end
+
+      def write_meta(db, key, value)
+        sql = <<~SQL
+          INSERT INTO map_meta (key, value)
+          VALUES (?, ?)
+          ON CONFLICT(key) DO UPDATE SET value = excluded.value
+        SQL
+        db.execute(sql, [key, value.to_s])
+      end
+
+      def gemfile_lock_hash(configuration)
+        path = configuration.absolute_path('Gemfile.lock')
+        return '' unless File.file?(path)
+
+        Digest::SHA256.file(path).hexdigest
+      end
+
+      def add_column(db, table, column, definition)
+        db.execute("ALTER TABLE #{table} ADD COLUMN #{column} #{definition}")
+      rescue SQLite3::SQLException
+        nil
+      end
+    end
+  end
+end

data/lib/kaisoku/test_map/snapshot.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Kaisoku
+  class TestMap
+    module Snapshot
+      def export_json
+        ::JSON.pretty_generate(
+          stats: stats,
+          entities: all_entities.map { |entity| export_entity(entity) }
+        )
+      end
+
+      def import_json(payload)
+        data = ::JSON.parse(payload)
+        Array(data['entities']).each do |row|
+          entity = import_entity(row)
+          replace_dependencies(entity, row.fetch('dependencies', {}))
+        end
+      end
+
+      private
+
+      def export_entity(entity)
+        {
+          adapter: entity.adapter,
+          identifier: entity.identifier,
+          file: entity.file,
+          line: entity.line,
+          avg_duration_ms: entity.avg_duration_ms,
+          last_status: entity.last_status,
+          last_failed_at: entity.last_failed_at,
+          failure_count: entity.failure_count,
+          dependencies: dependencies_for(entity)
+        }
+      end
+
+      def import_entity(row)
+        Entity.new(
+          adapter: row['adapter'],
+          identifier: row['identifier'],
+          file: row['file'],
+          line: row['line'],
+          avg_duration_ms: row['avg_duration_ms'],
+          last_status: row['last_status'],
+          last_failed_at: row['last_failed_at'],
+          failure_count: row['failure_count']
+        )
+      end
+    end
+  end
+end

data/lib/kaisoku/test_map/stats.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  class TestMap
+    module Stats
+      def stats
+        {
+          entities: @db.get_first_value('SELECT COUNT(*) FROM entities').to_i,
+          dependencies: @db.get_first_value('SELECT COUNT(*) FROM deps').to_i,
+          schema_version: Schema.meta(@db, 'schema_version'),
+          ruby_version: Schema.meta(@db, 'ruby_version'),
+          adapter: Schema.meta(@db, 'adapter'),
+          gemfile_lock_hash: Schema.meta(@db, 'gemfile_lock_hash'),
+          created_at: Schema.meta(@db, 'created_at')
+        }
+      end
+    end
+  end
+end

data/lib/kaisoku/test_map.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'sqlite3'
+require_relative 'test_map/dependency_queries'
+require_relative 'test_map/health'
+require_relative 'test_map/hot_files'
+require_relative 'test_map/schema'
+require_relative 'test_map/snapshot'
+require_relative 'test_map/stats'
+
+module Kaisoku
+  class TestMap
+    include DependencyQueries
+    include Health
+    include HotFiles
+    include Snapshot
+    include Stats
+
+    SCHEMA_VERSION = '1'
+    attr_reader :configuration, :path
+
+    def initialize(path: nil, configuration: Configuration.new)
+      @configuration = configuration
+      @path = path || configuration.map_path
+
+      FileUtils.mkdir_p(File.dirname(@path))
+      @db = SQLite3::Database.new(@path)
+      @db.results_as_hash = true
+      Schema.setup(@db)
+      Schema.write_runtime_metadata(@db, adapter: configuration.adapter, configuration: configuration)
+    end
+
+    def upsert_entity(entity)
+      sql = <<~SQL
+        INSERT INTO entities (adapter, identifier, file, line, avg_duration_ms, last_status, last_failed_at, failure_count)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(adapter, identifier) DO UPDATE SET
+          file = excluded.file,
+          line = excluded.line,
+          avg_duration_ms = COALESCE(excluded.avg_duration_ms, entities.avg_duration_ms),
+          last_status = COALESCE(excluded.last_status, entities.last_status),
+          last_failed_at = COALESCE(excluded.last_failed_at, entities.last_failed_at),
+          failure_count = excluded.failure_count
+      SQL
+      @db.execute(
+        sql,
+        [
+          entity.adapter,
+          entity.identifier,
+          entity.file,
+          entity.line,
+          entity.avg_duration_ms,
+          entity.last_status,
+          entity.last_failed_at,
+          entity.failure_count
+        ]
+      )
+
+      entity_id(entity)
+    end
+
+    def replace_dependencies(entity, dependencies, granularity: 'file')
+      normalized = dependencies.to_h.transform_keys { |file| configuration.relative_path(file) }
+
+      @db.transaction do
+        id = upsert_entity(entity)
+        @db.execute('DELETE FROM deps WHERE entity_id = ? AND granularity = ?', [id, granularity])
+
+        normalized.each do |file, checksum|
+          @db.execute(
+            'INSERT INTO deps (entity_id, dep_file, checksum, granularity) VALUES (?, ?, ?, ?)',
+            [id, file, checksum, granularity]
+          )
+        end
+      end
+    end
+
+    def entities_for_test_files(paths, adapter: nil)
+      files = paths.map { |path| configuration.relative_path(path) }.uniq
+      return [] if files.empty?
+
+      adapter_clause = adapter ? 'AND adapter = ?' : ''
+      bind = adapter ? files + [adapter.to_s] : files
+
+      sql = <<~SQL
+        SELECT *
+        FROM entities
+        WHERE file IN (#{placeholders(files)})
+        #{adapter_clause}
+        ORDER BY file ASC, identifier ASC
+      SQL
+
+      @db.execute(sql, bind).map { |row| entity_from_row(row) }
+    end
+
+    def all_entities(adapter: nil)
+      rows = if adapter
+               @db.execute('SELECT * FROM entities WHERE adapter = ? ORDER BY file ASC, identifier ASC', [adapter.to_s])
+             else
+               @db.execute('SELECT * FROM entities ORDER BY adapter ASC, file ASC, identifier ASC')
+             end
+
+      rows.map { |row| entity_from_row(row) }
+    end
+
+    def failed_entities(adapter: nil)
+      if adapter
+        sql = <<~SQL
+          SELECT * FROM entities WHERE adapter = ? AND last_status = 'failed'
+          ORDER BY last_failed_at DESC, file ASC
+        SQL
+        rows = @db.execute(sql, [adapter.to_s])
+      else
+        sql = <<~SQL
+          SELECT * FROM entities WHERE last_status = 'failed'
+          ORDER BY last_failed_at DESC, file ASC
+        SQL
+        rows = @db.execute(sql)
+      end
+
+      rows.map { |row| entity_from_row(row) }
+    end
+
+    def known_file?(path)
+      file = configuration.relative_path(path)
+      dep_count = @db.get_first_value('SELECT COUNT(*) FROM deps WHERE dep_file = ?', [file])
+      entity_count = @db.get_first_value('SELECT COUNT(*) FROM entities WHERE file = ?', [file])
+
+      dep_count.to_i.positive? || entity_count.to_i.positive?
+    end
+
+    def empty?
+      @db.get_first_value('SELECT COUNT(*) FROM entities').to_i.zero?
+    end
+
+    def clear!
+      @db.transaction do
+        @db.execute('DELETE FROM deps')
+        @db.execute('DELETE FROM entities')
+      end
+    end
+
+    private
+
+    def entity_id(entity)
+      @db.get_first_value(
+        'SELECT id FROM entities WHERE adapter = ? AND identifier = ?',
+        [entity.adapter, entity.identifier]
+      )
+    end
+
+    def entity_from_row(row)
+      Entity.new(
+        adapter: row['adapter'],
+        identifier: row['identifier'],
+        file: row['file'],
+        line: row['line'],
+        avg_duration_ms: row['avg_duration_ms'],
+        last_status: row['last_status'],
+        last_failed_at: row['last_failed_at'],
+        failure_count: row['failure_count']
+      )
+    end
+
+    def placeholders(values)
+      (['?'] * values.length).join(', ')
+    end
+  end
+end

data/lib/kaisoku/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  VERSION = '0.1.0'
+end

data/lib/kaisoku/watch_session.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Kaisoku
+  class WatchSession
+    def initialize(watcher:, runner:, debounce: 0.05)
+      @watcher = watcher
+      @debounce = debounce.to_f
+      @runner = runner
+      @current_pid = nil
+    end
+
+    def start
+      @watcher.each_change do |changed_paths|
+        sleep @debounce
+        cancel_current
+        @current_pid = fork { exit!(@runner.call(changed_paths).to_i) }
+        Process.detach(@current_pid)
+      end
+    ensure
+      cancel_current
+    end
+
+    private
+
+    def cancel_current
+      return unless @current_pid
+
+      Process.kill('TERM', @current_pid)
+    rescue Errno::ESRCH
+      nil
+    ensure
+      @current_pid = nil
+    end
+  end
+end