mutant 0.2.20 → 0.3.0.beta2

data/lib/mutant/reporter/stats.rb

@@ -1,120 +0,0 @@
-module Mutant
-  class Reporter
-
-    # Stats gathered while reporter is running
-    class Stats
-
-      # Return subject count
-      #
-      # @return [Fixnum]
-      #
-      # @api private
-      #
-      attr_reader :subjects
-
-      # Return mutation count
-      #
-      # @return [Fixnum]
-      #
-      # @api private
-      #
-      attr_reader :mutations
-
-      # Return skip count
-      #
-      # @return [Fixnum]
-      #
-      # @api private
-      #
-      attr_reader :noop_fails
-
-      # Return kill count
-      #
-      # @return [Fixnum]
-      #
-      # @api private
-      #
-      attr_reader :kills
-
-      # Return mutation runtime
-      #
-      # @return [Float]
-      #
-      # @api private
-      #
-      attr_reader :time
-
-      # Initialize object
-      #
-      # @return [undefined]
-      #
-      # @api private
-      #
-      def initialize
-        @start = Time.now
-        @noop_fails = @subjects = @mutations = @kills = @time = 0
-      end
-
-      # Return runtime in seconds
-      #
-      # @return [Float]
-      #
-      # @api private
-      #
-      def runtime
-        Time.now - @start
-      end
-
-      # Count subject
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def subject
-        @subjects +=1
-        self
-      end
-
-      # Return number of mutants alive
-      #
-      # @return [Fixnum]
-      #
-      # @api private
-      #
-      def alive
-        @mutations - @kills
-      end
-
-      # Count noop mutation fail
-      #
-      # @param [Killer] killer
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def noop_fail(killer)
-        @noop_fails += 1
-        @time += killer.runtime
-        self
-      end
-
-      # Count killer
-      #
-      # @param [Killer] killer
-      #
-      # @return [self]
-      #
-      # @api private
-      #
-      def killer(killer)
-        @mutations +=1
-        @kills +=1 unless killer.fail?
-        @time += killer.runtime
-        self
-      end
-
-    end
-  end
-end

data/lib/mutant/strategy/rspec/example_lookup.rb

@@ -1,163 +0,0 @@
-module Mutant
-  class Strategy
-    class Rspec
-
-      # Example lookup for rspec
-      class ExampleLookup
-        include Adamantium::Flat, Equalizer.new(:mutation)
-
-        # Perform example lookup
-        #
-        # @param [Mutation] mutation
-        #
-        # @return [Enumerable<String>]
-        #
-        # @api private
-        #
-        def self.run(mutation)
-          new(mutation).spec_files
-        end
-
-        # Return mutation
-        #
-        # @return [Mutation]
-        #
-        # @api private
-        #
-        attr_reader :mutation
-
-        # Return spec files
-        #
-        # @return [Enumerable<String>]
-        #
-        # @api private
-        #
-        def spec_files
-          expression = glob_expression
-          files = Dir[expression]
-
-          if files.empty?
-            $stderr.puts("Spec file(s): #{expression.inspect} not found for #{mutation.identification}")
-          end
-
-          files
-        end
-        memoize :spec_files
-
-      private
-
-        # Return method matcher
-        #
-        # @return [Matcher]
-        #
-        # @api private
-        #
-        def matcher
-          mutation.subject.matcher
-        end
-
-        EXPANSIONS = {
-          /\?\z/ => '_predicate',
-          /=\z/  => '_writer',
-          /!\z/  => '_bang'
-        }
-
-        # Return spec file
-        #
-        # @return [String]
-        #
-        # @api private
-        #
-        def spec_file
-          "#{mapped_name || expanded_name}_spec.rb"
-        end
-        memoize :spec_file
-
-        # Return mapped name
-        #
-        # @return [Symbol]
-        #   if name was mapped
-        #
-        # @return [nil]
-        #   otherwise
-        #
-        # @api private
-        #
-        def mapped_name
-          OPERATOR_EXPANSIONS[method_name]
-        end
-
-        # Return expanded name
-        #
-        # @return [Symbol]
-        #
-        # @api private
-        #
-        def expanded_name
-          EXPANSIONS.inject(method_name) do |name, (regexp, expansion)|
-            name.to_s.gsub(regexp, expansion)
-          end.to_sym
-        end
-
-        # Return method name
-        #
-        # @return [Symbol]
-        #
-        # @api private
-        #
-        def method_name
-          matcher.method_name
-        end
-
-        # Return glob expression
-        #
-        # @return [String]
-        #
-        # @api private
-        #
-        def glob_expression
-          base = base_path
-
-          if mutation.subject.matcher.public?
-            "#{base}/#{spec_file}"
-          else
-            "#{base}/*_spec.rb"
-          end
-        end
-
-        # Return instance of singleton path appendo
-        #
-        # @return [String]
-        #
-        # @api private
-        #
-        def scope_append
-          matcher.kind_of?(Matcher::Method::Singleton) ? '/class_methods' : ''
-        end
-        memoize :scope_append
-
-        # Return base path
-        #
-        # @return [String]
-        #
-        # @api private
-        #
-        def base_path
-          "spec/unit/#{Inflecto.underscore(mutation.subject.context.scope.name)}#{scope_append}"
-        end
-        memoize :base_path
-
-        # Initalize object
-        #
-        # @param [Mutation] mutation
-        #
-        # @api private
-        #
-        def initialize(mutation)
-          @mutation = mutation
-        end
-
-      end
-    end
-  end
-end

data/spec/integration/mutant/method_matching_spec.rb

@@ -1,269 +0,0 @@
-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

data/spec/shared/method_match_behavior.rb

@@ -1,39 +0,0 @@
-shared_examples_for 'a method match' do
-  subject { Mutant::Matcher::Method.parse(pattern).to_a }
-
-  let(:values) { defaults.merge(expectation) }
-
-  let(:method_name)       { values.fetch(:method_name)  }
-  let(:method_line)       { values.fetch(:method_line)  }
-  let(:method_arity)      { values.fetch(:method_arity) }
-  let(:scope)             { values.fetch(:scope)        }
-  let(:node_class)        { values.fetch(:node_class)   }
-                         
-  let(:node)              { mutation_subject.node    }
-  let(:context)           { mutation_subject.context }
-  let(:mutation_subject)  { subject.first   }
-
-  it 'should return one subject' do
-    subject.size.should be(1)
-  end
-
-  it 'should have correct method name' do
-    name(node).should eql(method_name)
-  end
-
-  it 'should have correct line number' do
-    node.line.should eql(method_line)
-  end
-
-  it 'should have correct arity' do
-    arguments(node).required.length.should eql(method_arity)
-  end
-
-  it 'should have correct scope in context' do
-    context.send(:scope).should eql(scope)
-  end
-
-  it 'should have the correct node class' do
-    node.should be_a(node_class)
-  end
-end

data/spec/unit/mutant/killer/fail_ques_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Killer,'#fail?' do
-  subject { object.fail? }
-
-  let(:object)           { class_under_test.new(strategy, mutation) }
-  let(:strategy)         { mock('Strategy')                         }
-  let(:mutation)         { mock('Mutation')                         }
-
-  before do
-    mutation.stub(:insert)
-    mutation.stub(:reset)
-  end
-
-  let(:class_under_test) do
-    kill_state = self.kill_state
-    Class.new(described_class) do
-      define_method :run do
-        kill_state
-      end
-    end
-  end
-
-  context 'when mutant was killed' do
-    let(:kill_state) { true }
-    
-    it_should_behave_like 'an idempotent method'
-
-    it { should be(false) }
-  end
-
-  context 'when mutant was NOT killed' do
-    let(:kill_state) { false }
-    
-    it_should_behave_like 'an idempotent method'
-
-    it { should be(true) }
-  end
-end

data/spec/unit/mutant/matcher/class_methods/from_string_spec.rb

@@ -1,49 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Matcher, '.from_string' do
-  subject { object.from_string(input) }
-
-  let(:input)   { mock('Input')   }
-  let(:matcher) { mock('Matcher') }
-
-  let(:descendant_a) { mock('Descendant A', :parse => nil) }
-  let(:descendant_b) { mock('Descendant B', :parse => nil) }
-
-  let(:object) { described_class }
-
-  before do
-    described_class.stub(:descendants => [descendant_a, descendant_b])
-  end
-
-  context 'when no descendant takes the input' do
-    it { should be(nil) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  context 'when one descendant handles input' do
-    before do
-      descendant_a.stub(:parse => matcher)
-    end
-
-    it { should be(matcher) }
-
-    it_should_behave_like 'an idempotent method'
-  end
-
-  context 'when more than one descendant handles input' do
-    let(:matcher_b) { mock('Matcher B') }
-
-    before do
-      descendant_a.stub(:parse => matcher)
-      descendant_b.stub(:parse => matcher_b)
-    end
-
-    it 'should return the first matcher' do 
-      should be(matcher)
-    end
-
-    it_should_behave_like 'an idempotent method'
-  end
-end
-

data/spec/unit/mutant/matcher/class_methods/parse_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Matcher, '.parse' do
-  subject { object.parse(input) }
-
-  let(:input) { mock('Input') }
-  let(:object) { described_class }
-
-  it { should be(nil) }
-
-  it_should_behave_like 'an idempotent method'
-end

data/spec/unit/mutant/matcher/method/class_methods/parse_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Matcher::Method, '.parse' do
-  subject { described_class.parse(input) }
-
-  let(:response) { mock('Response') }
-  let(:input)    { mock('Input')    }
-
-  let(:classifier) { described_class::Classifier }
-
-  before do
-    classifier.stub(:run => response)
-  end
-
-  it { should be(response) }
-
-  it 'should call classifier' do
-    classifier.should_receive(:run).with(input).and_return(response)
-    subject
-  end
-end