mutato 0.1.0

data/lib/mutato/flags.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Mutato
+  module Flags
+    TABLE = [
+      [%w[-h --help], :help, TrueClass],
+      [%w[-v --version], :version, TrueClass],
+      ["--spec ARGS", :spec, String],
+      ["--config FILE", :config, String],
+      ["--diff FILE", :diff, String],
+      ["--format NAME", :format, String],
+      ["--limit N", :limit, Integer],
+      ["--sample N", :sample, Integer],
+      ["--genre LIST", :genres, Array],
+      ["--only IDS", :only, Array],
+      ["--out DIR", :out, String],
+      ["--timeout-min S", :timeout_min, Float]
+    ].freeze
+    DEFAULTS = { spec: "spec", out: "mutato.out", timeout_min: 10.0 }.freeze
+    GENRES = %w[statement condition relational arithmetic swap-method value element].freeze
+    private_constant :TABLE, :DEFAULTS, :GENRES
+
+    module_function
+
+    def parse(argv)
+      values = Options.members.to_h { |member| [member, DEFAULTS[member]] }
+      parser(values).parse!(argv)
+      check(values)
+      Options.new(**values)
+    end
+
+    # Values OptionParser takes but mutato cannot use, reported the way it reports its own.
+    def check(values)
+      check_genres(values[:genres].to_a)
+      negative = %i[limit sample].find { |key| values[key]&.negative? }
+      raise OptionParser::InvalidArgument, "--#{negative} #{values[negative]}" if negative
+    end
+
+    def check_genres(genres)
+      unknown = genres - GENRES
+      wrong = "--genre #{unknown.join(",")} (genres: #{GENRES.join(", ")})"
+      raise OptionParser::InvalidArgument, wrong if unknown.any?
+    end
+
+    def parser(values)
+      parser = OptionParser.new
+      TABLE.each { |flag| define(parser, values, flag) }
+      parser
+    end
+
+    def define(parser, values, flag)
+      switches, key, type = flag
+      parser.on(*switches, type) { |value| values[key] = value }
+    end
+  end
+end

data/lib/mutato/generation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Mutato
+  class Generation
+    def initialize(file, source)
+      @file = file
+      @source = source
+      @tree = Prism.parse(source).value
+      @emitter = Emitter.new(file, source)
+    end
+
+    def generator
+      subjects = found
+      kept, dropped = mutate(subjects).partition { |mutation| parses?(mutation) }
+      Generator.new(file: @file, source: @source, subjects:, mutations: kept, dropped:)
+    end
+
+    private
+
+    def found
+      usage = Usage.new(@tree)
+      Subjects.find(@file, @tree).map { |subject| usage.demoted(subject) }
+    end
+
+    def mutate(subjects)
+      subjects.reject(&:skip).each { |subject| Visitor.new(subject, @emitter).run }
+      @emitter.mutations
+    end
+
+    def parses?(mutation)
+      Prism.parse(mutation.mutated_source(@source)).errors.empty?
+    end
+  end
+end

data/lib/mutato/generator.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Mutato
+  Generator = Data.define(:file, :source, :subjects, :mutations, :dropped) do
+    def self.read(file)
+      Generation.new(file, File.read(file)).generator
+    end
+  end
+  public_constant :Generator
+end

data/lib/mutato/genres/conditions.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "genre"
+
+module Mutato
+  module Genres
+    class Conditions < Genre
+      CONNECTORS = { Prism::AndNode => %w[|| or], Prism::OrNode => %w[&& and] }.freeze
+      LITERALS = [Prism::TrueNode, Prism::FalseNode].freeze
+      private_constant :CONNECTORS, :LITERALS
+
+      # `warn(...) unless ok`: a compound of arid parts is arid, children included.
+      def branch(node)
+        return :stop if Arid.arid_node?(node)
+
+        replace(node.predicate, literals(node))
+        spare_guard(node)
+      end
+
+      # The literal that skips the body: `while false`, `until true`.
+      def loop(node)
+        replace(node.predicate, node.is_a?(Prism::WhileNode) ? %w[false] : %w[true])
+      end
+
+      def connector(node)
+        operator = node.operator_loc
+        spelled = operator.slice
+        replacement = CONNECTORS.fetch(node.class)[spelled.match?(/\A\w/) ? 1 : 0]
+        emit(
+          :condition,
+          Change.whole(
+            node,
+            replacement,
+            "replace `#{spelled}` with `#{replacement}`"
+          ).at(operator)
+        )
+      end
+
+      private
+
+      def replace(predicate, literals)
+        return if predicate.nil? || Nodes.one_of?(predicate, LITERALS)
+
+        shown = Nodes.compact(predicate.slice)
+        literals.each do |literal|
+          emit(
+            :condition,
+            Change.whole(predicate, literal, "replace condition `#{shown}` with #{literal}")
+          )
+        end
+      end
+
+      # The disabling literal repeats a deletion, or for a memo guard only skips a cache.
+      def literals(node)
+        disabled = visitor.walk.deleted.include?(node) || Nodes.memo_guard?(node)
+        return %w[true false] unless Nodes.else_less?(node) && disabled
+
+        node.is_a?(Prism::IfNode) ? %w[true] : %w[false]
+      end
+
+      # Deleting a guard's lone statement repeats a literal or the whole statement's deletion.
+      def spare_guard(node)
+        return unless Nodes.else_less?(node) && Nodes.single_statement(node)
+
+        visitor.walk.spared << node.statements
+      end
+    end
+  end
+end

data/lib/mutato/genres/elements.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "genre"
+
+module Mutato
+  module Genres
+    # Newlines stay with a dropped element, so line numbers hold.
+    class Elements < Genre
+      MAX = 10
+      private_constant :MAX
+
+      # A lone element has nothing to drop it from; only its trailing comma would go.
+      def mutate(node)
+        elements = node.elements
+        return unless (2..MAX).cover?(elements.size)
+
+        elements.each_index do |index|
+          drop(elements, index) unless Nodes.nil_valued?(elements[index])
+        end
+      end
+
+      private
+
+      def drop(elements, index)
+        from, to = range(elements, index)
+        element = elements[index]
+        newlines = "\n" * source.byteslice(from...to).count("\n")
+        change = Change.whole(element, newlines, "drop `#{Nodes.compact(element.slice)}`")
+        emit(:element, change.covering([from, to - from]))
+      end
+
+      # The last element goes from the previous one's end, trailing comma included.
+      def range(elements, index)
+        location = elements[index].location
+        following = elements[index + 1]
+        return [location.start_offset, following.location.start_offset] if following
+
+        stop = location.end_offset
+        [elements[index - 1].location.end_offset, stop + trailing_comma(stop).bytesize]
+      end
+
+      # Only a comma that ends the list: one before `&block` must stay.
+      def trailing_comma(offset)
+        source.byteslice(offset, 200).to_s.b[/\A\s*,(?=(?:\s|#[^\n]*)*[\]})])/].to_s
+      end
+    end
+  end
+end

data/lib/mutato/genres/genre.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Mutato
+  module Genres
+    class Genre
+      def initialize(visitor)
+        @visitor = visitor
+      end
+
+      private
+
+      attr_reader :visitor
+
+      def emit(genre, change)
+        visitor.emit(genre, change)
+      end
+
+      def source
+        visitor.source
+      end
+    end
+  end
+end

data/lib/mutato/genres/operators.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "genre"
+
+module Mutato
+  module Genres
+    class Operators < Genre
+      RELATIONAL = {
+        "<" => %w[<= !=],
+        "<=" => %w[< ==],
+        ">" => %w[>= !=],
+        ">=" => %w[> ==],
+        "==" => %w[!=],
+        "!=" => %w[==]
+      }.freeze
+      # What a comparison gives when both sides are equal.
+      ALWAYS = { "<" => "false", "<=" => "true", ">" => "false", ">=" => "true" }.freeze
+      ARITHMETIC = { "+" => "-", "-" => "+", "*" => "/", "/" => "*" }.freeze
+      NON_COMMUTATIVE = %w[- / % **].freeze
+      private_constant :RELATIONAL, :ALWAYS, :ARITHMETIC, :NON_COMMUTATIVE
+
+      # A length is never negative, so `size > 0` is `size != 0`.
+      def self.neighbours(call, name)
+        same = name == ">" && Nodes.count_against_zero?(call)
+        RELATIONAL.fetch(name).reject { |operator| same && operator == "!=" }
+      end
+
+      def mutate(call)
+        name = call.name.to_s
+        relational(call, name) if RELATIONAL.key?(name)
+        arithmetic = ARITHMETIC[name]
+        operator(call, arithmetic, :arithmetic) if arithmetic
+        swap_operands(call) if NON_COMMUTATIVE.include?(name)
+      end
+
+      def compound(node)
+        operator = node.binary_operator.to_s
+        replacement = ARITHMETIC[operator]
+        return unless replacement
+
+        change = Change.whole(
+          node,
+          "#{replacement}=",
+          "replace `#{operator}=` with `#{replacement}=`"
+        )
+        emit(:arithmetic, change.at(node.binary_operator_loc))
+      end
+
+      private
+
+      def relational(call, name)
+        Operators.neighbours(call, name).each { |operator| operator(call, operator, :relational) }
+        literal = ALWAYS[name]
+        always(call, literal) if literal
+      end
+
+      def operator(call, replacement, genre)
+        change = Change.whole(call, replacement, "replace `#{call.name}` with `#{replacement}`")
+        emit(genre, change.at(call.message_loc))
+      end
+
+      def always(call, literal)
+        emit(
+          :relational,
+          Change.whole(call, literal, "replace `#{Nodes.compact(call.slice)}` with #{literal}")
+        )
+      end
+
+      def swap_operands(call)
+        name = call.name
+        lhs = call.receiver.slice
+        rhs = Nodes.sole_argument(call).slice
+        emit(
+          :arithmetic,
+          Change.whole(call, "(#{rhs}) #{name} (#{lhs})", "swap operands of `#{name}`")
+        )
+      end
+    end
+  end
+end

data/lib/mutato/genres/statements.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "genre"
+
+module Mutato
+  module Genres
+    class Statements < Genre
+      LOOPS = [
+        Prism::WhileNode,
+        Prism::UntilNode,
+        Prism::ForNode,
+        Prism::BlockNode,
+        Prism::LambdaNode
+      ].freeze
+      # `n += 1` and `n ||= x` read n as well.
+      READS = [
+        Prism::LocalVariableReadNode,
+        Prism::LocalVariableOperatorWriteNode,
+        Prism::LocalVariableOrWriteNode,
+        Prism::LocalVariableAndWriteNode
+      ].freeze
+      EFFECTS = [
+        Prism::YieldNode,
+        Prism::SuperNode,
+        Prism::ForwardingSuperNode,
+        Prism::InstanceVariableWriteNode,
+        Prism::ClassVariableWriteNode,
+        Prism::GlobalVariableWriteNode
+      ].freeze
+      private_constant :LOOPS, :READS, :EFFECTS
+
+      # Computing it has no effect: literals, reads, and operators between them.
+      def self.pure?(value)
+        Nodes.each_node(value).all? do |node|
+          node.is_a?(Prism::CallNode) ? Nodes.binary_operator?(node) : !Nodes.one_of?(node, EFFECTS)
+        end
+      end
+
+      def self.around?(node, offset)
+        span = node.location
+        Nodes.one_of?(node, LOOPS) && (span.start_offset...span.end_offset).cover?(offset)
+      end
+
+      # Deleting these changes nothing a test can see.
+      def self.keep?(statement)
+        return true if Arid.arid_node?(statement) || Nodes.one_of?(statement, Nodes::LITERALS)
+
+        statement.is_a?(Prism::DefNode) || Nodes.memo_guard?(statement)
+      end
+
+      def mutate(node)
+        spared = visitor.walk.spared
+        return if spared.include?(node)
+
+        statements = node.body
+        statements.each do |statement|
+          consider(statement, statements.last) unless spared.include?(statement)
+        end
+      end
+
+      private
+
+      def consider(statement, valued)
+        return visitor.walk.dead << statement if dead_store?(statement, valued)
+
+        delete(statement) unless Statements.keep?(statement)
+      end
+
+      def delete(statement)
+        visitor.walk.deleted << statement
+        change = Change.whole(
+          statement,
+          "nil",
+          "delete statement `#{Nodes.compact(statement.slice)}`"
+        )
+        visitor.with_statement(statement) do
+          emit(:statement, change.covering(Nodes.extent(statement, source)))
+        end
+      end
+
+      # A local store ending its list is the list's value; of ivars, only initialize's `@x = nil`.
+      def dead_store?(statement, valued)
+        case statement
+        when Prism::LocalVariableWriteNode then !statement.equal?(valued) && dead_local?(statement)
+        when Prism::InstanceVariableWriteNode then initial_nil?(statement)
+        when Prism::CallNode then Nodes.nil_store?(statement)
+        else false
+        end
+      end
+
+      def dead_local?(write)
+        unread_local?(write) && Statements.pure?(write.value)
+      end
+
+      def initial_nil?(write)
+        visitor.subject.name == :initialize && write.value.is_a?(Prism::NilNode)
+      end
+
+      # In a loop or block, a read earlier in the body sees the write on the next pass.
+      def unread_local?(write)
+        from = outermost_loop_start(write) || write.location.end_offset
+        reads_of(write.name).none? { |read| (from..).cover?(read.location.start_offset) }
+      end
+
+      def outermost_loop_start(write)
+        offset = write.location.start_offset
+        nodes = Nodes.each_node(visitor.subject.node)
+        starts = nodes.filter_map do |node|
+          node.location.start_offset if Statements.around?(node, offset)
+        end
+        starts.min
+      end
+
+      def reads_of(name)
+        Nodes.each_node(visitor.subject.node).select do |node|
+          Nodes.one_of?(node, READS) && node.name == name
+        end
+      end
+    end
+  end
+end

data/lib/mutato/genres/swaps.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "genre"
+
+module Mutato
+  module Genres
+    class Swaps < Genre
+      SWAPS = {
+        max: %i[min],
+        min: %i[max],
+        first: %i[last],
+        last: %i[first],
+        round: %i[floor ceil],
+        floor: %i[round ceil],
+        ceil: %i[round floor],
+        truncate: %i[round],
+        any?: %i[all? none?],
+        all?: %i[any?],
+        none?: %i[any?],
+        empty?: %i[any?]
+      }.freeze
+      FINDERS = %i[first last].freeze
+      private_constant :SWAPS, :FINDERS
+
+      # `first(id: x)` is a finder, and a receiverless `max` the method's own: not Array calls.
+      def self.swappable?(call)
+        return false if call.receiver.nil?
+
+        !(FINDERS.include?(call.name) && (call.arguments || call.block))
+      end
+
+      def mutate(call)
+        name = call.name
+        negation(call) if name == :! && call.receiver
+        replacements = SWAPS[name]
+        methods(call, replacements) if replacements && Swaps.swappable?(call)
+      end
+
+      private
+
+      def negation(call)
+        emit(
+          :condition,
+          Change.whole(call, call.receiver.slice, "drop `!` from `#{Nodes.compact(call.slice)}`")
+        )
+      end
+
+      def methods(call, replacements)
+        name = call.name
+        replacements.each do |replacement|
+          change = Change.whole(call, replacement.to_s, "replace `.#{name}` with `.#{replacement}`")
+          emit(:"swap-method", change.at(call.message_loc))
+        end
+      end
+    end
+  end
+end

data/lib/mutato/genres/values.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "genre"
+
+module Mutato
+  module Genres
+    class Values < Genre
+      GUESSES = {
+        Prism::ArrayNode => "[]",
+        Prism::HashNode => "{}",
+        Prism::StringNode => '""',
+        Prism::InterpolatedStringNode => '""',
+        Prism::IntegerNode => "0",
+        Prism::TrueNode => "true",
+        Prism::FalseNode => "true"
+      }.freeze
+      private_constant :GUESSES
+
+      def mutate(body)
+        # A def with a rescue: the statements are what the method returns.
+        body = body.statements if body.is_a?(Prism::BeginNode)
+        return unless body.is_a?(Prism::StatementsNode)
+
+        guesses(body.body.last).each do |value|
+          description = "replace body of #{visitor.subject} with #{value}"
+          emit(:value, Change.whole(body, value, description).covering(Nodes.extent(body, source)))
+        end
+      end
+
+      private
+
+      def guesses(last)
+        return %w[true false] if visitor.subject.name.to_s.end_with?("?")
+
+        guessed = GUESSES.filter_map { |klass, value| value if last.is_a?(klass) }
+        ["nil", *guessed].uniq
+      end
+    end
+  end
+end

data/lib/mutato/genres.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "genres/conditions"
+require_relative "genres/elements"
+require_relative "genres/operators"
+require_relative "genres/statements"
+require_relative "genres/swaps"
+require_relative "genres/values"
+
+module Mutato
+  module Genres
+    COLLECTIONS = [Prism::ArrayNode, Prism::HashNode, Prism::KeywordHashNode].freeze
+    COMPOUNDS = [
+      Prism::LocalVariableOperatorWriteNode,
+      Prism::InstanceVariableOperatorWriteNode,
+      Prism::ClassVariableOperatorWriteNode,
+      Prism::GlobalVariableOperatorWriteNode,
+      Prism::IndexOperatorWriteNode,
+      Prism::CallOperatorWriteNode,
+      Prism::ConstantOperatorWriteNode,
+      Prism::ConstantPathOperatorWriteNode
+    ].freeze
+    private_constant :COLLECTIONS, :COMPOUNDS
+
+    module_function
+
+    # :stop leaves the node's children alone.
+    def mutate(visitor, node)
+      case node
+      when Prism::IfNode, Prism::UnlessNode then Conditions.new(visitor).branch(node)
+      when Prism::WhileNode, Prism::UntilNode then Conditions.new(visitor).loop(node)
+      when Prism::AndNode, Prism::OrNode then Conditions.new(visitor).connector(node)
+      when Prism::CallNode then call(visitor, node)
+      else other(visitor, node)
+      end
+    end
+
+    def other(visitor, node)
+      return Elements.new(visitor).mutate(node) if Nodes.one_of?(node, COLLECTIONS)
+
+      Operators.new(visitor).compound(node) if Nodes.one_of?(node, COMPOUNDS)
+    end
+
+    # Nothing inside a logger call, or a loop that only logs, is mutated either.
+    def call(visitor, call)
+      return :stop if Arid.arid_node?(call)
+
+      Operators.new(visitor).mutate(call) if Nodes.binary_operator?(call)
+      Swaps.new(visitor).mutate(call)
+    end
+  end
+end

data/lib/mutato/group_hooks.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Mutato
+  # Lines a before(:all) hook hits count for every example of its group.
+  class GroupHooks
+    def self.assign(ids, line_map)
+      yield.each { |key| line_map[key].concat(ids) }
+    end
+
+    def self.all_ids
+      RSpec.world.example_groups.flat_map(&:descendant_filtered_examples).map(&:id)
+    end
+
+    def initialize
+      @pending = false
+      @suite = true
+      @ids = {}
+    end
+
+    # At the first group: what before(:suite) ran, which every example runs after.
+    def credit_suite(line_map, &)
+      return unless @suite
+
+      @suite = false
+      GroupHooks.assign(GroupHooks.all_ids, line_map, &)
+    end
+
+    def expect_hooks
+      @pending = true
+    end
+
+    def credit(group, line_map, &)
+      return unless @pending
+
+      @pending = false
+      GroupHooks.assign(served(group), line_map, &)
+    end
+
+    private
+
+    def served(group)
+      @ids[group] ||= group.parent_groups.flat_map(&:descendant_filtered_examples).map(&:id).uniq
+    end
+  end
+end

data/lib/mutato/hits.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Mutato
+  # Method start lines too, when coverage counts methods: an endless def gets no line hit.
+  module Hits
+    module_function
+
+    def keys(path, data)
+      lines = data.fetch(:lines).each_with_index.filter_map do |count, index|
+        "#{path}:#{index + 1}" if count&.positive?
+      end
+      methods = data.fetch(:methods, {}).filter_map do |(_, _, line), count|
+        "#{path}:#{line}" if count.positive?
+      end
+      lines + methods
+    end
+  end
+end