kimera 0.1.0

data/lib/kimera/registry/source_file.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../memoization"
+require_relative "mutation_point"
+require_relative "walking"
+
+class Kimera::RegistryScan::SourceFile
+  include Kimera::RegistryWalking
+
+  def initialize(source, file:, operators:, numbering:)
+    @source = source
+    @file = file
+    @operators = operators
+    @numbering = numbering
+  end
+
+  def points
+    parsed = Kimera::Syntax.parse(@source)
+    return [] if parsed.failure?
+    mined(parsed.value)
+  end
+
+  private
+
+  def tainted = @_tainted ||= Kimera::Memoization.ranges(@source)
+
+  def mined(root)
+    found = []
+    walk(root, origin) { |node, cursor| bank(found, node, cursor) }
+    found
+  end
+
+  def origin
+    Kimera::RegistryWalking::Cursor.new(position: nil, inside_def: nil, in_pattern: nil, def_body: nil, defname: nil)
+  end
+
+  def bank(found, node, cursor)
+    pairs = harvest(applicable(cursor), node, cursor.position)
+    return if pairs.empty?
+    found << assemble(node, pairs, cursor).taint!(tainted)
+  end
+
+  def applicable(cursor)
+    chosen = cursor.inside_def ? @operators : @operators.select(&:body?)
+    cursor.position ? chosen : chosen.reject(&:statement?)
+  end
+
+  def harvest(operators, node, position)
+    operators.flat_map { |operator| operator.pairs(node, position: position) }
+  end
+
+  def assemble(node, pairs, cursor)
+    point = Kimera::MutationPoint.new(**attrs(node, distinct(pairs), cursor.defname))
+    point.unsafe!(Kimera::MutationPoint::CLASS_BODY_REASON) unless cursor.inside_def
+    point
+  end
+
+  def distinct(pairs) = pairs.uniq { |(_key, variant)| variant.directive }
+
+  def attrs(node, pairs, name)
+    location = node.location
+    { point_id: @numbering.point, file: @file, operator: pairs.map(&:first).uniq.join("+") }
+      .merge(node_type: node.type.to_s, location: Kimera::Location.parse(location), original_source: location.slice)
+      .merge(method_name: name, mutants: mint(pairs))
+  end
+
+  def mint(pairs)
+    pairs.map { |(_key, variant)| Kimera::Mutant.of(@numbering.mutant, variant) }
+  end
+end

data/lib/kimera/registry/tally.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Kimera::RegistryScan::Tally
+  def initialize
+    @value = 0
+  end
+
+  def next
+    @value += 1
+  end
+end

data/lib/kimera/registry/walking.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Kimera::RegistryWalking
+  PATTERN_HOLDERS = [
+    Kimera::SyntaxTypes::InNode,
+    Kimera::SyntaxTypes::MatchRequiredNode,
+    Kimera::SyntaxTypes::MatchPredicateNode
+  ].freeze
+
+  Cursor = Data.define(:position, :inside_def, :in_pattern, :def_body, :defname)
+  Shape =
+    Data.define(:statements, :tail, :matchnode, :defbody, :insidedef) do
+      def advance(child, cursor)
+        cursor.with(
+          position: position(child), inside_def: insidedef,
+          in_pattern: cursor.in_pattern || child.equal?(matchnode), def_body: child.equal?(defbody)
+        )
+      end
+
+      def position(child)
+        return :tail if child.equal?(tail)
+        statements&.include?(child) || false
+      end
+    end
+
+  private
+
+  def walk(node, cursor, &)
+    return unless node.is_a?(Kimera::SyntaxTypes::Node)
+    cursor = cursor.with(defname: node.name.to_s) if node.is_a?(Kimera::SyntaxTypes::DefNode)
+    yield(node, cursor) unless cursor.in_pattern
+    shape = shape(node, cursor)
+    node.compact_child_nodes.each { |child| walk(child, shape.advance(child, cursor), &) }
+  end
+
+  def shape(node, cursor)
+    statements = node.is_a?(Kimera::SyntaxTypes::StatementsNode) ? node.body : nil
+    Shape.new(
+      statements: statements, tail: cursor.def_body ? statements&.last : nil, matchnode: pattern(node),
+      defbody: body(node), insidedef: cursor.inside_def || reexecuted?(node)
+    )
+  end
+
+  def pattern(node)
+    PATTERN_HOLDERS.any? { |k| node.is_a?(k) } ? node.pattern : nil
+  end
+
+  def body(node)
+    node.is_a?(Kimera::SyntaxTypes::DefNode) ? node.body : nil
+  end
+
+  def reexecuted?(node)
+    node.is_a?(Kimera::SyntaxTypes::DefNode) || node.is_a?(Kimera::SyntaxTypes::LambdaNode)
+  end
+end

data/lib/kimera/report/actions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Report
+  end
+end
+
+class Kimera::Report::Actions
+  def initialize(io: $stdout)
+    @io = io
+  end
+
+  def show(report, path: nil)
+    lines = [survivors(report.survived, path), uncovered(report.uncovered, path), unjudged(report.errors)].compact
+    @io.puts("", "Next actions:", *lines) unless lines.empty?
+  end
+
+  private
+
+  def survivors(found, path)
+    first = found.min_by(&:mutant_id)
+    first && advice(found, "surviving mutant(s): inspect ##{first.mutant_id} with `#{inspection(first, path)}`")
+  end
+
+  def inspection(first, path)
+    path ? "kimera mutant #{first.mutant_id} --report #{path}" : "kimera run --report tmp/kimera.json"
+  end
+
+  def uncovered(found, path) = advice(found, "uncovered mutant(s): #{listing(path)}")
+
+  def listing(path) = path ? "kimera report #{path} --status no_coverage" : "rerun with --report tmp/kimera.json"
+
+  def unjudged(found) = advice(found, "unjudged mutant(s): retry with `kimera run --isolated`")
+
+  def advice(found, text)
+    "  #{found.size} #{text}" unless found.empty?
+  end
+end

data/lib/kimera/report/coloring.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "screen"
+
+module Kimera
+  module Report
+  end
+end
+
+module Kimera::Report::Coloring
+  private
+
+  def bold(text)  = colorize(text, "1")
+  def red(text)   = colorize(text, "31")
+  def green(text) = colorize(text, "32")
+  def yellow(text) = colorize(text, "33")
+
+  def colorize(text, code)
+    color? ? "\e[#{code}m#{text}\e[0m" : text
+  end
+
+  def color? = Kimera::Report::Screen::MODES.key?(@color) ? @color : screen.colored?
+
+  def screen = @_screen ||= Kimera::Report::Screen.for(@io, @color)
+end

data/lib/kimera/report/formats.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Kimera
+  module Report
+  end
+end
+
+class Kimera::Report::Formats
+  NAMES = %w[text json ndjson github sarif].freeze
+  REPORTED = %w[survived no_coverage harness_error].freeze
+  SUMMARY = %w[schema_version counts mutation_score run].freeze
+  RECORDS = { "result" => "results", "leak" => "leaks" }.freeze
+
+  def initialize(io: $stdout)
+    @io = io
+  end
+
+  def emit(name, report, metadata: nil) = render(name, report.document(metadata))
+
+  def render(name, document) = __send__(normalize(name), document)
+
+  def normalize(name)
+    format = String(name)
+    return format if NAMES.include?(format)
+    raise(Kimera::UsageError, "unknown report format #{format.inspect} (choose: #{NAMES.join(", ")})")
+  end
+
+  private
+
+  def json(document) = write(JSON.pretty_generate(document))
+
+  def ndjson(document)
+    write(JSON.generate(type: "summary", **document.slice(*SUMMARY)))
+    RECORDS.each { |type, key| document.fetch(key).each { |row| write(JSON.generate(type: type, **row)) } }
+  end
+
+  def github(document)
+    findings(document).each { |result| write("::#{level(result)} #{fields(result)}::#{escaped(message(result))}") }
+  end
+
+  def sarif(document)
+    write(JSON.pretty_generate(envelope(findings(document).map { |result| finding(result) })))
+  end
+
+  def findings(document) = document.fetch("results").select { |result| REPORTED.include?(result.fetch("status")) }
+
+  def level(result) = result["status"] == "survived" ? "error" : "warning"
+
+  def fields(result) = "file=#{property(result.fetch("file"))},line=#{result["line"] || 1}"
+
+  def envelope(results)
+    { "$schema" => "https://json.schemastore.org/sarif-2.1.0.json", "version" => "2.1.0" }
+      .merge("runs" => [{ "tool" => { "driver" => { "name" => "Kimera" } }, "results" => results }])
+  end
+
+  def finding(result)
+    { "ruleId" => "kimera/#{result["operator"] || result["status"]}", "level" => level(result) }
+      .merge("message" => { "text" => message(result) }, "locations" => [location(result)])
+  end
+
+  def location(result)
+    region = { "startLine" => result["line"] || 1 }
+    { "physicalLocation" => { "artifactLocation" => { "uri" => result["file"] }, "region" => region } }
+  end
+
+  def message(result)
+    location = [result["file"], result["line"]].compact.join(":")
+    "#{result["status"]} mutant ##{result["mutant_id"]} at #{location}: #{result["label"] || result["detail"]}".strip
+  end
+
+  def property(value) = value.to_s.gsub(/[%\r\n,:]/) { |char| "%#{char.ord.to_s(16).upcase.rjust(2, "0")}" }
+
+  def escaped(value) = value.to_s.gsub("%", "%25").gsub("\r", "%0D").gsub("\n", "%0A")
+
+  def write(text) = @io.puts(text)
+end

data/lib/kimera/report/live.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "log"
+require "io/console"
+
+class Kimera::Report::Live < Kimera::Report::Log
+  REDRAW_EVERY = 0.1
+  ERASE = "\r\e[K"
+  CURSOR_UP = "\e[1A"
+
+  class << self
+    def for(io) = new(io, columns: width(io))
+
+    private
+
+    def width(io)
+      io.winsize.fetch(1)
+    rescue NoMethodError, SystemCallError
+      nil
+    end
+  end
+
+  def initialize(io, columns: nil)
+    super(io)
+    @columns = columns
+    @rows = 1
+  end
+
+  def cadence = REDRAW_EVERY
+
+  def commit
+    return unless @drawn
+    write("\n")
+    @drawn = false
+    @rows = 1
+  end
+
+  private
+
+  def frame(text)
+    prefix = erasure
+    @rows = rows_for(text)
+    "#{prefix}#{text}"
+  end
+
+  def wipe = write(erasure)
+
+  def erasure
+    ERASE + ((CURSOR_UP + ERASE) * (@rows - 1))
+  end
+
+  def rows_for(text)
+    return 1 unless @columns&.positive?
+    [(text.length + @columns - 1) / @columns, 1].max
+  end
+end

data/lib/kimera/report/log.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Report
+  end
+end
+
+class Kimera::Report::Log
+  HEARTBEAT_EVERY = 10.0
+  NEVER = -Float::INFINITY
+
+  def initialize(io)
+    @io = io
+    @last = NEVER
+    @drawn = false
+  end
+
+  def cadence = HEARTBEAT_EVERY
+
+  def due?(now, cadence) = now - @last >= cadence
+
+  def paint(text, now)
+    write(frame(text))
+    @drawn = true
+    @last = now
+  end
+
+  def clear
+    return unless @drawn
+    wipe
+    @drawn = false
+  end
+
+  def commit = clear
+
+  private
+
+  def frame(text) = "#{text}\n"
+
+  def wipe = @io.flush
+
+  def write(text)
+    @io.print(text)
+    @io.flush
+  end
+end

data/lib/kimera/report/progress.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "screen"
+require_relative "tally"
+
+module Kimera
+  module Report
+  end
+end
+
+class Kimera::Report::Progress
+  MONOTONIC = -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+
+  def initialize(io: $stderr, enabled: nil, interval: nil, clock: MONOTONIC)
+    @io = io
+    @enabled = enabled
+    @redraw = interval
+    @clock = clock
+  end
+
+  def enabled? = screen.enabled?
+
+  def start(total, label = "mutants")
+    tally.begin!(Integer(total), label, monotonic)
+    emit if visible?
+  end
+
+  def tick(status = nil)
+    tally.count!(status)
+    emit if visible? && (tally.complete? || due?)
+  end
+
+  def finish
+    return surface.clear unless tally.complete?
+    surface.commit
+  end
+
+  private
+
+  def screen = @_screen ||= Kimera::Report::Screen.for(@io, @enabled)
+
+  def surface = @_surface ||= screen.surface
+
+  def tally = @_tally ||= Kimera::Report::Tally.new
+
+  def visible? = enabled? && tally.running?
+
+  def due? = surface.due?(monotonic, cadence)
+
+  def cadence = @redraw || surface.cadence
+
+  def emit = surface.paint(tally.line(monotonic), monotonic)
+
+  def monotonic = @clock.call
+end

data/lib/kimera/report/screen.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "live"
+require_relative "log"
+
+module Kimera
+  module Report
+  end
+end
+
+class Kimera::Report::Screen
+  MODES = { true => :on, false => :off }.freeze
+
+  class << self
+    def for(io, preference) = public_send(MODES.fetch(preference, :auto), io)
+
+    def on(io) = new(io, enabled: true, interactive: tty?(io))
+
+    def off(io) = new(io, enabled: false, interactive: tty?(io))
+
+    def auto(io)
+      tty = tty?(io)
+      new(io, enabled: tty, interactive: tty)
+    end
+
+    private
+
+    def tty?(io) = io.tty?
+  end
+
+  def initialize(io, enabled:, interactive:)
+    @io = io
+    @enabled = enabled
+    @interactive = interactive
+  end
+
+  def enabled? = @enabled
+
+  def colored? = @enabled && !ENV.key?("NO_COLOR")
+
+  def surface
+    @interactive ? Kimera::Report::Live.for(@io) : Kimera::Report::Log.new(@io)
+  end
+end

data/lib/kimera/report/sections.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Kimera
+  module Report
+  end
+end
+
+module Kimera::Report::Sections
+  private
+
+  def unjudged(report) = section("Mutants Kimera could not judge", report.errors) { |r| unjudge(r) }
+
+  def unjudge(result)
+    id = result.mutant_id
+    @io.puts("  #{red("unjudged")} ##{id}  #{where(@registry.index[id], result)}  #{result.detail}")
+  end
+
+  def where(point, result)
+    point ? "#{point.file}:#{point.location.start_line}" : result.file.to_s
+  end
+
+  def hint(report, path)
+    count = report.uncovered.size
+    return if count.zero?
+    @io.puts
+    @io.puts("#{count} mutant(s) have no covering test; #{command(path)}")
+  end
+
+  def command(path)
+    return "list them with: kimera report #{path} --status no_coverage" if path
+    "re-run with --report FILE, then `kimera report FILE --status no_coverage` to list them"
+  end
+
+  def missing(report, _path = nil) = section("Mutants with no covering test", report.uncovered) { |r| uncovered(r) }
+
+  def uncovered(result)
+    resolved(result) { |id, mutant, point| spotted("no coverage", id, mutant, point) }
+  end
+
+  def spotted(status, id, mutant, point)
+    @io.puts("  #{yellow(status)} ##{id}  #{point.file}:#{point.location.start_line}  [#{mutant.label}]")
+  end
+
+  def leaks(leaks)
+    return if leaks.empty?
+    @io.puts
+    @io.puts(yellow("State-leak warnings (#{leaks.size}):"))
+    leaks.each { |leak| @io.puts("  - #{leak.detail}") }
+  end
+end

data/lib/kimera/report/tally.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative "../support/duration"
+
+module Kimera
+  module Report
+  end
+end
+
+class Kimera::Report::Tally
+  BAR_WIDTH = 24
+  ALWAYS_SHOWN = %i[killed survived].freeze
+
+  def initialize
+    @total = 0
+    @counts = {}
+    @label = nil
+    @started = 0.0
+  end
+
+  def begin!(total, label, now)
+    @total = total
+    @label = label
+    @started = now
+    @counts = {}
+  end
+
+  def count!(status)
+    @counts[status] = @counts.fetch(status, 0) + 1
+  end
+
+  def done = @counts.values.sum
+
+  def complete? = done >= @total
+
+  def running? = @total.positive?
+
+  def line(now)
+    ["#{@label} #{bar}", "#{done}/#{@total}", "#{percent}%", *pace(now), elapsed(now)].join("  ")
+  end
+
+  private
+
+  def statuses = @counts.keys.compact
+
+  def pace(now)
+    parts = statuses.empty? ? [] : [breakdown]
+    parts << rate(now) if done.positive?
+    parts << eta(now) unless complete? || done.zero?
+    parts
+  end
+
+  def bar
+    filled = (done * BAR_WIDTH) / @total
+    head = filled.between?(1, BAR_WIDTH - 1) ? ">" : ""
+    "[#{"=" * [filled - head.size, 0].max}#{head}#{" " * (BAR_WIDTH - filled)}]"
+  end
+
+  def percent = (done * 100) / @total
+
+  def breakdown
+    (ALWAYS_SHOWN + statuses).uniq.filter_map { |status| counted(status) }.join(" ")
+  end
+
+  def counted(status)
+    "#{status}=#{@counts.fetch(status, 0)}"
+  end
+
+  def elapsed(now) = clock(Integer(now - @started))
+
+  def rate(now)
+    seconds = now - @started
+    return "rate=—" if seconds <= 0
+    format("%.1f/s", done / seconds)
+  end
+
+  def eta(now)
+    seconds = now - @started
+    return "ETA —" if seconds <= 0
+    "ETA #{clock(Integer((@total - done) / (done / seconds)))}"
+  end
+
+  def clock(seconds) = Kimera::Duration.new(seconds).clock
+end