mutant 0.8.0 → 0.8.1

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

@@ -0,0 +1,11 @@
+RSpec.describe Mutant::Context::Scope do
+  let(:object)      { described_class.new(scope, source_path) }
+  let(:scope)       { double('scope', name: double('name'))   }
+  let(:source_path) { double('source path')                   }
+
+  describe '#identification' do
+    subject { object.identification }
+
+    it { should be(scope.name) }
+  end
+end

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

@@ -9,6 +9,8 @@ RSpec.describe Mutant::Env::Bootstrap do
     )
   end
 
+  let(:integration) { Mutant::Integration::Null.new(config) }
+
   let(:expected_env) do
     Mutant::Env.new(
       cache:            Mutant::Cache.new,
@@ -16,8 +18,9 @@ RSpec.describe Mutant::Env::Bootstrap do
       matchable_scopes: [],
       mutations:        [],
       config:           config,
-      selector:         Mutant::Selector::Expression.new(config.integration),
-      actor_env:        Mutant::Actor::Env.new(Thread)
+      selector:         Mutant::Selector::Expression.new(integration),
+      actor_env:        Mutant::Actor::Env.new(Thread),
+      integration:      integration
     )
   end
 

data/spec/unit/mutant/env_spec.rb

@@ -8,26 +8,26 @@ RSpec.describe Mutant::Env do
         selector:         selector,
         subjects:         [],
         mutations:        [],
-        matchable_scopes: []
+        matchable_scopes: [],
+        integration:      integration
       )
     end
 
+    let(:integration) { integration_class.new(config) }
+
     let(:config) do
-      Mutant::Config::DEFAULT.update(
-        isolation:   isolation,
-        integration: integration
-      )
+      Mutant::Config::DEFAULT.update(isolation: isolation, integration: integration_class)
     end
 
-    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')                                                      }
+    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')                                                      }
+    let(:integration_class) { Mutant::Integration::Null                                               }
 
     let(:mutation_subject) do
       double(
@@ -59,7 +59,6 @@ RSpec.describe Mutant::Env do
         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
 
       include_examples 'mutation kill'

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

@@ -1,9 +1,8 @@
 RSpec.describe Mutant::Expression::Method do
-
-  let(:object)           { described_class.parse(input) }
-  let(:env)              { Fixtures::TEST_ENV           }
-  let(:instance_method)  { 'TestApp::Literal#string'    }
-  let(:singleton_method) { 'TestApp::Literal.string'    }
+  let(:object)           { parse_expression(input)   }
+  let(:env)              { Fixtures::TEST_ENV        }
+  let(:instance_method)  { 'TestApp::Literal#string' }
+  let(:singleton_method) { 'TestApp::Literal.string' }
 
   describe '#match_length' do
     let(:input) { instance_method }
@@ -11,13 +10,13 @@ RSpec.describe Mutant::Expression::Method do
     subject { object.match_length(other) }
 
     context 'when other is an equivalent expression' do
-      let(:other) { described_class.parse(object.syntax) }
+      let(:other) { parse_expression(object.syntax) }
 
       it { should be(object.syntax.length) }
     end
 
     context 'when other is an unequivalent expression' do
-      let(:other) { described_class.parse('Foo*') }
+      let(:other) { parse_expression('Foo*') }
 
       it { should be(0) }
     end
@@ -30,19 +29,16 @@ RSpec.describe Mutant::Expression::Method do
       let(:input) { instance_method }
 
       it 'returns correct matcher' do
-        should eql(
-          Mutant::Matcher::Method::Instance.new(
-            env,
-            TestApp::Literal, TestApp::Literal.instance_method(:string)
-          )
-        )
+        expect(subject.map(&:expression)).to eql([object])
       end
     end
 
     context 'with a singleton method' do
       let(:input) { singleton_method }
 
-      it { should eql(Mutant::Matcher::Method::Singleton.new(env, TestApp::Literal, TestApp::Literal.method(:string))) }
+      it 'returns correct matcher' do
+        expect(subject.map(&:expression)).to eql([object])
+      end
     end
   end
 end

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

@@ -1,45 +1,58 @@
 RSpec.describe Mutant::Expression::Methods do
-
-  let(:object)            { described_class.parse(input) }
-  let(:env)               { Fixtures::TEST_ENV           }
-  let(:instance_methods)  { 'TestApp::Literal#'          }
-  let(:singleton_methods) { 'TestApp::Literal.'          }
+  let(:env)    { Fixtures::TEST_ENV              }
+  let(:object) { described_class.new(attributes) }
 
   describe '#match_length' do
-    let(:input) { instance_methods }
+    let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
 
     subject { object.match_length(other) }
 
     context 'when other is an equivalent expression' do
-      let(:other) { described_class.parse(object.syntax) }
+      let(:other) { parse_expression(object.syntax) }
 
       it { should be(object.syntax.length) }
     end
 
     context 'when other is matched' do
-      let(:other) { described_class.parse('TestApp::Literal#foo') }
+      let(:other) { parse_expression('TestApp::Literal#foo') }
 
       it { should be(object.syntax.length) }
     end
 
     context 'when other is an not matched expression' do
-      let(:other) { described_class.parse('Foo*') }
+      let(:other) { parse_expression('Foo*') }
 
       it { should be(0) }
     end
   end
 
+  describe '#syntax' do
+    subject { object.syntax }
+
+    context 'with an instance method' do
+      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
+
+      it { should eql('TestApp::Literal#') }
+    end
+
+    context 'with a singleton method' do
+      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '.' } }
+
+      it { should eql('TestApp::Literal.') }
+    end
+  end
+
   describe '#matcher' do
     subject { object.matcher(env) }
 
     context 'with an instance method' do
-      let(:input) { instance_methods }
+      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '#' } }
 
       it { should eql(Mutant::Matcher::Methods::Instance.new(env, TestApp::Literal)) }
     end
 
     context 'with a singleton method' do
-      let(:input) { singleton_methods }
+      let(:attributes) { { scope_name: 'TestApp::Literal', scope_symbol: '.' } }
 
       it { should eql(Mutant::Matcher::Methods::Singleton.new(env, TestApp::Literal)) }
     end

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

@@ -1,8 +1,7 @@
 RSpec.describe Mutant::Expression::Namespace::Exact do
-
-  let(:object) { described_class.parse(input) }
-  let(:env)    { Fixtures::TEST_ENV           }
-  let(:input)  { 'TestApp::Literal'           }
+  let(:object) { parse_expression(input) }
+  let(:env)    { Fixtures::TEST_ENV      }
+  let(:input)  { 'TestApp::Literal'      }
 
   describe '#matcher' do
     subject { object.matcher(env) }
@@ -14,13 +13,13 @@ RSpec.describe Mutant::Expression::Namespace::Exact do
     subject { object.match_length(other) }
 
     context 'when other is an equivalent expression' do
-      let(:other) { described_class.parse(object.syntax) }
+      let(:other) { parse_expression(object.syntax) }
 
       it { should be(object.syntax.length) }
     end
 
     context 'when other is an unequivalent expression' do
-      let(:other) { described_class.parse('Foo*') }
+      let(:other) { parse_expression('Foo*') }
 
       it { should be(0) }
     end

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

@@ -1,8 +1,8 @@
 RSpec.describe Mutant::Expression::Namespace::Recursive do
 
-  let(:object) { described_class.parse(input) }
-  let(:input)  { 'TestApp::Literal*'          }
-  let(:env)    { Fixtures::TEST_ENV           }
+  let(:object) { parse_expression(input) }
+  let(:input)  { 'TestApp::Literal*'     }
+  let(:env)    { Fixtures::TEST_ENV      }
 
   describe '#matcher' do
     subject { object.matcher(env) }
@@ -10,48 +10,54 @@ RSpec.describe Mutant::Expression::Namespace::Recursive do
     it { should eql(Mutant::Matcher::Namespace.new(env, object)) }
   end
 
+  describe '#syntax' do
+    subject { object.syntax }
+
+    it { should eql(input) }
+  end
+
   describe '#match_length' do
     subject { object.match_length(other) }
 
     context 'when other is an equivalent expression' do
-      let(:other) { described_class.parse(object.syntax) }
+      let(:other) { parse_expression(object.syntax) }
 
       it { should be(0) }
     end
 
     context 'when other expression describes a shorter prefix' do
-      let(:other) { described_class.parse('TestApp') }
+      let(:other) { parse_expression('TestApp') }
 
       it { should be(0) }
     end
 
     context 'when other expression describes adjacent namespace' do
-      let(:other) { described_class.parse('TestApp::LiteralFoo') }
+      let(:other) { parse_expression('TestApp::LiteralFoo') }
 
       it { should be(0) }
     end
 
     context 'when other expression describes root namespace' do
-      let(:other) { described_class.parse('TestApp::Literal') }
+      let(:other) { parse_expression('TestApp::Literal') }
 
       it { should be(16) }
     end
 
     context 'when other expression describes a longer prefix' do
       context 'on constants' do
-        let(:other) { described_class.parse('TestApp::Literal::Deep') }
+        let(:other) { parse_expression('TestApp::Literal::Deep') }
 
         it { should be(input[0..-2].length) }
       end
 
       context 'on singleton method' do
-        let(:other) { described_class.parse('TestApp::Literal.foo') }
+        let(:other) { parse_expression('TestApp::Literal.foo') }
 
         it { should be(input[0..-2].length) }
       end
 
       context 'on instance method' do
-        let(:other) { described_class.parse('TestApp::Literal#foo') }
+        let(:other) { parse_expression('TestApp::Literal#foo') }
 
         it { should be(input[0..-2].length) }
       end

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

@@ -0,0 +1,67 @@
+RSpec.describe Mutant::Expression::Parser do
+  let(:object) { Mutant::Config::DEFAULT.expression_parser }
+
+  describe '#call' do
+    subject { object.call(input) }
+
+    context 'on nonsense' do
+      let(:input) { 'foo bar' }
+
+      it 'raises an exception' do
+        expect { subject }.to raise_error(
+          Mutant::Expression::Parser::InvalidExpressionError,
+          'Expression: "foo bar" is not valid'
+        )
+      end
+    end
+
+    context 'on a valid expression' do
+      let(:input) { 'Foo' }
+
+      it { should eql(Mutant::Expression::Namespace::Exact.new(scope_name: 'Foo')) }
+    end
+  end
+
+  describe '.try_parse' do
+    subject { object.try_parse(input) }
+
+    context 'on nonsense' do
+      let(:input) { 'foo bar' }
+
+      it { should be(nil) }
+    end
+
+    context 'on a valid expression' do
+      let(:input) { 'Foo' }
+
+      it { should eql(Mutant::Expression::Namespace::Exact.new(scope_name: 'Foo')) }
+    end
+
+    context 'on ambiguous expression' do
+      let(:object) { described_class.new([test_a, test_b]) }
+
+      let(:test_a) do
+        Class.new(Mutant::Expression) do
+          include Anima.new
+          const_set(:REGEXP, /\Atest-syntax\z/.freeze)
+        end
+      end
+
+      let(:test_b) do
+        Class.new(Mutant::Expression) do
+          include Anima.new
+          const_set(:REGEXP, /^test-syntax$/.freeze)
+        end
+      end
+
+      let(:input) { 'test-syntax' }
+
+      it 'raises expected exception' do
+        expect { subject }.to raise_error(
+          Mutant::Expression::Parser::AmbiguousExpressionError,
+          'Ambiguous expression: "test-syntax"'
+        )
+      end
+    end
+  end
+end

data/spec/unit/mutant/expression_spec.rb

@@ -1,80 +1,47 @@
 RSpec.describe Mutant::Expression do
   let(:object) { described_class }
 
-  describe '.try_parse' do
-    subject { object.try_parse(input) }
+  let(:parser) { Mutant::Config::DEFAULT.expression_parser }
 
-    context 'on nonsense' do
-      let(:input) { 'foo bar' }
+  describe '#prefix?' do
+    let(:object) { parser.call('Foo*') }
 
-      it { should be(nil) }
-    end
+    subject { object.prefix?(other) }
 
-    context 'on a valid expression' do
-      let(:input) { 'Foo' }
+    context 'when object is a prefix of other' do
+      let(:other) { parser.call('Foo::Bar') }
 
-      it { should eql(Mutant::Expression::Namespace::Exact.new('Foo')) }
+      it { should be(true) }
     end
 
-    context 'on ambiguous expression' do
-      class ExpressionA < Mutant::Expression
-        register(/\Atest-syntax\z/)
-      end
+    context 'when other is not a prefix of other' do
+      let(:other) { parser.call('Bar') }
 
-      class ExpressionB < Mutant::Expression
-        register(/^test-syntax$/)
-      end
-
-      let(:input) { 'test-syntax' }
-
-      it 'raises an exception' do
-        expect { subject }.to raise_error(
-          Mutant::Expression::AmbiguousExpressionError,
-          'Ambiguous expression: "test-syntax"'
-        )
-      end
+      it { should be(false) }
     end
   end
 
-  describe '#inspect' do
-    let(:object) { described_class.parse('Foo') }
-    subject { object.inspect }
-
-    it { should eql('<Mutant::Expression: Foo>') }
-    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) }
-
-    context 'on nonsense' do
-      let(:input) { 'foo bar' }
+  describe '.try_parse' do
+    let(:object) do
+      Class.new(described_class) do
+        include Anima.new(:foo)
 
-      it 'raises an exception' do
-        expect { subject }.to raise_error(
-          Mutant::Expression::InvalidExpressionError,
-          'Expression: "foo bar" is not valid'
-        )
+        const_set(:REGEXP, /(?<foo>foo)/)
       end
     end
 
-    context 'on a valid expression' do
-      let(:input) { 'Foo' }
+    subject { object.try_parse(input) }
+
+    context 'on successful parse' do
+      let(:input) { 'foo' }
 
-      it { should eql(Mutant::Expression::Namespace::Exact.new('Foo')) }
+      it { should eql(object.new(foo: 'foo')) }
     end
-  end
 
-  describe '._load' do
-    subject { described_class._load('Foo') }
+    context 'on unsuccessful parse' do
+      let(:input) { 'bar' }
 
-    it { should eql(described_class.parse('Foo')) }
+      it { should be(nil) }
+    end
   end
 end