mutant 0.1.1 → 0.2.0

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

@@ -0,0 +1,25 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal
+        # Mutator for nil literals
+        class Nil < self
+
+          handle(Rubinius::AST::NilLiteral)
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit('Object.new'.to_ast)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal
+        # Abstract literal range mutator
+        class Range < self
+          include AbstractType
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_nil
+            emit(inverse)
+            emit_range
+          end
+
+          # Return inverse node
+          #
+          # @return [Rubinius::AST::Node]
+          #
+          # @api private
+          #
+          def inverse
+            new(inverse_class,node.start, node.finish)
+          end
+
+          # Emit range specific mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_range
+            emit_finish_mutations
+            emit_start_mutations
+          end
+
+          # Emit range start mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_finish_mutations
+            finish = node.finish
+            emit_self(negative_infinity, finish)
+            emit_self(nan, finish)
+          end
+
+          # Emit start mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_start_mutations
+            start = node.start
+            emit_self(start, infinity)
+            emit_self(start, nan)
+          end
+
+          # Return inverse AST node class
+          #
+          # @return [Class:Rubinius::AST::Node]
+          #
+          # @api private
+          #
+          def inverse_class
+            self.class::INVERSE_CLASS
+          end
+
+          # Mutator for range exclude literals
+          class Exclude < self
+            INVERSE_CLASS = Rubinius::AST::Range
+            handle(Rubinius::AST::RangeExclude)
+
+          end
+
+          # Mutator for range include literals
+          class Include < self
+            INVERSE_CLASS = Rubinius::AST::RangeExclude
+            handle(Rubinius::AST::Range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for regexp literals
+        class Regex < self
+
+          handle(Rubinius::AST::RegexLiteral)
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_nil
+            emit_self('') # match all
+            emit_self('a\A') # match nothing
+            emit_new { new_self(Random.hex_string) }
+          end
+
+          # Return new Rubinius::AST::Regex
+          #
+          # @param [String] source
+          #
+          # @param [Integer] options
+          #   options of regexp, defaults to mutation subject node options
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def new_self(source,options=nil)
+            super(source,options || node.options)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal
+        # Mutator for string literals
+        class String < self
+
+          handle(Rubinius::AST::StringLiteral)
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_nil
+            emit_new { new_self(Random.hex_string) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Mutant
+  class Mutator
+    class Node
+      class Literal < self
+        # Mutator for symbol literals
+        class Symbol < self
+
+          handle(Rubinius::AST::SymbolLiteral)
+
+        private
+
+          # Emit mutatns
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_nil
+            emit_new { new_self(('s'+Random.hex_string).to_sym) }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Mutant
+  class Mutator
+    class Node
+      # Mutator that does not do mutations on ast
+      class Noop < self
+
+        # Literal references to self do not need to be mutated?
+        handle(Rubinius::AST::Self)
+
+
+        # Currently unhandled node classes. Feel free to contribute your mutator!
+        handle(Rubinius::AST::While)
+        handle(Rubinius::AST::ElementAssignment)
+        handle(Rubinius::AST::AttributeAssignment)
+        handle(Rubinius::AST::Not)
+        handle(Rubinius::AST::And)
+        handle(Rubinius::AST::Defined)
+        handle(Rubinius::AST::Super)
+        handle(Rubinius::AST::Match3)
+        handle(Rubinius::AST::ZSuper)
+        handle(Rubinius::AST::MultipleAssignment)
+        handle(Rubinius::AST::ScopedConstant)
+        handle(Rubinius::AST::LocalVariableAssignment)
+        handle(Rubinius::AST::LocalVariableAccess)
+        handle(Rubinius::AST::InstanceVariableAssignment)
+        handle(Rubinius::AST::InstanceVariableAccess)
+        handle(Rubinius::AST::GlobalVariableAssignment)
+        handle(Rubinius::AST::GlobalVariableAccess)
+        handle(Rubinius::AST::ToplevelConstant)
+        handle(Rubinius::AST::Ensure)
+        handle(Rubinius::AST::Rescue)
+        handle(Rubinius::AST::DynamicString)
+        handle(Rubinius::AST::DynamicSymbol)
+        handle(Rubinius::AST::File)
+        handle(Rubinius::AST::DynamicRegex)
+        handle(Rubinius::AST::OpAssignOr19)
+        handle(Rubinius::AST::OpAssign1)
+        handle(Rubinius::AST::Or)
+        handle(Rubinius::AST::ConstantAccess)
+      
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          # noop
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for Rubinius::AST::When nodes
+      class When < self
+
+        handle(Rubinius::AST::When)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_attribute_mutations(:body)
+        end
+
+      end
+
+      # Mutator for Rubinius::AST::ReceiverCase nodes
+      class ReceiverCase < self
+
+        handle(Rubinius::AST::ReceiverCase)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_attribute_mutations(:receiver)
+          emit_when_branch_presence_mutations
+          emit_else_branch_presence_mutation
+          emit_when_branch_mutations
+        end
+
+        # Emit else branch presence mutation
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_else_branch_presence_mutation
+          emit_self(receiver, when_branches, nil)
+        end
+
+        # Emit when branch body mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_when_branch_mutations
+          when_branches.each_with_index do |branch,index|
+            Mutator.each(branch) do |mutant|
+              branches = dup_when_branches
+              branches[index]=mutant
+              emit_self(receiver, branches, else_branch)
+            end
+          end
+        end
+
+        # Emit when branch presence mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_when_branch_presence_mutations
+          return if one?
+          when_branches.each_index do |index|
+            dup_branches = dup_when_branches
+            dup_branches.delete_at(index)
+            emit_self(receiver, dup_branches, else_branch)
+          end
+        end
+
+        # Check for case there is only one when branch
+        #
+        # @return [true]
+        #   returns true when there is only one when branch
+        #
+        # @return [false]
+        #   returns false otherwise
+        #
+        # @api private
+        #
+        def one?
+          when_branches.one?
+        end
+
+        # Return duplicate of when branches
+        #
+        # @return [Array]
+        #
+        # @api private
+        #
+        def dup_when_branches
+          when_branches.dup
+        end
+
+        # Return when branches
+        #
+        # @return [Array]
+        #
+        # @api private
+        #
+        def when_branches
+          node.whens
+        end
+
+        # Return receiver
+        #
+        # @return [Rubinius::AST::Node]
+        #
+        # @api private
+        #
+        def receiver
+          node.receiver
+        end
+
+        # Return else branch
+        #
+        # @return [Rubinius::AST::Node]
+        #
+        # @api private
+        #
+        def else_branch
+          node.else
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for return statements
+      class Return < self
+
+        handle(Rubinius::AST::Return)
+
+      private
+
+
+        # Emit mutants
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          value = node.value
+          if value
+            emit(value)
+          else
+            emit_nil
+          end
+        end
+
+      end
+    end
+  end
+
+end