kimera 0.1.0

data/lib/kimera/scope/config.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "yaml"
+require_relative "../error"
+
+module Kimera
+  module Config
+    DEFAULT_PATH = ".kimera.yml"
+
+    SCALAR_KEYS = %w[framework source_root soft_timeout hard_timeout leak_every
+      jobs max_survivors max_ignored max_errors coverage isolate_db
+      fail_on_no_coverage progress color quiet verbose log format report baseline].freeze
+    LIST_KEYS = %w[paths tests operators exclude exclude_tests isolate_when_covered_by require].freeze
+
+    SCOPE_KEYS = %i[paths operators exclude].freeze
+
+    module_function
+
+    def parse(argv)
+      index = argv.index("--config")
+      return root unless index
+      file = argv[index + 1]
+      raise(UsageError, "no such config file: #{file}") unless file && File.exist?(file)
+      load(file)
+    end
+
+    def prefer(from_cli, from_config, default)
+      cli = Array(from_cli)
+      chosen = cli.empty? ? Array(from_config) : cli
+      chosen.empty? ? default.dup : chosen
+    end
+
+    def document(**options) = options.transform_keys(&:to_s)
+
+    def scope(defaults, argv)
+      defaults.merge(parse(argv).slice(*SCOPE_KEYS))
+    end
+
+    def load(file)
+      return {} unless File.exist?(file)
+      options = normalize(YAML.safe_load_file(file) || {})
+      baseline = options[:baseline]
+      baseline ? options.merge(ignore: Array(options[:ignore]) + ignores_from(baseline, file)) : options
+    end
+
+    def root(root: ".")
+      load(File.join(root, DEFAULT_PATH))
+    end
+
+    def normalize(data)
+      options = scalars(data)
+      options[:ignore] = Array(data["ignore"]).map { |r| validate(symbolize(r)) } if data.key?("ignore")
+      options
+    end
+
+    def ignores_from(baseline, file)
+      anchored = File.expand_path(baseline, File.dirname(file))
+      raise(UsageError, "no such baseline file: #{anchored}") unless File.file?(anchored)
+      Array((YAML.safe_load_file(anchored) || {})["ignore"]).map { |rule| validate(symbolize(rule)) }
+    end
+
+    def scalars(data)
+      (SCALAR_KEYS + LIST_KEYS).each_with_object({}) do |key, options|
+        next unless data.key?(key)
+        value = data[key]
+        options[key.to_sym] = LIST_KEYS.include?(key) ? Array(value) : value
+      end
+    end
+
+    def symbolize(rule)
+      rule.transform_keys(&:to_sym)
+    end
+
+    def validate(rule)
+      file = rule[:file]
+      raise(UsageError, "ignore entry missing file: #{rule.inspect}") unless file
+      reason(rule, file)
+      rule
+    end
+
+    def reason(rule, file)
+      return unless reasonless?(rule)
+      raise(UsageError, "ignore entry for #{file} needs a reason: (why is this mutant equivalent?)")
+    end
+
+    def reasonless?(rule)
+      rule[:reason].to_s.strip.empty?
+    end
+  end
+end

data/lib/kimera/scope/file_set.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "config"
+
+module Kimera
+  module FileSet
+    DEFAULT_GLOBS = ["app/**/*.rb", "lib/**/*.rb"].freeze
+
+    module_function
+
+    def globs(from_cli, options)
+      Config.prefer(from_cli, options[:paths], DEFAULT_GLOBS)
+    end
+
+    def scoped(from_cli, options)
+      expand(globs(from_cli, options), exclude: options[:exclude])
+    end
+
+    def expand(patterns, include: [], exclude: [])
+      exclude((Array(patterns) + Array(include)).flat_map { |pattern| resolve(pattern) }.uniq, exclude).sort
+    end
+
+    def relative(path, root)
+      absolute = File.expand_path(path)
+      absolute.start_with?("#{root}/") ? absolute[(root.length + 1)..] : path
+    end
+
+    def resolve(pattern)
+      return Dir.glob(File.join(pattern, "**", "*.rb")) if File.directory?(pattern)
+      Dir.glob(pattern).select { |f| File.file?(f) && f.end_with?(".rb") }
+    end
+
+    def unused(patterns, exclude)
+      files = expand(patterns)
+      Array(exclude).reject do |pattern|
+        resolved = resolve(pattern).to_set
+        files.any? { |file| resolved.include?(file) || matches?(file, [pattern]) }
+      end
+    end
+
+    def exclude(files, exclude)
+      patterns = Array(exclude)
+      excluded = patterns.flat_map { |p| resolve(p) }.to_set
+      files.reject { |file| excluded.include?(file) || matches?(file, patterns) }
+    end
+
+    def matches?(file, patterns)
+      Array(patterns).any? { |p| File.fnmatch?(p, file, File::FNM_PATHNAME) }
+    end
+  end
+end

data/lib/kimera/scope/ignore_list.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Kimera
+  module IgnoreList
+    Match =
+      Data.define(:point, :mutant) do
+        def rule?(rule)
+          glob = rule[:file]
+          glob && File.fnmatch?(glob, point.file, File::FNM_PATHNAME) && anchors?(rule)
+        end
+        private
+        def line?(value) = point.location.range.include?(Integer(value))
+        def column?(value) = point.location.start_column == Integer(value)
+        def label?(value) = value == mutant.label
+        def method?(value) = value.to_s == point.method_name
+        def original?(value) = squeeze(value) == squeeze(point.original_source)
+        def squeeze(source) = source.to_s.split.join(" ")
+
+        def anchors?(rule)
+          ANCHORS.all? do |field, matcher|
+            value = rule[field]
+            !value || __send__(matcher, value)
+          end
+        end
+      end
+
+    module_function
+
+    def ids(registry, rules)
+      rules = Array(rules)
+      registry.each.filter_map { |mutant, point| mutant.id if rules.any? { |rule| match?(rule, point, mutant) } }
+    end
+
+    def stale(registry, rules)
+      Array(rules).select do |rule|
+        relevant?(rule, registry) && !any?(rule, registry)
+      end
+    end
+
+    def relevant?(rule, registry)
+      glob = rule[:file]
+      glob && registry.files.any? { |file| File.fnmatch?(glob, file, File::FNM_PATHNAME) }
+    end
+
+    def any?(rule, registry)
+      registry.each.any? { |mutant, point| match?(rule, point, mutant) }
+    end
+
+    ANCHORS = { line: :line?, column: :column?, label: :label? }.merge(method: :method?, original: :original?).freeze
+
+    def match?(rule, point, mutant)
+      Match.new(point, mutant).rule?(rule)
+    end
+  end
+end

data/lib/kimera/self_protection.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "runtime"
+
+module Kimera
+  module SelfProtection
+    module_function
+
+    OUT_OF_PROCESS_ENTRYPOINTS = %w[
+      execution/isolated_child.rb
+      execution/isolated_child_minitest.rb
+    ].map { |path| File.expand_path(path, __dir__) }.freeze
+
+    def paths
+      [Runtime::SOURCE_PATH, *OUT_OF_PROCESS_ENTRYPOINTS]
+    end
+
+    HARNESS_CRITICAL_SUFFIXES = %w[
+      kimera/frameworks/adapter.rb
+      kimera/frameworks/rspec_adapter.rb
+      kimera/frameworks/rspec_group_index.rb
+      kimera/frameworks/minitest_adapter.rb
+      kimera/execution/shift.rb
+      kimera/execution/shift/attempt.rb
+      kimera/execution/shift/coverage_channel.rb
+      kimera/execution/shift/killer_memory.rb
+      kimera/execution/shift/leak_guard.rb
+      kimera/execution/harness.rb
+      kimera/execution/baseline_pass.rb
+      kimera/execution/reload.rb
+      kimera/execution/parallel_test_databases.rb
+      kimera/execution/verdicts.rb
+      kimera/execution/worker_pool.rb
+      kimera/execution/worker_pool/fleet.rb
+      kimera/execution/child_process.rb
+      kimera/execution/rig.rb
+      kimera/registry/builder.rb
+    ].freeze
+
+    def critical?(path)
+      text = path.to_s
+      HARNESS_CRITICAL_SUFFIXES.any? { |suffix| text.end_with?(suffix) }
+    end
+
+    def protected?(path)
+      target = canonical(path)
+      paths.any? { |own| canonical(own) == target }
+    end
+
+    def canonical(path)
+      File.realpath(path)
+    rescue SystemCallError
+      File.expand_path(path)
+    end
+  end
+end

data/lib/kimera/support/duration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Kimera
+  Duration =
+    Data.define(:seconds) do
+      def clock = format("%d:%02d", seconds / 60, seconds % 60)
+
+      def brief
+        return format("%.1fs", seconds) if seconds >= 1
+        format(seconds >= 0.01 ? "%.0fms" : "%.1fms", seconds * 1000)
+      end
+    end
+end

data/lib/kimera/support/errors.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Kimera
+end
+
+class Kimera::Error < StandardError; end
+
+class Kimera::UsageError < Kimera::Error; end

data/lib/kimera/support/operator_protocol.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Kimera
+  module OperatorProtocol
+    TYPE = "type"
+    INDEX = "index"
+    STATEMENT_DELETION = "statement_deletion"
+    Variant = Struct.new(:label, :directive, keyword_init: true)
+  end
+end

data/lib/kimera/support/syntax.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Kimera
+  module Syntax
+    %i[
+      AndNode ArrayNode AssocNode AssocSplatNode BlockArgumentNode BlockNode
+      CallNode ClassVariableOrWriteNode ClassVariableReadNode ClassVariableWriteNode
+      CallOperatorWriteNode ClassVariableOperatorWriteNode ConstantOperatorWriteNode
+      ConstantPathOperatorWriteNode GlobalVariableOperatorWriteNode
+      InstanceVariableOperatorWriteNode LocalVariableOperatorWriteNode
+      ConstantPathWriteNode ConstantWriteNode DefNode DefinedNode FalseNode FloatNode
+      ForwardingArgumentsNode GlobalVariableOrWriteNode GlobalVariableReadNode
+      GlobalVariableWriteNode HashNode IfNode InNode InstanceVariableOrWriteNode
+      InstanceVariableReadNode InstanceVariableWriteNode IntegerNode KeywordHashNode
+      LambdaNode MatchPredicateNode MatchRequiredNode NilNode Node
+      OptionalKeywordParameterNode OptionalParameterNode OrNode ParenthesesNode
+      RangeNode RegularExpressionNode ReturnNode SplatNode StatementsNode StringNode
+      SymbolNode TrueNode UnlessNode
+    ].each { |name| const_set(name, Prism.const_get(name)) }
+
+    OPERATOR_WRITES = [
+      CallOperatorWriteNode, ClassVariableOperatorWriteNode, ConstantOperatorWriteNode,
+      ConstantPathOperatorWriteNode, GlobalVariableOperatorWriteNode,
+      InstanceVariableOperatorWriteNode, LocalVariableOperatorWriteNode
+    ].freeze
+
+    View =
+      Data.define(:node) do
+        def collection(splats)
+          [node.elements, splats[node.class]] if splats.key?(node.class)
+        end
+
+        def unwrap(names)
+          return unless node.is_a?(CallNode) && node.receiver && names.include?(node.name)
+          node.name unless node.arguments || node.block
+        end
+
+        def operator
+          node.binary_operator if OPERATOR_WRITES.any? { |kind| node.is_a?(kind) }
+        end
+
+        def diagnostic?(names, loggers)
+          receiver = node.receiver
+          return names.include?(node.name) unless receiver
+          logger?(receiver, loggers)
+        end
+        private
+        def logger?(receiver, loggers)
+          while receiver
+            return true if named?(receiver, loggers)
+            receiver = receiver.is_a?(CallNode) ? receiver.receiver : nil
+          end
+          false
+        end
+
+        def named?(receiver, names)
+          receiver.class.method_defined?(:name) && names.include?(receiver.name)
+        end
+      end
+
+    module_function
+
+    def parse(source) = Prism.parse(source)
+    def view(node) = View.new(node)
+  end
+end

data/lib/kimera/support/syntax_types.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "syntax"
+
+module Kimera
+  module SyntaxTypes
+    Kimera::Syntax.constants.grep(/Node\z/).each do |name|
+      const_set(name, Kimera::Syntax.const_get(name))
+    end
+
+    Installer =
+      Data.define(:target) do
+        def call
+          SyntaxTypes.constants.grep(/Node\z/).each do |name|
+            target.const_set(name, SyntaxTypes.const_get(name)) unless target.constants.include?(name)
+          end
+        end
+      end
+  end
+end

data/lib/kimera/support/unparse.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "warnings"
+
+Kimera::Warnings.silence { require "unparser" }
+
+module Kimera
+  module Unparse
+    module_function
+
+    def parse(source) = Kimera::Warnings.silence { Unparser.parse(source) }
+
+    def unparse(node) = Kimera::Warnings.silence { Unparser.unparse(node) }
+  end
+end

data/lib/kimera/support/version.rb

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

data/lib/kimera/support/warnings.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Warnings
+    module_function
+
+    def silence
+      previous = $VERBOSE
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = previous
+    end
+  end
+end

data/lib/kimera/synthesis/file_weave.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../support/unparse"
+require_relative "overlay_splice"
+
+class Kimera::Overlay::FileWeave
+  include Kimera::OverlaySplice
+
+  def initialize(file, map, safe, unsafe)
+    @file = file
+    @map = map
+    @safe = safe
+    @unsafe = unsafe
+  end
+
+  def result
+    attempt(@safe) || fallback
+  end
+
+  private
+
+  def io = @_io ||= $stderr
+
+  def attempt(points)
+    render(Kimera::Guardrail.new(@map, points))
+  rescue StandardError
+    nil
+  end
+
+  def render(weaver)
+    Kimera::Overlay::Result.new(
+      file: @file, source: @map.restore(Kimera::Unparse.unparse(weaver.tree)), mutant_ids: weaver.applied,
+      skipped_unsafe: @unsafe.flat_map(&:ids)
+    )
+  end
+
+  def fallback
+    viable = bisect(@safe)
+    return recover if viable.empty?
+    finish(viable)
+  end
+
+  def finish(viable)
+    dropped = @safe - viable
+    notice(dropped)
+    result = attempt(viable)
+    result.skipped_unsafe.concat(dropped.flat_map(&:ids))
+    result
+  end
+
+  def notice(dropped)
+    io.puts(
+      "kimera: #{@file}: #{dropped.size} mutation point(s) at " \
+        "#{dropped.map { |p| "line #{p.location.start_line}" }.uniq.join(", ")} " \
+        "are unguardable (unparser round-trip); their mutants are reported no_coverage"
+    )
+  end
+
+  def recover
+    spliced = splice
+    return spliced if spliced
+    @map.restore(Kimera::Unparse.unparse(Kimera::Guardrail.new(@map, @safe).tree))
+  end
+
+  def bisect(points)
+    return points if attempt(points)
+    count = points.size
+    return [] if count <= 1
+    merge(points, count)
+  end
+
+  def merge(points, count)
+    half = count / 2
+    merged = bisect(points[0...half]) + bisect(points[half..])
+    merged.pop while merged.any? && !attempt(merged)
+    merged
+  end
+end

data/lib/kimera/synthesis/guard_weaver.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "../support/unparse"
+require_relative "../rewrite/ast_walk"
+require_relative "../rewrite/directive"
+require_relative "guardrail_dispatch"
+require_relative "guardrail_interpolation"
+require_relative "guardrail_value_objects"
+require_relative "source_map"
+
+class Kimera::Guardrail
+  include Kimera::GuardrailDispatch
+  include Kimera::GuardrailInterpolation
+  include Kimera::GuardrailValueObjects
+
+  attr_reader :applied
+
+  Patch =
+    Data.define(:map, :span, :directive) do
+      def apply(rebuilt, original)
+        expression = original.location&.expression
+        return rebuilt unless expression && map.span(expression) == span
+        Kimera::Rewrite::Directive.apply(rebuilt, directive)
+      end
+    end
+
+  def initialize(map, points)
+    @map = map
+    @points = points
+    @applied = []
+  end
+
+  def tree
+    transform(@map.ast)
+  end
+
+  def rewrite(node)
+    [Kimera::Unparse.unparse(transform(node)), applied]
+  end
+
+  def transform(node)
+    Kimera::Rewrite::AstWalk.rebuild(node) { |rebuilt, original| rebuild(rebuilt, original) }
+  end
+
+  def bake(location, directive)
+    prune(overlay([location.start_offset, location.finish], directive))
+  end
+
+  private
+
+  def rebuild(rebuilt, original)
+    rebuilt = flatten(rebuilt) if rebuilt.type == :dstr
+    rebuilt = dispatch(rebuilt, points(original))
+    reopen(rebuilt)
+  end
+
+  def overlay(target, directive)
+    patch = Patch.new(@map, target, directive)
+    Kimera::Rewrite::AstWalk.rebuild(@map.ast) do |rebuilt, original|
+      reopen(patch.apply(rebuilt, original))
+    end
+  end
+
+  def points(node)
+    expr = node.location&.expression
+    return [] unless expr
+    ranges.fetch(@map.span(expr), [])
+  end
+
+  def ranges
+    @_ranges ||= group(@points)
+  end
+
+  def ast(type, *children)
+    Parser::AST::Node.new(type, children)
+  end
+end

data/lib/kimera/synthesis/guardrail_dispatch.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Kimera
+  module GuardrailDispatch
+    private
+
+    def group(points)
+      points.group_by do |point|
+        location = point.location
+        [location.start_offset, location.finish]
+      end
+    end
+
+    def dispatch(original, points)
+      mutants = points.flat_map(&:mutants).reverse
+      return parameter(original, mutants) if %i[optarg kwoptarg].include?(original.type)
+      guarded = guard(mutants, original) { |mutant| variant(original, mutant) }
+      guarded.equal?(original) ? guarded : ast(:begin, guarded)
+    end
+
+    def branch(mutant, truthy, dispatch)
+      id = mutant.id
+      @applied << id
+      conditional(active(id), truthy, dispatch)
+    end
+
+    def variant(original, mutant)
+      Kimera::Rewrite::Directive.apply(original, mutant.directive, unguard: method(:unwrap))
+    end
+
+    def parameter(original, mutants)
+      name, default = original.children
+      original.updated(nil, [name, ast(:begin, guard(mutants, default) { missing(original, name) })])
+    end
+
+    def guard(mutants, seed) = mutants.reduce(seed) { |chain, mutant| branch(mutant, yield(mutant), chain) }
+
+    def missing(param, name)
+      ast(
+        :send, nil, :raise, ast(:const, nil, :ArgumentError),
+        ast(:str, "missing #{param.type == :kwoptarg ? "keyword" : "argument"}: #{name}")
+      )
+    end
+
+    def unwrap(node)
+      return node unless type?(node, :begin)
+      inner, extra = node.children
+      return node unless guarded?(inner, extra)
+      unwrap(inner.children[2])
+    end
+
+    def guarded?(inner, extra)
+      !extra && type?(inner, :if) && active?(inner.children[0])
+    end
+
+    def active?(node)
+      type?(node, :send) && node.children[1] == :active?
+    end
+
+    def active(id)
+      ast(:send, ast(:const, ast(:cbase), :MutantRuntime), :active?, ast(:int, id))
+    end
+
+    def conditional(condition, truthy, fallback)
+      ast(:if, condition, truthy, fallback)
+    end
+  end
+end