mutant 0.1.1 → 0.2.0

data/lib/mutant/mutator/node/arguments.rb

@@ -0,0 +1,24 @@
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for arguments
+      class Arguments < self
+
+        handle(Rubinius::AST::ActualArguments)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_attribute_mutations(:array)
+        end
+
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/block.rb

@@ -0,0 +1,24 @@
+module Mutant
+  class Mutator
+    class Node
+      # Mutator on AST blocks
+      class Block < self
+
+        handle(Rubinius::AST::Block)
+
+      private
+
+        # Emit mutants
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          array = input.array
+          emit_attribute_mutations(:array)
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/define.rb

@@ -0,0 +1,24 @@
+module Mutant
+  class Mutator
+    class Node
+      class Define < self
+
+        handle(Rubinius::AST::Define)
+        handle(Rubinius::AST::DefineSingleton)
+        handle(Rubinius::AST::DefineSingletonScope)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_attribute_mutations(:body)
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/if_statement.rb

@@ -0,0 +1,93 @@
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for Rubinius::AST::If nodes
+      class IfStatement < self
+
+        handle(Rubinius::AST::If)
+
+      private
+
+        # Emit mutations on Rubinius::AST::If nodes
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_attribute_mutations(:condition)
+          emit_attribute_mutations(:body)
+          emit_attribute_mutations(:else) if node.else
+          emit_inverted_condition 
+          emit_deleted_if_branch
+          emit_deleted_else_branch
+        end
+
+        # Emit inverted condition
+        #
+        # Especially the same like swap branches but more universal as it also 
+        # covers the case there is no else branch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_inverted_condition
+          emit_self(new_send(condition, :'!'), if_branch, else_branch)
+        end
+
+        # Emit deleted else branch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_deleted_else_branch
+          emit_self(condition, if_branch, nil)
+        end
+
+        # Emit deleted if branch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_deleted_if_branch
+          body = else_branch
+          return unless body
+          emit_self(condition, else_branch, nil)
+        end
+
+        # Return if_branch of node
+        #
+        # @return [Rubinius::AST::Node]
+        #
+        # @api private
+        #
+        def if_branch
+          node.body
+        end
+
+        # Return condition of node
+        #
+        # @return [Rubinius::AST::Node]
+        #
+        # @api private
+        #
+        def condition
+          node.condition
+        end
+
+        # Return else body of node
+        #
+        # @return [Rubinius::AST::Node]
+        #
+        # @api private
+        #
+        def else_branch
+          node.else
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/literal.rb

@@ -0,0 +1,54 @@
+module Mutant
+  class Mutator
+    class Node
+      # Abstract mutator for literal AST nodes
+      class Literal < self
+        include AbstractType
+
+      private
+
+        # Return new float literal
+        #
+        # @param [#to_f] value
+        #
+        # @return [Rubinius::Node::FloatLiteral]
+        #
+        # @api private
+        #
+        def new_float(value)
+          new(Rubinius::AST::FloatLiteral, value)
+        end
+
+        # Return AST representing NaN
+        #
+        # @return [Rubinius::Node::AST]
+        #
+        # @api private
+        #
+        def nan
+          new_send(new_float(0), :/, new_float(0))
+        end
+
+        # Return AST representing negative infinity
+        #
+        # @return [Rubinius::Node::AST]
+        #
+        # @api private
+        #
+        def negative_infinity
+          new(Rubinius::AST::Negate, infinity)
+        end
+
+        # Return AST representing infinity
+        #
+        # @return [Rubinius::Node::AST]
+        #
+        # @api private
+        #
+        def infinity
+          new_send(new_float(1), :/, new_float(0))
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/literal/array.rb

@@ -0,0 +1,28 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for array literals
+        class Array < self
+
+          handle(Rubinius::AST::ArrayLiteral)
+
+        private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_attribute_mutations(:body)
+            emit_self([])
+            emit_nil
+            emit_self(node.body.dup << new_nil)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/literal/boolean.rb

@@ -0,0 +1,49 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal < self
+        # Abstract mutator for boolean literals
+        class Boolean < self
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_nil
+            emit(inverse)
+          end
+
+          # Return inverse
+          #
+          # @return [Rubinius::AST::Node]
+          #
+          # @api private
+          #
+          def inverse
+            new(self.class::INVERSE_CLASS)
+          end
+
+          # Mutator for true literals
+          class TrueLiteral < self
+            INVERSE_CLASS = Rubinius::AST::FalseLiteral
+
+            handle(Rubinius::AST::TrueLiteral)
+          end
+
+
+          # Mutator for false literals
+          class FalseLiteral < self
+            INVERSE_CLASS = Rubinius::AST::TrueLiteral
+
+            handle(Rubinius::AST::FalseLiteral)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/literal/dynamic.rb

@@ -0,0 +1,24 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal
+        # Abstract mutations on dynamic literals
+        class Dynamic < self
+          include AbstractType
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/literal/empty_array.rb

@@ -0,0 +1,26 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for empty array literals
+        class EmptyArray < self
+
+          handle(Rubinius::AST::EmptyArray)
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_nil
+            emit_node(Rubinius::AST::ArrayLiteral, [new_nil])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/literal/fixnum.rb

@@ -0,0 +1,37 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for fixnum literals
+        class Fixnum < self
+
+          handle(Rubinius::AST::FixnumLiteral)
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_nil
+            emit_values(values)
+            emit_new { new_self(Random.fixnum) }
+          end
+
+          # Return values to mutate against
+          #
+          # @return [Array]
+          #
+          # @api private
+          #
+          def values
+            [0, 1, -node.value]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/literal/float.rb

@@ -0,0 +1,48 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for float literals
+        class Float < self
+
+          handle(Rubinius::AST::FloatLiteral)
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          def dispatch
+            emit_nil
+            emit_values(values)
+            emit_special_cases
+            emit_new { new_self(Random.float) }
+          end
+
+          # Emit special cases
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_special_cases
+            [infinity, negative_infinity, nan].each do |value|
+              emit(value)
+            end
+          end
+
+          # Return values to test against
+          #
+          # @return [Array]
+          #
+          # @api private
+          #
+          def values
+            [0.0, 1.0] << -node.value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/literal/hash.rb

@@ -0,0 +1,89 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal
+        # Mutator for hash literals
+        class Hash < self
+
+          handle(Rubinius::AST::HashLiteral)
+
+        private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_nil
+            emit_values(values)
+            emit_element_presence
+            emit_body
+          end
+
+          # Emit body mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_body
+            array.each_with_index do |element, index|
+              dup = dup_array
+              Mutator.each(element).each do |mutation|
+                dup[index]=mutation
+                emit_self(dup)
+              end
+            end
+          end
+
+          # Return array of values in literal
+          #
+          # @return [Array]
+          #
+          # @api private
+          #
+          def array
+            node.array
+          end
+
+          # Return duplicate of array values in literal
+          #
+          # @return [Array]
+          #
+          # @api private
+          #
+          def dup_array
+            array.dup
+          end
+
+          # Return values to mutate against
+          #
+          # @return [Array]
+          #
+          # @api private
+          #
+          def values
+            [[], dup_array << new_nil << new_nil ]
+          end
+
+          # Emit element presence mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_element_presence
+            0.step(array.length-1, 2) do |index|
+              contents = dup_array
+              contents.delete_at(index)
+              contents.delete_at(index)
+              emit_self(contents)
+            end
+          end
+        end
+      end
+    end
+  end
+end