mutant 0.3.6 → 0.5.0

data/lib/mutant/strategy.rb

@@ -4,7 +4,35 @@ module Mutant
 
   # Abstract base class for killing strategies
   class Strategy
-    include AbstractType, Adamantium::Flat
+    include AbstractType, Adamantium::Flat, Equalizer.new
+
+    REGISTRY = {}
+
+    # Lookup strategy for name
+    #
+    # @param [String] name
+    #
+    # @return [Strategy]
+    #   if found
+    #
+    # @api private
+    #
+    def self.lookup(name)
+      REGISTRY.fetch(name)
+    end
+
+    # Register strategy
+    #
+    # @param [String] name
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def self.register(name)
+      REGISTRY[name] = self
+    end
+    private_class_method :register
 
     # Perform strategy setup
     #
@@ -50,5 +78,15 @@ module Mutant
       self.class::KILLER
     end
 
+    # Null strategy that never kills a mutation
+    class Null < self
+
+      register 'null'
+
+      KILLER = Killer::Null
+
+    end # Null
+
   end # Strategy
+
 end # Mutant

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # The current mutant version
-  VERSION = '0.3.6'.freeze
+  VERSION = '0.5.0'.freeze
 end # Mutant

data/lib/mutant/walker.rb

@@ -0,0 +1,51 @@
+module Mutant
+
+  # Walker for all ast nodes
+  class Walker
+
+    # Run walkter
+    #
+    # @param [Parser::AST::Node] root
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def self.run(root, &block)
+      new(root, block)
+      self
+    end
+
+    private_class_method :new
+
+    # Initialize and run walker
+    #
+    # @param [Parser::AST::Node] root
+    # @param [#call(node)] block
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(root, block)
+      @root, @block = root, block
+      dispatch(root)
+    end
+
+  private
+
+    # Perform dispatch
+    #
+    # @param [Parser::AST::Node] node
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def dispatch(node)
+      @block.call(node)
+      node.children.grep(Parser::AST::Node).each(&method(:dispatch))
+    end
+  end # Walker
+
+end # Mutant

data/mutant-rspec.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+#
+require File.expand_path('../lib/mutant/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'mutant-rspec'
+  gem.version     = Mutant::VERSION.dup
+  gem.authors     = ['Markus Schirp']
+  gem.email       = ['mbj@schirp-dso.com']
+  gem.description = 'Rspec integration for mutant'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/mbj/mutant'
+  gem.license     = 'MIT'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files -- lib/mutant{-,/}rspec.rb lib/mutant/rspec`.split("\n")
+  gem.test_files       = `git ls-files -- spec/{unit/mutant/rspec,integration/rspec}`.split("\n")
+  gem.extra_rdoc_files = %w[TODO LICENSE]
+
+  gem.add_runtime_dependency('mutant', "~> #{gem.version}")
+  gem.add_runtime_dependency('rspec-core',  '~> 2.14.1')
+
+  gem.add_development_dependency('bundler', '~> 1.3', '>= 1.3.5')
+end

data/mutant.gemspec

@@ -13,7 +13,10 @@ Gem::Specification.new do |gem|
   gem.license     = 'MIT'
 
   gem.require_paths    = %w[lib]
-  gem.files            = `git ls-files`.split("\n")
+
+  mutant_rspec_files = `git ls-files -- lib/mutant{-,/}rspec.rb lib/mutant/rspec`.split("\n")
+
+  gem.files            = `git ls-files`.split("\n") - mutant_rspec_files
   gem.test_files       = `git ls-files -- spec/{unit,integration}`.split("\n")
   gem.extra_rdoc_files = %w[TODO LICENSE]
   gem.executables      = %w[mutant]
@@ -21,12 +24,13 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version = '>= 1.9.3'
 
   gem.add_runtime_dependency('parser',              '~> 2.1.4')
+  gem.add_runtime_dependency('morpher',             '~> 0.0.1')
   gem.add_runtime_dependency('procto',              '~> 0.0.2')
   gem.add_runtime_dependency('abstract_type',       '~> 0.0.7')
   gem.add_runtime_dependency('unparser',            '~> 0.1.8')
-  gem.add_runtime_dependency('ice_nine',            '~> 0.9.0')
+  gem.add_runtime_dependency('ice_nine',            '~> 0.11.0')
   gem.add_runtime_dependency('descendants_tracker', '~> 0.0.1')
-  gem.add_runtime_dependency('adamantium',          '~> 0.1.0')
+  gem.add_runtime_dependency('adamantium',          '~> 0.2.0')
   gem.add_runtime_dependency('equalizer',           '~> 0.0.7')
   gem.add_runtime_dependency('inflecto',            '~> 0.0.2')
   gem.add_runtime_dependency('anima',               '~> 0.2.0')

data/spec/integration/mutant/rspec_spec.rb

@@ -10,24 +10,29 @@ describe Mutant, 'rspec integration' do
     end
   end
 
-  let(:base_cmd) { 'bundle exec mutant -I lib --require test_app --rspec' }
+  let(:base_cmd) { 'bundle exec mutant -I lib --require test_app --use rspec' }
 
   specify 'it allows to kill mutations' do
-    Kernel.system("#{base_cmd} ::TestApp::Literal#string").should be(true)
+    expect(Kernel.system("#{base_cmd} ::TestApp::Literal#string")).to be(true)
   end
 
   specify 'it allows to exclude mutations' do
-    cli = "#{base_cmd} ::TestApp::Literal#string --ignore-subject ::TestApp::Literal#uncovered_string"
-    Kernel.system(cli).should be(true)
+    cli = <<-CMD.split("\n").join(' ')
+      #{base_cmd}
+      ::TestApp::Literal#string
+      ::TestApp::Literal#uncovered_string
+        --ignore-subject ::TestApp::Literal#uncovered_string
+    CMD
+    expect(Kernel.system(cli)).to be(true)
   end
 
   specify 'fails to kill mutations when they are not covered' do
     cli = "#{base_cmd} ::TestApp::Literal#uncovered_string"
-    Kernel.system(cli).should be(false)
+    expect(Kernel.system(cli)).to be(false)
   end
 
   specify 'fails when some mutations are not covered' do
     cli = "#{base_cmd} ::TestApp::Literal"
-    Kernel.system(cli).should be(false)
+    expect(Kernel.system(cli)).to be(false)
   end
 end

data/spec/integration/mutant/zombie_spec.rb

@@ -3,8 +3,8 @@
 require 'spec_helper'
 
 describe Mutant, 'as a zombie' do
-  specify 'it allows to create zombie from mutant' do
+  pending 'it allows to create zombie from mutant' do
     Mutant::Zombifier.run('mutant')
-    Zombie.constants.should include(:Mutant)
+    expect(Zombie.constants).to include(:Mutant)
   end
 end

data/spec/shared/method_matcher_behavior.rb

@@ -9,28 +9,28 @@ shared_examples_for 'a method matcher' do
   let(:mutation_subject)  { yields.first             }
 
   it 'should return one subject' do
-    yields.size.should be(1)
+    expect(yields.size).to be(1)
   end
 
   it_should_behave_like 'an #each method'
 
   it 'should have correct method name' do
-    name.should eql(method_name)
+    expect(name).to eql(method_name)
   end
 
   it 'should have correct line number' do
-    (node.location.expression.line - base).should eql(method_line)
+    expect(node.location.expression.line - base).to eql(method_line)
   end
 
   it 'should have correct arity' do
-    arguments.children.length.should eql(method_arity)
+    expect(arguments.children.length).to eql(method_arity)
   end
 
   it 'should have correct scope in context' do
-    context.send(:scope).should eql(scope)
+    expect(context.scope).to eql(scope)
   end
 
   it 'should have the correct node type' do
-    node.type.should be(type)
+    expect(node.type).to be(type)
   end
 end

data/spec/spec_helper.rb

@@ -17,7 +17,7 @@ if ENV['COVERAGE'] == 'true'
     add_filter 'vendor'
     add_filter 'test_app'
 
-    minimum_coverage 90.1  # TODO: raise this to 100, then mutation test
+    minimum_coverage 89.79  # TODO: raise this to 100, then mutation test
   end
 end
 
@@ -48,6 +48,6 @@ RSpec.configure do |config|
   config.include(ParserHelper)
   config.include(Mutant::NodeHelpers)
   config.expect_with :rspec do |rspec|
-    rspec.syntax = [:expect, :should]
+    rspec.syntax = :expect
   end
 end

data/spec/unit/mutant/cli_new_spec.rb

@@ -27,8 +27,8 @@ describe Mutant::CLI, '.new' do
   end
 
   # Defaults
-  let(:expected_filter)   { Mutant::Predicate::TAUTOLOGY       }
-  let(:expected_strategy) { Mutant::Strategy::Rspec.new(0)     }
+  let(:expected_filter)   { Morpher.evaluator(s(:true))        }
+  let(:expected_strategy) { Mutant::Strategy::Null.new         }
   let(:expected_reporter) { Mutant::Reporter::CLI.new($stdout) }
 
   let(:ns)    { Mutant::Matcher   }
@@ -54,80 +54,95 @@ describe Mutant::CLI, '.new' do
     it_should_behave_like 'an invalid cli run'
   end
 
-  context 'with many strategy flags' do
-    let(:arguments) { %w(--rspec --rspec TestApp) }
-    let(:expected_matcher) { Mutant::Matcher::Scope.new(cache, TestApp) }
-
-    it_should_behave_like 'a cli parser'
-  end
-
   context 'without arguments' do
     let(:arguments) { [] }
 
-    let(:expected_message) { 'No matchers given' }
+    let(:expected_message) { 'No patterns given' }
 
     it_should_behave_like 'an invalid cli run'
   end
 
   context 'with code filter and missing argument' do
-    let(:arguments)        { %w(--rspec --code)    }
+    let(:arguments)        { %w(--code)    }
     let(:expected_message) { 'missing argument: --code' }
 
     it_should_behave_like 'an invalid cli run'
   end
 
-  context 'with explicit method matcher' do
-    let(:arguments)        { %w(--rspec TestApp::Literal#float) }
-    let(:expected_matcher) { ns::Method::Instance.new(cache, TestApp::Literal, TestApp::Literal.instance_method(:float)) }
+  context 'with explicit method pattern' do
+    let(:arguments)        { %w(TestApp::Literal#float) }
+
+    let(:expected_matcher) do
+      ns::Method::Instance.new(cache, TestApp::Literal, TestApp::Literal.instance_method(:float))
+    end
 
     it_should_behave_like 'a cli parser'
   end
 
   context 'with debug flag' do
-    let(:matcher)          { '::TestApp*'                      }
-    let(:arguments)        { %W(--debug --rspec #{matcher})    }
+    let(:pattern)          { '::TestApp*'           }
+    let(:arguments)        { %W(--debug #{pattern}) }
     let(:expected_matcher) { ns::Namespace.new(cache, TestApp) }
 
     it_should_behave_like 'a cli parser'
 
     it 'should set the debug option' do
-      subject.config.debug.should be(true)
+      expect(subject.config.debug).to be(true)
     end
   end
 
   context 'with zombie flag' do
-    let(:matcher)          { '::TestApp*'                      }
-    let(:arguments)        { %W(--zombie --rspec #{matcher})   }
+    let(:pattern)          { '::TestApp*'            }
+    let(:arguments)        { %W(--zombie #{pattern}) }
     let(:expected_matcher) { ns::Namespace.new(cache, TestApp) }
 
     it_should_behave_like 'a cli parser'
 
     it 'should set the zombie option' do
-      subject.config.zombie.should be(true)
+      expect(subject.config.zombie).to be(true)
     end
   end
 
-  context 'with namespace matcher' do
-    let(:matcher)          { '::TestApp*'                      }
-    let(:arguments)        { %W(--rspec #{matcher})            }
+  context 'with namespace pattern' do
+    let(:pattern)          { '::TestApp*'   }
+    let(:arguments)        { %W(#{pattern}) }
     let(:expected_matcher) { ns::Namespace.new(cache, TestApp) }
 
     it_should_behave_like 'a cli parser'
   end
 
-  context 'with code filter' do
-    let(:matcher)   { 'TestApp::Literal#float'                     }
-    let(:arguments) { %W(--rspec --code faa --code bbb #{matcher}) }
-
-    let(:filters) do
-      [
-        Mutant::Predicate::Attribute.new(:code, 'faa'),
-        Mutant::Predicate::Attribute.new(:code, 'bbb'),
-      ]
+  context 'with subject code filter' do
+    let(:pattern)   { 'TestApp::Literal#float' }
+    let(:arguments) { %W(--code faa --code bbb #{pattern}) }
+
+    let(:expected_filter) do
+      Morpher.evaluator(
+        s(:mxor,
+          s(:eql, s(:attribute, :code), s(:value, 'faa')),
+          s(:eql, s(:attribute, :code), s(:value, 'bbb'))
+        )
+      )
     end
 
-    let(:expected_matcher) { ns::Method::Instance.new(cache, TestApp::Literal, TestApp::Literal.instance_method(:float))  }
-    let(:expected_filter)  { Mutant::Predicate::Whitelist.new(filters) }
+    let(:expected_matcher) do
+      matcher = ns::Method::Instance.new(
+        cache,
+        TestApp::Literal, TestApp::Literal.instance_method(:float)
+      )
+      predicate = Morpher.evaluator(
+        s(:or,
+          s(:eql,
+            s(:attribute, :code),
+            s(:static, 'faa')
+          ),
+          s(:eql,
+            s(:attribute, :code),
+            s(:static, 'bbb')
+          )
+        )
+      )
+      ns::Filter.new(matcher, predicate)
+    end
 
     it_should_behave_like 'a cli parser'
   end

data/spec/unit/mutant/context/scope/root_spec.rb

@@ -31,6 +31,6 @@ describe Mutant::Context::Scope, '#root' do
   end
 
   it 'should create correct source' do
-    generated_source.should eql(expected_source)
+    expect(generated_source).to eql(expected_source)
   end
 end

data/spec/unit/mutant/loader/eval_spec.rb

@@ -41,8 +41,8 @@ describe Mutant::Loader::Eval, '.call' do
 
   it 'should set file and line correctly' do
     subject
-    ::SomeNamespace::Bar
+    expect(::SomeNamespace::Bar
       .instance_method(:some_method)
-      .source_location.should eql([__FILE__, 3])
+      .source_location).to eql([__FILE__, 3])
   end
 end

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

@@ -32,7 +32,7 @@ describe Mutant::Matcher::Chain do
         pending 'FIX RBX rspec? BUG HERE'
       else
         it 'yields the expected values' do
-          subject.to_a.should eql(object.to_a)
+          expect(subject.to_a).to eql(object.to_a)
         end
       end
     end

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

@@ -58,7 +58,7 @@ describe Mutant::Matcher::Methods::Instance, '#each' do
 
   it 'should yield expected subjects' do
     subject
-    yields.should eql(subjects)
+    expect(yields).to eql(subjects)
   end
 
   it_should_behave_like 'an #each method'