mutant 0.3.1 → 0.3.2

data/mutant.gemspec

@@ -18,12 +18,13 @@ Gem::Specification.new do |gem|
   gem.extra_rdoc_files = %w[TODO LICENSE]
   gem.executables      = %w[mutant]
 
-  gem.add_runtime_dependency('parser',              '~> 2.0.0')
+  gem.add_runtime_dependency('parser',              '~> 2.1.0')
+  gem.add_runtime_dependency('procto',              '~> 0.0.2')
   gem.add_runtime_dependency('abstract_type',       '~> 0.0.7')
-  gem.add_runtime_dependency('unparser',            '~> 0.1.4')
+  gem.add_runtime_dependency('unparser',            '~> 0.1.6')
   gem.add_runtime_dependency('ice_nine',            '~> 0.9')
   gem.add_runtime_dependency('descendants_tracker', '~> 0.0.1')
-  gem.add_runtime_dependency('adamantium',          '~> 0.1.0')
+  gem.add_runtime_dependency('adamantium',          '~> 0.1')
   gem.add_runtime_dependency('equalizer',           '~> 0.0.7')
   gem.add_runtime_dependency('inflecto',            '~> 0.0.2')
   gem.add_runtime_dependency('anima',               '~> 0.1.1')

data/spec/integration/mutant/test_mutator_handles_types_spec.rb

@@ -3,6 +3,7 @@
 require 'spec_helper'
 
 describe Mutant do
+
   specify 'mutant should not crash for any node parser can generate' do
     Mutant::NODE_TYPES.each do |type|
       Mutant::Mutator::Registry.lookup(Mutant::NodeHelpers.s(type))

data/spec/spec_helper.rb

@@ -22,7 +22,7 @@ if ENV['COVERAGE'] == 'true'
 end
 
 require 'equalizer'
-require 'triage/spec_helper'
+require 'devtools/spec_helper'
 require 'mutant'
 
 $LOAD_PATH << File.join(TestApp.root, 'lib')

data/spec/unit/mutant/cli/classifier/method_spec.rb

@@ -11,7 +11,7 @@ describe Mutant::CLI::Classifier::Method, '#each' do
   let(:unknown_method)   { '::TestApp::Literal#unknown'        }
 
   context 'with a block' do
-    subject { object.each { } }
+    subject { object.each {} }
 
     context 'with an instance method name' do
       let(:input) { instance_method }

data/spec/unit/mutant/cli/classifier/namespace/flat_spec.rb

@@ -9,7 +9,7 @@ describe Mutant::CLI::Classifier::Namespace::Flat, '#each' do
   let(:unknown_namespace) { '::TestApp::Object'                 }
 
   context 'with a block' do
-    subject { object.each { } }
+    subject { object.each {} }
 
     context 'with a known namespace' do
       let(:input) { known_namespace }
@@ -51,7 +51,7 @@ describe Mutant::CLI::Classifier::Namespace::Flat, '#each' do
       let(:input) { unknown_namespace }
 
       it 'raises an exception when #each is called' do
-        expect { subject.each { } }.to raise_error(NameError)
+        expect { subject.each {} }.to raise_error(NameError)
       end
     end
   end

data/spec/unit/mutant/cli/classifier/namespace/recursive_spec.rb

@@ -9,7 +9,7 @@ describe Mutant::CLI::Classifier::Namespace::Recursive, '#each' do
   let(:unknown_namespace) { '::TestApp::Object'                       }
 
   context 'with a block' do
-    subject { object.each { } }
+    subject { object.each {} }
 
     context 'with a known namespace' do
       let(:input) { known_namespace }
@@ -51,7 +51,7 @@ describe Mutant::CLI::Classifier::Namespace::Recursive, '#each' do
       let(:input) { unknown_namespace }
 
       it 'raises an exception when #each is called' do
-        expect { subject.each { } }.to raise_error(NameError)
+        expect { subject.each {} }.to raise_error(NameError)
       end
     end
   end

data/spec/unit/mutant/differ_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mutant::Differ do
+  let(:object) { described_class }
+
+  describe '.build' do
+
+    subject { object.build(old_string, new_string) }
+
+    let(:old_string) { "foo\nbar" }
+    let(:new_string) { "bar\nbaz" }
+
+    it { should eql(Mutant::Differ.new(%w(foo bar), %w(bar baz))) }
+
+  end
+
+  describe '.colorize_line' do
+    let(:object) { described_class }
+
+    subject { object.colorize_line(line) }
+
+    context 'line beginning with "+"' do
+      let(:line) { '+line' }
+
+      it { should eql(Mutant::Color::GREEN.format(line)) }
+    end
+
+    context 'line beginning with "-"' do
+      let(:line) { '-line' }
+
+      it { should eql(Mutant::Color::RED.format(line)) }
+    end
+
+    context 'line beginning in other char' do
+      let(:line) { ' line' }
+
+      it { should eql(line) }
+    end
+  end
+end

data/spec/unit/mutant/loader/{eval/class_methods/run_spec.rb → eval_spec.rb}

@@ -2,9 +2,9 @@
 
 require 'spec_helper'
 
-describe Mutant::Loader::Eval, '.run' do
+describe Mutant::Loader::Eval, '.call' do
 
-  subject { object.run(node, mutation_subject) }
+  subject { object.call(node, mutation_subject) }
 
   let(:object) { described_class }
   let(:path)   { __FILE__        }

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mutant::Matcher::Chain do
+
+  let(:object) { described_class.new(matchers) }
+
+  describe '#each' do
+    subject { object.each { |entry| yields << entry } }
+
+    let(:matchers) { [matcher_a, matcher_b] }
+
+    let(:matcher_a) { double('Matcher A') }
+    let(:matcher_b) { double('Matcher B') }
+
+    let(:subject_a) { double('Subject A') }
+    let(:subject_b) { double('Subject B') }
+
+    before do
+      matcher_a.stub(:each).and_yield(subject_a).and_return(matcher_a)
+      matcher_b.stub(:each).and_yield(subject_b).and_return(matcher_b)
+    end
+
+    # it_should_behave_like 'an #each method'
+    context 'with no block' do
+      subject { object.each }
+
+      it { should be_instance_of(to_enum.class) }
+
+      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+        pending 'FIX RBX rspec? BUG HERE'
+      else
+        it 'yields the expected values' do
+          subject.to_a.should eql(object.to_a)
+        end
+      end
+    end
+
+    let(:yields) { [] }
+
+    it 'should yield subjects' do
+      expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
+    end
+  end
+
+  describe '#matchers' do
+    subject { object.matchers }
+
+    let(:matchers) { double('Matchers')            }
+
+    it { should be(matchers) }
+
+    it_should_behave_like 'an idempotent method'
+  end
+
+end

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

@@ -0,0 +1,155 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mutant::Matcher::Method::Instance do
+
+  let(:cache) { Fixtures::AST_CACHE }
+
+  describe '#each' do
+    subject { object.each { |subject| yields << subject } }
+
+    let(:object)       { described_class.new(cache, scope, method) }
+    let(:method)       { scope.instance_method(method_name)        }
+    let(:yields)       { []                                        }
+    let(:namespace)    { self.class                                }
+    let(:scope)        { self.class::Foo                           }
+    let(:type)         { :def                                      }
+    let(:method_name)  { :bar                                      }
+    let(:method_arity) { 0                                         }
+
+    def name
+      node.children[0]
+    end
+
+    def arguments
+      node.children[1]
+    end
+
+    context 'when method is defined once' do
+      let(:base) { __LINE__ }
+      class self::Foo
+        def bar; end
+      end
+
+      let(:method_line) { 2 }
+
+      it_should_behave_like 'a method matcher'
+    end
+
+    context 'when method is defined multiple times' do
+      context 'on differend lines' do
+        let(:base) { __LINE__ }
+        class self::Foo
+          def bar
+          end
+
+          def bar(arg)
+          end
+        end
+
+        let(:method_line)  { 5 }
+        let(:method_arity) { 1 }
+
+        it_should_behave_like 'a method matcher'
+      end
+
+      context 'on the same line' do
+        let(:base) { __LINE__ }
+        class self::Foo
+          def bar; end; def bar(arg); end
+        end
+
+        let(:method_line)  { 2 }
+        let(:method_arity) { 1 }
+
+        it_should_behave_like 'a method matcher'
+      end
+
+      context 'on the same line with differend scope' do
+        let(:base) { __LINE__ }
+        class self::Foo
+          def self.bar; end; def bar(arg); end
+        end
+
+        let(:method_line)  { 2 }
+        let(:method_arity) { 1 }
+
+        it_should_behave_like 'a method matcher'
+      end
+
+      context 'when nested' do
+        let(:pattern) { 'Foo::Bar#baz' }
+
+        context 'in class' do
+          let(:base) { __LINE__ }
+          class self::Foo
+            class Bar
+              def baz
+              end
+            end
+          end
+
+          let(:method_line) { 3                    }
+          let(:method_name) { :baz                 }
+          let(:scope)       { self.class::Foo::Bar }
+
+          it_should_behave_like 'a method matcher'
+        end
+
+        context 'in module' do
+          let(:base) { __LINE__ }
+          module self::Foo
+            class Bar
+              def baz
+              end
+            end
+          end
+
+          let(:method_line) { 3                    }
+          let(:method_name) { :baz                 }
+          let(:scope)       { self.class::Foo::Bar }
+
+          it_should_behave_like 'a method matcher'
+        end
+      end
+    end
+  end
+
+  describe '.build' do
+    let(:object) { described_class }
+
+    subject { object.build(cache, scope, method) }
+
+    let(:scope) do
+      Class.new do
+        include Adamantium
+
+        def foo
+        end
+        memoize :foo
+
+        def bar
+        end
+      end
+    end
+
+    let(:method) do
+      scope.instance_method(method_name)
+    end
+
+    context 'with adamantium infected scope' do
+      context 'with unmemoized method' do
+        let(:method_name) { :bar }
+
+        it { should eql(described_class.new(cache, scope, method)) }
+      end
+
+      context 'with memoized method' do
+        let(:method_name) { :foo }
+
+        it { should eql(described_class::Memoized.new(cache, scope, method)) }
+      end
+    end
+  end
+end

data/spec/unit/mutant/mutator/node/{connective/binary/mutation_spec.rb → binary_spec.rb}

@@ -2,7 +2,7 @@
 
 require 'spec_helper'
 
-describe Mutant::Mutator::Node::Connective::Binary, 'mutations' do
+describe Mutant::Mutator::Node::Binary, 'mutations' do
   context 'and' do
     let(:source) { 'true and false' }
 

data/spec/unit/mutant/mutator/node/conditional_loop_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mutant::Mutator::Node::ConditionalLoop do
+
+  context 'with while statement' do
+    let(:source) { 'while true; foo; bar; end' }
+
+    let(:mutations) do
+      mutations = []
+      mutations << 'while true; bar; end'
+      mutations << 'while true; foo; end'
+      mutations << 'while true; end'
+      mutations << 'while false; foo; bar; end'
+      mutations << 'while nil;   foo; bar; end'
+      mutations << 'while true;  foo; nil; end'
+      mutations << 'while true;  nil; bar; end'
+      mutations << 'nil'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+
+  context 'with until statement' do
+    let(:source) { 'until true; foo; bar; end' }
+
+    let(:mutations) do
+      mutations = []
+      mutations << 'until true; bar; end'
+      mutations << 'until true; foo; end'
+      mutations << 'until true; end'
+      mutations << 'until false; foo; bar; end'
+      mutations << 'until nil;   foo; bar; end'
+      mutations << 'until true;  foo; nil; end'
+      mutations << 'until true;  nil; bar; end'
+      mutations << 'nil'
+    end
+
+    it_should_behave_like 'a mutator'
+  end
+end