kimera 0.1.0

data/lib/kimera/frameworks/adapter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative "../error"
+
+module Kimera
+  module Frameworks
+    RunOutcome =
+      Struct.new(:passed, :failed_ids, :failures, keyword_init: true) do
+        def passed?
+          passed
+        end
+
+        def failures
+          self[:failures] || {}
+        end
+
+        def verdict
+          passed? ? [:survived, []] : [:killed, failed_ids]
+        end
+      end
+  end
+end
+
+class Kimera::Frameworks::Adapter
+  def source(files)
+    raise(NotImplementedError)
+  end
+
+  def test_ids
+    raise(NotImplementedError)
+  end
+
+  def start; end
+
+  def finish; end
+
+  def run(ids)
+    raise(NotImplementedError)
+  end
+
+  def describe(id)
+    id
+  end
+
+  @registry = {}
+
+  NO_LOADER = -> {}
+  ADAPTER_LOADERS = {
+    "rspec" => lambda do
+      require_relative "rspec_adapter"
+    end,
+    "minitest" => lambda do
+      require_relative "minitest_adapter"
+    end
+  }.freeze
+
+  class << self
+    attr_reader :registry
+
+    def load(name)
+      ADAPTER_LOADERS.fetch(name.to_s, NO_LOADER).call
+      fetch(name).build
+    rescue LoadError => error
+      raise(Kimera::Error, unloadable(name, error))
+    end
+
+    def unloadable(name, error)
+      "framework #{name} is configured but cannot be loaded (#{error.message}); " \
+        "set framework: rspec or minitest in .kimera.yml, or add it to the Gemfile"
+    end
+
+    def register(name, klass)
+      registry[name.to_s] = klass
+    end
+
+    def fetch(name)
+      registry.fetch(name.to_s) do
+        raise(Kimera::Error, "unknown test framework adapter: #{name}")
+      end
+    end
+  end
+end

data/lib/kimera/frameworks/minitest_adapter.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative "adapter"
+
+module Kimera
+  module Frameworks
+  end
+end
+
+class Kimera::Frameworks::MinitestAdapter < Kimera::Frameworks::Adapter
+  TESTROOTS = %w[test spec].freeze
+  INSTALLED = true
+
+  class << self
+    def build
+      require("minitest")
+      Minitest.seed ||= 1
+      disable
+      new
+    end
+
+    private
+
+    def disable
+      Minitest.class_variable_set(:@@installed_at_exit, INSTALLED)
+    rescue NameError, ArgumentError
+      Minitest.define_singleton_method(:run) { |*| true }
+    end
+  end
+
+  def initialize
+    super
+    @methods = {}
+  end
+
+  def source(files)
+    paths(files)
+    Array(files).each { |f| load(File.expand_path(f)) }
+    reindex
+    self
+  end
+
+  def test_ids
+    @methods.keys
+  end
+
+  def run(ids)
+    failed = []
+    failures = {}
+    ids.each { |id| record(id, failed, failures) }
+    Kimera::Frameworks::RunOutcome.new(passed: failed.empty?, failed_ids: failed, failures: failures)
+  end
+
+  private
+
+  def record(id, failed, failures)
+    klass, name = @methods[id]
+    return unless klass
+    result = klass.new(name).run
+    return unless killing?(result)
+    failure(id, result, failed, failures)
+  end
+
+  def failure(id, result, failed, failures)
+    failed << id
+    failures[id] = message(result)
+  end
+
+  def paths(files)
+    Array(files).each do |file|
+      parts = File.expand_path(file).split(File::SEPARATOR)
+      TESTROOTS.each { |root| prepend(parts, root) }
+    end
+  end
+
+  def prepend(parts, root)
+    index = parts.rindex(root)
+    return unless index
+    dir = parts[0..index].join(File::SEPARATOR)
+    $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
+  end
+
+  def reindex
+    @methods = {}
+    Minitest::Runnable.runnables.each { |runnable| index(runnable) }
+  end
+
+  def index(runnable)
+    runnable.runnable_methods.each { |name| @methods["#{runnable}##{name}"] = [runnable, name] }
+  end
+
+  def killing?(result)
+    !result.passed? && !result.skipped?
+  end
+
+  def message(result)
+    assertion = result.failures.first
+    assertion && "#{assertion.class.name.split("::").last}: #{assertion.message}"
+  end
+end
+
+Kimera::Frameworks::Adapter.register(:minitest, Kimera::Frameworks::MinitestAdapter)

data/lib/kimera/frameworks/rspec_adapter.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "rspec/core"
+require_relative "adapter"
+require_relative "rspec_group_index"
+
+module Kimera
+  module Frameworks
+  end
+end
+
+class Kimera::Frameworks::RSpecAdapter < Kimera::Frameworks::Adapter
+  class << self
+    def build
+      configure
+      new
+    end
+
+    private
+
+    def configure
+      RSpec::Core::ConfigurationOptions.new([]).configure(RSpec.configuration)
+    rescue StandardError, ScriptError
+      nil
+    end
+  end
+
+  def initialize
+    super
+    @examples = {}
+    @suite = nil
+  end
+
+  def source(files)
+    Array(files).each { |file| load(file) }
+    reindex
+    self
+  end
+
+  def test_ids
+    @examples.keys
+  end
+
+  def describe(id)
+    ex = @examples[id]
+    ex ? ex.full_description : id
+  end
+
+  def start
+    pid = Process.pid
+    return if @suite == pid
+    @suite = pid
+    hooks(:@before_suite_hooks)
+  end
+
+  def finish
+    return unless @suite == Process.pid
+    hooks(:@after_suite_hooks)
+  end
+
+  def run(ids)
+    selected = ids.filter_map { |id| @examples[id] }
+    reset
+    clear(selected)
+    execute(selected)
+    outcome(selected)
+  end
+
+  private
+
+  def outcome(selected)
+    failed = selected.select { |ex| ex.execution_result.status == :failed }
+    Kimera::Frameworks::RunOutcome.new(
+      passed: failed.empty?, failed_ids: failed.map(&:id),
+      failures: failed.to_h { |example| [example.id, failure(example)] }
+    )
+  end
+
+  def hooks(store)
+    config = RSpec.configuration
+    context = RSpec::Core::SuiteHookContext.new(store.to_s, config.reporter)
+    config.instance_variable_get(store).each { |hook| hook.run(context) }
+  end
+
+  def failure(example)
+    exception = example.execution_result.exception
+    exception && "#{exception.class}: #{exception.message}"
+  end
+
+  def reset
+    world = RSpec.world
+    world.wants_to_quit = false
+    world.non_example_failure = false
+  end
+
+  def load(file) = Kernel.load(File.expand_path(file))
+
+  def reindex
+    @examples = {}
+    RSpec.world.example_groups.each { |top| index(top) }
+  end
+
+  def index(top)
+    Kimera::Frameworks::RSpecGroupIndex.examples(top).each { |example| @examples[example.id] = example }
+  end
+
+  def clear(examples)
+    examples.each { |ex| ex.instance_variable_set(:@exception, nil) }
+  end
+
+  def execute(selected)
+    reporter = RSpec::Core::Reporter.new(RSpec.configuration)
+    filtered = RSpec.world.filtered_examples
+    wanted = selected.to_a
+    Kimera::Frameworks::RSpecGroupIndex.top(selected).each { |top| perform(top, reporter, filtered, wanted) }
+  end
+
+  def perform(top, reporter, filtered, wanted)
+    Kimera::Frameworks::RSpecGroupIndex.narrow(filtered, top, wanted) { top.run(reporter) }
+  end
+end
+
+Kimera::Frameworks::Adapter.register(:rspec, Kimera::Frameworks::RSpecAdapter)

data/lib/kimera/frameworks/rspec_group_index.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Frameworks
+  end
+end
+
+class Kimera::Frameworks::RSpecGroupIndex
+  class << self
+    def top(examples)
+      examples.map { |example| group(example) }.uniq
+    end
+
+    def tree(group, collected = [])
+      collected << group
+      group.children.each { |child| tree(child, collected) }
+      collected
+    end
+
+    def filtered(group)
+      RSpec.configuration.filter_manager.prune(group.examples)
+    end
+
+    def examples(top)
+      tree(top).flat_map { |group| filtered(group) }
+    end
+
+    def narrow(filtered, top, wanted, &)
+      swap(filtered, tree(top).to_h { |group| [group, group.examples & wanted] }, &)
+    end
+
+    private
+
+    def swap(filtered, scoped)
+      filtered.merge!(scoped)
+      yield
+    ensure
+      scoped.each_key { |group| filtered.delete(group) }
+    end
+
+    def group(example)
+      example.example_group.parent_groups.last
+    end
+  end
+end

data/lib/kimera/incremental/git_diff.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "open3"
+require_relative "../error"
+
+module Kimera
+  module Incremental
+  end
+end
+
+class Kimera::Incremental::DiffError < Kimera::Error; end
+
+class Kimera::Incremental::GitDiff
+  FILE_HEADER = %r{\A\+\+\+ b/(.*)\n?\z}
+  HUNK_HEADER = /\A@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/
+  BASEFLAGS = %w[diff --relative --unified=0 --no-color --no-ext-diff --src-prefix=a/ --dst-prefix=b/].freeze
+
+  class << self
+    def lines(**scope)
+      new(**scope).lines
+    end
+
+    def files(**scope)
+      new(**scope).files
+    end
+
+    def parse(text)
+      files = {}
+      current = nil
+      text.each_line { |line| current = advance(files, current, line) }
+      files
+    end
+
+    private
+
+    def advance(files, current, line)
+      header = line.match(FILE_HEADER)
+      return named(header) if header
+      hunk = line.match(HUNK_HEADER)
+      collect(files, current, hunk) if current && hunk
+      current
+    end
+
+    def named(header)
+      path = header[1]
+      path unless path == File::NULL
+    end
+
+    def collect(files, file, match)
+      span = match[2]
+      count = span ? Integer(span, 10) : 1
+      return if count.zero?
+      range(files, file, Integer(match[1], 10), count)
+    end
+
+    def range(files, file, start, count)
+      set = (files[file] ||= Set.new)
+      (start...(start + count)).each { |line| set << line }
+    end
+  end
+
+  def initialize(since:, root: ".", paths: nil)
+    @since = since
+    @root = root
+    @paths = paths
+  end
+
+  def lines
+    out, ok = read
+    raise(failure) unless ok
+    self.class.parse(out)
+  end
+
+  def files
+    lines.keys
+  end
+
+  private
+
+  def failure
+    Kimera::Incremental::DiffError.new(
+      "git diff against #{@since.inspect} failed (unknown ref, not a git repository, or git missing)"
+    )
+  end
+
+  def read
+    out, _error, status = Open3.capture3(*command)
+    [out, status.success?]
+  rescue Errno::ENOENT
+    ["", false]
+  end
+
+  def command
+    cmd = ["git", "-C", @root.to_s, *BASEFLAGS, @since.to_s]
+    cmd += ["--", *Array(@paths)] if @paths
+    cmd
+  end
+end

data/lib/kimera/incremental/selection.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "git_diff"
+
+module Kimera
+  module Incremental
+    module Selection
+      module_function
+
+      def select(registry, changes)
+        ids = []
+        registry.points.each { |point| ids.concat(ids(point, changes)) }
+        ids
+      end
+
+      def ids(point, changes)
+        lines = changes[point.file]
+        return [] unless lines && point.location.range.any? { |line| lines.include?(line) }
+        point.ids
+      end
+
+      def changed(registry, since:, root: ".")
+        select(registry, GitDiff.lines(since: since, root: root))
+      end
+    end
+  end
+end

data/lib/kimera/incremental/session.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "../results/result"
+require_relative "../results/run_report"
+
+module Kimera
+  module Incremental
+  end
+end
+
+class Kimera::Incremental::Session
+  VERSION = 2
+
+  attr_reader :results, :leaks
+
+  def initialize(results: {}, leaks: [], meta: {}, fingerprints: {})
+    @results = results
+    @leaks = leaks
+    @meta = meta
+    @fingerprints = fingerprints
+  end
+
+  class << self
+    def load(path, registry: nil)
+      return new unless path && File.exist?(path)
+      session = decode(JSON.parse(File.read(path)))
+      session.prune!(registry) if registry
+      session
+    end
+
+    def decode(data)
+      new(**attributes(data))
+    end
+
+    def attributes(data)
+      attrs = { leaks: leaks(data["leaks"]), meta: data["meta"] || {} }
+      attrs[:results] = keys(data["results"]) { |hash| Kimera::MutantResult.from_h(hash) }
+      attrs[:fingerprints] = keys(data["fingerprints"]) { |fingerprint| fingerprint }
+      attrs
+    end
+
+    def leaks(raw)
+      Array(raw).map { |hash| Kimera::LeakReport.new(mutant_id: hash["mutant_id"], detail: hash["detail"]) }
+    end
+
+    def keys(hash)
+      Hash(hash).to_h { |id, value| [Integer(id, 10), yield(value)] }
+    end
+
+    def fingerprint(registry, id)
+      pair = registry.point(id)
+      return unless pair
+      mutant, point = pair
+      [point.file, point.location.start_line, point.original_source, mutant.label].join(" ")
+    end
+  end
+
+  def prune!(registry)
+    @results.reject! { |id, _| stale?(id, registry) }
+    @leaks.select! { |leak| @results.key?(leak.mutant_id) }
+    self
+  end
+
+  def done?(id)
+    @results.key?(id)
+  end
+
+  def report(evaluated, waived, registry)
+    results = evaluated.filter_map { |id| @results[id] }
+    results += waived.map { |id| Kimera::MutantResult.waived(id, registry.index[id]&.file) }
+    Kimera::RunReport.new(results: results, leaks: @leaks, registry: registry)
+  end
+
+  def merge!(report)
+    report.results.each { |r| @results[r.mutant_id] = r }
+    @leaks.concat(report.leaks)
+    self
+  end
+
+  def save(path, registry: nil, meta: {})
+    @meta = @meta.merge(meta)
+    @fingerprints = fingerprints(registry) if registry
+    File.write(path, JSON.pretty_generate(payload))
+    path
+  end
+
+  private
+
+  def stale?(id, registry)
+    stored = @fingerprints[id]
+    !stored || stored != self.class.fingerprint(registry, id)
+  end
+
+  def payload
+    base.merge("fingerprints" => @fingerprints.transform_keys(&:to_s), "leaks" => @leaks.map(&:to_h))
+  end
+
+  def base
+    { "version" => VERSION, "meta" => @meta, "results" => @results.transform_keys(&:to_s).transform_values(&:to_h) }
+  end
+
+  def fingerprints(registry)
+    @results.keys.each_with_object({}) do |id, hash|
+      fingerprint = self.class.fingerprint(registry, id)
+      hash[id] = fingerprint if fingerprint
+    end
+  end
+end

data/lib/kimera/memoization.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "support/syntax"
+require_relative "support/syntax_types"
+
+module Kimera
+  module Memoization
+    OR_WRITE_NODES = [
+      SyntaxTypes::InstanceVariableOrWriteNode,
+      SyntaxTypes::ClassVariableOrWriteNode,
+      SyntaxTypes::GlobalVariableOrWriteNode
+    ].freeze
+
+    CONST_WRITE_NODES = [SyntaxTypes::ConstantWriteNode, SyntaxTypes::ConstantPathWriteNode].freeze
+
+    SELF_OR_WRITE = {
+      SyntaxTypes::InstanceVariableWriteNode => SyntaxTypes::InstanceVariableReadNode,
+      SyntaxTypes::ClassVariableWriteNode => SyntaxTypes::ClassVariableReadNode,
+      SyntaxTypes::GlobalVariableWriteNode => SyntaxTypes::GlobalVariableReadNode
+    }.freeze
+
+    Range =
+      Struct.new(:start_offset, :end_offset, :reason, :holes) do
+        def contains?(start, finish)
+          return false unless start >= start_offset && finish <= end_offset
+          Array(holes).none? { |first, last| start >= first && finish <= last }
+        end
+      end
+
+    module_function
+
+    def ranges(source)
+      result = Kimera::Syntax.parse(source)
+      return [] if result.failure?
+      ranges = []
+      visit(result.value, ranges)
+      ranges
+    end
+
+    def visit(node, ranges)
+      return unless node.is_a?(SyntaxTypes::Node)
+      taint = taint(node)
+      ranges << taint if taint
+      node.compact_child_nodes.each { |child| visit(child, ranges) }
+    end
+
+    def taint(node)
+      case node
+      when *OR_WRITE_NODES then value(node, "memoized via ||=")
+      when *CONST_WRITE_NODES then value(node, "constant assignment (computed once)")
+      else cached(node)
+      end
+    end
+
+    def value(node, reason)
+      expression = node.value
+      range(expression, reason) if expression
+    end
+
+    def cached(node)
+      reader = SELF_OR_WRITE[node.class]
+      return unless reader
+      memoized(node, reader)
+    end
+
+    def memoized(node, reader)
+      value = node.value
+      return unless value.is_a?(SyntaxTypes::OrNode)
+      left = value.left
+      return unless left.is_a?(reader) && same?(node, left)
+      range(value, "memoized via `x = x || ...`")
+    end
+
+    def same?(write, read)
+      write.name == read.name
+    end
+
+    def range(node, reason)
+      start, finish = span(node)
+      Range.new(start, finish, reason, holes(node))
+    end
+
+    HOLE_NODES = [SyntaxTypes::DefNode, SyntaxTypes::LambdaNode].freeze
+
+    def holes(node, holes = [])
+      return holes unless node.is_a?(SyntaxTypes::Node)
+      return body(node, holes) if HOLE_NODES.any? { |kind| node.is_a?(kind) }
+      node.compact_child_nodes.each { |child| holes(child, holes) }
+      holes
+    end
+
+    def body(node, holes)
+      value = node.body
+      holes << span(value) if value
+      holes
+    end
+
+    def span(node)
+      location = node.location
+      start = location.start_offset
+      [start, start + location.length]
+    end
+  end
+end

data/lib/kimera/operators/argument_drop.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "base"
+
+class Kimera::Operators::ArgumentDrop < Kimera::Operators::Base
+  SKIP_KINDS = [SplatNode, KeywordHashNode, BlockArgumentNode, ForwardingArgumentsNode].freeze
+
+  class << self
+    def key = "argument_drop"
+  end
+
+  def variants(node, **)
+    return unless identifier?(node)
+    args = arguments(node)
+    return if args.any? { |a| SKIP_KINDS.any? { |k| a.is_a?(k) } }
+    drops(args, "drop_argument", label: "drop arg")
+  end
+end