mutato 0.1.0

data/lib/mutato/usage.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Mutato
+  # Which methods are only called from logging: a file-wide fact no single method shows.
+  class Usage
+    def initialize(tree)
+      # Names called inside logging, and names called anywhere else.
+      @calls = { true => Set.new, false => Set.new }
+      @private = Set.new
+      scan(tree, in_arid: false)
+    end
+
+    def logging_only?(name)
+      @calls.fetch(true).include?(name) && !@calls.fetch(false).include?(name)
+    end
+
+    # A private method only ever called from logging is as arid as the logging. A public one
+    # may be called from another file.
+    def demoted(subject)
+      name = subject.name
+      return subject if subject.skip || !logging_only?(name) || !@private.include?(name)
+
+      subject.with(skip: "only used in logging")
+    end
+
+    private
+
+    def scan(node, in_arid:)
+      in_arid = called(node, in_arid:) if node.is_a?(Prism::CallNode)
+      @private.merge(Privates.names(node)) if node.is_a?(Prism::StatementsNode)
+      node.compact_child_nodes.each { |child| scan(child, in_arid:) }
+    end
+
+    def called(call, in_arid:)
+      @calls.fetch(in_arid) << call.name
+      in_arid || Arid.arid_node?(call)
+    end
+  end
+end

data/lib/mutato/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Mutato
+  VERSION = "0.1.0"
+  public_constant :VERSION
+end

data/lib/mutato/visitor/cursor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mutato
+  class Visitor
+    # Inside a block, `outer` stays the statement outside it, whose tests judge the mutant.
+    Cursor = Data.define(:statement, :outer, :in_block) do
+      def self.start
+        new(statement: nil, outer: nil, in_block: false)
+      end
+
+      def at(statement)
+        with(statement:, outer: in_block ? outer : statement)
+      end
+
+      def inside_block
+        with(in_block: true)
+      end
+
+      def outer_lines(node)
+        return unless in_block
+
+        location = (outer || node).location
+        location.start_line..location.end_line
+      end
+    end
+    private_constant :Cursor
+  end
+end

data/lib/mutato/visitor/walk.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Mutato
+  class Visitor
+    Walk = Struct.new(:cursor, :deleted, :spared, :dead) do
+      def self.start
+        new(Cursor.start, identity_set, identity_set, identity_set)
+      end
+
+      # Nodes compare by structure; the walk needs the very node.
+      def self.identity_set
+        Set.new.compare_by_identity
+      end
+    end
+    private_constant :Walk
+  end
+end

data/lib/mutato/visitor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "visitor/cursor"
+require_relative "visitor/walk"
+
+module Mutato
+  class Visitor
+    DEFINITIONS = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode].freeze
+    private_constant :DEFINITIONS
+
+    attr_reader :subject, :walk
+
+    def initialize(subject, emitter)
+      @subject = subject
+      @emitter = emitter
+      @walk = Walk.start
+    end
+
+    # The last statement is the value and stays, unless the caller drops it: `new`, `x.y = 1`.
+    def run
+      body = subject.node.body
+      Genres::Values.new(self).mutate(body)
+      statements = Nodes.statements_of(body)
+      walk.spared << statements.last if statements && !Nodes.value_dropped?(subject.name)
+      visit(body)
+    end
+
+    def source
+      @emitter.source
+    end
+
+    def emit(genre, change)
+      @emitter.add(change.with(genre:), subject, walk.cursor)
+    end
+
+    def with_statement(statement, &)
+      with_cursor(walk.cursor.at(statement), &)
+    end
+
+    def visit(node)
+      case node
+      when Prism::StatementsNode then visit_statements(node)
+      when Prism::BlockNode, Prism::LambdaNode then visit_block(node)
+      when Prism::EmbeddedStatementsNode, Prism::ParenthesesNode then visit_expression(node)
+      when nil, *DEFINITIONS then nil
+      else visit_other(node)
+      end
+    end
+
+    private
+
+    def visit_statements(node)
+      Genres::Statements.new(self).mutate(node)
+      node.body.each { |statement| visit_statement(statement) }
+    end
+
+    # Nothing inside a store no one reads is mutated either.
+    def visit_statement(statement)
+      with_statement(statement) { visit(statement) } unless walk.dead.include?(statement)
+    end
+
+    def visit_block(node)
+      with_cursor(walk.cursor.inside_block) { visit_children(node) }
+    end
+
+    # Statements inside `#{}` or parentheses are expressions: mutated, never deleted.
+    def visit_expression(node)
+      node.compact_child_nodes.flat_map(&:body).each { |child| visit(child) }
+    end
+
+    def visit_other(node)
+      visit_children(node) unless Genres.mutate(self, node) == :stop
+    end
+
+    def visit_children(node)
+      node.compact_child_nodes.each { |child| visit(child) }
+    end
+
+    def with_cursor(cursor)
+      previous = walk.cursor
+      walk.cursor = cursor
+      yield
+    ensure
+      walk.cursor = previous
+    end
+  end
+end

data/lib/mutato/watchdog.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Mutato
+  # Past the budget it stops the framework and raises; the parent's SIGKILL is the backstop.
+  class Watchdog
+    def initialize(adapter, budget)
+      @adapter = adapter
+      @budget = budget
+      @expired = false
+      @running = nil
+    end
+
+    # A timeout whatever the tests made of it, as RSpec rescues the exception like any other,
+    # unless a test had failed before time ran out.
+    def run(ids)
+      timer = Thread.new { expire }
+      judged(guarded(ids))
+    ensure
+      timer&.kill
+    end
+
+    private
+
+    def judged(verdict)
+      return verdict unless @expired
+
+      failing = verdict[:failing]
+      failing && failing != @running ? verdict : { outcome: :timeout, running: @running }
+    end
+
+    def guarded(ids)
+      @adapter.run(ids).outcome
+    rescue SoftTimeout
+      { outcome: :timeout, running: @running }
+    rescue SystemExit, SignalException => error
+      exited(error)
+    end
+
+    def expire
+      sleep @budget
+      @running = @adapter.current
+      @expired = true
+      @adapter.stop
+      Thread.main.raise(SoftTimeout)
+    end
+
+    # A mutant forced an exit path.
+    def exited(error)
+      puts "#{error.class}: #{error.message}"
+      current = @adapter.current
+      { outcome: :caught, failing: current, ran: [current].compact }
+    end
+  end
+end

data/lib/mutato.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "mutato/arid"
+require_relative "mutato/change"
+require_relative "mutato/config"
+require_relative "mutato/emitter"
+require_relative "mutato/generation"
+require_relative "mutato/generator"
+require_relative "mutato/genres"
+require_relative "mutato/installer"
+require_relative "mutato/mutation"
+require_relative "mutato/nodes"
+require_relative "mutato/privates"
+require_relative "mutato/skips"
+require_relative "mutato/subject"
+require_relative "mutato/subjects"
+require_relative "mutato/usage"
+require_relative "mutato/version"
+require_relative "mutato/visitor"
+
+module Mutato
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.before_fork(&block)
+    config.hooks[:before_fork] << block
+  end
+
+  def self.after_fork(&block)
+    config.hooks[:after_fork] << block
+  end
+
+  def self.after_boot(&block)
+    config.hooks[:after_boot] << block
+  end
+
+  def self.before_mutant(&block)
+    config.hooks[:before_mutant] << block
+  end
+
+  def self.skip(pattern, reason)
+    config.skip(pattern, reason)
+  end
+
+  def self.arid(*names)
+    config.arid(*names)
+  end
+
+  # A forked child must not share the parent's database sockets.
+  before_fork { Sequel::DATABASES.each(&:disconnect) if defined?(Sequel) }
+  before_fork do
+    ActiveRecord::Base.connection_handler.clear_all_connections! if defined?(ActiveRecord)
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: mutato
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mathias Løkke Madsen
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: prism
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: |
+  Mutates methods with Prism, redefines them in forked children of a
+  test process booted once, selects the tests that cover each mutant from
+  per-test coverage, and reports the survivors. RSpec.
+executables:
+- mutato
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- exe/mutato
+- lib/mutato.rb
+- lib/mutato/abort.rb
+- lib/mutato/annotations.rb
+- lib/mutato/arid.rb
+- lib/mutato/baseline.rb
+- lib/mutato/boot.rb
+- lib/mutato/campaign.rb
+- lib/mutato/change.rb
+- lib/mutato/child.rb
+- lib/mutato/cli.rb
+- lib/mutato/clock.rb
+- lib/mutato/config.rb
+- lib/mutato/console.rb
+- lib/mutato/coverage_listener.rb
+- lib/mutato/coverage_listener/tally.rb
+- lib/mutato/covering.rb
+- lib/mutato/diff.rb
+- lib/mutato/emitter.rb
+- lib/mutato/equivalence.rb
+- lib/mutato/experience.rb
+- lib/mutato/flags.rb
+- lib/mutato/generation.rb
+- lib/mutato/generator.rb
+- lib/mutato/genres.rb
+- lib/mutato/genres/conditions.rb
+- lib/mutato/genres/elements.rb
+- lib/mutato/genres/genre.rb
+- lib/mutato/genres/operators.rb
+- lib/mutato/genres/statements.rb
+- lib/mutato/genres/swaps.rb
+- lib/mutato/genres/values.rb
+- lib/mutato/group_hooks.rb
+- lib/mutato/hits.rb
+- lib/mutato/installer.rb
+- lib/mutato/installer/header.rb
+- lib/mutato/measure.rb
+- lib/mutato/mode.rb
+- lib/mutato/mode/control.rb
+- lib/mutato/mode/run.rb
+- lib/mutato/mutation.rb
+- lib/mutato/nodes.rb
+- lib/mutato/options.rb
+- lib/mutato/output.rb
+- lib/mutato/privates.rb
+- lib/mutato/report.rb
+- lib/mutato/rspec_adapter.rb
+- lib/mutato/rspec_adapter/progress.rb
+- lib/mutato/rspec_adapter/result.rb
+- lib/mutato/run.rb
+- lib/mutato/selection.rb
+- lib/mutato/session.rb
+- lib/mutato/skips.rb
+- lib/mutato/soft_timeout.rb
+- lib/mutato/subject.rb
+- lib/mutato/subjects.rb
+- lib/mutato/subjects/scope.rb
+- lib/mutato/suite.rb
+- lib/mutato/trial.rb
+- lib/mutato/usage.rb
+- lib/mutato/version.rb
+- lib/mutato/visitor.rb
+- lib/mutato/visitor/cursor.rb
+- lib/mutato/visitor/walk.rb
+- lib/mutato/watchdog.rb
+homepage: https://github.com/LQkkeN/mutato
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/LQkkeN/mutato
+  changelog_uri: https://github.com/LQkkeN/mutato/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/LQkkeN/mutato/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: 'Mutation testing for Ruby: boot once, fork per mutant'
+test_files: []