reek 1.3.8 → 1.4.0

data/spec/reek/source/sexp_formatter_spec.rb

@@ -4,16 +4,15 @@ require 'reek/source/sexp_formatter'
 include Reek::Source
 
 describe SexpFormatter do
-  describe "::format" do
+  describe '::format' do
     it 'formats a simple s-expression' do
       result = SexpFormatter.format s(:lvar, :foo)
-      result.should == "foo"
+      expect(result).to eq('foo')
     end
 
     it 'formats a more complex s-expression' do
       result = SexpFormatter.format s(:call, nil, :foo, s(:arglist, s(:lvar, :bar)))
-      result.should == "foo(bar)"
+      expect(result).to eq('foo(bar)')
     end
   end
 end
-

data/spec/reek/source/sexp_node_spec.rb

@@ -8,7 +8,7 @@ describe SexpNode do
     it 'formats self' do
       @node = s(:self)
       @node.extend(SexpNode)
-      @node.format_ruby.should == 'self'
+      expect(@node.format_ruby).to eq('self')
     end
   end
 
@@ -16,12 +16,12 @@ describe SexpNode do
     it 'hashes equal for equal sexps' do
       node1 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 4), :fred))
       node2 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 4), :fred))
-      node1.hash.should == node2.hash
+      expect(node1.hash).to eq(node2.hash)
     end
     it 'hashes diferent for diferent sexps' do
       node1 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 4), :fred))
       node2 = ast(:defn, s(:const2, :Fred, :jim), s(:call, :+, s(:lit, 3), :fred))
-      node1.hash.should_not == node2.hash
+      expect(node1.hash).not_to eq(node2.hash)
     end
   end
 end

data/spec/reek/source/source_code_spec.rb

@@ -13,59 +13,60 @@ describe SourceCode do
 
     before :each do
       @catcher = StringIO.new
-      @old_err_io = (SourceCode.err_io = @catcher)
+      @old_std_err = $stderr
+      $stderr = @catcher
     end
 
-    shared_examples_for "handling and recording the error" do
+    shared_examples_for 'handling and recording the error' do
       it 'does not raise an error' do
         src.syntax_tree
       end
 
       it 'returns an empty syntax tree' do
-        src.syntax_tree.should == s()
+        expect(src.syntax_tree).to eq(s())
       end
 
       it 'records the syntax error' do
         src.syntax_tree
-        @catcher.string.should match(error_class.name)
+        expect(@catcher.string).to match(error_class.name)
       end
 
       it 'records the source name' do
         src.syntax_tree
-        @catcher.string.should match(source_name)
+        expect(@catcher.string).to match(source_name)
       end
 
       it 'records the error message' do
         src.syntax_tree
-        @catcher.string.should match(error_message)
+        expect(@catcher.string).to match(error_message)
       end
     end
 
-    context "with a RubyParser::SyntaxError" do
+    context 'with a RubyParser::SyntaxError' do
       let(:error_class) { RubyParser::SyntaxError }
 
       before do
-        parser.stub(:parse).and_raise(error_class.new(error_message))
+        allow(parser).to receive(:parse).and_raise(error_class.new(error_message))
       end
 
-      it_should_behave_like "handling and recording the error"
+      it_should_behave_like 'handling and recording the error'
     end
 
-    context "with a Racc::ParseError" do
+    context 'with a Racc::ParseError' do
       let(:error_class) { Racc::ParseError }
 
       before do
-        parser.stub(:parse).and_raise(error_class.new(error_message))
+        allow(parser).to receive(:parse).and_raise(error_class.new(error_message))
       end
 
-      it_should_behave_like "handling and recording the error"
+      it_should_behave_like 'handling and recording the error'
     end
 
-    context "with a generic error" do
+    context 'with a generic error' do
       let(:error_class) { RuntimeError }
 
       before do
-        parser.stub(:parse).and_raise(error_class.new(error_message))
+        allow(parser).to receive(:parse).and_raise(error_class.new(error_message))
       end
 
       it 'raises the error' do
@@ -74,7 +75,7 @@ describe SourceCode do
     end
 
     after :each do
-      SourceCode.err_io = @old_err_io
+      $stderr = @old_std_err
     end
   end
 end

data/spec/reek/source/tree_dresser_spec.rb

@@ -9,10 +9,10 @@ describe TreeDresser do
   let(:dresser) { TreeDresser.new }
 
   it 'dresses :if sexp with IfNode' do
-    dresser.dress(ifnode).should be_a Reek::Source::SexpExtensions::IfNode
+    expect(dresser.dress(ifnode)).to be_a Reek::Source::SexpExtensions::IfNode
   end
 
   it 'dresses :call sexp with CallNode' do
-    dresser.dress(callnode).should be_a Reek::Source::SexpExtensions::CallNode
+    expect(dresser.dress(callnode)).to be_a Reek::Source::SexpExtensions::CallNode
   end
 end

data/spec/reek/spec/should_reek_of_spec.rb

@@ -11,13 +11,13 @@ describe ShouldReekOf do
     end
 
     it 'reports duplicate calls to @other.thing' do
-      @ruby.should reek_of(:Duplication, /@other.thing[^\.]/)
+      expect(@ruby).to reek_of(:Duplication, /@other.thing[^\.]/)
     end
     it 'reports duplicate calls to @other.thing.foo' do
-      @ruby.should reek_of(:Duplication, /@other.thing.foo/)
+      expect(@ruby).to reek_of(:Duplication, /@other.thing.foo/)
     end
     it 'does not report any feature envy' do
-      @ruby.should_not reek_of(:FeatureEnvy)
+      expect(@ruby).not_to reek_of(:FeatureEnvy)
     end
   end
 
@@ -29,16 +29,16 @@ describe ShouldReekOf do
     end
 
     it 'matches a smelly String' do
-      @matcher.matches?(@smelly_code).should be_true
+      expect(@matcher.matches?(@smelly_code)).to be_truthy
     end
 
     it 'doesnt match a fragrant String' do
-      @matcher.matches?(@clean_code).should be_false
+      expect(@matcher.matches?(@clean_code)).to be_falsey
     end
 
     it 'reports the smells when should_not fails' do
-      @matcher.matches?(@smelly_code).should be_true
-      @matcher.failure_message_for_should_not.should match('UncommunicativeVariableName')
+      expect(@matcher.matches?(@smelly_code)).to be_truthy
+      expect(@matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
     end
   end
 
@@ -50,11 +50,11 @@ describe ShouldReekOf do
     end
 
     it 'matches a smelly String' do
-      @matcher.matches?(@smelly_dir).should be_true
+      expect(@matcher.matches?(@smelly_dir)).to be_truthy
     end
 
     it 'doesnt match a fragrant String' do
-      @matcher.matches?(@clean_dir).should be_false
+      expect(@matcher.matches?(@clean_dir)).to be_falsey
     end
   end
 
@@ -66,11 +66,11 @@ describe ShouldReekOf do
     end
 
     it 'matches a smelly String' do
-      @matcher.matches?(@smelly_file).should be_true
+      expect(@matcher.matches?(@smelly_file)).to be_truthy
     end
 
     it 'doesnt match a fragrant String' do
-      @matcher.matches?(@clean_file).should be_false
+      expect(@matcher.matches?(@clean_file)).to be_falsey
     end
   end
 end

data/spec/reek/spec/should_reek_only_of_spec.rb

@@ -10,24 +10,24 @@ describe ShouldReekOnlyOf do
     @expected_context_name = 'SmellyClass#big_method'
     @matcher = ShouldReekOnlyOf.new(@expected_smell_class, [/#{@expected_context_name}/])
     @examiner = double('examiner').as_null_object
-    @examiner.should_receive(:smells).and_return {smells}
+    expect(@examiner).to receive(:smells) { smells }
     @match = @matcher.matches_examiner?(@examiner)
   end
 
   shared_examples_for 'no match' do
     it 'does not match' do
-      @match.should be_false
+      expect(@match).to be_falsey
     end
     context 'when a match was expected' do
       before :each do
         @source = 'the_path/to_a/source_file.rb'
-        @examiner.should_receive(:description).and_return(@source)
+        expect(@examiner).to receive(:description).and_return(@source)
       end
       it 'reports the source' do
-        @matcher.failure_message_for_should.should match(@source)
+        expect(@matcher.failure_message).to match(@source)
       end
       it 'reports the expected smell class' do
-        @matcher.failure_message_for_should.should match(@expected_smell_class.to_s)
+        expect(@matcher.failure_message).to match(@expected_smell_class.to_s)
       end
     end
   end
@@ -53,7 +53,7 @@ describe ShouldReekOnlyOf do
       [
         SmellWarning.new('ControlCouple', 'context', [1], 'any old message'),
         SmellWarning.new('FeatureEnvy', 'context', [1], 'any old message')
-        ]
+      ]
     end
 
     it_should_behave_like 'no match'
@@ -64,7 +64,7 @@ describe ShouldReekOnlyOf do
       [
         SmellWarning.new('ControlCouple', 'context', [1], 'any old message'),
         SmellWarning.new(@expected_smell_class.to_s, 'context', [1], "message mentioning #{@expected_context_name}")
-        ]
+      ]
     end
 
     it_should_behave_like 'no match'
@@ -75,15 +75,15 @@ describe ShouldReekOnlyOf do
       [SmellWarning.new(@expected_smell_class.to_s, nil, [1], "message mentioning #{@expected_context_name}")]
     end
     it 'matches' do
-      @match.should be_true
+      expect(@match).to be_truthy
     end
     it 'reports the expected smell when no match was expected' do
-      @matcher.failure_message_for_should_not.should match(@expected_smell_class.to_s)
+      expect(@matcher.failure_message_when_negated).to match(@expected_smell_class.to_s)
     end
     it 'reports the source when no match was expected' do
       source = 'the_path/to_a/source_file.rb'
-      @examiner.should_receive(:description).and_return(source)
-      @matcher.failure_message_for_should_not.should match(source)
+      expect(@examiner).to receive(:description).and_return(source)
+      expect(@matcher.failure_message_when_negated).to match(source)
     end
   end
 end

data/spec/reek/spec/should_reek_spec.rb

@@ -12,16 +12,16 @@ describe ShouldReek do
     let(:smelly_code) { 'def x() y = 4; end' }
 
     it 'matches a smelly String' do
-      matcher.matches?(smelly_code).should be_true
+      expect(matcher.matches?(smelly_code)).to be_truthy
     end
 
     it 'doesnt match a fragrant String' do
-      matcher.matches?(clean_code).should be_false
+      expect(matcher.matches?(clean_code)).to be_falsey
     end
 
     it 'reports the smells when should_not fails' do
       matcher.matches?(smelly_code)
-      matcher.failure_message_for_should_not.should match('UncommunicativeVariableName')
+      expect(matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
     end
   end
 
@@ -31,20 +31,20 @@ describe ShouldReek do
     let(:masked_dir) { Dir['spec/samples/clean_due_to_masking/*.rb'] }
 
     it 'matches a smelly Dir' do
-      matcher.matches?(smelly_dir).should be_true
+      expect(matcher.matches?(smelly_dir)).to be_truthy
     end
 
     it 'doesnt match a fragrant Dir' do
-      matcher.matches?(clean_dir).should be_false
+      expect(matcher.matches?(clean_dir)).to be_falsey
     end
 
     it 'masks smells using the relevant configuration' do
-      matcher.matches?(masked_dir).should be_false
+      expect(matcher.matches?(masked_dir)).to be_falsey
     end
 
     it 'reports the smells when should_not fails' do
       matcher.matches?(smelly_dir)
-      matcher.failure_message_for_should_not.should match('UncommunicativeVariableName')
+      expect(matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
     end
   end
 
@@ -54,20 +54,20 @@ describe ShouldReek do
     let(:masked_file) { File.new('spec/samples/clean_due_to_masking/dirty_one.rb') }
 
     it 'matches a smelly File' do
-      matcher.matches?(smelly_file).should be_true
+      expect(matcher.matches?(smelly_file)).to be_truthy
     end
 
     it 'doesnt match a fragrant File' do
-      matcher.matches?(clean_file).should be_false
+      expect(matcher.matches?(clean_file)).to be_falsey
     end
 
     it 'masks smells using the relevant configuration' do
-      matcher.matches?(masked_file).should be_false
+      expect(matcher.matches?(masked_file)).to be_falsey
     end
 
     it 'reports the smells when should_not fails' do
       matcher.matches?(smelly_file)
-      matcher.failure_message_for_should_not.should match('UncommunicativeVariableName')
+      expect(matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
     end
   end
 end

data/spec/samples/one_smelly_file/dirty.rb

@@ -0,0 +1,3 @@
+class D
+  def a; end
+end

data/spec/spec_helper.rb

@@ -2,11 +2,6 @@ require 'reek/spec'
 require 'reek/source/tree_dresser'
 
 require 'matchers/smell_of_matcher'
-begin
-  require 'debugger'
-rescue LoadError
-  # Swallow error. Not required to run tests
-end
 
 SAMPLES_DIR = 'spec/samples'
 
@@ -18,7 +13,6 @@ end
 
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
 end

data/tasks/develop.rake

@@ -1,29 +1,21 @@
 require 'rake/clean'
-require 'reek/core/sniffer'
-require 'yaml'
 
-CONFIG_DIR = 'config'
-CONFIG_FILE = "#{CONFIG_DIR}/defaults.reek"
+CONFIG_FILE = 'config/defaults.reek'
 
-CLOBBER.include(CONFIG_DIR)
-
-directory CONFIG_DIR
-
-file CONFIG_FILE => [CONFIG_DIR] do
+file CONFIG_FILE do
   config = {}
+  require 'reek/core/sniffer'
   Reek::Core::SmellRepository.smell_classes.each do |klass|
     config[klass.name.split(/::/)[-1]] = klass.default_config
   end
   $stderr.puts "Creating #{CONFIG_FILE}"
+  require 'yaml'
   File.open(CONFIG_FILE, 'w') { |f| YAML.dump(config, f) }
 end
 
 task CONFIG_FILE => FileList['lib/reek/smells/*.rb']
 
-task 'test:spec' => [CONFIG_FILE]
-task 'test:slow' => [CONFIG_FILE]
-task 'test:rcov' => [CONFIG_FILE]
-task 'test:quality' => [CONFIG_FILE]
-task 'test:features' => [CONFIG_FILE]
-task 'reek' => [CONFIG_FILE]
-task 'check:manifest' => [CONFIG_FILE]
+task 'test:spec' => CONFIG_FILE
+task 'test:quality' => CONFIG_FILE
+task 'test:features' => CONFIG_FILE
+task 'reek' => CONFIG_FILE

data/tasks/reek.rake

@@ -1,15 +1,7 @@
-begin
-  require 'reek/rake/task'
+require 'reek/rake/task'
 
-  Reek::Rake::Task.new do |t|
-    t.fail_on_error = true
-    t.verbose = false
-    t.reek_opts = '--quiet'
-  end
-rescue Gem::LoadError
-end
-
-begin
-  require 'metric_fu'
-rescue LoadError
+Reek::Rake::Task.new do |t|
+  t.fail_on_error = true
+  t.verbose = false
+  t.reek_opts = '--quiet'
 end

data/tasks/test.rake

@@ -1,48 +1,31 @@
-require 'rubygems'
-require 'cucumber'
 require 'cucumber/rake/task'
-require 'rspec'
 require 'rspec/core/rake_task'
 
 namespace 'test' do
-  UNIT_TESTS = FileList['spec/reek/**/*_spec.rb']
-
   RSpec::Core::RakeTask.new('spec') do |t|
-    t.pattern = UNIT_TESTS
-    t.ruby_opts = ['-Ilib']
-    t.rcov = false
+    t.pattern = 'spec/reek/**/*_spec.rb'
+    t.ruby_opts = ['-Ilib -w']
   end
 
   desc 'Tests various release attributes of the gem'
   RSpec::Core::RakeTask.new('gem') do |t|
-    t.pattern = FileList['spec/gem/**/*_spec.rb']
-    t.rcov = false
+    t.pattern = 'spec/gem/**/*_spec.rb'
   end
 
   desc 'Tests code quality'
   RSpec::Core::RakeTask.new('quality') do |t|
-    t.pattern = FileList['quality/**/*_spec.rb']
+    t.pattern = 'spec/quality/**/*_spec.rb'
     t.ruby_opts = ['-Ilib']
-    t.rcov = false
-  end
-
-  desc 'Runs all unit tests under RCov'
-  RSpec::Core::RakeTask.new('rcov') do |t|
-    t.pattern = UNIT_TESTS
-    t.rcov = true
-    t.rcov_opts = '-o build/coverage'
   end
 
   Cucumber::Rake::Task.new(:features) do |t|
-    t.cucumber_opts = "features --format progress --color"
+    t.cucumber_opts = 'features --format progress --color'
   end
 
   desc 'Runs all unit tests and acceptance tests'
   task 'all' => ['test:spec', 'test:features']
 end
 
-task 'clobber_rcov' => 'test:clobber_rcov'
-
 desc 'Synonym for test:spec'
 task 'spec' => 'test:spec'