mutant 0.1.1 → 0.2.0

data/lib/mutant/support/method_object.rb

@@ -0,0 +1,31 @@
+module Mutant
+  # A mixing to create method object semantics
+  module MethodObject
+    # Hook called when descendant is extended
+    #
+    # @param [Module|Class] descendant
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.extended(descendant)
+      descendant.class_eval do
+        private_class_method :new
+      end
+    end
+
+    # Run the method object
+    #
+    # Not aliased to prevent problems from inheritance
+    #
+    # @return [Objecct]
+    #   returns the created object
+    #
+    # @api private
+    #
+    def run(*args)
+      new(*args)
+    end
+  end
+end

data/locator.rb

@@ -0,0 +1,87 @@
+
+require 'spec_helper'
+
+describe Mutant::Matcher::Method::Instance, '.each' do
+  subject { object.each(scope) { |item| yields << item } }
+
+  let(:object)   { described_class }
+  let(:yields)   { []              }
+
+  context 'when scope is a Class' do
+    let(:scope) do
+      ancestor = Class.new do
+        def ancestor_method
+        end
+      end
+
+      Class.new(ancestor) do
+        def self.name; 'SomeRandomClass'; end
+
+        def public_method; end
+        public :public_method
+
+        def protected_method; end
+        protected :protected_method
+
+        def private_method; end
+        private :private_method
+      end
+    end
+
+    it 'should yield instance method matchers' do
+      expected = [
+        Mutant::Matcher::Method::Instance.new(scope, :public_method   ),
+        Mutant::Matcher::Method::Instance.new(scope, :protected_method),
+        Mutant::Matcher::Method::Instance.new(scope, :private_method  )
+      ].sort_by(&:method_name)
+
+      expect { subject }.to change { yields.dup }.from([]).to(expected)
+    end
+  end
+end
+
+require 'spec_helper'
+
+describe Mutant::Matcher::Method::Singleton, '.each' do
+  subject { object.each(scope) { |item| yields << item } }
+
+  let(:each_arguments) { [scope] }
+
+  let(:object)   { described_class }
+  let(:yields)   { []              }
+
+  context 'when scope is a Class' do
+    let(:scope) do
+      ancestor = Class.new do
+        def self.ancestor_method
+        end
+
+        def self.name; 'SomeRandomClass'; end
+      end
+
+      Class.new(ancestor) do
+        def self.public_method; end
+        public_class_method :public_method
+
+        class << self
+          def protected_method; end
+
+          protected :protected_method
+        end
+
+        def self.private_method; end
+        private_class_method :private_method
+      end
+    end
+
+    it 'should yield instance method matchers' do
+      expected = [
+        Mutant::Matcher::Method::Singleton.new(scope, :public_method   ),
+        Mutant::Matcher::Method::Singleton.new(scope, :protected_method),
+        Mutant::Matcher::Method::Singleton.new(scope, :private_method  )
+      ].sort_by(&:method_name)
+
+      expect { subject }.to change { yields.dup }.from([]).to(expected)
+    end
+  end
+end

data/mutant.gemspec

@@ -1,26 +1,26 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "mutant/version"
 
-Gem::Specification.new do |s|
-  s.name        = 'mutant'
-  s.version     = Mutant::VERSION
-  s.authors     = ["Justin Ko", "Josep M. Bach"]
-  s.email       = ["justin@kospecinc.com", "josep.m.bach@gmail.com"]
-  s.homepage    = ""
-  s.summary     = %q{Mutation tester}
-  s.description = %q{Mutation tester}
+Gem::Specification.new do |gem|
+  gem.name        = 'mutant'
+  gem.version     = '0.2.0'
+  gem.authors     = [ 'Markus Schirp' ]
+  gem.email       = [ 'mbj@seonic.net' ]
+  gem.description = 'Mutation testing for ruby under rubinius'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/mbj/mutant'
 
-  s.rubyforge_project = "mutant"
+  gem.require_paths    = [ 'lib' ]
+  gem.files            = `git ls-files`.split("\n")
+  gem.test_files       = `git ls-files -- spec`.split("\n")
+  gem.extra_rdoc_files = %w[TODO]
+  gem.executables       = [ 'mutant' ]
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- spec/*`.split("\n")
-  s.bindir        = 'exe'
-  s.executables   = `git ls-files -- exe/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.add_runtime_dependency 'to_source'
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'rspec', '~> 2.7'
-  s.add_development_dependency 'aruba'
+  gem.add_runtime_dependency('to_source',           '~> 0.2.0')
+  gem.add_runtime_dependency('ice_nine',            '~> 0.5.0')
+  gem.add_runtime_dependency('descendants_tracker', '~> 0.0.1')
+  gem.add_runtime_dependency('backports',           '~> 2.6')
+  gem.add_runtime_dependency('adamantium',          '~> 0.0.3')
+  gem.add_runtime_dependency('equalizer',           '~> 0.0.1')
+  gem.add_runtime_dependency('abstract_type',       '~> 0.0.2')
+  gem.add_runtime_dependency('diff-lcs',            '~> 1.1.3')
 end

data/spec/integration/mutant/differ_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Mutant,'differ' do
+  specify 'allows to create diffs from text' do
+    a = "Foo\nBar\n"
+    b = "Foo\nBaz\n"
+    differ = Mutant::Differ.new(a,b)
+    differ.diff.should == strip_indent(<<-RUBY)
+      @@ -1,3 +1,3 @@
+       Foo
+      -Bar
+      +Baz
+    RUBY
+  end
+end

data/spec/integration/mutant/loader_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+class CodeLoadingSubject
+  def x
+    true
+  end
+end
+
+describe Mutant, 'code loading' do
+  let(:context) { Mutant::Context::Scope.build(CodeLoadingSubject,"/some/path") }
+  let(:node)    { 'def foo; :bar; end'.to_ast                                   }
+  let(:root)    { context.root(node)                                            }
+ 
+  subject       { Mutant::Loader::Eval.run(root)                                }
+
+  before { subject }
+
+  it 'should add the method to subject' do
+    CodeLoadingSubject.new.foo.should be(:bar)
+  end
+end

data/spec/integration/mutant/method_matching_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+
+describe Mutant, 'method matching' do
+  after do
+    if defined?(::Foo)
+      Object.send(:remove_const, 'Foo')
+    end
+  end
+
+  before do
+    #eval(body, TOPLEVEL_BINDING, __FILE__, 0)
+    eval(body)
+    File.stub(:read => body)
+  end
+
+  let(:defaults) { {} }
+
+  context 'on instance methods' do
+    def name(node)
+      node.name
+    end
+
+    def arguments(node)
+      node.arguments
+    end
+
+    let(:pattern) { 'Foo#bar' }
+    let(:defaults) do
+      {
+        :scope        => Foo,
+        :node_class   => Rubinius::AST::Define,
+        :method_name  => :bar,
+        :method_arity => 0
+      }
+    end
+
+    context 'when method is defined once' do
+      let(:body) do
+        <<-RUBY
+          class Foo
+            def bar; end
+          end
+        RUBY
+      end
+
+      let(:expectation) do
+        { :method_line  => 2 }
+      end
+
+      it_should_behave_like 'a method match'
+    end
+
+    context 'when method is defined multiple times' do
+      context 'on differend lines' do
+        let(:body) do
+          <<-RUBY
+            class Foo
+              def bar; end
+              def bar(arg); end
+            end
+          RUBY
+        end
+
+        let(:expectation) do
+          {
+            :method_line  => 3,
+            :method_arity => 1
+          }
+        end
+
+        it_should_behave_like 'a method match'
+      end
+
+      context 'on the same line' do
+        let(:body) do
+          <<-RUBY
+            class Foo
+              def bar; end; def bar(arg); end
+            end
+          RUBY
+        end
+
+        let(:expectation) do
+          {
+            :method_line  => 2,
+            :method_arity => 1
+          }
+        end
+
+        it_should_behave_like 'a method match'
+      end
+
+      context 'on the same line with differend scope' do
+        let(:body) do
+          <<-RUBY
+            class Foo
+              def self.bar; end; def bar(arg); end
+            end
+          RUBY
+        end
+
+        let(:expectation) do
+          {
+            :method_line  => 2,
+            :method_arity => 1
+          }
+        end
+
+        it_should_behave_like 'a method match'
+      end
+
+      context 'when nested' do
+        let(:pattern) { 'Foo::Bar#baz' }
+
+        context 'in class' do
+          let(:body) do
+            <<-RUBY
+              class Foo
+                class Bar
+                  def baz; end
+                end
+              end
+            RUBY
+          end
+
+          let(:expectation) do
+            {
+              :method_line => 3,
+              :method_name => :baz,
+              :scope    => Foo::Bar
+            }
+          end
+
+          it_should_behave_like 'a method match'
+        end
+
+        context 'in module' do
+          let(:body) do
+            <<-RUBY
+              module Foo
+                class Bar
+                  def baz; end
+                end
+              end
+            RUBY
+          end
+
+          let(:expectation) do
+            {
+              :method_line => 3,
+              :method_name => :baz,
+              :scope    => Foo::Bar
+            }
+          end
+
+          it_should_behave_like 'a method match'
+        end
+      end
+    end
+  end
+
+  context 'on singleton methods' do
+    let(:pattern) { 'Foo.bar' }
+    let(:defaults) do
+      {
+        :scope        => Foo,
+        :node_class   => Rubinius::AST::DefineSingleton,
+        :method_arity => 0
+      }
+    end
+
+    def name(node)
+      node.body.name
+    end
+
+    def arguments(node)
+      node.body.arguments
+    end
+
+    context 'when defined on self' do
+      let(:body) do
+        <<-RUBY
+          class Foo
+            def self.bar; end
+          end
+        RUBY
+      end
+
+
+      let(:expectation) do
+        {
+          :method_name  => :bar,
+          :method_line  => 2,
+        }
+      end
+
+      it_should_behave_like 'a method match'
+    end
+
+    context 'when defined on constant' do
+
+      context 'inside namespace' do
+        let(:body) do
+          <<-RUBY
+            class Foo
+              def Foo.bar; end
+            end
+          RUBY
+        end
+
+
+        let(:expectation) do
+          {
+            :method_name  => :bar,
+            :method_line  => 2,
+          }
+        end
+
+        it_should_behave_like 'a method match'
+      end
+
+      context 'outside namespace' do
+        let(:body) do
+          <<-RUBY
+            class Foo; end;
+            def Foo.bar; end
+          RUBY
+        end
+
+
+        let(:expectation) do
+          {
+            :method_name  => :bar,
+            :method_line  => 2,
+          }
+        end
+
+        it_should_behave_like 'a method match'
+      end
+    end
+
+    context 'when defined multiple times in the same line' do
+      context 'with method on differend scope' do
+        let(:body) do
+          <<-RUBY
+            module Foo; end
+
+            module Bar
+              def self.baz; end; def Foo.baz(arg); end
+            end
+          RUBY
+        end
+
+        let(:pattern) { 'Bar.baz' }
+
+        let(:expectation) do
+          {
+            :scope        => Bar,
+            :method_name  => :baz,
+            :method_line  => 4,
+            :method_arity => 0
+          }
+        end
+
+        it_should_behave_like 'a method match'
+      end
+    end
+  end
+end