mutant 0.8.7 → 0.8.8

data/spec/unit/mutant/env_spec.rb

@@ -55,7 +55,6 @@ RSpec.describe Mutant::Env do
 
       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

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

@@ -23,13 +23,13 @@ RSpec.describe Mutant::Expression::Method do
   end
 
   describe '#matcher' do
-    subject { object.matcher(env) }
+    subject { object.matcher }
 
     context 'with an instance method' do
       let(:input) { instance_method }
 
       it 'returns correct matcher' do
-        expect(subject.map(&:expression)).to eql([object])
+        expect(subject.call(env).map(&:expression)).to eql([object])
       end
     end
 
@@ -37,7 +37,7 @@ RSpec.describe Mutant::Expression::Method do
       let(:input) { singleton_method }
 
       it 'returns correct matcher' do
-        expect(subject.map(&:expression)).to eql([object])
+        expect(subject.call(env).map(&:expression)).to eql([object])
       end
     end
   end

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

@@ -1,5 +1,4 @@
 RSpec.describe Mutant::Expression::Methods do
-  let(:env)    { Fixtures::TEST_ENV              }
   let(:object) { described_class.new(attributes) }
 
   describe '#match_length' do
@@ -43,18 +42,18 @@ RSpec.describe Mutant::Expression::Methods do
   end
 
   describe '#matcher' do
-    subject { object.matcher(env) }
+    subject { object.matcher }
 
     context 'with an instance method' do
       let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
 
-      it { should eql(Mutant::Matcher::Methods::Instance.new(env, TestApp::Literal)) }
+      it { should eql(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(env, TestApp::Literal)) }
+      it { should eql(Mutant::Matcher::Methods::Singleton.new(TestApp::Literal)) }
     end
   end
 end

data/spec/unit/mutant/expression/namespace/flat_spec.rb

@@ -1,12 +1,11 @@
 RSpec.describe Mutant::Expression::Namespace::Exact do
   let(:object) { parse_expression(input) }
-  let(:env)    { Fixtures::TEST_ENV      }
   let(:input)  { 'TestApp::Literal'      }
 
   describe '#matcher' do
-    subject { object.matcher(env) }
+    subject { object.matcher }
 
-    it { should eql(Mutant::Matcher::Scope.new(env, TestApp::Literal, object)) }
+    it { should eql(Mutant::Matcher::Scope.new(TestApp::Literal)) }
   end
 
   describe '#match_length' do

data/spec/unit/mutant/expression/namespace/recursive_spec.rb

@@ -1,13 +1,11 @@
 RSpec.describe Mutant::Expression::Namespace::Recursive do
-
   let(:object) { parse_expression(input) }
   let(:input)  { 'TestApp::Literal*'     }
-  let(:env)    { Fixtures::TEST_ENV      }
 
   describe '#matcher' do
-    subject { object.matcher(env) }
+    subject { object.matcher }
 
-    it { should eql(Mutant::Matcher::Namespace.new(env, object)) }
+    it { should eql(Mutant::Matcher::Namespace.new(object)) }
   end
 
   describe '#syntax' do

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

@@ -1,32 +1,24 @@
-RSpec.describe Mutant::Matcher::Chain do
-
-  let(:object) { described_class.new(matchers) }
-
-  describe '#each' do
-    let(:yields) { [] }
-    subject { object.each { |entry| yields << entry } }
-
-    let(:matchers) { [matcher_a, matcher_b] }
-
-    let(:matcher_a) { [subject_a] }
-    let(:matcher_b) { [subject_b] }
-
-    let(:subject_a) { double('Subject A') }
-    let(:subject_b) { double('Subject B') }
-
-    # it_should_behave_like 'an #each method'
-    context 'with no block' do
-      subject { object.each }
-
-      it { should be_instance_of(to_enum.class) }
-
-      it 'yields the expected values' do
-        expect(subject.to_a).to eql(object.to_a)
-      end
-    end
+RSpec.describe Mutant::Matcher::Chain, '#call' do
+  subject { object.call(env) }
+
+  let(:object)    { described_class.new([matcher_a, matcher_b]) }
+  let(:env)       { instance_double(Mutant::Env)                }
+  let(:matcher_a) { instance_double(Mutant::Matcher)            }
+  let(:matcher_b) { instance_double(Mutant::Matcher)            }
+  let(:subject_a) { instance_double(Mutant::Subject)            }
+  let(:subject_b) { instance_double(Mutant::Subject)            }
+
+  before do
+    expect(matcher_a).to receive(:call)
+      .with(env)
+      .and_return([subject_a])
+
+    expect(matcher_b).to receive(:call)
+      .with(env)
+      .and_return([subject_b])
+  end
 
-    it 'should yield subjects' do
-      expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
-    end
+  it 'returns concatenated matches' do
+    should eql([subject_a, subject_b])
   end
 end

data/spec/unit/mutant/matcher/compiler/subject_prefix_spec.rb

@@ -1,21 +1,24 @@
-RSpec.describe Mutant::Matcher::Compiler::SubjectPrefix do
-  let(:object) { described_class.new(parse_expression('Foo*')) }
+RSpec.describe Mutant::Matcher::Compiler::SubjectPrefix, '#call' do
+  let(:object)   { described_class.new(parse_expression('Foo*')) }
 
-  let(:_subject) { double('Subject', expression: parse_expression(subject_expression)) }
+  let(:_subject) do
+    instance_double(
+      Mutant::Subject,
+      expression: parse_expression(subject_expression)
+    )
+  end
 
-  describe '#call' do
-    subject { object.call(_subject) }
+  subject { object.call(_subject) }
 
-    context 'when subject expression is prefixed by expression' do
-      let(:subject_expression) { 'Foo::Bar' }
+  context 'when subject expression is prefixed by expression' do
+    let(:subject_expression) { 'Foo::Bar' }
 
-      it { should be(true) }
-    end
+    it { should be(true) }
+  end
 
-    context 'when subject expression is NOT prefixed by expression' do
-      let(:subject_expression) { 'Bar' }
+  context 'when subject expression is NOT prefixed by expression' do
+    let(:subject_expression) { 'Bar' }
 
-      it { should be(false) }
-    end
+    it { should be(false) }
   end
 end

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

@@ -1,89 +1,78 @@
-RSpec.describe Mutant::Matcher::Compiler do
-  let(:object) { described_class }
-
-  let(:env) { Fixtures::TEST_ENV }
-
-  let(:expression_a) { parse_expression('Foo*') }
-  let(:expression_b) { parse_expression('Bar*') }
-
-  let(:matcher_a) { expression_a.matcher(env) }
-  let(:matcher_b) { expression_b.matcher(env) }
+RSpec.describe Mutant::Matcher::Compiler, '#call' do
+  let(:object)         { described_class                  }
+  let(:env)            { Fixtures::TEST_ENV               }
+  let(:matcher_config) { Mutant::Matcher::Config::DEFAULT }
+  let(:expression_a)   { parse_expression('Foo*')         }
+  let(:expression_b)   { parse_expression('Bar*')         }
+  let(:matcher_a)      { expression_a.matcher             }
+  let(:matcher_b)      { expression_b.matcher             }
 
   let(:expected_matcher) do
-    Mutant::Matcher::Filter.new(expected_positive_matcher, expected_predicate)
+    Mutant::Matcher::Filter.new(
+      expected_positive_matcher,
+      expected_predicate
+    )
   end
 
   let(:expected_predicate) do
     Morpher.compile(s(:and, s(:negate, s(:or)), s(:and)))
   end
 
-  describe '.call' do
-    subject { object.call(env, matcher_config.with(attributes)) }
+  subject { object.call(matcher_config.with(attributes)) }
 
-    let(:matcher_config) { Mutant::Matcher::Config::DEFAULT }
+  context 'on empty config' do
+    let(:attributes) { {} }
 
-    context 'on empty config' do
-      let(:attributes) { {} }
+    let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([]) }
 
-      let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([]) }
+    it { should eql(expected_matcher) }
+  end
 
-      it { should eql(expected_matcher) }
+  context 'on config with match expression' do
+    let(:expected_predicate) do
+      Morpher::Evaluator::Predicate::Boolean::And.new(
+        [
+          Morpher::Evaluator::Predicate::Negation.new(
+            Morpher::Evaluator::Predicate::Boolean::Or.new(ignore_expression_predicates)
+          ),
+          Morpher::Evaluator::Predicate::Boolean::And.new(subject_filter_predicates)
+        ]
+      )
     end
 
-    context 'on config with match expression' do
-      let(:expected_predicate) do
-        Morpher::Evaluator::Predicate::Boolean::And.new(
-          [
-            Morpher::Evaluator::Predicate::Negation.new(
-              Morpher::Evaluator::Predicate::Boolean::Or.new(ignore_expression_predicates)
-            ),
-            Morpher::Evaluator::Predicate::Boolean::And.new(subject_filter_predicates)
-          ]
-        )
-      end
+    let(:expected_positive_matcher)    { Mutant::Matcher::Chain.new([matcher_a]) }
+    let(:attributes)                   { { match_expressions: [expression_a] }   }
+    let(:ignore_expression_predicates) { []                                      }
+    let(:subject_filter_predicates)    { []                                      }
 
-      let(:expected_positive_matcher)    { Mutant::Matcher::Chain.new([matcher_a]) }
-      let(:attributes)                   { { match_expressions: [expression_a] }   }
-      let(:ignore_expression_predicates) { []                                      }
-      let(:subject_filter_predicates)    { []                                      }
+    context 'and no other constraints' do
+      it { should eql(expected_matcher) }
+    end
 
-      context 'and no other constraints' do
-        it { should eql(expected_matcher) }
+    context 'and ignore expressions' do
+      let(:attributes) do
+        super().merge(ignore_expressions: [expression_b])
       end
 
-      context 'and ignore expressions' do
-        let(:attributes) do
-          super().merge(ignore_expressions: [expression_b])
-        end
-
-        let(:ignore_expression_predicates) do
-          [Mutant::Matcher::Compiler::SubjectPrefix.new(expression_b)]
-        end
-
-        it { should eql(expected_matcher) }
+      let(:ignore_expression_predicates) do
+        [Mutant::Matcher::Compiler::SubjectPrefix.new(expression_b)]
       end
 
-      context 'and subject filters' do
-        let(:filter) { double('filter') }
-
-        let(:attributes) do
-          super().merge(subject_filters: [filter])
-        end
+      it { should eql(expected_matcher) }
+    end
 
-        let(:subject_filter_predicates) do
-          [filter]
-        end
+    context 'and subject filters' do
+      let(:filter) { double('filter') }
 
-        it { should eql(expected_matcher) }
+      let(:attributes) do
+        super().merge(subject_filters: [filter])
       end
-    end
 
-    context 'on config with multiple match expressions' do
-      let(:attributes) do
-        { match_expressions: [expression_a, expression_b] }
+      let(:subject_filter_predicates) do
+        [filter]
       end
 
-      let(:expected_positive_matcher) { Mutant::Matcher::Chain.new([matcher_a, matcher_b]) }
+      it { should eql(expected_matcher) }
     end
   end
 end

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

@@ -1,36 +1,20 @@
-RSpec.describe Mutant::Matcher::Filter do
-  let(:object)    { described_class.new(matcher, predicate) }
-  let(:matcher)   { [subject_a, subject_b]                  }
-  let(:subject_a) { double('Subject A')                     }
-  let(:subject_b) { double('Subject B')                     }
-
-  describe '#each' do
-    let(:yields) { [] }
-    subject { object.each { |entry| yields << entry } }
-
-    let(:predicate) { ->(node) { node.eql?(subject_a) } }
-
-    # it_should_behave_like 'an #each method'
-    context 'with no block' do
-      subject { object.each }
-
-      it { should be_instance_of(to_enum.class) }
+RSpec.describe Mutant::Matcher::Filter, '#call' do
+  subject { object.call(env) }
 
-      it 'yields the expected values' do
-        expect(subject.to_a).to eql(object.to_a)
-      end
-    end
-
-    it 'should yield subjects' do
-      expect { subject }.to change { yields }.from([]).to([subject_a])
-    end
+  let(:object)    { described_class.new(matcher, predicate) }
+  let(:matcher)   { instance_double(Mutant::Matcher)        }
+  let(:subject_a) { instance_double(Mutant::Subject)        }
+  let(:subject_b) { instance_double(Mutant::Subject)        }
+  let(:env)       { instance_double(Mutant::Env)            }
+  let(:predicate) { ->(node) { node.eql?(subject_a) }       }
+
+  before do
+    expect(matcher).to receive(:call)
+      .with(env)
+      .and_return([subject_a, subject_b])
   end
 
-  describe '.build' do
-    subject { described_class.build(matcher, &predicate) }
-
-    let(:predicate) { ->(_subject) { false } }
-
-    its(:to_a) { should eql([]) }
+  it 'returns subjects after filtering' do
+    should eql([subject_a])
   end
 end

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

@@ -1,157 +1,113 @@
-RSpec.describe Mutant::Matcher::Method::Instance do
-
-  let(:env)      { Fixtures::TEST_ENV             }
-  let(:reporter) { Fixtures::TEST_CONFIG.reporter }
+RSpec.describe Mutant::Matcher::Method::Instance, '#call' do
+  subject { object.call(env) }
+
+  let(:object)       { described_class.new(scope, method)                }
+  let(:env)          { test_env                                          }
+  let(:method_name)  { :foo                                              }
+  let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
+  let(:method)       { scope.instance_method(method_name)                }
+  let(:namespace)    { self.class                                        }
+  let(:type)         { :def                                              }
+  let(:method_arity) { 0                                                 }
+  let(:base)         { TestApp::InstanceMethodTests                      }
+
+  def name
+    node.children.fetch(0)
+  end
 
-  describe '#each' do
-    subject { object.each(&yields.method(:<<)) }
+  def arguments
+    node.children.fetch(1)
+  end
 
-    let(:object)       { described_class.build(env, scope, method) }
-    let(:method)       { scope.instance_method(method_name)        }
-    let(:yields)       { []                                        }
-    let(:namespace)    { self.class                                }
-    let(:type)         { :def                                      }
-    let(:method_name)  { :foo                                      }
-    let(:method_arity) { 0                                         }
-    let(:base)         { TestApp::InstanceMethodTests              }
+  context 'when method is defined inside eval' do
+    let(:scope)             { base::WithMemoizer          }
+    let(:method)            { scope.instance_method(:boz) }
+    let(:method_name)       { :boz                        }
 
-    def name
-      node.children[0]
+    let(:expected_warnings) do
+      [
+        "#{method} does not have a valid source location, unable to emit subject"
+      ]
     end
 
-    def arguments
-      node.children[1]
-    end
+    include_examples 'skipped candidate'
+  end
 
-    context 'when method is defined without source location' do
-      let(:scope) { Module }
-      let(:method) { scope.instance_method(:object_id) }
-
-      it 'does not emit matcher' do
-        subject
-        expect(yields.length).to be(0)
-      end
-
-      it 'does warn' do
-        subject
-        expect(reporter.warn_calls.last).to(
-          eql("#{method.inspect} does not have valid source location unable to emit subject")
-        )
-      end
+  context 'when method is defined without source location' do
+    let(:scope)             { Module                            }
+    let(:method)            { scope.instance_method(:object_id) }
+
+    let(:expected_warnings) do
+      [
+        "#{method} does not have a valid source location, unable to emit subject"
+      ]
     end
 
-    context 'when method is defined once' do
-      let(:scope)       { base::DefinedOnce                                 }
-      let(:source_path) { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
-      let(:method_line) { 10                                                }
+    include_examples 'skipped candidate'
+  end
 
-      it_should_behave_like 'a method matcher'
+  context 'in module eval' do
+    let(:scope) { base::InModuleEval }
+
+    let(:expected_warnings) do
+      [
+        "#{method} is dynamically defined in a closure, unable to emit subject"
+      ]
     end
 
-    context 'when method is defined once with a memoizer' do
-      let(:scope)       { base::WithMemoizer                                }
-      let(:source_path) { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
-      let(:method_line) { 15                                                }
+    include_examples 'skipped candidate'
+  end
+
+  context 'in class eval' do
+    let(:scope) { base::InClassEval }
 
-      it_should_behave_like 'a method matcher'
+    let(:expected_warnings) do
+      [
+        "#{method} is dynamically defined in a closure, unable to emit subject"
+      ]
     end
 
-    context 'when method is defined multiple times' do
-      context 'on different lines' do
-        let(:scope)        { base::DefinedMultipleTimes::DifferentLines        }
-        let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
-        let(:method_line)  { 24                                                }
-        let(:method_arity) { 1                                                 }
-
-        it_should_behave_like 'a method matcher'
-      end
-
-      context 'on the same line' do
-        let(:scope)        { base::DefinedMultipleTimes::SameLineSameScope     }
-        let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb') }
-        let(:method_line)  { 29                                                }
-        let(:method_arity) { 1                                                 }
-
-        it_should_behave_like 'a method matcher'
-      end
-
-      context 'on the same line with different scope' do
-        let(:scope)        { base::DefinedMultipleTimes::SameLineDifferentScope }
-        let(:source_path)  { MutantSpec::ROOT.join('test_app/lib/test_app.rb')  }
-        let(:method_line)  { 33                                                 }
-        let(:method_arity) { 1                                                  }
-
-        it_should_behave_like 'a method matcher'
-      end
-
-      context 'in module eval' do
-        let(:scope) { base::InModuleEval }
-
-        it 'does not emit matcher' do
-          subject
-          expect(yields.length).to be(0)
-        end
-
-        it 'does warn' do
-          subject
-          expect(reporter.warn_calls.last).to(
-            eql("#{method.inspect} is defined from a 3rd party lib unable to emit subject")
-          )
-        end
-      end
-
-      context 'in class eval' do
-        let(:scope) { base::InClassEval }
-
-        it 'does not emit matcher' do
-          subject
-          expect(yields.length).to be(0)
-        end
-
-        it 'does warn' do
-          subject
-          expect(reporter.warn_calls.last).to(
-            eql("#{method.inspect} is defined from a 3rd party lib unable to emit subject")
-          )
-        end
-      end
-    end
+    include_examples 'skipped candidate'
   end
 
-  describe '.build' do
-    let(:object) { described_class }
+  context 'when method is defined once' do
+    let(:method_name) { :bar               }
+    let(:scope)       { base::WithMemoizer }
+    let(:method_line) { 13                 }
 
-    subject { object.build(env, scope, method) }
+    it_should_behave_like 'a method matcher'
+  end
 
-    let(:scope) do
-      Class.new do
-        include Adamantium
+  context 'when method is defined once with a memoizer' do
+    let(:scope)       { base::WithMemoizer }
+    let(:method_line) { 15                 }
 
-        def foo
-        end
-        memoize :foo
+    it_should_behave_like 'a method matcher'
+  end
 
-        def bar
-        end
-      end
-    end
+  context 'when method is defined multiple times' do
+    context 'on different lines' do
+      let(:scope)        { base::DefinedMultipleTimes::DifferentLines }
+      let(:method_line)  { 24                                         }
+      let(:method_arity) { 1                                          }
 
-    let(:method) do
-      scope.instance_method(method_name)
+      it_should_behave_like 'a method matcher'
     end
 
-    context 'with adamantium infected scope' do
-      context 'with unmemoized method' do
-        let(:method_name) { :bar }
+    context 'on the same line' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLineSameScope }
+      let(:method_line)  { 29                                            }
+      let(:method_arity) { 1                                             }
 
-        it { should eql(described_class.new(env, scope, method)) }
-      end
+      it_should_behave_like 'a method matcher'
+    end
 
-      context 'with memoized method' do
-        let(:method_name) { :foo }
+    context 'on the same line with different scope' do
+      let(:scope)        { base::DefinedMultipleTimes::SameLineDifferentScope }
+      let(:method_line)  { 33                                                 }
+      let(:method_arity) { 1                                                  }
 
-        it { should eql(described_class::Memoized.new(env, scope, method)) }
-      end
+      it_should_behave_like 'a method matcher'
     end
   end
 end