mutant 0.2.12 → 0.2.13

data/lib/mutant/mutator/node/send/binary_operator_method.rb

@@ -0,0 +1,61 @@
+module Mutant
+  class Mutator
+    class Node
+      class Send
+
+        # Mutator for sends that correspond to a binary operator
+        class BinaryOperatorMethod < Node
+
+        private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_left_mutations
+            emit_right_mutations
+            emit(right)
+          end
+
+          # Emit left mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_left_mutations
+            emit_attribute_mutations(:receiver)
+          end
+
+          # Return right
+          #
+          # @return [Rubinius::AST::Node]
+          #
+          # @api private
+          #
+          def right
+            node.arguments.array.first
+          end
+
+          # Emit right mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_right_mutations
+            Mutator.each(right).each do |mutated|
+              dup = dup_node
+              dup.arguments.array[0] = mutated
+              emit(dup)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/send/with_arguments.rb

@@ -0,0 +1,81 @@
+module Mutant
+  class Mutator
+    class Node
+      class Send
+
+        # Mutator for send with arguments
+        class WithArguments < self
+          
+          handle(Rubinius::AST::SendWithArguments)
+
+        private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            super
+
+            if binary_operator?
+              run(BinaryOperatorMethod)
+              return
+            end
+
+            emit_send_remove_mutation
+            emit_argument_mutations
+          end
+
+          # Test if message is a binary operator
+          #
+          # @return [true]
+          #   if message is a binary operator
+          #
+          # @return [false]
+          #   otherwise
+          #
+          # @api private
+          #
+          def binary_operator?
+            Mutant::BINARY_METHOD_OPERATORS.include?(node.name)
+          end
+
+          # Emit argument mutations
+          #
+          # @api private
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_argument_mutations
+            emit_attribute_mutations(:arguments) do |mutation|
+              if mutation.arguments.array.empty?
+                mutation = new_send(receiver, node.name)
+                mutation.privately = node.privately
+                mutation
+              else
+                mutation
+              end
+            end
+          end
+
+          # Emit send remove mutation
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_send_remove_mutation
+            array = node.arguments.array
+            return unless array.length == 1
+            emit(array.first)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -2,6 +2,7 @@ module Mutant
   class Mutator
     class Node
 
+      # Mutator for super without parantheses
       class ZSuper < self
 
         handle(Rubinius::AST::ZSuper)
@@ -18,6 +19,7 @@ module Mutant
 
       end
 
+      # Mutator for super with parantheses
       class Super < self
         handle(Rubinius::AST::Super)
 

data/lib/mutant/mutator/node/{arguments.rb → when.rb}

@@ -2,10 +2,10 @@ module Mutant
   class Mutator
     class Node
 
-      # Mutator for arguments
-      class Arguments < self
+      # Mutator for Rubinius::AST::When nodes
+      class When < self
 
-        handle(Rubinius::AST::ActualArguments)
+        handle(Rubinius::AST::When)
 
       private
 
@@ -16,7 +16,7 @@ module Mutant
         # @api private
         #
         def dispatch
-          emit_attribute_mutations(:array)
+          emit_attribute_mutations(:body)
         end
 
       end

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

@@ -1,6 +1,8 @@
 module Mutant
   class Mutator
     class Node
+
+      # Mutator for while expressions
       class While < self
 
         handle(Rubinius::AST::While)

data/lib/mutant/mutator/util/array.rb

@@ -7,6 +7,7 @@ module Mutant
 
         handle(::Array)
 
+        # Element presence mutator
         class Presence < Util
 
         private
@@ -27,6 +28,7 @@ module Mutant
 
         end
 
+        # Array element mutator
         class Element < Util
 
         private
@@ -40,7 +42,6 @@ module Mutant
           def dispatch
             input.each_with_index do |element, index|
               dup = dup_input
-
               Mutator.each(element).each do |mutation|
                 dup[index]=mutation
                 emit(dup)

data/lib/mutant/mutator/util/symbol.rb

@@ -27,7 +27,7 @@ module Mutant
         # @return [false]
         #   otherwise
         #
-        # @pai private
+        # @api private
         #
         def ignore?
           input.to_s[0] == '_'

data/lib/mutant/reporter/null.rb

@@ -1,6 +1,7 @@
 module Mutant
   class Reporter
 
+    # Null reporter
     class Null < self
 
       # Report subject

data/lib/mutant/runner.rb

@@ -47,11 +47,10 @@ module Mutant
     def initialize(config)
       @config, @errors = config, []
 
-      reporter.config(config)
-
+      util_reporter = reporter
+      util_reporter.config(config)
       run
-
-      reporter.errors(@errors)
+      util_reporter.errors(@errors)
     end
 
     # Return reporter

data/lib/mutant/singleton_methods.rb

@@ -0,0 +1,28 @@
+# Singleton methods are defined here so zombie can pick them up
+module Mutant
+
+  # Define instance of subclassed superclass as constant
+  #
+  # @param [Class] superclass
+  # @param [Symbol] name
+  #
+  # @return [self]
+  #
+  # @api private
+  #
+  def self.define_singleton_subclass(name, superclass, &block)
+    klass = Class.new(superclass) do
+
+      def inspect; self.class.name; end
+
+      define_singleton_method(:name) do
+        "#{superclass.name}::#{name}".freeze
+      end
+
+    end
+    klass.class_eval(&block)
+    superclass.const_set(name, klass.new)
+    self
+  end
+
+end

data/lib/mutant/strategy.rb

@@ -1,4 +1,6 @@
 module Mutant
+
+  # Abstract base class for killing strategies
   class Strategy 
     include AbstractType, Adamantium::Flat, Equalizer.new
 

data/lib/mutant/strategy/rspec/example_lookup.rb

@@ -116,10 +116,12 @@ module Mutant
         # @api private
         #
         def glob_expression
+          base = base_path
+
           if mutation.subject.matcher.public?
-            "#{base_path}/#{spec_file}"
+            "#{base}/#{spec_file}"
           else
-            "#{base_path}/*_spec.rb"
+            "#{base}/*_spec.rb"
           end
         end
 

data/mutant.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |gem|
   gem.name        = 'mutant'
-  gem.version     = '0.2.12'
+  gem.version     = '0.2.13'
   gem.authors     = [ 'Markus Schirp' ]
   gem.email       = [ 'mbj@seonic.net' ]
-  gem.description = 'Mutation testing for ruby under rubinius'
-  gem.summary     = gem.description
+  gem.description = 'Mutation testing for ruby'
+  gem.summary     = 'Mutation testing tool for ruby under MRI and Rubinius'
   gem.homepage    = 'https://github.com/mbj/mutant'
 
   gem.require_paths    = [ 'lib' ]
@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.extra_rdoc_files = %w[TODO LICENSE]
   gem.executables       = [ 'mutant' ]
 
-  gem.add_runtime_dependency('to_source',           '~> 0.2.8')
+  gem.add_runtime_dependency('to_source',           '~> 0.2.13')
   gem.add_runtime_dependency('ice_nine',            '~> 0.6.0')
   gem.add_runtime_dependency('descendants_tracker', '~> 0.0.1')
   gem.add_runtime_dependency('backports',           '~> 2.6')

data/spec/shared/mutator_behavior.rb

@@ -51,8 +51,7 @@ shared_examples_for 'a mutator' do
       unexpected = (generated - expected_mutations).to_a
 
       unless generated == expected_mutations
-        message ="Missing mutations:\n%s\nUnexpected mutations:\n%s" % [missing.join("\n----\n"), unexpected.join("\n----\n")]
-        fail message
+        fail "Missing mutations:\n%s\nUnexpected mutations:\n%s" % [missing.join("\n----\n"), unexpected.join("\n----\n")]
       end
     end
   end

data/spec/support/zombie.rb

@@ -26,6 +26,39 @@ module Zombie
   end
   private_class_method :root
 
+  class DummySubject
+
+    # Return line
+    #
+    # @return [Fixnum]
+    #
+    # @api private
+    #
+    attr_reader :source_line
+
+    # Return path
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    attr_reader :source_path
+
+  private
+
+    # Initialize object
+    #
+    # @param [String] path
+    # @param [Fixnum] line
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(path, line)
+      @source_path, @source_line = path, line
+    end
+  end
 
   # Replace Mutant with Zombie namespace
   #
@@ -51,7 +84,7 @@ module Zombie
       node.body = Rubinius::AST::ModuleScope.new(scope.line, node.name, scope.body)
     end
 
-    ::Mutant::Loader::Eval.run(root, path, 1)
+    ::Mutant::Loader::Eval.run(root, DummySubject.new(path, 1))
   end
   private_class_method :zombify
 
@@ -122,7 +155,7 @@ module Zombie
   #  Yeah looks very ugly but im currently to exited to do a cleanup.
   #
   def self.files
-    block = File.read("lib/mutant.rb").to_ast
+    block = File.read('lib/mutant.rb').to_ast
     files = block.array.select do |node|
       node.class          == Rubinius::AST::SendWithArguments &&
       node.receiver.class == Rubinius::AST::Self              &&

data/spec/unit/mutant/loader/eval/class_methods/run_spec.rb

@@ -2,15 +2,14 @@ require 'spec_helper'
 
 describe Mutant::Loader::Eval, '.run' do
 
-  subject { object.run(node, file, line) }
+  subject { object.run(node, mutation_subject) }
 
-  let(:object) { described_class }
-  let(:file)   { 'test.rb'       }
-  let(:line)   { 1               }
+  let(:object)           { described_class                                             }
+  let(:mutation_subject) { mock('Subject', :source_path => path, :source_line => line) }
+  let(:path)             { 'test.rb'                                                   }
+  let(:line)             { 1                                                           }
 
   let(:source) do
-    # This test case will blow up when not executed
-    # under toplevel binding.
     <<-RUBY
       class SomeNamespace
         class Bar

data/spec/unit/mutant/mutator/node/literal/float_spec.rb

@@ -11,7 +11,7 @@ describe Mutant::Mutator::Node::Literal, 'float' do
     mutations << random_float.to_s
     mutations << '0.0/0.0'
     mutations << '1.0/0.0'
-    mutations << '-(1.0 / 0.0)'
+    mutations << '(-1.0 / 0.0)'
     mutations << '-10.0'
   end
 

data/spec/unit/mutant/mutator/node/send/mutation_spec.rb

@@ -55,6 +55,66 @@ describe Mutant::Mutator, 'send' do
     end
   end
 
+  context 'with block' do
+    let(:source) { 'foo() { a; b }' }
+
+    let(:mutations) do 
+      mutations = []
+      mutations << 'foo() { a }'
+      mutations << 'foo() { b }'
+      mutations << 'foo() { }'
+      mutations << 'foo'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'with block args' do
+
+    let(:source) { 'foo { |a, b| }' }
+
+    before do
+      Mutant::Random.stub(:hex_string => :random)
+    end
+
+    let(:mutations) do 
+      mutations = []
+      mutations << 'foo'
+      mutations << 'foo { |a, b| Object.new }'
+      mutations << 'foo { |a, srandom| }'
+      mutations << 'foo { |srandom, b| }'
+      mutations << 'foo { |a| }'
+      mutations << 'foo { |b| }'
+      mutations << 'foo { || }'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'with block pattern args' do
+
+    before do
+      Mutant::Random.stub(:hex_string => :random)
+    end
+
+    let(:source) { 'foo { |(a, b), c| }' }
+
+    let(:mutations) do 
+      mutations = []
+      mutations << 'foo { || }'
+      mutations << 'foo { |a, b, c| }'
+      mutations << 'foo { |(a, b), c| Object.new }'
+      mutations << 'foo { |(a, b)| }'
+      mutations << 'foo { |c| }'
+      mutations << 'foo { |(srandom, b), c| }'
+      mutations << 'foo { |(a, srandom), c| }'
+      mutations << 'foo { |(a, b), srandom| }'
+      mutations << 'foo'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
   context 'send with arguments' do
 
     context 'one argument' do
@@ -62,7 +122,7 @@ describe Mutant::Mutator, 'send' do
 
       let(:mutations) do 
         mutations = []
-        mutations << 'foo()'
+        mutations << 'foo'
         mutations << 'nil'
         mutations << 'foo(Object.new)'
       end
@@ -134,65 +194,5 @@ describe Mutant::Mutator, 'send' do
       it_should_behave_like 'a mutator'
     end
 
-    context 'with block' do
-      let(:source) { 'foo() { a; b }' }
-
-      let(:mutations) do 
-        mutations = []
-        mutations << 'foo() { a }'
-        mutations << 'foo() { b }'
-        mutations << 'foo() { }'
-        mutations << 'foo'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
-    context 'with block args' do
-
-      let(:source) { 'foo { |a, b| }' }
-
-      before do
-        Mutant::Random.stub(:hex_string => :random)
-      end
-
-      let(:mutations) do 
-        mutations = []
-        mutations << 'foo'
-        mutations << 'foo() { |a, b| Object.new }'
-        mutations << 'foo() { |a, srandom| }'
-        mutations << 'foo() { |srandom, b| }'
-        mutations << 'foo() { |a| }'
-        mutations << 'foo() { |b| }'
-        mutations << 'foo() { || }'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
-    context 'with block pattern args' do
-
-      before do
-        Mutant::Random.stub(:hex_string => :random)
-      end
-
-      let(:source) { 'foo { |(a, b), c| }' }
-
-      let(:mutations) do 
-        mutations = []
-        mutations << 'foo() { || }'
-        mutations << 'foo() { |a, b, c| }'
-        mutations << 'foo() { |(a, b), c| Object.new }'
-        mutations << 'foo() { |(a, b)| }'
-        mutations << 'foo() { |c| }'
-        mutations << 'foo() { |(srandom, b), c| }'
-        mutations << 'foo() { |(a, srandom), c| }'
-        mutations << 'foo() { |(a, b), srandom| }'
-        mutations << 'foo'
-      end
-
-      it_should_behave_like 'a mutator'
-    end
-
   end
 end