kimera 0.1.0

data/lib/kimera/report/text.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require_relative "../rewrite/directive"
+require_relative "coloring"
+require_relative "screen"
+require_relative "sections"
+require_relative "actions"
+
+module Kimera
+  module Report
+  end
+end
+
+class Kimera::Report::Text
+  include Kimera::Report::Coloring
+  include Kimera::Report::Sections
+
+  MAX_TESTS_SHOWN = 5
+
+  def initialize(registry, io: $stdout, color: nil)
+    @registry = registry
+    @io = io
+    @color = color
+  end
+
+  COVERAGE_SECTIONS = { hint: :hint, list: :missing }.freeze
+
+  def report(report, scope: nil, coverage: :hint, path: nil)
+    header(report, scope)
+    survivors(report)
+    __send__(COVERAGE_SECTIONS.fetch(coverage), report, path)
+    leaks(report.leaks)
+    Kimera::Report::Actions.new(io: @io).show(report, path: path)
+  end
+
+  private
+
+  def header(report, scope)
+    @io.puts(scope) if scope
+    @io.puts(summary(report))
+  end
+
+  def survivors(report)
+    section("Surviving mutants", report.survived) { |result| survivor(result) }
+    unjudged(report)
+  end
+
+  def summary(report)
+    bold(report.summary)
+  end
+
+  def section(title, results, &)
+    heading(title, results.sort_by(&:mutant_id)).each(&)
+  end
+
+  def heading(title, listed)
+    return listed if listed.empty?
+    @io.puts
+    @io.puts(bold("#{title} (#{listed.size}):"))
+    listed
+  end
+
+  def survivor(result)
+    resolved(result) { |id, mutant, point| display(id, mutant, point, result) }
+  end
+
+  def display(id, mutant, point, result)
+    @io.puts
+    spotted("survived", id, mutant, point)
+    diff(point, mutant)
+    covering(result)
+  end
+
+  def resolved(result)
+    id = result.mutant_id
+    pair = @registry.point(id)
+    yield(id, *pair) if pair
+  end
+
+  def diff(point, mutant)
+    original = point.original_source
+    variant = Kimera::Rewrite::Directive.render(original, mutant.directive)
+    source(red("-"), original)
+    source(green("+"), variant) if variant
+  end
+
+  def source(sign, text)
+    first, *rest = text.split("\n")
+    @io.puts("    #{sign} #{first}")
+    rest.each { |line| @io.puts("      #{line}") }
+  end
+
+  def covering(result)
+    tests = Array(result.covering_tests)
+    return if tests.empty?
+    @io.puts("    covered by #{tests.size} test(s): #{names(tests)}")
+  end
+
+  def names(tests)
+    shown = tests.first(MAX_TESTS_SHOWN)
+    more = tests.size - shown.size
+    "#{shown.join(", ")}#{" (+#{more} more)" if more.positive?}"
+  end
+end

data/lib/kimera/results/result.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Status
+    KILLING = %i[killed timeout error].freeze
+
+    UNJUDGED = %i[no_coverage ignored isolated_only harness_error].freeze
+
+    REPORTED = ([:survived] + (KILLING - [:killed]) + %i[no_coverage harness_error ignored isolated_only]).freeze
+
+    SELF_SUSPECT = ((KILLING - [:killed]) + [:survived]).freeze
+  end
+
+  MutantResult =
+    Struct.new(
+      :mutant_id, :status, :file, :duration, :failing_tests, :covering_tests,
+      :detail,
+      keyword_init: true
+    ) do
+      def duration
+        self[:duration] || 0.0
+      end
+
+      def killed?
+        Status::KILLING.include?(status)
+      end
+
+      def isolated(detail)
+        self.class.new(mutant_id: mutant_id, status: :isolated_only, file: file, duration: duration, detail: detail)
+      end
+
+      def covered?
+        !Status::UNJUDGED.include?(status)
+      end
+
+      def message
+        { t: "result", id: mutant_id, status: status.to_s }
+          .merge(ms: duration, fails: failing_tests, cover: covering_tests)
+      end
+
+      def to_h
+        identity.merge(outcome)
+      end
+
+      def identity
+        { "mutant_id" => mutant_id, "status" => status.to_s, "file" => file }
+      end
+
+      def outcome
+        { "duration" => duration, "failing_tests" => failing_tests }
+          .merge("covering_tests" => covering_tests, "detail" => detail)
+      end
+      class << self
+        def waived(id, file)
+          new(mutant_id: id, status: :ignored, file: file, detail: "marked equivalent (ignored)")
+        end
+
+        def from_h(hash)
+          new(**identity(hash), **outcome(hash))
+        end
+
+        def identity(hash)
+          { mutant_id: hash["mutant_id"], status: hash["status"].to_sym, file: hash["file"] }
+        end
+
+        def outcome(hash)
+          { duration: hash["duration"], failing_tests: hash["failing_tests"] }
+            .merge(covering_tests: hash["covering_tests"], detail: hash["detail"])
+        end
+      end
+    end
+end

data/lib/kimera/results/run_report.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative "../rewrite/directive"
+require_relative "result"
+
+module Kimera
+  LeakReport = Struct.new(:mutant_id, :detail, keyword_init: true)
+end
+
+class Kimera::RunReport
+  attr_reader :results, :leaks, :registry
+
+  CONDITIONAL = %i[harness_error ignored isolated_only leaks].freeze
+  LABELS = { total: "mutants", harness_error: "unjudged" }.freeze
+  SCHEMA_VERSION = 1
+
+  def initialize(results:, leaks: [], registry: nil)
+    @results = results
+    @leaks = leaks
+    @registry = registry
+  end
+
+  def statuses(status)
+    grouped.fetch(status, [])
+  end
+
+  def merge(other)
+    Kimera::RunReport.new(results: @results + other.results, leaks: @leaks, registry: @registry)
+  end
+
+  def killed
+    @results.select(&:killed?)
+  end
+
+  def survived
+    statuses(:survived)
+  end
+
+  def uncovered
+    statuses(:no_coverage)
+  end
+
+  def errors
+    statuses(:harness_error)
+  end
+
+  def covered
+    @results.select(&:covered?)
+  end
+
+  def score
+    total = covered.size
+    return 1.0 if total.zero?
+    Float(killed.size) / total
+  end
+
+  def counts
+    { total: @results.size, killed: killed.size, leaks: @leaks.size, **reported }
+  end
+
+  def reported
+    Kimera::Status::REPORTED.to_h { |status| [status, statuses(status).size] }
+  end
+
+  def summary
+    tallies = counts
+    tallies.keys.filter_map { |key| labeled(key) }.insert(tallies.size - CONDITIONAL.size, scoreline).join(" ")
+  end
+
+  def labeled(key)
+    count = counts[key]
+    return if CONDITIONAL.include?(key) && count.zero?
+    "#{LABELS.fetch(key, key)}=#{count}"
+  end
+
+  def document(metadata) = metadata ? to_h.merge("run" => metadata) : to_h
+
+  def to_h
+    { "schema_version" => SCHEMA_VERSION, "counts" => counts, "mutation_score" => score }
+      .merge("results" => @results.map { |result| detailed(result) }, "leaks" => @leaks.map(&:to_h))
+  end
+
+  private
+
+  def scoreline
+    return "score=n/a (0 of #{@results.size} mutants evaluated)" if covered.empty? && !@results.empty?
+    text = format("score=%.1f%%", score * 100)
+    count = uncovered.size
+    count.positive? ? "#{text} (#{count} uncovered not scored)" : text
+  end
+
+  def grouped
+    @_grouped ||= @results.group_by(&:status)
+  end
+
+  def detailed(result)
+    base = result.to_h
+    pair = @registry&.point(result.mutant_id)
+    pair ? base.merge(rewritten(pair)) : base
+  end
+
+  def rewritten(pair)
+    mutant, point = pair
+    place(point, mutant).merge(rendered(point.original_source, mutant))
+  end
+
+  def rendered(original, mutant)
+    { "original" => original, "mutated" => Kimera::Rewrite::Directive.render(original, mutant.directive) }
+  end
+
+  def place(point, mutant)
+    { "line" => point.location.start_line, "operator" => point.operator, "label" => mutant.label }
+  end
+end

data/lib/kimera/rewrite/ast_walk.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Rewrite
+    module AstWalk
+      module_function
+
+      def rebuild(node, &)
+        return node unless node.is_a?(Parser::AST::Node)
+        yield(node.updated(nil, node.children.map { |child| rebuild(child, &) }), node)
+      end
+
+      def visit(node, &)
+        return unless node.is_a?(Parser::AST::Node)
+        yield(node)
+        node.children.each { |child| visit(child, &) }
+      end
+    end
+  end
+end

data/lib/kimera/rewrite/directive.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../support/operator_protocol"
+require_relative "../support/unparse"
+
+require_relative "directive_handlers"
+require_relative "numbered_params"
+
+module Kimera
+  module Rewrite
+    TYPE = OperatorProtocol::TYPE
+    INDEX = OperatorProtocol::INDEX
+    STATEMENT_DELETION = OperatorProtocol::STATEMENT_DELETION
+
+    module Directive
+      module_function
+
+      def render(source, directive)
+        shortcut(directive) || attempt(source, directive)
+      end
+
+      def shortcut(directive)
+        type = directive[TYPE]
+        return "(statement deleted)" if type == STATEMENT_DELETION
+        return String(directive["value"]).inspect if type == "string_literal"
+        "#{directive["name"]} (default removed)" if type == "required_argument"
+      end
+
+      def attempt(source, directive)
+        Kimera::Unparse.unparse(apply(NumberedParams.normalize(Kimera::Unparse.parse(source)), directive))
+      rescue StandardError
+        nil
+      end
+
+      def table(*entries) = entries.each_slice(2).to_h.freeze
+
+      VALUE_HANDLERS = table(
+        "comparison", :swap, "op_swap", :swap, "selector_swap", :select,
+        "op_asgn_swap", :assign, "csend_to_send", :send, "index_to_fetch", :fetch,
+        "boolean_literal", :literal, "integer_literal", :integer, "float_literal", :float,
+        "string_literal", :string, "symbol_literal", :symbol, "regexp_literal", :regexp,
+        "boolean_connective", :retype, "range_flip", :retype, "condition", :retest
+      )
+      STRUCTURAL_HANDLERS = table(
+        STATEMENT_DELETION, :clear, "return_nil", :nothing, "empty_collection", :empty,
+        "unwrap_receiver", :receiver, "drop_receiver_link", :unlink, "drop_element", :remove,
+        "drop_argument", :drop, "unwrap_argument", :argument, "required_argument", :default,
+        "kwarg_element_drop", :keyword, "kwarg_pair_drop", :option
+      )
+      HANDLERS = VALUE_HANDLERS.merge(STRUCTURAL_HANDLERS).freeze
+
+      def apply(node, directive, unguard: DirectiveHandlers::IDENTITY)
+        DirectiveHandlers::Operation.new(node, directive, unguard).public_send(handler(directive))
+      end
+
+      def handler(directive)
+        HANDLERS.fetch(directive[TYPE]) { raise(ArgumentError, "unknown directive #{directive.inspect}") }
+      end
+    end
+  end
+end

data/lib/kimera/rewrite/directive_extra_handlers.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Rewrite
+    module DirectiveExtraHandlers
+      Operation =
+        Data.define(:node, :directive, :unguard) do
+          def trim(pair)
+            key, value = pair.children
+            elements = value.children.dup
+            elements.delete_at(Integer(directive[INDEX]))
+            pair.updated(nil, [key, value.updated(nil, elements)])
+          end
+
+          def fetch
+            node.type == :index ? index(node) : call(node)
+          end
+
+          def index(node)
+            receiver, *args = node.children
+            node.updated(:send, [receiver, :fetch, *args])
+          end
+
+          def call(node)
+            receiver, _selector, *args = node.children
+            node.updated(nil, [receiver, :fetch, *args])
+          end
+
+          def argument
+            node.children[2]
+          end
+
+          def symbol
+            node.updated(:sym, [directive["value"].to_sym])
+          end
+
+          def default
+            node.updated(node.type == :kwoptarg ? :kwarg : :arg, [node.children[0]])
+          end
+
+          def regexp
+            source = directive["source"].to_s
+            ast(:regexp, *(source.empty? ? [] : [ast(:str, source)]), ast(:regopt))
+          end
+
+          def ast(type, *children)
+            Parser::AST::Node.new(type, children)
+          end
+        end
+    end
+  end
+end

data/lib/kimera/rewrite/directive_handlers.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "directive_extra_handlers"
+require_relative "directive_kwarg_handlers"
+
+module Kimera
+  module Rewrite
+    module DirectiveHandlers
+      IDENTITY = ->(node) { node }
+
+      Operation =
+        Data.define(:node, :directive, :unguard) do
+          def target = directive["to"]&.to_sym
+
+          def swap
+            receiver, _selector, *args = node.children
+            node.updated(:send, [receiver, target, *args])
+          end
+
+          def retype
+            node.updated(target, node.children)
+          end
+
+          def literal
+            node.updated(target, [])
+          end
+
+          def clear
+            node.updated(:nil, [])
+          end
+
+          def receiver
+            node.children[0]
+          end
+
+          def unlink
+            DirectiveKwargHandlers.block(node) do |call|
+              receiver, *rest = call.children
+              call.updated(nil, [unguard.call(receiver).children[0], *rest])
+            end
+          end
+
+          def send
+            DirectiveKwargHandlers.block(node) { |call| call.updated(:send, call.children) }
+          end
+
+          def retest
+            node.updated(nil, [ast(target), *node.children[1..]])
+          end
+
+          def integer
+            node.updated(:int, [Integer(directive["value"])])
+          end
+
+          def float
+            node.updated(:float, [Float(directive["value"])])
+          end
+
+          def string
+            node.updated(:str, [String(directive["value"])])
+          end
+
+          def empty
+            node.updated(nil, [])
+          end
+
+          def drop
+            DirectiveKwargHandlers.block(node) do |call|
+              receiver, selector, *args = call.children
+              args.delete_at(Integer(directive[INDEX]))
+              call.updated(nil, [receiver, selector, *args])
+            end
+          end
+
+          def nothing
+            node.updated(nil, [ast(:nil)])
+          end
+
+          def select
+            DirectiveKwargHandlers.block(node) do |call|
+              DirectiveKwargHandlers.select(call, target)
+            end
+          end
+
+          def remove
+            elements = node.children.dup
+            elements.delete_at(Integer(directive[INDEX]))
+            node.updated(nil, elements)
+          end
+
+          def assign
+            target, _operator, value = node.children
+            node.updated(nil, [target, self.target, value])
+          end
+
+          def keyword
+            kwargs { |pair| extra.trim(pair) }
+          end
+
+          def option
+            kwargs { |_pair| next }
+          end
+
+          def kwargs(&)
+            DirectiveKwargHandlers.block(node) { |call| DirectiveKwargHandlers.rewrite(call, directive["key"], &) }
+          end
+
+          def fetch
+            extra.fetch
+          end
+
+          def argument
+            extra.argument
+          end
+
+          def symbol
+            extra.symbol
+          end
+
+          def default
+            extra.default
+          end
+
+          def regexp
+            extra.regexp
+          end
+
+          def extra
+            DirectiveExtraHandlers::Operation.new(node, directive, unguard)
+          end
+
+          def ast(type, *children)
+            Parser::AST::Node.new(type, children)
+          end
+        end
+    end
+  end
+end

data/lib/kimera/rewrite/directive_kwarg_handlers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Rewrite
+    module DirectiveKwargHandlers
+      module_function
+
+      def select(call, to)
+        receiver, _selector, *args = call.children
+        call.updated(nil, [receiver, to, *args])
+      end
+
+      def block(node)
+        return yield(node) unless %i[block numblock].include?(node.type)
+        call, *rest = node.children
+        node.updated(nil, [yield(call), *rest])
+      end
+
+      def rewrite(call, key, &)
+        receiver, selector, *args = call.children
+        position = index(args)
+        return call unless position
+        apply(args, position, key, &)
+        call.updated(nil, [receiver, selector, *args])
+      end
+
+      def index(args)
+        args.rindex { |a| a.is_a?(Parser::AST::Node) && %i[kwargs hash].include?(a.type) }
+      end
+
+      def apply(args, position, key)
+        hash = args[position]
+        pairs = hash.children.filter_map { |pair| matches?(pair, key) ? yield(pair) : pair }
+        pairs.empty? ? args.delete_at(position) : args[position] = hash.updated(nil, pairs)
+      end
+
+      def matches?(pair, key)
+        symbol = pair.children.first
+        pair.type == :pair && symbol.type == :sym &&
+          symbol.children.first.to_s == key
+      end
+    end
+  end
+end

data/lib/kimera/rewrite/numbered_params.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "ast_walk"
+
+module Kimera
+  module Rewrite
+    module NumberedParams
+      module_function
+
+      PREFIX = "__kimera_"
+
+      def normalize(node)
+        AstWalk.rebuild(node) { |rebuilt, _original| dispatch(rebuilt) }
+      end
+
+      def dispatch(node)
+        case node.type
+        when :numblock then numbered(node)
+        when :itblock then implicit(node)
+        else node
+        end
+      end
+
+      def numbered(node)
+        call, count, body = node.children
+        renames = (1..count).to_h { |n| [:"_#{n}", :"#{PREFIX}#{n}"] }
+        node.updated(:block, [call, arguments(renames.values), rename(body, renames)])
+      end
+
+      def implicit(node)
+        call, _name, body = node.children
+        name = :"#{PREFIX}it"
+        node.updated(:block, [call, arguments([name]), rename(body, { it: name })])
+      end
+
+      def arguments(names)
+        args = names.map { Parser::AST::Node.new(:arg, [it]) }
+        args = [Parser::AST::Node.new(:procarg0, args)] if args.one?
+        Parser::AST::Node.new(:args, args)
+      end
+
+      def rename(node, renames)
+        AstWalk.rebuild(node) do |rebuilt, _original|
+          name = rebuilt.type == :lvar ? rebuilt.children.first : nil
+          renames.key?(name) ? rebuilt.updated(nil, [renames.fetch(name)]) : rebuilt
+        end
+      end
+    end
+  end
+end

data/lib/kimera/runtime.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Runtime
+    SOURCE_PATH = File.expand_path(__FILE__)
+
+    class << self
+      attr_reader :active
+
+      def active=(id)
+        @active = id && Integer(id)
+      end
+
+      def active?(id)
+        @ledgers&.each { |ledger| ledger.push(id) }
+        @active == id
+      end
+
+      def start!
+        ledger = []
+        (@ledgers ||= []).push(ledger)
+        ledger
+      end
+
+      def drain!(ledger)
+        touched = ledger.uniq
+        clear!(ledger)
+        touched
+      end
+
+      def clear!(ledger)
+        ledger.clear
+      end
+
+      def stop!(ledger)
+        open = @ledgers
+        return unless open
+        open.delete_if { |l| l.equal?(ledger) }
+        @ledgers = nil if open.empty?
+      end
+
+      def reset!
+        @active = nil
+      end
+    end
+
+    reset!
+  end
+end
+
+MutantRuntime = Kimera::Runtime unless defined?(MutantRuntime)