mutant 0.9.4 → 0.9.9

data/meta/true.rb

@@ -3,6 +3,5 @@
 Mutant::Meta::Example.add :true do
   source 'true'
 
-  mutation 'nil'
   mutation 'false'
 end

data/meta/until.rb

@@ -8,7 +8,6 @@ Mutant::Meta::Example.add :until do
   mutation 'until true; foo; end'
   mutation 'until true; end'
   mutation 'until false; foo; bar; end'
-  mutation 'until nil; foo; bar; end'
   mutation 'until true; foo; nil; end'
   mutation 'until true; foo; self; end'
   mutation 'until true; nil; bar; end'

data/meta/while.rb

@@ -10,7 +10,6 @@ Mutant::Meta::Example.add :while do
   mutation 'while true; foo; end'
   mutation 'while true; end'
   mutation 'while false; foo; bar; end'
-  mutation 'while nil;   foo; bar; end'
   mutation 'while true;  foo; nil; end'
   mutation 'while true;  nil; bar; end'
   mutation 'while true;  raise; end'
@@ -22,5 +21,4 @@ Mutant::Meta::Example.add :while do
   singleton_mutations
   mutation 'while true; raise; end'
   mutation 'while false; end'
-  mutation 'while nil; end'
 end

data/meta/yield.rb

@@ -5,6 +5,5 @@ Mutant::Meta::Example.add :yield do
 
   singleton_mutations
   mutation 'yield false'
-  mutation 'yield nil'
   mutation 'yield'
 end

data/mutant.gemspec

@@ -26,15 +26,16 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency('anima',         '~> 0.3.1')
   gem.add_runtime_dependency('ast',           '~> 2.2')
   gem.add_runtime_dependency('concord',       '~> 0.1.5')
-  gem.add_runtime_dependency('diff-lcs',      '~> 1.3')
+  gem.add_runtime_dependency('diff-lcs',      '= 1.3')
   gem.add_runtime_dependency('equalizer',     '~> 0.0.9')
   gem.add_runtime_dependency('ice_nine',      '~> 0.11.1')
   gem.add_runtime_dependency('memoizable',    '~> 0.4.2')
   gem.add_runtime_dependency('mprelude',      '~> 0.1.0')
-  gem.add_runtime_dependency('parser',        '~> 2.6.5')
+  gem.add_runtime_dependency('parser',        '~> 2.7.1')
   gem.add_runtime_dependency('procto',        '~> 0.0.2')
   gem.add_runtime_dependency('unparser',      '~> 0.4.6')
+  gem.add_runtime_dependency('variable',      '~> 0.0.1')
 
-  gem.add_development_dependency('devtools', '~> 0.1.23')
+  gem.add_development_dependency('devtools', '~> 0.1.25')
   gem.add_development_dependency('parallel', '~> 1.3')
 end

data/mutant.sh

@@ -0,0 +1,12 @@
+#/usr/bin/bash -ex
+
+bundle exec mutant                                               \
+  --since HEAD~1                                                 \
+  --zombie                                                       \
+  --ignore-subject Mutant::CLI#add_debug_options                 \
+  --ignore-subject Mutant::Mutator::Node::Argument#skip?         \
+  --ignore-subject Mutant::Mutator::Node::ProcargZero#dispatch   \
+  --ignore-subject Mutant::Mutator::Node::When#mutate_conditions \
+  --ignore-subject Mutant::Zombifier#call                        \
+  --                                                             \
+  'Mutant*'

data/spec/integrations.yml

@@ -2,13 +2,14 @@
 - name: rubyspec
   namespace: Rubyspec
   repo_uri: 'https://github.com/ruby/rubyspec.git'
-  repo_ref: 'origin/master'
+  repo_ref: 249a36c2e9fcddbb208a0d618d05f6bd9a64fd17
   integration: mspec
   mutation_coverage: false
   mutation_generation: true
   exclude:
     - command_line/fixtures/bad_syntax.rb
     - command_line/fixtures/freeze_flag_required_diff_enc.rb
+    - core/file/stat_spec.rb
     - core/kernel/shared/sprintf_encoding.rb
     - core/module/fixtures/autoload_empty.rb
     - core/module/fixtures/autoload_never_set.rb
@@ -26,6 +27,7 @@
     - language/predefined/fixtures/data_only.rb
     - language/source_encoding_spec.rb
     - library/base64/decode64_spec.rb
+    - library/cgi/escapeHTML_spec.rb
     - security/cve_2010_1330_spec.rb
 - name: regexp_parser
   namespace: Regexp

data/spec/support/corpus.rb

@@ -10,7 +10,7 @@ module MutantSpec
 
   # Namespace module for corpus testing
   #
-  # rubocop:disable MethodLength
+  # rubocop:disable Metrics/MethodLength
   module Corpus
     TMP                 = ROOT.join('tmp').freeze
     EXCLUDE_GLOB_FORMAT = '{%s}'
@@ -22,7 +22,7 @@ module MutantSpec
     private_constant(*constants(false))
 
     # Project under corpus test
-    # rubocop:disable ClassLength
+    # rubocop:disable Metrics/ClassLength
     class Project
       MUTEX = Mutex.new
 
@@ -259,7 +259,7 @@ module MutantSpec
       #
       # @param [Array<String>] arguments
       #
-      # rubocop:disable GuardClause - guard clause without else does not make sense
+      # rubocop:disable Style/GuardClause - guard clause without else does not make sense
       def system(arguments)
         return if Kernel.system(*arguments)
 

data/spec/support/ruby_vm.rb

@@ -26,8 +26,7 @@ module MutantSpec
         super(DEFAULTS.merge(attributes))
       end
 
-      # rubocop:disable Naming/UncommunicativeMethodParamName
-      def handle(vm, observation)
+      def handle(vm, observation) # rubocop:disable Naming/MethodParameterName
         unless match?(observation)
           fail "Unexpected event observation: #{observation.inspect}, expected #{inspect}"
         end

data/spec/support/shared_context.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable ModuleLength
+# rubocop:disable Metrics/ModuleLength
 module SharedContext
   # Prepend an anonymous module with the new `with` method
   #
@@ -25,8 +25,8 @@ module SharedContext
     end
   end
 
-  # rubocop:disable MethodLength
-  # rubocop:disable AbcSize
+  # rubocop:disable Metrics/MethodLength
+  # rubocop:disable Metrics/AbcSize
   def setup_shared_context
     let(:mutation_a)      { Mutant::Mutation::Evil.new(subject_a, mutation_a_node)   }
     let(:mutation_a_node) { s(:false)                                                }

data/spec/support/xspec.rb

@@ -93,7 +93,7 @@ module XSpec
   class MessageExpectation
     include Anima.new(:receiver, :selector, :arguments, :reaction)
 
-    # rubocop:disable ParameterLists
+    # rubocop:disable Metrics/ParameterLists
     def self.parse(receiver:, selector:, arguments: [], reaction: nil)
       new(
         receiver:  receiver,
@@ -152,7 +152,7 @@ module XSpec
       expectations.empty? or fail "unconsumed expectations:\n#{expectations.map(&:inspect).join("\n")}"
     end
 
-    # rubocop:disable MethodLength
+    # rubocop:disable Metrics/MethodLength
     def self.verify(rspec_context, expectations)
       verifier = new(expectations)
 

data/spec/unit/mutant/ast/find_metaclass_containing_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::AST::FindMetaclassContaining do
+  describe '#call' do
+    subject { described_class.call(ast, node) }
+
+    let(:metaclass_node) { s(:sclass, s(:self), method_node) }
+    let(:method_node) { s(:def, 'test', s(:nil)) }
+
+    let(:ast) { metaclass_node }
+    let(:node) { method_node }
+
+    context 'when called without ast' do
+      let(:ast) { nil }
+
+      it { expect { subject }.to raise_error }
+    end
+
+    context 'when called without node' do
+      let(:node) { nil }
+
+      it { is_expected.to be nil }
+    end
+
+    context 'when called with ast which contains a duplicate of the node' do
+      let(:node) { s(:def, 'test', s(:nil)) }
+
+      shared_examples_for 'unfooled by the duplicate node' do
+        it { is_expected.to be nil }
+
+        # if we changed method_node or node without altering the other to match,
+        # the above example would provide a false positive. by ensuring node and
+        # method_node are eq but not equal, we ensure the usefulness of the
+        # above example.
+        it { expect(node).to eq(method_node) }
+        it { expect(node).not_to be method_node }
+      end
+
+      it_behaves_like 'unfooled by the duplicate node'
+
+      context 'when the node is in a begin block' do
+        let(:metaclass_node) { s(:sclass, s(:self), s(:begin, method_node)) }
+
+        it_behaves_like 'unfooled by the duplicate node'
+      end
+    end
+
+    context 'when called with ast containing the node' do
+      it { is_expected.to be metaclass_node }
+
+      context 'inside a begin block' do
+        let(:metaclass_node) { s(:sclass, s(:self), s(:begin, method_node)) }
+
+        it { is_expected.to be metaclass_node }
+      end
+
+      context 'inside a different class' do
+        let(:metaclass_node) { s(:sclass, s(:self), s(:class, :MyClass, nil, method_node)) }
+
+        it { is_expected.to be nil }
+      end
+    end
+  end
+end

data/spec/unit/mutant/expression/methods_spec.rb

@@ -49,13 +49,18 @@ RSpec.describe Mutant::Expression::Methods do
     context 'with an instance method' do
       let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
 
-      it { should eql(Mutant::Matcher::Methods::Instance.new(TestApp::Literal)) }
+      it { should eql(Mutant::Matcher::Chain.new([Mutant::Matcher::Methods::Instance.new(TestApp::Literal)])) }
     end
 
     context 'with a singleton method' do
       let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '.' } }
 
-      it { should eql(Mutant::Matcher::Methods::Singleton.new(TestApp::Literal)) }
+      it do
+        should eql(Mutant::Matcher::Chain.new([
+          Mutant::Matcher::Methods::Singleton.new(TestApp::Literal),
+          Mutant::Matcher::Methods::Metaclass.new(TestApp::Literal)
+        ]))
+      end
     end
   end
 end

data/spec/unit/mutant/license_spec.rb

@@ -89,7 +89,7 @@ RSpec.describe Mutant::License do
 
       expect(stderr)
         .to have_received(:puts)
-        .with('[Mutant-License-Error]: Soft fail, continuing in 20 seconds')
+        .with('[Mutant-License-Error]: Soft fail, continuing in 40 seconds')
         .ordered
 
       expect(stderr)
@@ -104,7 +104,7 @@ RSpec.describe Mutant::License do
 
       expect(kernel)
         .to have_received(:sleep)
-        .with(20)
+        .with(40)
         .ordered
     end
   end
@@ -283,11 +283,23 @@ RSpec.describe Mutant::License do
     context 'when mutant-license gem cannot be loaded' do
       let(:load_json) { false }
 
-      before do
-        allow(gem_method).to receive(:call).and_raise(Gem::LoadError, 'test-error')
+      def self.setup_error(message)
+        before do
+          allow(gem_method).to receive(:call).and_raise(Gem::LoadError, message)
+        end
+      end
+
+      context 'while the mutant license gem from rubygems is present' do
+        setup_error %{can't activate mutant-license (~> 0.1.0), already activated mutant-license-0.0.0.}
+
+        it_fails_with_message '[Mutant-License-Error]: mutant-license gem from rubygems.org is a dummy'
       end
 
-      it_fails_with_message '[Mutant-License-Error]: test-error'
+      context 'with other error message' do
+        setup_error 'test-error'
+
+        it_fails_with_message '[Mutant-License-Error]: test-error'
+      end
     end
   end
 end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Matcher::Method::Metaclass, '#call' do
+  SOURCE_PATH = 'test_app/lib/test_app/metaclasses.rb'
+  subject { object.call(env) }
+
+  let(:object)       { described_class.new(scope, method) }
+  let(:method)       { scope.method(method_name)          }
+  let(:type)         { :def                               }
+  let(:method_name)  { :foo                               }
+  let(:method_arity) { 0                                  }
+  let(:base)         { TestApp::MetaclassMethodTests      }
+  let(:source_path)  { MutantSpec::ROOT.join(SOURCE_PATH) }
+  let(:warnings)     { instance_double(Mutant::Warnings)  }
+
+  let(:world) do
+    instance_double(
+      Mutant::World,
+      pathname: Pathname,
+      warnings: warnings
+    )
+  end
+
+  let(:env) do
+    instance_double(
+      Mutant::Env,
+      config: Mutant::Config::DEFAULT,
+      parser: Fixtures::TEST_ENV.parser,
+      world:  world
+    )
+  end
+
+  def name
+    node.children.fetch(0)
+  end
+
+  def arguments
+    node.children.fetch(1)
+  end
+
+  context 'when also defined on lvar' do
+    let(:scope) { base::DefinedOnLvar }
+    let(:expected_warnings) do
+      [
+        'Can only match :def inside :sclass on :self or :const, got :sclass on :lvar unable to match'
+      ]
+    end
+
+    include_examples 'skipped candidate'
+  end
+
+  context 'when defined on self' do
+    let(:scope)       { base::DefinedOnSelf }
+    let(:method_line) { 7                   }
+
+    it_should_behave_like 'a method matcher'
+
+    context 'when scope is a metaclass' do
+      let(:scope) { base::DefinedOnSelf::InsideMetaclass.metaclass }
+      let(:method_line) { 28 }
+
+      it_should_behave_like 'a method matcher'
+    end
+  end
+
+  context 'when defined on constant' do
+    context 'inside namespace' do
+      let(:scope)       { base::DefinedOnConstant::InsideNamespace }
+      let(:method_line) { 44                                       }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'outside namespace' do
+      let(:scope)       { base::DefinedOnConstant::OutsideNamespace }
+      let(:method_line) { 52                                        }
+
+      it_should_behave_like 'a method matcher'
+    end
+  end
+
+  context 'when defined multiple times in the same line' do
+    context 'with method on different scope' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLine::DifferentScope }
+      let(:method_line)  { 76                                                   }
+      let(:method_arity) { 1                                                    }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'with different name' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLine::DifferentName }
+      let(:method_line)  { 80                                                  }
+
+      it_should_behave_like 'a method matcher'
+    end
+  end
+
+  # tests that the evaluator correctly returns nil when the metaclass doesn't
+  # directly contain the method
+  context 'when defined inside a class in a metaclass' do
+    let(:scope)       { base::NotActuallyInAMetaclass               }
+    let(:method)      { scope.metaclass::SomeClass.new.method(:foo) }
+    let(:method_line) { 93                                          }
+
+    it { is_expected.to be_empty }
+  end
+end

data/spec/unit/mutant/matcher/methods/metaclass_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Matcher::Methods::Metaclass, '#call' do
+  let(:object) { described_class.new(class_under_test) }
+  let(:env)    { Fixtures::TEST_ENV                    }
+
+  let(:class_under_test) do
+    parent = Module.new do
+      class << self
+        def method_d; end
+
+        protected
+
+        def method_e; end
+
+        private
+
+        def method_f; end
+      end
+    end
+
+    Class.new do
+      extend parent
+
+      class << self
+        def method_a; end
+
+        protected
+
+        def method_b; end
+
+        private
+
+        def method_c; end
+      end
+    end
+  end
+
+  let(:subject_a) { instance_double(Mutant::Subject, 'A') }
+  let(:subject_b) { instance_double(Mutant::Subject, 'B') }
+  let(:subject_c) { instance_double(Mutant::Subject, 'C') }
+
+  let(:subjects) { [subject_a, subject_b, subject_c] }
+
+  before do
+    matcher = Mutant::Matcher::Method::Metaclass
+
+    {
+      method_a: subject_a,
+      method_b: subject_b,
+      method_c: subject_c
+    }.each do |method, subject|
+      allow(matcher).to receive(:new)
+        .with(class_under_test, class_under_test.method(method))
+        .and_return(Mutant::Matcher::Static.new([subject]))
+    end
+  end
+
+  it 'returns expected subjects' do
+    expect(object.call(env)).to eql(subjects)
+  end
+end