mutant 0.7.4 → 0.7.5

data/lib/mutant/version.rb

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

data/mutant.gemspec

@@ -21,16 +21,16 @@ Gem::Specification.new do |gem|
   gem.extra_rdoc_files = %w[TODO LICENSE]
   gem.executables      = %w[mutant]
 
-  gem.required_ruby_version = '>= 2.0.0'
+  gem.required_ruby_version = '>= 1.9.3'
 
-  gem.add_runtime_dependency('parser',        '~> 2.2.pre.7')
+  gem.add_runtime_dependency('parser',        '~> 2.2.0.2')
   gem.add_runtime_dependency('ast',           '~> 2.0')
   gem.add_runtime_dependency('diff-lcs',      '~> 1.2')
   gem.add_runtime_dependency('parallel',      '~> 1.3')
   gem.add_runtime_dependency('morpher',       '~> 0.2.3')
   gem.add_runtime_dependency('procto',        '~> 0.0.2')
   gem.add_runtime_dependency('abstract_type', '~> 0.0.7')
-  gem.add_runtime_dependency('unparser',      '~> 0.1.16')
+  gem.add_runtime_dependency('unparser',      '~> 0.2.2')
   gem.add_runtime_dependency('ice_nine',      '~> 0.11.1')
   gem.add_runtime_dependency('adamantium',    '~> 0.2.0')
   gem.add_runtime_dependency('memoizable',    '~> 0.4.2')

data/spec/spec_helper.rb

@@ -34,7 +34,7 @@ require 'test_app'
 module Fixtures
   TEST_CONFIG = Mutant::Config::DEFAULT.update(reporter: Mutant::Reporter::Trace.new)
   TEST_CACHE  = Mutant::Cache.new
-  TEST_ENV    = Mutant::Env.new(TEST_CONFIG, TEST_CACHE)
+  TEST_ENV    = Mutant::Env::Bootstrap.call(TEST_CONFIG, TEST_CACHE)
 end # Fixtures
 
 module ParserHelper

data/spec/support/corpus.rb

@@ -94,7 +94,7 @@ module Corpus
       TMP.mkdir unless TMP.directory?
       if repo_path.exist?
         Dir.chdir(repo_path) do
-          system(%w[git fetch])
+          system(%w[git fetch origin])
           system(%w[git reset --hard])
           system(%w[git clean -f -d -x])
           system(%w[git checkout origin/master])
@@ -119,10 +119,10 @@ module Corpus
     def install_mutant
       return if noinstall?
       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)
+      repo_path.join('Gemfile').open('a') do |file|
+        file << "gem 'mutant', path: '#{relative}'\n"
+        file << "gem 'mutant-rspec', path: '#{relative}'\n"
+      end
       lockfile = repo_path.join('Gemfile.lock')
       lockfile.delete if lockfile.exist?
       system('bundle install')

data/spec/support/shared_context.rb

@@ -25,7 +25,6 @@ module SharedContext
     let(:matchable_scopes) { double('matchable scopes', length: 10)                                     }
     let(:test_a)           { double('test a', identification: 'test-a')                                 }
     let(:test_b)           { double('test b', identification: 'test-b')                                 }
-    let(:actor_names)      { []                                                                         }
     let(:message_sequence) { FakeActor::MessageSequence.new                                             }
 
     let(:status) do
@@ -38,16 +37,11 @@ module SharedContext
 
     let(:config) do
       Mutant::Config::DEFAULT.update(
-        actor_env: actor_env,
         jobs:      1,
         reporter:  Mutant::Reporter::Trace.new
       )
     end
 
-    let(:actor_env) do
-      FakeActor::Env.new(message_sequence, actor_names)
-    end
-
     let(:subject_a) do
       double(
         'subject a',
@@ -111,6 +105,7 @@ module SharedContext
     let(:subject_a_result) do
       Mutant::Result::Subject.new(
         subject:          subject_a,
+        tests:            [test_a],
         mutation_results: [mutation_a_result, mutation_b_result]
       )
     end

data/spec/unit/mutant/cli_spec.rb

@@ -9,7 +9,7 @@ end
 RSpec.shared_examples_for 'a cli parser' do
   it { expect(subject.config.integration).to eql(expected_integration)       }
   it { expect(subject.config.reporter).to eql(expected_reporter)             }
-  it { expect(subject.config.matcher_config).to eql(expected_matcher_config) }
+  it { expect(subject.config.matcher).to eql(expected_matcher_config) }
 end
 
 RSpec.describe Mutant::CLI do
@@ -25,7 +25,7 @@ RSpec.describe Mutant::CLI do
 
     before do
       expect(Mutant::CLI).to receive(:call).with(arguments).and_return(config)
-      expect(Mutant::Env).to receive(:new).with(config).and_return(env)
+      expect(Mutant::Env::Bootstrap).to receive(:call).with(config).and_return(env)
       expect(Mutant::Runner).to receive(:call).with(env).and_return(report)
     end
 

data/spec/unit/mutant/env/boostrap_spec.rb

@@ -0,0 +1,130 @@
+RSpec.describe Mutant::Env::Bootstrap do
+  let(:config) do
+    Mutant::Config::DEFAULT.update(
+      jobs:     1,
+      reporter: Mutant::Reporter::Trace.new,
+      includes: [],
+      requires: [],
+      matcher:  Mutant::Matcher::Config::DEFAULT
+    )
+  end
+
+  let(:expected_env) do
+    Mutant::Env.new(
+      cache:            Mutant::Cache.new,
+      subjects:         [],
+      matchable_scopes: [],
+      mutations:        [],
+      config:           config,
+      selector:         Mutant::Selector::Expression.new(config.integration),
+      actor_env:        Mutant::Actor::Env.new(Thread)
+    )
+  end
+
+  shared_examples_for 'bootstrap call' do
+    it { should eql(expected_env) }
+  end
+
+  let(:object_space_modules) { [] }
+
+  before do
+    allow(ObjectSpace).to receive(:each_object).with(Module).and_return(object_space_modules.each)
+  end
+
+  describe '.call' do
+    subject { described_class.call(config) }
+
+    context 'when Module#name calls result in exceptions' do
+      let(:invalid_class) do
+        Class.new do
+          def self.name
+            fail
+          end
+        end
+      end
+
+      let(:object_space_modules) { [invalid_class] }
+
+      after do
+        # Fix Class#name so other specs do not see this one
+        class << invalid_class
+          undef :name
+          def name
+          end
+        end
+      end
+
+      it 'warns via reporter' do
+        expected_warnings = [
+          "Class#name from: #{invalid_class} raised an error: RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
+        ]
+
+        expect { subject }.to change { config.reporter.warn_calls }.from([]).to(expected_warnings)
+      end
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when includes are present' do
+      let(:config) { super().update(includes: %w[foo bar]) }
+
+      before do
+        %w[foo bar].each do |component|
+          expect($LOAD_PATH).to receive(:<<).with(component).and_return($LOAD_PATH)
+        end
+      end
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when Module#name does not return a String or nil' do
+      let(:invalid_class) do
+        Class.new do
+          def self.name
+            Object
+          end
+        end
+      end
+
+      let(:object_space_modules) { [invalid_class] }
+
+      after do
+        # Fix Class#name so other specs do not see this one
+        class << invalid_class
+          undef :name
+          def name
+          end
+        end
+      end
+
+      it 'warns via reporter' do
+
+        expected_warnings = [
+          "Class#name from: #{invalid_class.inspect} returned Object. #{Mutant::Env::SEMANTICS_MESSAGE}"
+        ]
+
+        expect { subject }.to change { config.reporter.warn_calls }.from([]).to(expected_warnings)
+      end
+
+      include_examples 'bootstrap call'
+    end
+
+    context 'when scope matches expression' do
+      let(:mutations) { [double('Mutation')]                      }
+      let(:subjects)  { [double('Subject', mutations: mutations)] }
+
+      before do
+        expect(Mutant::Matcher::Compiler).to receive(:call).and_return(subjects)
+      end
+
+      let(:expected_env) do
+        super().update(
+          subjects:  subjects,
+          mutations: mutations
+        )
+      end
+
+      include_examples 'bootstrap call'
+    end
+  end
+end

data/spec/unit/mutant/env_spec.rb

@@ -1,67 +1,79 @@
 RSpec.describe Mutant::Env do
-  let(:config) { Mutant::Config::DEFAULT.update(jobs: 1, reporter: Mutant::Reporter::Trace.new) }
+  context '#kill' do
+    let(:object) do
+      described_class.new(
+        config:           config,
+        actor_env:        Mutant::Actor::Env.new(Thread),
+        cache:            Mutant::Cache.new,
+        selector:         selector,
+        subjects:         [],
+        mutations:        [],
+        matchable_scopes: []
+      )
+    end
 
-  context '.new' do
-    subject { described_class.new(config) }
+    let(:config) do
+      Mutant::Config::DEFAULT.update(
+        isolation:   isolation,
+        integration: integration
+      )
+    end
 
-    context 'when Module#name calls result in exceptions' do
-      it 'warns via reporter' do
-        klass = Class.new do
-          def self.name
-            fail
-          end
-        end
+    let(:isolation)    { Mutant::Isolation::None                                                 }
+    let(:integration)  { double('Integration')                                                   }
+    let(:isolation)    { double('Isolation')                                                     }
+    let(:mutation)     { Mutant::Mutation::Evil.new(mutation_subject, Mutant::AST::Nodes::N_NIL) }
+    let(:wrapped_node) { double('Wrapped Node')                                                  }
+    let(:context)      { double('Context')                                                       }
+    let(:test_a)       { double('Test A')                                                        }
+    let(:test_b)       { double('Test B')                                                        }
+    let(:tests)        { [test_a, test_b]                                                        }
+    let(:selector)     { double('Selector')                                                      }
 
-        expected_warnings = [
-          "Class#name from: #{klass} raised an error: RuntimeError. #{Mutant::Env::SEMANTICS_MESSAGE}"
-        ]
+    let(:mutation_subject) do
+      double(
+        'Subject',
+        identification: 'subject',
+        context: context,
+        source: 'original',
+        tests:  tests
+      )
+    end
 
-        expect { subject }.to change { config.reporter.warn_calls }.from([]).to(expected_warnings)
+    subject { object.kill(mutation) }
 
-        # Fix Class#name so other specs do not see this one
-        class << klass
-          undef :name
-          def name
-          end
-        end
-      end
+    shared_examples_for 'mutation kill' do
+      it { should eql(Mutant::Result::Mutation.new(mutation: mutation, test_result: test_result)) }
     end
 
-    context 'when Module#name does not return a String or nil' do
-      it 'warns via reporter' do
-        klass = Class.new do
-          def self.name
-            Object
-          end
-        end
-
-        expected_warnings = ["Class#name from: #{klass.inspect} returned Object. #{Mutant::Env::SEMANTICS_MESSAGE}"]
+    before do
+      expect(selector).to receive(:call).with(mutation_subject).and_return(tests)
+      allow(Time).to receive(:now).and_return(Time.at(0))
+    end
 
-        expect { subject }.to change { config.reporter.warn_calls }.from([]).to(expected_warnings)
+    context 'when isolation does not raise error' do
+      let(:test_result)  { double('Test Result A', passed: false) }
 
-        # Fix Class#name so other specs do not see this one
-        class << klass
-          undef :name
-          def name
-          end
-        end
+      before do
+        expect(isolation).to receive(:call).and_yield.and_return(test_result)
+        expect(mutation_subject).to receive(:public?).and_return(true).ordered
+        expect(mutation_subject).to receive(:prepare).and_return(mutation_subject).ordered
+        expect(context).to receive(:root).with(s(:nil)).and_return(wrapped_node).ordered
+        expect(Mutant::Loader::Eval).to receive(:call).with(wrapped_node, mutation_subject).and_return(nil).ordered
+        expect(integration).to receive(:call).with(tests).and_return(test_result).ordered
       end
-    end
-  end
 
-  context '#kill_mutation' do
-    let(:object)   { described_class.new(config) }
-    let(:result)   { double('Result')            }
-    let(:mutation) { double('Mutation')          }
+      include_examples 'mutation kill'
+    end
 
-    subject { object.kill_mutation(mutation) }
+    context 'when isolation does raise error' do
+      before do
+        expect(isolation).to receive(:call).and_raise(Mutant::Isolation::Error, 'test-error')
+      end
 
-    before do
-      expect(mutation).to receive(:kill).with(config.isolation, config.integration).and_return(result)
-    end
+      let(:test_result) { Mutant::Result::Test.new(tests: tests, output: 'test-error', passed: false, runtime: 0.0) }
 
-    it 'uses the configured integration and isolation to kill mutation' do
-      should eql(Mutant::Result::Mutation.new(mutation: mutation, test_result: result))
+      include_examples 'mutation kill'
     end
   end
 end

data/spec/unit/mutant/expression_spec.rb

@@ -44,6 +44,13 @@ RSpec.describe Mutant::Expression do
     it_should_behave_like 'an idempotent method'
   end
 
+  describe '#_dump' do
+    let(:object) { described_class.parse('Foo') }
+    subject { object._dump(double('Level')) }
+
+    it { should eql('Foo') }
+  end
+
   describe '.parse' do
     subject { object.parse(input) }
 
@@ -64,4 +71,10 @@ RSpec.describe Mutant::Expression do
       it { should eql(Mutant::Expression::Namespace::Exact.new('Foo')) }
     end
   end
+
+  describe '._load' do
+    subject { described_class._load('Foo') }
+
+    it { should eql(described_class.parse('Foo')) }
+  end
 end

data/spec/unit/mutant/matcher/filter_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Mutant::Matcher::Filter do
     subject { object.each { |entry| yields << entry } }
 
     let(:matcher)   { [subject_a, subject_b] }
-    let(:predicate) { ->(subject) { subject.eql?(subject_a) } }
+    let(:predicate) { ->(node) { node.eql?(subject_a) } }
 
     let(:subject_a) { double('Subject A') }
     let(:subject_b) { double('Subject B') }

data/spec/unit/mutant/matcher/method/instance_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Mutant::Matcher::Method::Instance do
   let(:reporter) { Fixtures::TEST_CONFIG.reporter }
 
   describe '#each' do
-    subject { object.each { |subject| yields << subject } }
+    subject { object.each(&yields.method(:<<)) }
 
     let(:object)       { described_class.build(env, scope, method) }
     let(:method)       { scope.instance_method(method_name)        }

data/spec/unit/mutant/matcher/method/singleton_spec.rb

@@ -1,6 +1,6 @@
 # rubocop:disable ClassAndModuleChildren
 RSpec.describe Mutant::Matcher::Method::Singleton, '#each' do
-  subject { object.each { |subject| yields << subject } }
+  subject { object.each(&yields.method(:<<)) }
 
   let(:object)       { described_class.new(env, scope, method) }
   let(:method)       { scope.method(method_name)               }

data/spec/unit/mutant/mutation_spec.rb

@@ -21,42 +21,6 @@ RSpec.describe Mutant::Mutation do
   let(:test_b) { double('Test B') }
   let(:tests)  { [test_a, test_b] }
 
-  describe '#kill' do
-    let(:isolation)    { Mutant::Isolation::None                                                 }
-    let(:integration)  { double('Integration')                                                   }
-    let(:object)       { Mutant::Mutation::Evil.new(mutation_subject, Mutant::AST::Nodes::N_NIL) }
-    let(:wrapped_node) { double('Wrapped Node')                                                  }
-
-    subject { object.kill(isolation, integration) }
-
-    before do
-      allow(Time).to receive(:now).and_return(Time.at(0))
-    end
-
-    context 'when isolation does not raise error' do
-      let(:test_result)  { double('Test Result A', passed: false)                                  }
-
-      before do
-        expect(mutation_subject).to receive(:public?).and_return(true).ordered
-        expect(mutation_subject).to receive(:prepare).and_return(mutation_subject).ordered
-        expect(context).to receive(:root).with(s(:nil)).and_return(wrapped_node).ordered
-        expect(Mutant::Loader::Eval).to receive(:call).with(wrapped_node, mutation_subject).and_return(nil).ordered
-        expect(integration).to receive(:call).with(tests).and_return(test_result).ordered
-        expect(test_result).to receive(:update).with(tests: tests).and_return(test_result).ordered
-      end
-
-      it { should eql(test_result) }
-    end
-
-    context 'when isolation does raise error' do
-      before do
-        expect(isolation).to receive(:call).and_raise(Mutant::Isolation::Error, 'test-error')
-      end
-
-      it { should eql(Mutant::Result::Test.new(tests: tests, output: 'test-error', passed: false, runtime: 0.0)) }
-    end
-  end
-
   describe '#code' do
     subject { object.code }