mutant 0.9.4 → 0.9.9

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

@@ -13,8 +13,10 @@ RSpec.describe Mutant::Matcher::Namespace, '#call' do
     [
       [Mutant::Matcher::Methods::Singleton, raw_scope_b, [subject_b]],
       [Mutant::Matcher::Methods::Instance,  raw_scope_b, []],
+      [Mutant::Matcher::Methods::Metaclass, raw_scope_b, []],
       [Mutant::Matcher::Methods::Singleton, raw_scope_a, [subject_a]],
-      [Mutant::Matcher::Methods::Instance,  raw_scope_a, []]
+      [Mutant::Matcher::Methods::Instance,  raw_scope_a, []],
+      [Mutant::Matcher::Methods::Metaclass, raw_scope_a, []]
     ].each do |klass, scope, subjects|
       matcher = instance_double(Mutant::Matcher)
       expect(matcher).to receive(:call).with(env).and_return(subjects)

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

@@ -6,8 +6,10 @@ RSpec.describe Mutant::Matcher::Scope, '#call' do
   let(:env)       { instance_double(Mutant::Env)     }
   let(:matcher_a) { instance_double(Mutant::Matcher) }
   let(:matcher_b) { instance_double(Mutant::Matcher) }
+  let(:matcher_c) { instance_double(Mutant::Matcher) }
   let(:subject_a) { instance_double(Mutant::Subject) }
   let(:subject_b) { instance_double(Mutant::Subject) }
+  let(:subject_c) { instance_double(Mutant::Subject) }
 
   subject { object.call(env) }
 
@@ -20,6 +22,10 @@ RSpec.describe Mutant::Matcher::Scope, '#call' do
       .with(scope)
       .and_return(matcher_b)
 
+    expect(Mutant::Matcher::Methods::Metaclass).to receive(:new)
+      .with(scope)
+      .and_return(matcher_c)
+
     expect(matcher_a).to receive(:call)
       .with(env)
       .and_return([subject_a])
@@ -27,9 +33,13 @@ RSpec.describe Mutant::Matcher::Scope, '#call' do
     expect(matcher_b).to receive(:call)
       .with(env)
       .and_return([subject_b])
+
+    expect(matcher_c).to receive(:call)
+      .with(env)
+      .and_return([subject_c])
   end
 
   it 'concatenates subjects from matched singleton and instance methods' do
-    should eql([subject_a, subject_b])
+    should eql([subject_a, subject_b, subject_c])
   end
 end

data/spec/unit/mutant/meta/example_spec.rb

@@ -10,9 +10,9 @@ RSpec.describe Mutant::Meta::Example do
     )
   end
 
-  let(:file)           { 'foo/bar.rb'         }
-  let(:node)           { s(:true)             }
-  let(:mutation_nodes) { [s(:nil), s(:false)] }
+  let(:file)           { 'foo/bar.rb' }
+  let(:node)           { s(:true)     }
+  let(:mutation_nodes) { [s(:false)]  }
 
   let(:mutations) do
     mutation_nodes.map do |node|

data/spec/unit/mutant/mutator/node_spec.rb

@@ -41,12 +41,7 @@ RSpec.describe Mutant::Mutator::Node do
     end
 
     specify do
-      expect(apply).to eql(
-        [
-          s(:and, s(:nil), s(:true)),
-          s(:and, s(:true), s(:nil))
-        ].to_set
-      )
+      expect(apply).to eql([s(:and, s(:nil), s(:true))].to_set)
     end
   end
 end

data/spec/unit/mutant/parallel/driver_spec.rb

@@ -16,15 +16,15 @@ RSpec.describe Mutant::Parallel::Driver do
   end
 
   let(:var_active_jobs) do
-    instance_double(Mutant::Variable::IVar, 'active jobs')
+    instance_double(Variable::IVar, 'active jobs')
   end
 
   let(:var_final) do
-    instance_double(Mutant::Variable::IVar, 'final')
+    instance_double(Variable::IVar, 'final')
   end
 
   let(:var_sink) do
-    instance_double(Mutant::Variable::IVar, 'sink')
+    instance_double(Variable::IVar, 'sink')
   end
 
   subject do
@@ -64,7 +64,7 @@ RSpec.describe Mutant::Parallel::Driver do
           receiver:  var_final,
           selector:  :take_timeout,
           arguments: [timeout],
-          reaction:  { return: Mutant::Variable.const_get(:Result)::Timeout.new }
+          reaction:  { return: Variable.const_get(:Result)::Timeout.new }
         },
         {
           receiver: var_active_jobs,

data/spec/unit/mutant/parallel/worker_spec.rb

@@ -31,23 +31,23 @@ RSpec.describe Mutant::Parallel::Worker do
     end
 
     let(:var_active_jobs) do
-      instance_double(Mutant::Variable::IVar, 'active jobs')
+      instance_double(Variable::IVar, 'active jobs')
     end
 
     let(:var_final) do
-      instance_double(Mutant::Variable::IVar, 'final')
+      instance_double(Variable::IVar, 'final')
     end
 
     let(:var_running) do
-      instance_double(Mutant::Variable::MVar, 'running')
+      instance_double(Variable::MVar, 'running')
     end
 
     let(:var_sink) do
-      instance_double(Mutant::Variable::IVar, 'sink')
+      instance_double(Variable::IVar, 'sink')
     end
 
     let(:var_source) do
-      instance_double(Mutant::Variable::IVar, 'source')
+      instance_double(Variable::IVar, 'source')
     end
 
     subject do

data/spec/unit/mutant/parallel_spec.rb

@@ -30,28 +30,28 @@ RSpec.describe Mutant::Parallel do
     end
 
     let(:var_active_jobs) do
-      instance_double(Mutant::Variable::IVar, 'active jobs')
+      instance_double(Variable::IVar, 'active jobs')
     end
 
     let(:var_final) do
-      instance_double(Mutant::Variable::IVar, 'final')
+      instance_double(Variable::IVar, 'final')
     end
 
     let(:var_running) do
-      instance_double(Mutant::Variable::MVar, 'running')
+      instance_double(Variable::MVar, 'running')
     end
 
     let(:var_sink) do
-      instance_double(Mutant::Variable::IVar, 'sink')
+      instance_double(Variable::IVar, 'sink')
     end
 
     let(:var_source) do
-      instance_double(Mutant::Variable::IVar, 'source')
+      instance_double(Variable::IVar, 'source')
     end
 
     def ivar(value, **attributes)
       {
-        receiver:  Mutant::Variable::IVar,
+        receiver:  Variable::IVar,
         selector:  :new,
         arguments: [
           condition_variable: condition_variable,
@@ -63,7 +63,7 @@ RSpec.describe Mutant::Parallel do
     end
 
     def mvar(*arguments)
-      ivar(*arguments).merge(receiver: Mutant::Variable::MVar)
+      ivar(*arguments).merge(receiver: Variable::MVar)
     end
 
     let(:raw_expectations) do

data/spec/unit/mutant/registry_spec.rb

@@ -1,47 +1,74 @@
 # frozen_string_literal: true
 
 RSpec.describe Mutant::Registry do
-  let(:lookup)  { object.lookup(type)           }
-  let(:object)  { described_class.new           }
   let(:mutator) { class_double(Mutant::Mutator) }
+  let(:object)  { described_class.new           }
 
-  def register_mutator
-    object.register(type, mutator)
-  end
-
-  context 'on registered type' do
-    subject { register_mutator }
+  describe '#lookup' do
+    subject { object.lookup(type) }
 
-    let(:type) { :true }
+    def register
+      object.register(type, mutator)
+    end
 
-    before { subject }
+    context 'on known type' do
+      let(:type) { :true }
 
-    it 'returns registered mutator' do
-      expect(lookup).to be(mutator)
+      it 'returns registered' do
+        register
+        expect(subject).to be(mutator)
+      end
     end
 
-    it_behaves_like 'a command method'
+    context 'on unknown type' do
+      let(:type) { :unknown }
 
-    context 'when registered twice' do
-      it 'fails upon registration' do
-        expect { register_mutator }.to raise_error(described_class::RegistryError, 'Duplicate type registration: :true')
+      it 'returns genericm mutator' do
+        expect(subject).to be(Mutant::Mutator::Node::Generic)
       end
     end
   end
 
-  context 'on unknown type' do
-    let(:type) { :unknown }
+  describe '#register' do
+    subject { object.register(type, mutator) }
 
-    it 'raises error' do
-      expect { lookup }.to raise_error(described_class::RegistryError, 'No entry for: :unknown')
+    def lookup
+      subject.lookup(type)
     end
-  end
 
-  context 'when registering an invalid node type' do
-    let(:type) { :invalid }
+    context 'on registered type' do
+      let(:type) { :true }
+
+      it_behaves_like 'a command method'
 
-    it 'raises error' do
-      expect { register_mutator }.to raise_error(described_class::RegistryError, 'Invalid type registration: :invalid')
+      it 'allows to lookup the mutator' do
+        subject
+        expect(lookup).to be(mutator)
+      end
+
+      context 'when registering twice' do
+        it 'fails upon registration' do
+          object.register(type, mutator)
+
+          expect { subject }
+            .to raise_error(
+              described_class::RegistryError,
+              'Duplicate type registration: :true'
+            )
+        end
+      end
+    end
+
+    context 'when registering an invalid node type' do
+      let(:type) { :invalid }
+
+      it 'raises error' do
+        expect { subject }
+          .to raise_error(
+            described_class::RegistryError,
+            'Invalid type registration: :invalid'
+          )
+      end
     end
   end
 end

data/spec/unit/mutant/repository/diff/ranges_spec.rb

@@ -13,7 +13,7 @@ describe Mutant::Repository::Diff::Ranges do
         Tempfile.open('new') do |new_file|
           new_file.write(new)
           new_file.flush
-          # rubocop:disable Lint/UnneededSplatExpansion
+          # rubocop:disable Lint/RedundantSplatExpansion
           stdout, status = Open3.capture2(
             *%W[
               git
@@ -25,7 +25,7 @@ describe Mutant::Repository::Diff::Ranges do
               #{new_file.path}
             ]
           )
-          # rubocop:enable Lint/UnneededSplatExpansion
+          # rubocop:enable Lint/RedundantSplatExpansion
 
           fail unless [0, 256].include?(status.to_i)
 

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+RSpec.describe Mutant::Subject::Method::Metaclass do
+  let(:object) do
+    described_class.new(
+      context:  context,
+      node:     node,
+      warnings: warnings
+    )
+  end
+
+  let(:node)     { s(:def, :foo, s(:args)) }
+  let(:warnings) { instance_double(Mutant::Warnings) }
+
+  let(:context) do
+    Mutant::Context.new(scope, instance_double(Pathname))
+  end
+
+  let(:scope) do
+    Class.new do
+      class << self
+        def foo; end
+
+        def name
+          'Test'
+        end
+      end
+    end
+  end
+
+  describe '#expression' do
+    subject { object.expression }
+
+    it { should eql(parse_expression('Test.foo')) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#match_expression' do
+    subject { object.match_expressions }
+
+    it { should eql(%w[Test.foo Test*].map(&method(:parse_expression))) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+  describe '#prepare' do
+
+    subject { object.prepare }
+
+    it 'undefines method on scope' do
+      expect { subject }.to change { scope.methods.include?(:foo) }.from(true).to(false)
+    end
+
+    it_should_behave_like 'a command method'
+  end
+
+  describe '#source' do
+    subject { object.source }
+
+    it { should eql("class << self\n  def foo\n  end\nend") }
+  end
+end

data/test_app/lib/test_app.rb

@@ -105,5 +105,6 @@ module TestApp
   end
 end
 
+require 'test_app/metaclasses'
 require 'test_app/literal'
 $VERBOSE = original

data/test_app/lib/test_app/metaclasses.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module TestApp
+  module MetaclassMethodTests
+    module DefinedOnSelf
+      class << self
+        def foo; end
+      end
+
+      # again this is a weird edge-case that's being checked for consistent
+      # behaviour, not something that people ought to be doing.
+      module InsideMetaclass
+        class << self
+          # some older versions of ruby don't have Object#singleton_class,
+          # this is just an implementation of that so we can grab
+          # InsideMetaclass.metaclass for use as the scope object
+          def metaclass
+            class << self
+              self
+            end
+          end
+
+          # InsideMetaclass.foo
+          def foo; end
+
+          class << self
+            # #<Class:InsideMetaclass>.foo
+            def foo; end
+          end
+        end
+      end
+    end
+
+    module DefinedOnLvar
+      a = self
+      class << a
+        def foo; end
+      end
+    end
+
+    module DefinedOnConstant
+      module InsideNamespace
+        class << InsideNamespace
+          def foo; end
+        end
+      end
+
+      module OutsideNamespace
+      end
+
+      class << OutsideNamespace
+        def foo
+        end
+      end
+    end
+
+    module DefinedMultipleTimes
+      module DifferentLines
+        class << self
+          def foo
+          end
+
+          def foo(_arg)
+          end
+        end
+      end
+
+      module SameLine
+        module SameScope
+          class << self
+            def foo; end; def foo(_arg); end
+          end
+        end
+
+        module DifferentScope
+          class << self; def foo; end; end; class << DifferentScope; def foo(_arg); end; end; class << MetaclassMethodTests; def foo; end; end
+        end
+
+        module DifferentName
+          class << self; def foo; end; def bar(_arg); end; end
+        end
+      end
+    end
+
+    module NotActuallyInAMetaclass
+      class << self
+        # some older versions of ruby don't have Object#singleton_class,
+        # this is just an implementation of that so we can grab
+        # InsideMetaclass.metaclass for use as the scope object
+        def metaclass
+          class << self
+            self
+          end
+        end
+
+        # this is a very weird construction that I do not recommend.
+        # to access SomeClass you have to do
+        # NotActuallyInAMetaclass.singleton_class::SomeClass. Very weird
+        # This is only here so we can test that metaclass_receiver? correctly
+        # returns false
+        class SomeClass
+          def foo
+          end
+        end
+      end
+    end
+  end
+end