reek 4.6.0 → 5.0.0

data/spec/reek/spec/should_reek_of_spec.rb

@@ -1,7 +1,6 @@
 require 'pathname'
 require_relative '../../spec_helper'
 require_lib 'reek/spec'
-require 'active_support/core_ext/string/strip'
 require 'active_support/core_ext/hash/except'
 
 RSpec.describe Reek::Spec::ShouldReekOf do
@@ -12,50 +11,46 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       expect(ruby).to reek_of(:DuplicateMethodCall)
     end
 
-    it 'reports duplicate calls by smell detector class' do
-      expect(ruby).to reek_of(Reek::SmellDetectors::DuplicateMethodCall)
-    end
-
     it 'does not report any feature envy' do
       expect(ruby).not_to reek_of(:FeatureEnvy)
     end
   end
 
   describe 'different sources of input' do
-    context 'checking code in a string' do
+    context 'when checking code in a string' do
       let(:clean_code) { 'def good() true; end' }
       let(:matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
       let(:smelly_code) { 'def x() y = 4; end' }
 
       it 'matches a smelly String' do
-        expect(matcher.matches?(smelly_code)).to be_truthy
+        expect(matcher).to be_matches(smelly_code)
       end
 
       it 'doesnt match a fragrant String' do
-        expect(matcher.matches?(clean_code)).to be_falsey
+        expect(matcher).not_to be_matches(clean_code)
       end
 
       it 're-calculates matches every time' do
         matcher.matches? smelly_code
-        expect(matcher.matches?(clean_code)).to be_falsey
+        expect(matcher).not_to be_matches(clean_code)
       end
     end
 
-    context 'checking code in a File' do
+    context 'when checking code in a File' do
       let(:matcher) { described_class.new(:UncommunicativeMethodName, name: 'x') }
 
       it 'matches a smelly file' do
-        expect(matcher.matches?(SMELLY_FILE)).to be_truthy
+        expect(matcher).to be_matches(SMELLY_FILE)
       end
 
       it 'doesnt match a fragrant file' do
-        expect(matcher.matches?(CLEAN_FILE)).to be_falsey
+        expect(matcher).not_to be_matches(CLEAN_FILE)
       end
     end
   end
 
   describe 'smell types and smell details' do
-    context 'passing in smell_details with unknown parameter name' do
+    context 'when passing in smell_details with unknown parameter name' do
       let(:matcher) { described_class.new(:UncommunicativeVariableName, foo: 'y') }
       let(:smelly_code) { 'def x() y = 4; end' }
 
@@ -64,23 +59,23 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       end
     end
 
-    context 'both are matching' do
+    context 'when both are matching' do
       let(:matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
       let(:smelly_code) { 'def x() y = 4; end' }
 
       it 'is truthy' do
-        expect(matcher.matches?(smelly_code)).to be_truthy
+        expect(matcher).to be_matches(smelly_code)
       end
     end
 
-    context 'no smell_type is matching' do
+    context 'when no smell_type is matching' do
       let(:smelly_code) { 'def dummy() y = 4; end' }
 
       let(:falsey_matcher) { described_class.new(:FeatureEnvy, name: 'y') }
       let(:truthy_matcher) { described_class.new(:UncommunicativeVariableName, name: 'y') }
 
       it 'is falsey' do
-        expect(falsey_matcher.matches?(smelly_code)).to be_falsey
+        expect(falsey_matcher).not_to be_matches(smelly_code)
       end
 
       it 'sets the proper error message' do
@@ -98,12 +93,12 @@ RSpec.describe Reek::Spec::ShouldReekOf do
       end
     end
 
-    context 'smell type is matching but smell details are not' do
+    context 'when smell type is matching but smell details are not' do
       let(:smelly_code) { 'def double_thing() @other.thing.foo + @other.thing.foo end' }
       let(:matcher) { described_class.new(:DuplicateMethodCall, name: 'foo', count: 15) }
 
       it 'is falsey' do
-        expect(matcher.matches?(smelly_code)).to be_falsey
+        expect(matcher).not_to be_matches(smelly_code)
       end
 
       it 'sets the proper error message' do
@@ -130,15 +125,15 @@ RSpec.describe Reek::Spec::ShouldReekOf do
     end
   end
 
-  context 'for a smell that is disabled by default' do
-    before do
-      default_config = Reek::SmellDetectors::UnusedPrivateMethod.default_config
-      expect(default_config[Reek::SmellConfiguration::ENABLED_KEY]).to be_falsy
-    end
-
+  context 'with a smell that is disabled by default' do
     it 'enables the smell detector to match automatically' do
+      default_config = Reek::SmellDetectors::UnusedPrivateMethod.default_config
       src = 'class C; private; def foo; end; end'
-      expect(src).to reek_of(:UnusedPrivateMethod)
+
+      aggregate_failures do
+        expect(default_config[Reek::SmellConfiguration::ENABLED_KEY]).to be_falsy
+        expect(src).to reek_of(:UnusedPrivateMethod)
+      end
     end
   end
 
@@ -147,13 +142,13 @@ RSpec.describe Reek::Spec::ShouldReekOf do
     let(:configured_matcher) { matcher.with_config('accept' => 'x') }
 
     it 'uses the passed-in configuration for matching' do
-      expect(configured_matcher.matches?('def foo; q = 2; end')).to be_truthy
-      expect(configured_matcher.matches?('def foo; x = 2; end')).to be_falsey
+      expect(configured_matcher).to be_matches('def foo; q = 2; end')
+      expect(configured_matcher).not_to be_matches('def foo; x = 2; end')
     end
 
     it 'leaves the original matcher intact' do
-      expect(configured_matcher.matches?('def foo; x = 2; end')).to be_falsey
-      expect(matcher.matches?('def foo; x = 2; end')).to be_truthy
+      expect(configured_matcher).not_to be_matches('def foo; x = 2; end')
+      expect(matcher).to be_matches('def foo; x = 2; end')
     end
   end
 end

data/spec/reek/spec/should_reek_only_of_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
     context 'when a match was expected' do
       let(:source) { 'the_path/to_a/source_file.rb' }
 
-      before { allow(examiner).to receive(:description).and_return(source) }
+      before { allow(examiner).to receive(:origin).and_return(source) }
 
       it 'reports the source' do
         expect(matcher.failure_message).to match(source)
@@ -91,7 +91,7 @@ RSpec.describe Reek::Spec::ShouldReekOnlyOf do
 
     it 'reports the source when no match was expected' do
       source = 'the_path/to_a/source_file.rb'
-      allow(examiner).to receive(:description).and_return(source)
+      allow(examiner).to receive(:origin).and_return(source)
       expect(matcher.failure_message_when_negated).to match(source)
     end
   end

data/spec/reek/spec/should_reek_spec.rb

@@ -8,11 +8,11 @@ RSpec.describe Reek::Spec::ShouldReek do
     let(:smelly_code) { 'def x() y = 4; end' }
 
     it 'matches a smelly String' do
-      expect(matcher.matches?(smelly_code)).to be_truthy
+      expect(matcher).to be_matches(smelly_code)
     end
 
     it 'doesnt match a fragrant String' do
-      expect(matcher.matches?(clean_code)).to be_falsey
+      expect(matcher).not_to be_matches(clean_code)
     end
 
     it 'reports the smells when should_not fails' do
@@ -22,15 +22,15 @@ RSpec.describe Reek::Spec::ShouldReek do
   end
 
   describe 'checking code in a File' do
-    context 'matcher without masking' do
+    context 'without masking' do
       let(:matcher) { described_class.new }
 
       it 'matches a smelly File' do
-        expect(matcher.matches?(SMELLY_FILE)).to be_truthy
+        expect(matcher).to be_matches(SMELLY_FILE)
       end
 
       it 'doesnt match a fragrant File' do
-        expect(matcher.matches?(CLEAN_FILE)).to be_falsey
+        expect(matcher).not_to be_matches(CLEAN_FILE)
       end
 
       it 'reports the smells when should_not fails' do
@@ -39,13 +39,13 @@ RSpec.describe Reek::Spec::ShouldReek do
       end
     end
 
-    context 'matcher without masking' do
-      let(:path) { CONFIG_PATH.join('full_mask.reek') }
+    context 'with masking' do
+      let(:path) { CONFIGURATION_DIR.join('full_mask.reek') }
       let(:configuration) { test_configuration_for(path) }
       let(:matcher) { described_class.new(configuration: configuration) }
 
       it 'masks smells using the relevant configuration' do
-        expect(matcher.matches?(SMELLY_FILE)).to be_falsey
+        expect(matcher).not_to be_matches(SMELLY_FILE)
       end
     end
   end

data/spec/reek/spec/smell_matcher_spec.rb

@@ -10,35 +10,35 @@ RSpec.describe Reek::Spec::SmellMatcher do
   end
   let(:matcher) { described_class.new(smell_warning) }
 
-  context '#matches?' do
+  describe '#matches?' do
     it 'matches on class symbol' do
-      expect(matcher.matches?(:UncommunicativeVariableName)).to be_truthy
+      expect(matcher).to be_matches(:UncommunicativeVariableName)
     end
 
     it 'matches on class symbol and params' do
-      expect(matcher.matches?(:UncommunicativeVariableName,
-                              test: 'something')).to be_truthy
+      expect(matcher).to be_matches(:UncommunicativeVariableName,
+                                    test: 'something')
     end
 
     it 'matches on class symbol, params and attributes' do
-      expect(matcher.matches?(:UncommunicativeVariableName,
-                              test: 'something',
-                              message: "has the variable name '@s'")).to be_truthy
+      expect(matcher).to be_matches(:UncommunicativeVariableName,
+                                    test: 'something',
+                                    message: "has the variable name '@s'")
     end
 
     it 'does not match on different class symbol' do
-      expect(matcher.matches?(:FeatureEnvy)).to be_falsy
+      expect(matcher).not_to be_matches(:FeatureEnvy)
     end
 
     it 'does not match on different params' do
-      expect(matcher.matches?(:UncommunicativeVariableName,
-                              test: 'something else')).to be_falsy
+      expect(matcher).not_to be_matches(:UncommunicativeVariableName,
+                                        test: 'something else')
     end
 
     it 'does not match on different attributes' do
-      expect(matcher.matches?(:UncommunicativeVariableName,
-                              test: 'something',
-                              message: 'nothing')).to be_falsy
+      expect(matcher).not_to be_matches(:UncommunicativeVariableName,
+                                        test: 'something',
+                                        message: 'nothing')
     end
 
     it 'raises error on uncomparable attribute' do
@@ -50,33 +50,33 @@ RSpec.describe Reek::Spec::SmellMatcher do
     end
   end
 
-  context '#matches_smell_type?' do
+  describe '#matches_smell_type?' do
     it 'matches on class symbol' do
-      expect(matcher.matches_smell_type?(:UncommunicativeVariableName)).to be_truthy
+      expect(matcher).to be_matches_smell_type(:UncommunicativeVariableName)
     end
 
     it 'does not match on different class symbol' do
-      expect(matcher.matches_smell_type?(:FeatureEnvy)).to be_falsy
+      expect(matcher).not_to be_matches_smell_type(:FeatureEnvy)
     end
   end
 
-  context '#matches_attributes?' do
+  describe '#matches_attributes?' do
     it 'matches on params' do
-      expect(matcher.matches_attributes?(test: 'something')).to be_truthy
+      expect(matcher).to be_matches_attributes(test: 'something')
     end
 
     it 'matches on class symbol, params and attributes' do
-      expect(matcher.matches_attributes?(test: 'something',
-                                         message: "has the variable name '@s'")).to be_truthy
+      expect(matcher).to be_matches_attributes(test: 'something',
+                                               message: "has the variable name '@s'")
     end
 
     it 'does not match on different params' do
-      expect(matcher.matches_attributes?(test: 'something else')).to be_falsy
+      expect(matcher).not_to be_matches_attributes(test: 'something else')
     end
 
     it 'does not match on different attributes' do
-      expect(matcher.matches_attributes?(test: 'something',
-                                         message: 'nothing')).to be_falsy
+      expect(matcher).not_to be_matches_attributes(test: 'something',
+                                                   message: 'nothing')
     end
 
     it 'raises error on uncomparable attribute' do

data/spec/reek/tree_dresser_spec.rb

@@ -1,17 +1,15 @@
-require_lib 'reek/cli/silencer'
-Reek::CLI::Silencer.silently do
-  require 'parser/ruby22'
-end
-
 require_relative '../spec_helper'
+Reek::CLI::Silencer.without_warnings { require 'parser/ruby25' }
 require_lib 'reek/tree_dresser'
 
 RSpec.describe Reek::TreeDresser do
-  let(:dresser) { described_class.new }
-  let(:sexp) do
-    Parser::Ruby22.parse('class Klazz; def meth(argument); argument.call_me; end; end')
-  end
-  let(:dressed_ast) do
+  describe '#dress' do
+    let(:dresser) { described_class.new }
+    let(:sexp) do
+      Parser::Ruby25.parse('class Klazz; def meth(argument); argument.call_me; end; end')
+    end
+    let(:dressed_ast) { dresser.dress(sexp, {}) }
+
     # The dressed AST looks like this:
     #   (class
     #     (const nil :Klazz) nil
@@ -20,14 +18,11 @@ RSpec.describe Reek::TreeDresser do
     #         (arg :argument))
     #       (send
     #         (lvar :argument) :call_me)))
-    dresser.dress(sexp, {})
-  end
-  let(:const_node) { dressed_ast.children.first }
-  let(:def_node) { dressed_ast.children.last }
-  let(:args_node) { def_node.children[1] }
-  let(:send_node) { def_node.children[2] }
+    let(:const_node) { dressed_ast.children.first }
+    let(:def_node) { dressed_ast.children.last }
+    let(:args_node) { def_node.children[1] }
+    let(:send_node) { def_node.children[2] }
 
-  context 'dresses the given sexp' do
     it 'dresses `const` nodes properly' do
       expect(const_node).to be_a Reek::AST::SexpExtensions::ConstNode
     end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'pathname'
 require 'timeout'
+require 'active_support/core_ext/string/strip'
 require_relative '../lib/reek'
 require_relative '../lib/reek/spec'
 require_relative '../lib/reek/ast/ast_node_class_map'
@@ -7,15 +8,13 @@ require_relative '../lib/reek/configuration/app_configuration'
 
 require_relative '../samples/paths'
 
-Reek::CLI::Silencer.silently do
-  begin
-    require 'pry-byebug'
-  rescue LoadError # rubocop:disable Lint/HandleExceptions
-  end
+begin
+  Reek::CLI::Silencer.without_warnings { require 'pry-byebug' }
+rescue LoadError # rubocop:disable Lint/HandleExceptions
 end
 
-require 'factory_girl'
-FactoryGirl.find_definitions
+require 'factory_bot'
+FactoryBot.find_definitions
 
 # Simple helpers for our specs.
 module Helpers
@@ -75,7 +74,7 @@ end
 RSpec.configure do |config|
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
-  config.include FactoryGirl::Syntax::Methods
+  config.include FactoryBot::Syntax::Methods
   config.include Helpers
 
   config.disable_monkey_patching!
@@ -84,15 +83,6 @@ RSpec.configure do |config|
     mocks.verify_partial_doubles = true
     mocks.verify_doubled_constant_names = true
   end
-
-  # Avoid infinitely running tests. This is mainly useful when running a
-  # mutation tester. Set the DEBUG environment variable to something truthy
-  # like '1' to disable this and allow using pry without specs failing.
-  unless ENV['DEBUG']
-    config.around(:each) do |example|
-      Timeout.timeout(5, &example)
-    end
-  end
 end
 
 RSpec::Matchers.define_negated_matcher :not_reek_of, :reek_of

data/tasks/configuration.rake

@@ -1,15 +1,18 @@
 require_relative '../lib/reek/detector_repository'
+require_relative '../lib/reek/configuration/rake_task_converter'
+require_relative '../lib/reek/configuration/app_configuration'
+
 require 'yaml'
 
 namespace :configuration do
   desc 'Updates the default configuration file when smell defaults change'
   task :update_default_configuration do
-    DEFAULT_SMELL_CONFIGURATION = 'defaults.reek'.freeze
+    DEFAULT_SMELL_CONFIGURATION = 'docs/defaults.reek.yml'.freeze
     content = Reek::DetectorRepository.smell_types.each_with_object({}) do |klass, hash|
-      hash[klass.smell_type] = klass.default_config
+      hash[klass.smell_type] = Reek::Configuration::RakeTaskConverter.convert klass.default_config
+    end
+    File.open(DEFAULT_SMELL_CONFIGURATION, 'w') do |file|
+      YAML.dump({ Reek::Configuration::AppConfiguration::DETECTORS_KEY => content }, file)
     end
-    File.open(DEFAULT_SMELL_CONFIGURATION, 'w') { |file| YAML.dump(content, file) }
   end
 end
-
-task 'test:spec' => 'configuration:update_default_configuration'