mutant 0.5.26 → 0.6.0

data/lib/mutant/runner/collector.rb

@@ -0,0 +1,134 @@
+module Mutant
+  class Runner
+    # Parallel process collector
+    class Collector
+      include Concord::Public.new(:env)
+
+      # Initialize object
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(*)
+        super
+        @start                = Time.now
+        @aggregate            = Hash.new { |hash, key| hash[key] = [] }
+        @activity             = Hash.new(0)
+        @last_mutation_result = nil
+      end
+
+      # Return last mutation result
+      #
+      # @return [Result::Mutation]
+      #   if there is a last mutation result
+      #
+      # @return [nil]
+      #   otherwise
+      #
+      # @api private
+      #
+      attr_reader :last_mutation_result
+
+      # Return active subject results
+      #
+      # @return [Array<Result::Subject>]
+      #
+      # @api private
+      #
+      def active_subject_results
+        active_subjects.map(&method(:subject_result))
+      end
+
+      # Return current result
+      #
+      # @return [Result::Env]
+      #
+      # @api private
+      #
+      def result
+        Result::Env.new(
+          env:             env,
+          runtime:         Time.now - @start,
+          subject_results: subject_results,
+          done:            false
+        )
+      end
+
+      # Handle mutation start
+      #
+      # @param [Mutation] mutation
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def start(mutation)
+        @activity[mutation.subject] += 1
+        self
+      end
+
+      # Handle mutation finish
+      #
+      # @param [Result::Mutation] mutation_result
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def finish(mutation_result)
+        @last_mutation_result = mutation_result
+
+        subject = mutation_result.mutation.subject
+
+        @activity[subject] -= 1
+        @aggregate[subject] << mutation_result
+
+        self
+      end
+
+    private
+
+      # Return current subject results
+      #
+      # @return [Array<Result::Subject>]
+      #
+      # @api private
+      #
+      def subject_results
+        env.subjects.map(&method(:subject_result))
+      end
+
+      # Return active subjects
+      #
+      # @return [Array<Subject>]
+      #
+      # @api private
+      #
+      def active_subjects
+        @activity.select do |_subject, count|
+          count > 0
+        end.map(&:first)
+      end
+
+      # Return current subject result
+      #
+      # @param [Subject] subject
+      #
+      # @return [Array<Subject::Result>]
+      #
+      # @api private
+      #
+      def subject_result(subject)
+        mutation_results = @aggregate[subject].sort_by(&:index)
+
+        Result::Subject.new(
+          subject:          subject,
+          runtime:          mutation_results.map(&:runtime).inject(0.0, :+),
+          mutation_results: mutation_results
+        )
+      end
+
+    end # Collector
+  end # Runner
+end # Mutant

data/lib/mutant/subject/method/instance.rb

@@ -5,7 +5,15 @@ module Mutant
       class Instance < self
 
         NAME_INDEX = 0
-        SYMBOL = '#'.freeze
+        SYMBOL     = '#'.freeze
+
+        # A list of methods that will warn when they are undefined
+        WARN_METHODS_UNDEFINED =
+          if RUBY_ENGINE.eql?('ruby')
+            [:initialize, :__send__, :object_id].freeze
+          else
+            EMPTY_ARRAY
+          end
 
         # Test if method is public
         #
@@ -26,10 +34,10 @@ module Mutant
         #
         def prepare
           expected_warnings =
-            if RUBY_ENGINE.eql?('ruby') && name.equal?(:initialize)
-              ["#{__FILE__}:#{__LINE__ + 5}: warning: undefining `initialize' may cause serious problems\n"]
+            if WARN_METHODS_UNDEFINED.include?(name)
+              ["#{__FILE__}:#{__LINE__ + 5}: warning: undefining `#{name}' may cause serious problems\n"]
             else
-              []
+              EMPTY_ARRAY
             end
           WarningExpectation.new(expected_warnings).execute do
             scope.send(:undef_method, name)

data/lib/mutant/version.rb

@@ -1,4 +1,4 @@
 module Mutant
   # The current mutant version
-  VERSION = '0.5.26'.freeze
+  VERSION = '0.6.0'.freeze
 end # Mutant

data/lib/mutant/warning_filter.rb

@@ -1,5 +1,3 @@
-# encoding: UTF-8
-
 module Mutant
   # Stream filter for warnings
   class WarningFilter

data/lib/mutant/zombifier/file.rb

@@ -1,6 +1,6 @@
 module Mutant
   class Zombifier
-    # File containing source beeing zombified
+    # File containing source being zombified
     class File
       include Adamantium::Flat, Concord::Public.new(:path), AST::Sexp
 

data/meta/block.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 Mutant::Meta::Example.add do
-  source 'foo() { a; b }'
+  source 'foo { a; b }'
 
   singleton_mutations
   mutation 'foo { a }'
@@ -13,6 +13,7 @@ Mutant::Meta::Example.add do
   mutation 'foo { nil; b }'
   mutation 'foo { self; b }'
   mutation 'foo'
+  mutation 'a; b'
 end
 
 Mutant::Meta::Example.add do
@@ -45,6 +46,21 @@ Mutant::Meta::Example.add do
   mutation 'foo'
 end
 
+Mutant::Meta::Example.add do
+  source 'foo(a, b) {}'
+
+  singleton_mutations
+  mutation 'foo(a, nil) {}'
+  mutation 'foo(nil, b) {}'
+  mutation 'foo(self, b) {}'
+  mutation 'foo(a, self) {}'
+  mutation 'foo(a, b)'
+  mutation 'foo(a, b) { raise }'
+  mutation 'foo(a) {}'
+  mutation 'foo(b) {}'
+  mutation 'foo {}'
+end
+
 Mutant::Meta::Example.add do
   source 'foo { |(a)| }'
 

data/meta/send.rb

@@ -1,5 +1,67 @@
 # encoding: utf-8
 
+Mutant::Meta::Example.add do
+  source 'a > b'
+
+  singleton_mutations
+  mutation 'a == b'
+  mutation 'a.eql?(b)'
+  mutation 'a.equal?(b)'
+  mutation 'nil > b'
+  mutation 'self > b'
+  mutation 'a > nil'
+  mutation 'a > self'
+  mutation 'a'
+  mutation 'b'
+end
+
+Mutant::Meta::Example.add do
+  source 'a >= b'
+
+  singleton_mutations
+  mutation 'a > b'
+  mutation 'a == b'
+  mutation 'a.eql?(b)'
+  mutation 'a.equal?(b)'
+  mutation 'nil >= b'
+  mutation 'self >= b'
+  mutation 'a >= nil'
+  mutation 'a >= self'
+  mutation 'a'
+  mutation 'b'
+end
+
+Mutant::Meta::Example.add do
+  source 'a <= b'
+
+  singleton_mutations
+  mutation 'a < b'
+  mutation 'a == b'
+  mutation 'a.eql?(b)'
+  mutation 'a.equal?(b)'
+  mutation 'nil <= b'
+  mutation 'self <= b'
+  mutation 'a <= nil'
+  mutation 'a <= self'
+  mutation 'a'
+  mutation 'b'
+end
+
+Mutant::Meta::Example.add do
+  source 'a < b'
+
+  singleton_mutations
+  mutation 'a == b'
+  mutation 'a.eql?(b)'
+  mutation 'a.equal?(b)'
+  mutation 'nil < b'
+  mutation 'self < b'
+  mutation 'a < nil'
+  mutation 'a < self'
+  mutation 'a'
+  mutation 'b'
+end
+
 Mutant::Meta::Example.add do
   source 'reverse_each'
 
@@ -7,6 +69,13 @@ Mutant::Meta::Example.add do
   mutation 'each'
 end
 
+Mutant::Meta::Example.add do
+  source 'reverse_merge'
+
+  singleton_mutations
+  mutation 'merge'
+end
+
 Mutant::Meta::Example.add do
   source 'reverse_map'
 
@@ -22,6 +91,33 @@ Mutant::Meta::Example.add do
   mutation 'each'
 end
 
+Mutant::Meta::Example.add do
+  source 'foo.to_s'
+
+  singleton_mutations
+  mutation 'foo'
+  mutation 'self.to_s'
+  mutation 'foo.to_str'
+end
+
+Mutant::Meta::Example.add do
+  source 'foo.to_a'
+
+  singleton_mutations
+  mutation 'foo'
+  mutation 'self.to_a'
+  mutation 'foo.to_ary'
+end
+
+Mutant::Meta::Example.add do
+  source 'foo.to_i'
+
+  singleton_mutations
+  mutation 'foo'
+  mutation 'self.to_i'
+  mutation 'foo.to_int'
+end
+
 Mutant::Meta::Example.add do
   source 'foo == bar'
 
@@ -36,6 +132,32 @@ Mutant::Meta::Example.add do
   mutation 'foo.equal?(bar)'
 end
 
+Mutant::Meta::Example.add do
+  source 'foo.is_a?(bar)'
+
+  singleton_mutations
+  mutation 'foo'
+  mutation 'bar'
+  mutation 'foo.is_a?'
+  mutation 'foo.is_a?(nil)'
+  mutation 'foo.is_a?(self)'
+  mutation 'self.is_a?(bar)'
+  mutation 'foo.instance_of?(bar)'
+end
+
+Mutant::Meta::Example.add do
+  source 'foo.kind_of?(bar)'
+
+  singleton_mutations
+  mutation 'foo'
+  mutation 'bar'
+  mutation 'foo.kind_of?'
+  mutation 'foo.kind_of?(nil)'
+  mutation 'foo.kind_of?(self)'
+  mutation 'self.kind_of?(bar)'
+  mutation 'foo.instance_of?(bar)'
+end
+
 Mutant::Meta::Example.add do
   source 'foo.gsub(a, b)'
 
@@ -259,7 +381,7 @@ Mutant::Meta::Example.add do
   mutation 'self[*bar]'
 end
 
-(Mutant::AST::Types::BINARY_METHOD_OPERATORS - [:==, :eql?]).each do |operator|
+(Mutant::AST::Types::BINARY_METHOD_OPERATORS - [:<=, :>=, :<, :>, :==, :eql?]).each do |operator|
   Mutant::Meta::Example.add do
     source "true #{operator} false"
 

data/mutant-rspec.gemspec

@@ -13,12 +13,12 @@ Gem::Specification.new do |gem|
   gem.license     = 'MIT'
 
   gem.require_paths    = %w[lib]
-  gem.files            = `git ls-files -- lib/mutant/integration/rspec{,2,3}.rb`.split("\n")
-  gem.test_files       = `git ls-files -- spec/{unit/mutant/rspec,integration/rspec}`.split("\n")
+  gem.files            = `git ls-files -- lib/mutant/integration/rspec.rb`.split("\n")
+  gem.test_files       = `git ls-files -- spec/{unit,integration}/mutant/rspec/**/*.rb}`.split("\n")
   gem.extra_rdoc_files = %w[TODO LICENSE]
 
   gem.add_runtime_dependency('mutant', "~> #{gem.version}")
-  gem.add_runtime_dependency('rspec-core', '>= 2.14.1', '<= 3.0.0')
+  gem.add_runtime_dependency('rspec-core', '>= 2.14.1', '< 3.1.0')
 
   gem.add_development_dependency('bundler', '~> 1.3', '>= 1.3.5')
 end

data/mutant.gemspec

@@ -37,7 +37,7 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency('inflecto',      '~> 0.0.2')
   gem.add_runtime_dependency('anima',         '~> 0.2.0')
   gem.add_runtime_dependency('concord',       '~> 0.1.5')
-  gem.add_runtime_dependency('parallel',      '~> 1.0.0')
+  gem.add_runtime_dependency('parallel',      '~> 1.2.0')
 
   gem.add_development_dependency('bundler', '~> 1.3', '>= 1.3.5')
 end

data/spec/integration/mutant/corpus_spec.rb

@@ -1,209 +1,18 @@
-# encoding: UTF-8
-
-require 'parallel'
-require 'spec_helper'
-
-describe 'Mutant on ruby corpus' do
-
-  ROOT = Pathname.new(__FILE__).parent.parent.parent.parent
-
-  TMP = ROOT.join('tmp').freeze
+RSpec.describe 'Mutant on ruby corpus' do
 
   before do
     skip 'Corpus test is deactivated on 1.9.3' if RUBY_VERSION.eql?('1.9.3')
     skip 'Corpus test is deactivated on RBX' if RUBY_ENGINE.eql?('rbx')
   end
 
-  MUTEX = Mutex.new
-
-  class Project
-    include Adamantium, Anima.new(
-      :name,
-      :repo_uri,
-      :exclude,
-      :mutation_coverage,
-      :mutation_generation,
-      :namespace,
-      :expect_coverage
-    )
-
-    # Verify mutation coverage
-    #
-    # @return [self]
-    #   if successufl
-    #
-    # @raise [Exception]
-    #
-    def verify_mutation_coverage
-      checkout
-      Dir.chdir(repo_path) do
-        relative = ROOT.relative_path_from(repo_path)
-        devtools = ROOT.join('Gemfile.devtools').read
-        devtools << "gem 'mutant', path: '#{relative}'\n"
-        devtools << "gem 'mutant-rspec', path: '#{relative}'\n"
-        File.write(repo_path.join('Gemfile.devtools'), devtools)
-        lockfile = repo_path.join('Gemfile.lock')
-        lockfile.delete if lockfile.exist?
-        Bundler.with_clean_env do
-          system('bundle install')
-          system(%W[bundle exec mutant -I lib -r #{name} --score #{expect_coverage} --use rspec #{namespace}*])
-        end
-      end
-    end
-
-    # Verify mutation generation
-    #
-    # @return [self]
-    #   if successful
-    #
-    # @raise [Exception]
-    #   otherwise
-    #
-    # rubocop:disable MethodLength
-    def verify_mutation_generation
-      checkout
-      start = Time.now
-      paths = Pathname.glob(repo_path.join('**/*.rb')).sort_by(&:size).reverse
-      total = Parallel.map(paths, finish: method(:finish), start: method(:start)) do |path|
-        count = 0
-        node =
-          begin
-            Parser::CurrentRuby.parse(path.read)
-          rescue EncodingError, ArgumentError
-            nil # Make rubocop happy
-          end
-        if node
-          Mutant::Mutator::Node.each(node) do
-            count += 1
-          end
-        end
-        count
-      end.inject(0, :+)
-      took = Time.now - start
-      puts format(
-        'Total Mutations/Time/Parse-Errors: %s/%0.2fs - %0.2f/s',
-        total,
-        took,
-        total / took
-      )
-      self
-    end
-
-    # Checkout repository
-    #
-    # @return [self]
-    #
-    # @api private
-    #
-    def checkout
-      TMP.mkdir unless TMP.directory?
-      if repo_path.exist?
-        Dir.chdir(repo_path) do
-          system(%w[git pull -f origin master])
-          system(%w[git clean -f -d -x])
-        end
-      else
-        system(%W[git clone #{repo_uri} #{repo_path}])
-      end
-      self
-    end
-    memoize :checkout
-
-  private
-
-    # Return repository path
-    #
-    # @return [Pathname]
-    #
-    # @api private
-    #
-    def repo_path
-      TMP.join(name)
-    end
-
-    # Print start progress
-    #
-    # @param [Pathname] path
-    # @param [Fixnum] _index
-    # @param [Fixnum] count
-    #
-    # @return [undefined]
-    #
-    def start(path, _index)
-      MUTEX.synchronize do
-        puts format('Starting - %s', path)
-      end
-    end
-
-    # Print finish progress
-    #
-    # @param [Pathname] path
-    # @param [Fixnum] _index
-    # @param [Fixnum] count
-    #
-    # @return [undefined]
-    #
-    def finish(path, _index, count)
-      MUTEX.synchronize do
-        puts format('Mutations - %4i - %s', count, path)
-      end
-    end
-
-    # Helper method to execute system commands
-    #
-    # @param [Array<String>] arguments
-    #
-    # @api private
-    #
-    def system(arguments)
-      return if Kernel.system(*arguments)
-      if block_given?
-        yield
-      else
-        fail 'System command failed!'
-      end
-    end
-
-    LOADER = Morpher.build do
-      s(:block,
-        s(:guard, s(:primitive, Array)),
-        s(:map,
-          s(:block,
-            s(:guard, s(:primitive, Hash)),
-            s(:hash_transform,
-              s(:key_symbolize, :repo_uri,            s(:guard, s(:primitive, String))),
-              s(:key_symbolize, :name,                s(:guard, s(:primitive, String))),
-              s(:key_symbolize, :namespace,           s(:guard, s(:primitive, String))),
-              s(:key_symbolize, :expect_coverage,     s(:guard, s(:primitive, Float))),
-              s(:key_symbolize, :mutation_coverage,
-                s(:guard, s(:or, s(:primitive, TrueClass), s(:primitive, FalseClass)))),
-              s(:key_symbolize, :mutation_generation,
-                s(:guard, s(:or, s(:primitive, TrueClass), s(:primitive, FalseClass)))),
-              s(:key_symbolize, :exclude,             s(:map, s(:guard, s(:primitive, String))))
-            ),
-            s(:load_attribute_hash,
-              # NOTE: The domain param has no DSL currently!
-              Morpher::Evaluator::Transformer::Domain::Param.new(
-                Project,
-                [:repo_uri, :name, :exclude, :mutation_coverage, :mutation_generation]
-              )
-            )
-          )
-        )
-      )
-    end
-
-    ALL = LOADER.call(YAML.load_file(ROOT.join('spec', 'integrations.yml')))
-  end
-
-  Project::ALL.select(&:mutation_generation).each do |project|
+  Corpus::Project::ALL.select(&:mutation_generation).each do |project|
     specify "#{project.name} does not fail on mutation generation" do
       project.verify_mutation_generation
     end
   end
 
-  Project::ALL.select(&:mutation_coverage).each do |project|
-    specify "#{project.name} does have expected mutaiton coverage" do
+  Corpus::Project::ALL.select(&:mutation_coverage).each do |project|
+    specify "#{project.name} does have expected mutation coverage" do
       project.verify_mutation_coverage
     end
   end