evilution 0.1.0

data/lib/evilution/mutator/operator/arithmetic_replacement.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class ArithmeticReplacement < Base
+        REPLACEMENTS = {
+          :+ => [:-],
+          :- => [:+],
+          :* => [:/],
+          :/ => [:*],
+          :% => [:*],
+          :** => [:*]
+        }.freeze
+
+        def visit_call_node(node)
+          replacements = REPLACEMENTS[node.name]
+          return super unless replacements
+
+          loc = node.message_loc
+          return super unless loc
+
+          replacements.each do |replacement|
+            add_mutation(
+              offset: loc.start_offset,
+              length: loc.length,
+              replacement: replacement.to_s,
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/array_literal.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class ArrayLiteral < Base
+        def visit_array_node(node)
+          if node.opening_loc && node.elements.any?
+            add_mutation(
+              offset: node.location.start_offset,
+              length: node.location.length,
+              replacement: "[]",
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/boolean_literal_replacement.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class BooleanLiteralReplacement < Base
+        def visit_true_node(node)
+          add_mutation(
+            offset: node.location.start_offset,
+            length: node.location.length,
+            replacement: "false",
+            node: node
+          )
+
+          super
+        end
+
+        def visit_false_node(node)
+          add_mutation(
+            offset: node.location.start_offset,
+            length: node.location.length,
+            replacement: "true",
+            node: node
+          )
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/boolean_operator_replacement.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class BooleanOperatorReplacement < Base
+        REPLACEMENTS = {
+          "&&" => "||",
+          "||" => "&&",
+          "and" => "or",
+          "or" => "and"
+        }.freeze
+
+        def visit_and_node(node)
+          loc = node.operator_loc
+          operator = loc.slice
+          replacement = REPLACEMENTS[operator]
+
+          if replacement
+            add_mutation(
+              offset: loc.start_offset,
+              length: loc.length,
+              replacement: replacement,
+              node: node
+            )
+          end
+
+          super
+        end
+
+        def visit_or_node(node)
+          loc = node.operator_loc
+          operator = loc.slice
+          replacement = REPLACEMENTS[operator]
+
+          if replacement
+            add_mutation(
+              offset: loc.start_offset,
+              length: loc.length,
+              replacement: replacement,
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/collection_replacement.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class CollectionReplacement < Base
+        REPLACEMENTS = {
+          map: [:each],
+          each: [:map],
+          select: [:reject],
+          reject: [:select],
+          flat_map: [:map],
+          collect: [:each]
+        }.freeze
+
+        def visit_call_node(node)
+          replacements = REPLACEMENTS[node.name]
+          return super unless replacements
+
+          loc = node.message_loc
+          return super unless loc
+
+          replacements.each do |replacement|
+            add_mutation(
+              offset: loc.start_offset,
+              length: loc.length,
+              replacement: replacement.to_s,
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/comparison_replacement.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class ComparisonReplacement < Base
+        REPLACEMENTS = {
+          :> => %i[>= ==],
+          :< => %i[<= ==],
+          :>= => %i[> ==],
+          :<= => %i[< ==],
+          :== => [:!=],
+          :!= => [:==]
+        }.freeze
+
+        def visit_call_node(node)
+          replacements = REPLACEMENTS[node.name]
+          return super unless replacements
+
+          loc = node.message_loc
+          return super unless loc
+
+          replacements.each do |replacement|
+            add_mutation(
+              offset: loc.start_offset,
+              length: loc.length,
+              replacement: replacement.to_s,
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/conditional_branch.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class ConditionalBranch < Base
+        def visit_if_node(node)
+          if node.statements && node.subsequent.nil?
+            add_mutation(
+              offset: node.statements.location.start_offset,
+              length: node.statements.location.length,
+              replacement: "nil",
+              node: node
+            )
+          elsif node.statements && node.subsequent&.statements
+            add_mutation(
+              offset: node.statements.location.start_offset,
+              length: node.statements.location.length,
+              replacement: "nil",
+              node: node
+            )
+
+            add_mutation(
+              offset: node.subsequent.statements.location.start_offset,
+              length: node.subsequent.statements.location.length,
+              replacement: "nil",
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/conditional_negation.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class ConditionalNegation < Base
+        def visit_if_node(node)
+          mutate_predicate(node)
+          super
+        end
+
+        def visit_unless_node(node)
+          mutate_predicate(node)
+          super
+        end
+
+        private
+
+        def mutate_predicate(node)
+          add_mutation(
+            offset: node.predicate.location.start_offset,
+            length: node.predicate.location.length,
+            replacement: "true",
+            node: node
+          )
+          add_mutation(
+            offset: node.predicate.location.start_offset,
+            length: node.predicate.location.length,
+            replacement: "false",
+            node: node
+          )
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/float_literal.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class FloatLiteral < Base
+        def visit_float_node(node)
+          replacement = case node.value
+                        when 0.0 then "1.0"
+                        when 1.0 then "0.0"
+                        else "0.0"
+                        end
+
+          add_mutation(
+            offset: node.location.start_offset,
+            length: node.location.length,
+            replacement: replacement,
+            node: node
+          )
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/hash_literal.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class HashLiteral < Base
+        def visit_hash_node(node)
+          if node.elements.any?
+            add_mutation(
+              offset: node.location.start_offset,
+              length: node.location.length,
+              replacement: "{}",
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/integer_literal.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class IntegerLiteral < Base
+        def visit_integer_node(node)
+          value = node.value
+
+          if value.zero?
+            add_mutation(
+              offset: node.location.start_offset,
+              length: node.location.length,
+              replacement: "1",
+              node: node
+            )
+          elsif value == 1
+            add_mutation(
+              offset: node.location.start_offset,
+              length: node.location.length,
+              replacement: "0",
+              node: node
+            )
+          else
+            add_mutation(
+              offset: node.location.start_offset,
+              length: node.location.length,
+              replacement: "0",
+              node: node
+            )
+
+            add_mutation(
+              offset: node.location.start_offset,
+              length: node.location.length,
+              replacement: (node.value + 1).to_s,
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/method_body_replacement.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class MethodBodyReplacement < Base
+        def visit_def_node(node)
+          if node.body
+            add_mutation(
+              offset: node.body.location.start_offset,
+              length: node.body.location.length,
+              replacement: "nil",
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/negation_insertion.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class NegationInsertion < Base
+        def visit_call_node(node)
+          if node.name.to_s.end_with?("?")
+            add_mutation(
+              offset: node.location.start_offset,
+              length: 0,
+              replacement: "!",
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/nil_replacement.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class NilReplacement < Base
+        def visit_nil_node(node)
+          add_mutation(
+            offset: node.location.start_offset,
+            length: node.location.length,
+            replacement: "true",
+            node: node
+          )
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/return_value_removal.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class ReturnValueRemoval < Base
+        def visit_return_node(node)
+          if node.arguments
+            add_mutation(
+              offset: node.location.start_offset,
+              length: node.location.length,
+              replacement: "return",
+              node: node
+            )
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/statement_deletion.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class StatementDeletion < Base
+        def visit_statements_node(node)
+          if node.body.length > 1
+            node.body.each do |child|
+              add_mutation(
+                offset: child.location.start_offset,
+                length: child.location.length,
+                replacement: "",
+                node: child
+              )
+            end
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/string_literal.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class StringLiteral < Base
+        def visit_string_node(node)
+          replacement = node.content.empty? ? '"mutation"' : '""'
+
+          add_mutation(
+            offset: node.location.start_offset,
+            length: node.location.length,
+            replacement: replacement,
+            node: node
+          )
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/operator/symbol_literal.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    module Operator
+      class SymbolLiteral < Base
+        def visit_symbol_node(node)
+          add_mutation(
+            offset: node.location.start_offset,
+            length: node.location.length,
+            replacement: ":__evilution_mutated__",
+            node: node
+          )
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/evilution/mutator/registry.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Evilution
+  module Mutator
+    class Registry
+      def self.default
+        registry = new
+        [
+          Operator::ComparisonReplacement,
+          Operator::ArithmeticReplacement,
+          Operator::BooleanOperatorReplacement,
+          Operator::BooleanLiteralReplacement,
+          Operator::NilReplacement,
+          Operator::IntegerLiteral,
+          Operator::FloatLiteral,
+          Operator::StringLiteral,
+          Operator::ArrayLiteral,
+          Operator::HashLiteral,
+          Operator::SymbolLiteral,
+          Operator::ConditionalNegation,
+          Operator::ConditionalBranch,
+          Operator::StatementDeletion,
+          Operator::MethodBodyReplacement,
+          Operator::NegationInsertion,
+          Operator::ReturnValueRemoval,
+          Operator::CollectionReplacement
+        ].each { |op| registry.register(op) }
+        registry
+      end
+
+      def initialize
+        @operators = []
+      end
+
+      def register(operator_class)
+        @operators << operator_class
+        self
+      end
+
+      def mutations_for(subject)
+        @operators.flat_map do |operator_class|
+          operator_class.new.call(subject)
+        end
+      end
+
+      def operator_count
+        @operators.length
+      end
+
+      def operators
+        @operators.dup
+      end
+    end
+  end
+end