mutineer-mongoid 2.0.0

data/lib/mutineer/mutators/base.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "prism"
+require_relative "../mutation"
+
+module Mutineer
+  # Namespace for all built-in mutator implementations.
+  module Mutators
+    # Base Prism visitor for operators.
+    #
+    # Subclasses override `visit_*` methods to push `Mutation` objects onto
+    # `@mutations`. Visiting only `def_node.body` is the body-only enforcement:
+    # the def signature line is never touched.
+    class Base < Prism::Visitor
+      # Walks the subject body and collects mutations.
+      #
+      # @param subject [Mutineer::Subject] subject whose body is visited.
+      # @param source [String] full source text for byte-based slicing.
+      # @return [Array<Mutineer::Mutation>] collected mutations.
+      def mutations_for(subject, source)
+        @source = source
+        @mutations = []
+        @body = subject.def_node.body
+        @body&.accept(self)
+        drop_dangling_heredocs
+        @mutations
+      end
+
+      # Skips a nested method definition. The project finds it as a subject of
+      # its own, so a visit here counts its mutations twice. Inside
+      # `class << obj`, the project finds no subject, so the visit continues.
+      #
+      # @param node [Prism::DefNode] nested definition node.
+      # @return [void]
+      def visit_def_node(node)
+        super if @in_undiscovered
+      end
+
+      # Tracks a `class << obj` whose `obj` is not `self`. The project does not
+      # recurse into it, so its defs are no subjects (see
+      # `Project::SubjectVisitor#visit_singleton_class_node`).
+      #
+      # @param node [Prism::SingletonClassNode] singleton-class node.
+      # @return [void]
+      def visit_singleton_class_node(node)
+        return super if node.expression.is_a?(Prism::SelfNode)
+
+        outer, @in_undiscovered = @in_undiscovered, true
+        super
+        @in_undiscovered = outer
+      end
+
+      private
+
+      # Drops a mutation that deletes a heredoc opener and leaves its body.
+      #
+      # The body sits past the opener's node. Replacing the opener with text
+      # that does not contain it turns the body into Ruby, which parses and
+      # then raises. A replacement that still contains the opener keeps the
+      # body attached, so that mutation stays.
+      #
+      # @return [void]
+      def drop_dangling_heredocs
+        @mutations.reject! { |mutation| dangling_heredoc?(mutation) }
+      end
+
+      # Returns whether the mutation removes a heredoc opener whose body hangs
+      # past the replaced range.
+      #
+      # @param mutation [Mutineer::Mutation] candidate edit.
+      # @param node [Prism::Node, nil] subtree to search. Defaults to the body.
+      # @return [Boolean] true when the edit would leave a heredoc body behind.
+      def dangling_heredoc?(mutation, node = @body)
+        return false if node.nil? || !node.is_a?(Prism::Node)
+
+        if node.respond_to?(:heredoc?) && node.heredoc? && node.respond_to?(:opening_loc)
+          opening = node.opening_loc
+          if opening && opening.start_offset >= mutation.start_offset && opening.start_offset < mutation.end_offset
+            closing = node.respond_to?(:closing_loc) ? node.closing_loc : nil
+            hangs = closing.nil? || closing.end_offset > mutation.end_offset
+            if hangs
+              opener = @source.byteslice(opening.start_offset, opening.end_offset - opening.start_offset)
+              return true if opener.empty? || !mutation.replacement.include?(opener)
+            end
+          end
+        end
+
+        node.compact_child_nodes.any? { |child| dangling_heredoc?(mutation, child) }
+      end
+
+      # Returns whether a node is, or contains, a heredoc.
+      #
+      # A heredoc's body lies outside its node's byte range. A mutation that
+      # deletes the node leaves the body behind as code, so the mutant
+      # always raises.
+      #
+      # @param node [Prism::Node] node to inspect.
+      # @return [Boolean] true when a heredoc is inside the node.
+      def heredoc?(node)
+        (node.respond_to?(:heredoc?) && node.heredoc?) ||
+          node.compact_child_nodes.any? { |child| heredoc?(child) }
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/boolean_connector.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Boolean connector mutator.
+    #
+    # Replaces symbolic and keyword connectors with their opposite form.
+    class BooleanConnector < Base
+      # Token replacements for boolean connectors.
+      REPLACEMENTS = { "&&" => "||", "||" => "&&", "and" => "or", "or" => "and" }.freeze
+
+      # Visits `and` nodes.
+      #
+      # @param node [Prism::AndNode] node to inspect.
+      # @return [void]
+      def visit_and_node(node)
+        emit(node)
+        super
+      end
+
+      # Visits `or` nodes.
+      #
+      # @param node [Prism::OrNode] node to inspect.
+      # @return [void]
+      def visit_or_node(node)
+        emit(node)
+        super
+      end
+
+      private
+
+      # Emits a connector mutation when the token is replaceable.
+      #
+      # @param node [Prism::Node] connector node.
+      # @return [void]
+      def emit(node)
+        loc = node.operator_loc
+        replacement = REPLACEMENTS[loc.slice]
+        return unless replacement
+
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: replacement,
+          operator: :boolean_connector
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/boolean_literal.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Boolean literal mutator.
+    #
+    # Mutates true/false and nil literals in the boolean_literal family.
+    class BooleanLiteral < Base
+      # Visits true literals.
+      #
+      # @param node [Prism::TrueNode] node to inspect.
+      # @return [void]
+      def visit_true_node(node)
+        emit(node, "false")
+        super
+      end
+
+      # Visits false literals.
+      #
+      # @param node [Prism::FalseNode] node to inspect.
+      # @return [void]
+      def visit_false_node(node)
+        emit(node, "true")
+        super
+      end
+
+      # Visits nil literals.
+      #
+      # @param node [Prism::NilNode] node to inspect.
+      # @return [void]
+      def visit_nil_node(node)
+        emit(node, "true")
+        super
+      end
+
+      private
+
+      # Emits a boolean-literal mutation.
+      #
+      # @param node [Prism::Node] literal node.
+      # @param replacement [String] replacement token.
+      # @return [void]
+      def emit(node, replacement)
+        loc = node.location
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: replacement,
+          operator: :boolean_literal
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/chain_link.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Chain-link mutator (Tier-2).
+    #
+    # Drops one dotted call from a chain of calls, with its arguments and block:
+    # `user.account.owner.name` becomes `user.owner.name` and `user.account.name`.
+    # The chain's receiver and its final call stay, so a chain of n dotted calls
+    # gives at most n - 1 mutations. A chain begins at a receiver that is not a
+    # dotted call: a local, a constant, `self`, `list[i]`, `(a + b)`. A call in
+    # an argument or a block starts a chain of its own.
+    #
+    # The mutant survives when no test tells the chain apart from the same chain
+    # without that step: a scope, a filter or a lookup the tests never see.
+    #
+    # Links in {SKIPPED} are never dropped. On a value that already has the
+    # target type or needs no copy, a conversion (`name.to_s.strip`) or a copy
+    # (`list.dup.sort`) is a no-op, so dropping it most often makes an
+    # equivalent mutant. Dropping `new` sends the next call to the class, which
+    # raises (killed by any test that runs the line) or reaches a class method
+    # that builds the instance itself (equivalent); neither says anything about
+    # the tests.
+    class ChainLink < Base
+      # Method names whose link is never dropped: core conversions and copies,
+      # plus `new`.
+      SKIPPED = %i[
+        to_s to_str to_sym to_i to_int to_f to_r to_c to_a to_ary to_h to_hash to_proc to_set
+        dup clone freeze itself
+        new
+      ].freeze
+
+      # Resets the per-subject record of calls already placed in a chain.
+      #
+      # @param subject [Mutineer::Subject] subject whose body is visited.
+      # @param source [String] full source text for byte-based slicing.
+      # @return [Array<Mutineer::Mutation>] collected mutations.
+      def mutations_for(subject, source)
+        @links = {}.compare_by_identity
+        super
+      end
+
+      # Visits a call. The outermost dotted call of a chain is its final call;
+      # the dotted calls below it in the receiver are its links.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        chain(node) if dotted?(node) && !@links.key?(node)
+        super
+      end
+
+      # Visits `a.b.c += 1`, whose final call Prism parses as its own node.
+      #
+      # @param node [Prism::CallOperatorWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_operator_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits `a.b.c ||= 1`.
+      #
+      # @param node [Prism::CallOrWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_or_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits `a.b.c &&= 1`.
+      #
+      # @param node [Prism::CallAndWriteNode] node to inspect.
+      # @return [void]
+      def visit_call_and_write_node(node)
+        chain(node)
+        super
+      end
+
+      # Visits a call used as an assignment target, as in `a.b.c, d = 1, 2`.
+      #
+      # @param node [Prism::CallTargetNode] node to inspect.
+      # @return [void]
+      def visit_call_target_node(node)
+        chain(node)
+        super
+      end
+
+      private
+
+      # Walks a final call's receiver chain, recording each link so it is not
+      # taken for the final call of a chain of its own, and dropping each link
+      # not in {SKIPPED}.
+      #
+      # @param top [Prism::Node] the chain's final call; responds to `receiver`.
+      # @return [void]
+      def chain(top)
+        link = top.receiver
+        while dotted?(link)
+          @links[link] = true
+          drop(link) unless SKIPPED.include?(link.name)
+          link = link.receiver
+        end
+      end
+
+      # Emits the removal of one link: from the end of its receiver to the end
+      # of its arguments and block, so a chain split across lines keeps the
+      # layout of the lines that remain.
+      #
+      # @param link [Prism::CallNode] the dotted call to drop.
+      # @return [void]
+      def drop(link)
+        @mutations << Mutation.new(
+          start_offset: link.receiver.location.end_offset,
+          end_offset: link.location.end_offset,
+          replacement: "",
+          operator: :chain_link
+        )
+      end
+
+      # Returns whether a node is a call through `.`, `&.` or `::`.
+      #
+      # @param node [Prism::Node, nil] node to inspect.
+      # @return [Boolean] true for a call node with a call operator.
+      def dotted?(node)
+        node.is_a?(Prism::CallNode) && !node.call_operator_loc.nil?
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/collection_method.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Collection / enumerable method-name mutator (Tier-2).
+    #
+    # Swaps the method-name token of a call to its semantic opposite, one
+    # mutation per occurrence, exactly like the arithmetic/comparison operators.
+    class CollectionMethod < Base
+      # Method-name swaps. All targets are core-Ruby Enumerable/Array methods so
+      # the mutant exercises real behaviour rather than always raising.
+      #
+      # include? -> exclude? is left out: exclude? is not
+      # core Ruby, so that mutant would always NoMethodError (a weak mutant).
+      REPLACEMENTS = {
+        map: "each", each: "map",
+        all?: "any?", any?: "all?",
+        first: "last", last: "first",
+        min: "max", max: "min",
+        select: "reject", reject: "select"
+      }.freeze
+
+      # Visits call nodes and emits collection-method mutations.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        replacement = REPLACEMENTS[node.name]
+        loc = node.message_loc
+        if replacement && loc
+          @mutations << Mutation.new(
+            start_offset: loc.start_offset,
+            end_offset: loc.end_offset,
+            replacement: replacement,
+            operator: :collection_method
+          )
+        end
+        super
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/comparison.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Comparison and boundary mutator.
+    #
+    # Rewrites comparison operators one occurrence at a time.
+    class Comparison < Base
+      # Token replacements for comparison operators.
+      REPLACEMENTS = {
+        :< => "<=", :<= => "<", :> => ">=", :>= => ">", :== => "!=", :!= => "=="
+      }.freeze
+
+      # Visits call nodes and emits comparison mutations.
+      #
+      # @param node [Prism::CallNode] call node to inspect.
+      # @return [void]
+      def visit_call_node(node)
+        replacement = REPLACEMENTS[node.name]
+        loc = node.message_loc
+        if replacement && loc && node.receiver
+          @mutations << Mutation.new(
+            start_offset: loc.start_offset,
+            end_offset: loc.end_offset,
+            replacement: replacement,
+            operator: :comparison
+          )
+        end
+        super # nested comparisons (a >= b && c <= d) each get their own mutation
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/condition_forcing.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Shared base of the condition-forcing mutators (Tier-2).
+    #
+    # Replaces the condition of an `if`, `elsif`, `unless`, ternary, modifier
+    # guard (`x if y`) or `case`/`in` guard with a literal, so its branch always
+    # runs or never runs. {ConditionTrue} forces `true` and {ConditionFalse}
+    # forces `false`; one mutation per condition each.
+    #
+    # A condition that is already `true`, `false` or `nil`, even in
+    # parentheses, is left alone: forcing it changes nothing or repeats the
+    # `boolean_literal` flip. This holds even when `boolean_literal` does not run.
+    # A condition that holds a heredoc is left alone too: the heredoc body lies
+    # outside the condition, so it would stay behind as code. A condition that
+    # assigns a variable keeps its code and only its value is forced.
+    #
+    # The never-runs side of an else-less conditional can be the same program
+    # as the `nil` that `statement_removal` or `return_nil` puts in place of the
+    # whole conditional. It is still made: dropping it would make the mutants
+    # of one operator depend on which other operators run, and on what the user
+    # suppressed for them. The two then get the same verdict.
+    #
+    # `condition_negation` wraps the condition in `!( ... )`, which neither
+    # forced value is.
+    class ConditionForcing < Base
+      # Condition nodes that `boolean_literal` already mutates.
+      LITERALS = [Prism::TrueNode, Prism::FalseNode, Prism::NilNode].freeze
+
+      # Visits if nodes: `if`, `elsif`, a ternary, a modifier `if` and an
+      # `in ... if` guard.
+      #
+      # @param node [Prism::IfNode] node to inspect.
+      # @return [void]
+      def visit_if_node(node)
+        force(node)
+        super
+      end
+
+      # Visits unless nodes: `unless`, a modifier `unless` and an
+      # `in ... unless` guard.
+      #
+      # @param node [Prism::UnlessNode] node to inspect.
+      # @return [void]
+      def visit_unless_node(node)
+        force(node)
+        super
+      end
+
+      private
+
+      # Emits the forced condition unless the condition is a literal or holds a
+      # heredoc, whose body would stay behind as code.
+      #
+      # @param node [Prism::IfNode, Prism::UnlessNode] the conditional.
+      # @return [void]
+      def force(node)
+        predicate = node.predicate
+        return if LITERALS.include?(unwrap(predicate).class) || heredoc?(predicate)
+
+        loc = predicate.location
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: replacement(predicate),
+          operator: self.class::OPERATOR
+        )
+      end
+
+      # Returns the forced value for the condition, always in parentheses, so it
+      # cannot fuse with a keyword or a `?` next to it: `x if@a` becomes
+      # `x if(true)` and `@a?1:2` becomes `(true)?1:2`. A condition that assigns
+      # a variable keeps its code, so later reads still see the variable:
+      # `(m = x; true)`.
+      #
+      # @param predicate [Prism::Node] the condition.
+      # @return [String] the replacement source.
+      def replacement(predicate)
+        value = self.class::VALUE.to_s
+        writes?(predicate) ? "(#{predicate.slice}; #{value})" : "(#{value})"
+      end
+
+      # Returns whether the node writes a variable or constant anywhere inside
+      # it: a local, instance, class or global variable, or a constant, in a
+      # plain, compound, multiple or pattern write, or a named regex capture.
+      #
+      # @param node [Prism::Node] the node to inspect.
+      # @return [Boolean] true when a write or target node is inside.
+      def writes?(node)
+        return true if node.type.name.end_with?("_write_node", "_target_node")
+
+        node.compact_child_nodes.any? { |child| writes?(child) }
+      end
+
+      # Returns the node inside parentheses that hold exactly one expression,
+      # so `(true)` and `((true))` read as `true`.
+      #
+      # @param node [Prism::Node] the condition.
+      # @return [Prism::Node] the innermost wrapped node, or `node` itself.
+      def unwrap(node)
+        body = node.body if node.is_a?(Prism::ParenthesesNode)
+        body = body.body.first if body.is_a?(Prism::StatementsNode) && body.body.size == 1
+        body && !body.is_a?(Prism::StatementsNode) ? unwrap(body) : node
+      end
+    end
+
+    # Condition-forcing mutator: the condition becomes `true` (Tier-2).
+    #
+    # An `if` branch always runs; an `unless` branch never runs. The mutant
+    # survives when no test runs the code with the condition false (for an
+    # `if`) or true (for an `unless`) and checks what changes.
+    class ConditionTrue < ConditionForcing
+      # The literal the condition is replaced with.
+      VALUE = true
+      # The operator name mutations carry.
+      OPERATOR = :condition_true
+    end
+
+    # Condition-forcing mutator: the condition becomes `false` (Tier-2).
+    #
+    # An `if` branch never runs; an `unless` branch always runs. The mutant
+    # survives when no test needs the branch the condition guards (for an
+    # `if`) or skips it (for an `unless`).
+    class ConditionFalse < ConditionForcing
+      # The literal the condition is replaced with.
+      VALUE = false
+      # The operator name mutations carry.
+      OPERATOR = :condition_false
+    end
+  end
+end

data/lib/mutineer/mutators/condition_negation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Condition-negation mutator.
+    #
+    # Wraps if/unless predicates in `!( ... )` textually.
+    class ConditionNegation < Base
+      # Visits if nodes.
+      #
+      # @param node [Prism::IfNode] node to inspect.
+      # @return [void]
+      def visit_if_node(node)
+        wrap(node.predicate)
+        super
+      end
+
+      # Visits unless nodes.
+      #
+      # @param node [Prism::UnlessNode] node to inspect.
+      # @return [void]
+      def visit_unless_node(node)
+        wrap(node.predicate)
+        super
+      end
+
+      private
+
+      # Wraps a predicate in negation.
+      #
+      # @param predicate [Prism::Node, nil] predicate node.
+      # @return [void]
+      def wrap(predicate)
+        return unless predicate
+
+        loc = predicate.location
+        original = @source.byteslice(loc.start_offset...loc.end_offset)
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: "!( #{original} )",
+          operator: :condition_negation
+        )
+      end
+    end
+  end
+end

data/lib/mutineer/mutators/literal_mutation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Mutineer
+  module Mutators
+    # Literal mutation mutator.
+    #
+    # Mutates integers and strings with the Tier-2 literal rules.
+    class LiteralMutation < Base
+      # Visits integer literals.
+      #
+      # @param node [Prism::IntegerNode] node to inspect.
+      # @return [void]
+      def visit_integer_node(node)
+        n = node.value
+        emit(node.location, "0") unless n.zero?
+        emit(node.location, "1") unless n == 1
+        emit(node.location, (n + 1).to_s)
+        super
+      end
+
+      # Visits string literals.
+      #
+      # @param node [Prism::StringNode] node to inspect.
+      # @return [void]
+      def visit_string_node(node)
+        loc = node.location
+        token = @source.byteslice(loc.start_offset...loc.end_offset)
+        emit(loc, '""') unless token == '""' || token == "''" || node.unescaped.empty?
+        super
+      end
+
+      private
+
+      # Emits a literal mutation.
+      #
+      # @param loc [Prism::Location] source location.
+      # @param replacement [String] replacement literal.
+      # @return [void]
+      def emit(loc, replacement)
+        @mutations << Mutation.new(
+          start_offset: loc.start_offset,
+          end_offset: loc.end_offset,
+          replacement: replacement,
+          operator: :literal_mutation
+        )
+      end
+    end
+  end
+end