mutant 0.2.20 → 0.3.0.beta2

data/spec/unit/mutant/matcher/method/classifier/class_methods/run_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Matcher::Method::Classifier, '.run' do
-  subject { described_class.run(input) }
-
-  shared_examples_for 'Mutant::Matcher::Method::Classifier.run' do
-    before do
-      expected_class.stub(:new => response)
-    end
-
-    let(:response) { :Response }
-
-    it { should be(response) }
-
-    it 'should initialize method filter with correct arguments' do
-      expected_class.should_receive(:new).with(TestApp::Literal, expected_method).and_return(response)
-      subject
-    end
-  end
-
-  context 'with explicit toplevel scope' do
-    let(:input)           { '::TestApp::Literal#string' }
-    let(:expected_class)  { Mutant::Matcher::Method::Instance }
-    let(:expected_method) { TestApp::Literal.instance_method(:string) }
-
-    it_should_behave_like 'Mutant::Matcher::Method::Classifier.run'
-  end
-
-  context 'with instance method notation' do
-    let(:input)           { 'TestApp::Literal#string' }
-    let(:expected_method) { TestApp::Literal.instance_method(:string) }
-    let(:expected_class)  { Mutant::Matcher::Method::Instance }
-
-    it_should_behave_like 'Mutant::Matcher::Method::Classifier.run'
-  end
-
-  context 'with singleton method notation' do
-    let(:input)           { 'TestApp::Literal.string' }
-    let(:expected_method) { TestApp::Literal.method(:string) }
-    let(:expected_class)  { Mutant::Matcher::Method::Singleton }
-
-    it_should_behave_like 'Mutant::Matcher::Method::Classifier.run'
-  end
-
-  context 'with invalid notation' do
-    let(:input) { 'Foo' }
-
-    it 'should return nil' do
-      should be(nil)
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Matcher::ObjectSpace, '.parse' do
-  subject { object.parse(input) }
-
-  let(:object) { described_class }
-
-  let(:matcher) { mock('Matcher') }
-
-  context 'with valid notation' do
-    let(:input) { '::TestApp::Literal' }
-
-    it 'should return matcher' do
-      described_class.should_receive(:new).with(%r(\ATestApp::Literal(\z|::))).and_return(matcher)
-      should be(matcher)
-    end
-  end
-
-  context 'with invalid notation' do
-    let(:input) { 'TestApp' }
-
-    it { should be(nil) }
-  end
-end

data/spec/unit/mutant/matcher/object_space/each_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Matcher::ObjectSpace, '#each' do
-  before do
-    pending "defunct"
-  end
-  subject { object.each { |item| yields << item } }
-
-  let(:yields) { []                                               }
-  let(:object) { described_class.new(/\ATestApp::Literal(\z|::)/) }
-
-  before do
-    Mutant::Matcher::Method::Singleton.stub(:each).and_yield(matcher_a)
-    Mutant::Matcher::Method::Instance.stub(:each).and_yield(matcher_b)
-    matcher_a.stub(:each).and_yield(subject_a)
-    matcher_b.stub(:each).and_yield(subject_b)
-  end
-
-
-  let(:matcher_a) { mock('Matcher A') }
-  let(:matcher_b) { mock('Matcher B') }
-
-  let(:subject_a) { mock('Subject A') }
-  let(:subject_b) { mock('Subject B') }
-  
-  it_should_behave_like 'an #each method'
-
-  it 'should yield subjects' do
-    expect { subject }.to change { yields }.from([]).to([subject_a, subject_b])
-  end
-end

data/spec/unit/mutant/mutator/node/if_statement/mutation_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Mutator, 'if statement' do
-
-  context 'if with two branches' do
-    let(:source) { 'if self.condition; true; else false; end' }
-
-    let(:mutations) do
-      mutants = []
-
-      # mutations of condition
-      mutants << 'if condition; true; else false; end'
-
-      mutants << 'if !self.condition; true; else false; end'
-
-      # Deleted else branch
-      mutants << 'if self.condition; true end'
-
-      # Deleted if branch with promoting else branch to if branch
-      mutants << 'if self.condition; false end'
-
-      # mutations of body
-      mutants << 'if self.condition; false; else false; end' 
-      mutants << 'if self.condition; nil;   else false; end' 
-
-      # mutations of else body
-      mutants << 'if self.condition; true;  else true;  end' 
-      mutants << 'if self.condition; true;  else nil;   end' 
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'unless with one branch' do
-    let(:source) { 'unless condition; true; end' }
-
-    let(:mutations) do
-      mutants = []
-      mutants << 'unless !condition; true; end'
-      mutants << 'if condition; true; end'
-      mutants << 'unless condition; false; end'
-      mutants << 'unless condition; nil; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-
-  context 'if with one branch' do
-    let(:source) { 'if condition; true; end' }
-
-    let(:mutations) do
-      mutants = []
-      mutants << 'if !condition; true; end'
-      mutants << 'if condition; false; end'
-      mutants << 'if condition; nil; end'
-    end
-
-    it_should_behave_like 'a mutator'
-  end
-end

data/spec/unit/mutant/mutator/node/receiver_case/mutation_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Mutator::Node::ReceiverCase do
-  let(:source) { 'case self.condition; when true; true; when false; false; else raise; end' }
-
-  let(:mutations) do
-    mutations = []
-
-    # Delete each when once
-    mutations << 'case self.condition; when true; true; else raise; end'
-    mutations << 'case self.condition; when false; false; else raise; end'
-
-    # Mutate receiver
-    mutations << 'case condition; when true; true; when false; false; else raise; end'
-
-    # Remove else branch
-    mutations << 'case self.condition; when true; true; when false; false; end'
-
-    # Mutate when branch bodies
-    mutations << 'case self.condition; when true; nil;   when false; false; else raise; end'
-    mutations << 'case self.condition; when true; false; when false; false; else raise; end'
-    mutations << 'case self.condition; when true; true;  when false; nil;   else raise; end'
-    mutations << 'case self.condition; when true; true;  when false; true;  else raise; end'
-  end
-
-  it_should_behave_like 'a mutator'
-end

data/spec/unit/mutant/strategy/rspec/example_lookup/spec_file_spec.rb

@@ -1,236 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Strategy::Rspec::ExampleLookup, '#spec_file' do
-
-  let(:object)           { described_class.new(mutation)                  }
-  let(:mutation)         { mock('Mutation', :subject => mutation_subject) }
-  let(:mutation_subject) { mock('Subject', :matcher => matcher)           }
-  let(:matcher)          { mock('Matcher', :method_name => method_name)   }
-
-  subject { object.send(:spec_file) }
-
-  shared_examples_for 'Mutant::Strategy::Rspec::ExampleLookup#spec_file' do
-    it_should_behave_like 'an idempotent method'
-
-    it { should eql(expected_spec_file) }
-    it { should be_frozen }
-  end
-
-  context 'negation operator' do
-    let(:method_name) { :'!' }
-    let(:expected_spec_file) { 'negation_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with unary match method' do
-    let(:method_name) { :~@ }
-    let(:expected_spec_file) { 'unary_match_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with unary substraction method' do
-    let(:method_name) { :-@ }
-    let(:expected_spec_file) { 'unary_substraction_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with unary addition method' do
-    let(:method_name) { :+@ }
-    let(:expected_spec_file) { 'unary_addition_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with bitwise xor method' do
-    let(:method_name) { :^ }
-    let(:expected_spec_file) { 'bitwise_xor_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with bitwise or method' do
-    let(:method_name) { :| }
-    let(:expected_spec_file) { 'bitwise_or_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with bitwise and method' do
-    let(:method_name) { :& }
-    let(:expected_spec_file) { 'bitwise_and_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with spaceship method' do
-    let(:method_name) { :<=> }
-    let(:expected_spec_file) { 'spaceship_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with case equality operator method' do
-    let(:method_name) { :=== }
-    let(:expected_spec_file) { 'case_equality_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with modulo operator method' do
-    let(:method_name) { :% }
-    let(:expected_spec_file) { 'modulo_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with exponentation operator method' do
-    let(:method_name) { :** }
-    let(:expected_spec_file) { 'exponentation_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with substraction operator method' do
-    let(:method_name) { :- }
-    let(:expected_spec_file) { 'substraction_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with addition operator method' do
-    let(:method_name) { :+ }
-    let(:expected_spec_file) { 'addition_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with greater than or equal to operator method' do
-    let(:method_name) { :>= }
-    let(:expected_spec_file) { 'greater_than_or_equal_to_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with less than or equal to operator method' do
-    let(:method_name) { :<= }
-    let(:expected_spec_file) { 'less_than_or_equal_to_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with greater than operator method' do
-    let(:method_name) { :> }
-    let(:expected_spec_file) { 'greater_than_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with less than operator method' do
-    let(:method_name) { :< }
-    let(:expected_spec_file) { 'less_than_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with right shift operator method' do
-    let(:method_name) { :>> }
-    let(:expected_spec_file) { 'right_shift_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with left shift operator method' do
-    let(:method_name) { :<< }
-    let(:expected_spec_file) { 'left_shift_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with division operator method' do
-    let(:method_name) { :/ }
-    let(:expected_spec_file) { 'division_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with multiplication operator method' do
-    let(:method_name) { :* }
-    let(:expected_spec_file) { 'multiplication_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with nomatch operator method' do
-    let(:method_name) { :'!~' }
-    let(:expected_spec_file) { 'nomatch_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with match operator method' do
-    let(:method_name) { :=~ }
-    let(:expected_spec_file) { 'match_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with inequality operator method' do
-    let(:method_name) { :'!=' }
-    let(:expected_spec_file) { 'inequality_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with equality operator method' do
-    let(:method_name) { :== }
-    let(:expected_spec_file) { 'equality_operator_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with element reader method' do
-    let(:method_name) { :[] }
-    let(:expected_spec_file) { 'element_reader_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with element writer method' do
-    let(:method_name) { :[]= }
-
-    let(:expected_spec_file) { 'element_writer_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with writer method' do
-    let(:method_name) { :foo= }
-    let(:expected_spec_file) { 'foo_writer_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with bang method' do
-    let(:method_name) { :foo! }
-    let(:expected_spec_file) { 'foo_bang_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with predicate method' do
-    let(:method_name) { :foo? }
-    let(:expected_spec_file) { 'foo_predicate_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-
-  context 'with regular method' do
-    let(:method_name) { :foo }
-    let(:expected_spec_file) { 'foo_spec.rb' }
-
-    it_should_behave_like 'Mutant::Strategy::Rspec::ExampleLookup#spec_file'
-  end
-end

data/spec/unit/mutant/subject/class_methods/new_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Mutant::Subject, '.new' do
-  subject { object.new(matcher, context, ast) }
-
-  let(:object) { described_class }
-
-  let(:matcher) { mock('Matcher') }
-  let(:context) { mock('Context') }
-  let(:ast)     { mock('AST')     }
-
-  it { should be_frozen }
-end

data/tasks/metrics/ci.rake

@@ -1,7 +0,0 @@
-desc 'Run metrics with Heckle'
-task :ci => %w[ ci:metrics heckle ]
-
-namespace :ci do
-  desc 'Run metrics'
-  task :metrics => %w[ verify_measurements flog flay reek roodi metrics:all ]
-end

data/tasks/metrics/flay.rake

@@ -1,41 +0,0 @@
-begin
-  require 'flay'
-  require 'yaml'
-
-  config      = YAML.load_file(File.expand_path('../../../config/flay.yml', __FILE__)).freeze
-  threshold   = config.fetch('threshold').to_i
-  total_score = config.fetch('total_score').to_f
-  files       = Flay.expand_dirs_to_files(config.fetch('path', 'lib'))
-
-  # original code by Marty Andrews:
-  # http://blog.martyandrews.net/2009/05/enforcing-ruby-code-quality.html
-  desc 'Analyze for code duplication'
-  task :flay do
-    # run flay once without a threshold to ensure the max mass matches the threshold
-    flay = Flay.new(:fuzzy => false, :verbose => false, :mass => 0)
-    flay.process(*files)
-
-    max = flay.masses.map { |hash, mass| mass.to_f / flay.hashes[hash].size }.max
-    unless max >= threshold
-      raise "Adjust flay threshold down to #{max}"
-    end
-
-    total = flay.masses.reduce(0.0) { |total, (hash, mass)| total + (mass.to_f / flay.hashes[hash].size) }
-    unless total == total_score
-      raise "Flay total is now #{total}, but expected #{total_score}"
-    end
-
-    # run flay a second time with the threshold set
-    flay = Flay.new(:fuzzy => false, :verbose => false, :mass => threshold.succ)
-    flay.process(*files)
-
-    if flay.masses.any?
-      flay.report
-      raise "#{flay.masses.size} chunks of code have a duplicate mass > #{threshold}"
-    end
-  end
-rescue LoadError
-  task :flay do
-    abort 'Flay is not available. In order to run flay, you must: gem install flay'
-  end
-end

data/tasks/metrics/flog.rake

@@ -1,43 +0,0 @@
-begin
-  require 'flog'
-  require 'yaml'
-
-  class Float
-    def round_to(n)
-      (self * 10**n).round.to_f * 10**-n
-    end
-  end
-
-  config    = YAML.load_file(File.expand_path('../../../config/flog.yml', __FILE__)).freeze
-  threshold = config.fetch('threshold').to_f.round_to(1)
-
-  # original code by Marty Andrews:
-  # http://blog.martyandrews.net/2009/05/enforcing-ruby-code-quality.html
-  desc 'Analyze for code complexity'
-  task :flog do
-    flog = Flog.new
-    flog.flog Array(config.fetch('path', 'lib'))
-
-    totals = flog.totals.select  { |name, score| name[-5, 5] != '#none' }.
-                         map     { |name, score| [ name, score.round_to(1) ] }.
-                         sort_by { |name, score| score }
-
-    max = totals.last[1]
-    unless max >= threshold
-      raise "Adjust flog score down to #{max}"
-    end
-
-    bad_methods = totals.select { |name, score| score > threshold }
-    if bad_methods.any?
-      bad_methods.reverse_each do |name, score|
-        puts '%8.1f: %s' % [ score, name ]
-      end
-
-      raise "#{bad_methods.size} methods have a flog complexity > #{threshold}"
-    end
-  end
-rescue LoadError
-  task :flog do
-    abort 'Flog is not available. In order to run flog, you must: gem install flog'
-  end
-end