reek 4.6.0 → 5.0.0

data/spec/reek/configuration/configuration_file_finder_spec.rb

@@ -1,12 +1,14 @@
-# encoding: UTF-8
-
 require 'fileutils'
 require 'pathname'
 require 'tmpdir'
 require_relative '../../spec_helper'
+require_lib 'reek/configuration/app_configuration'
 
 RSpec.describe Reek::Configuration::ConfigurationFileFinder do
   describe '.find' do
+    let(:regular_configuration_dir) { CONFIGURATION_DIR.join('regular_configuration') }
+    let(:regular_configuration_file) { regular_configuration_dir.join('.reek.yml') }
+
     it 'returns any explicitely passed path' do
       path = Pathname.new 'foo/bar'
       found = described_class.find(path: path)
@@ -15,42 +17,44 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
 
     it 'prefers an explicitely passed path over a file in current dir' do
       path = Pathname.new 'foo/bar'
-      found = described_class.find(path: path, current: SAMPLES_PATH)
+      found = described_class.find(path: path, current: regular_configuration_dir)
       expect(found).to eq(path)
     end
 
     it 'returns the file in current dir if path is not set' do
-      found = described_class.find(current: SAMPLES_PATH)
-      expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
+      found = described_class.find(current: regular_configuration_dir)
+      expect(found).to eq(regular_configuration_file)
     end
 
     it 'returns the file in a parent dir if none in current dir' do
-      Dir.mktmpdir(nil, SAMPLES_PATH) do |tempdir|
-        found = described_class.find(current: Pathname.new(tempdir))
-        expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
-      end
+      empty_sub_directory = CONFIGURATION_DIR.join('regular_configuration').join('empty_sub_directory')
+      found = described_class.find(current: empty_sub_directory)
+      expect(found).to eq(regular_configuration_file)
     end
 
-    it 'returns the file even if it’s just ‘.reek’' do
-      single_configuration_file_dir = CONFIG_PATH.join('single_configuration_file')
-      found = described_class.find(current: single_configuration_file_dir)
-      expect(found).to eq(single_configuration_file_dir.join('.reek'))
+    it 'skips files ending in .reek.yml in current dir' do
+      Dir.mktmpdir(nil, regular_configuration_dir) do |tempdir|
+        current = Pathname.new(tempdir)
+        bad_config = current.join('ignoreme.reek.yml')
+        FileUtils.touch bad_config
+        found = described_class.find(current: Pathname.new(tempdir))
+        expect(found).to eq(regular_configuration_file)
+      end
     end
 
     it 'returns the file in home if traversing from the current dir fails' do
       skip_if_a_config_in_tempdir
 
-      Dir.mktmpdir(nil, SAMPLES_PATH) do |tempdir|
-        found = described_class.find(current: Pathname.new(tempdir))
-        expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
+      Dir.mktmpdir do |tempdir|
+        found = described_class.find(current: Pathname.new(tempdir), home: regular_configuration_dir)
+        expect(found).to eq(regular_configuration_file)
       end
     end
 
     it 'prefers the file in :current over one in :home' do
-      found = described_class.find(current: SAMPLES_PATH, home: CONFIG_PATH)
-      file_in_current = SAMPLES_PATH.join('exceptions.reek')
-
-      expect(found).to eq(file_in_current)
+      home_dir = CONFIGURATION_DIR.join('home')
+      found = described_class.find(current: regular_configuration_dir, home: home_dir)
+      expect(found).to eq(regular_configuration_file)
     end
 
     it 'returns nil when there are no files to find' do
@@ -70,12 +74,10 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
       skip_if_a_config_in_tempdir
 
       Dir.mktmpdir do |tempdir|
-        dir = Pathname.new(tempdir)
-        subdir = dir.join('subdir')
-
-        FileUtils.mkdir(subdir)
+        current = Pathname.new(tempdir)
+        home = SAMPLES_DIR.join('no_config_file')
 
-        found = described_class.find(current: subdir, home: dir)
+        found = described_class.find(current: current, home: home)
 
         expect(found).to be_nil
       end
@@ -83,7 +85,7 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
 
     it 'works with paths that need escaping' do
       Dir.mktmpdir("ma\ngic d*r") do |tempdir|
-        config = Pathname.new("#{tempdir}/ma\ngic f*le.reek")
+        config = Pathname.new("#{tempdir}/.reek.yml")
         subdir = Pathname.new("#{tempdir}/ma\ngic subd*r")
         FileUtils.touch config
         FileUtils.mkdir subdir
@@ -91,42 +93,122 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
         expect(found).to eq(config)
       end
     end
-
-    context 'more than one configuration file' do
-      let(:path) { CONFIG_PATH.join('more_than_one_configuration_file') }
-
-      it 'prints a message on STDERR' do
-        expected_message = "Error: Found multiple configuration files 'regular.reek', 'todo.reek'"
-        expect do
-          begin
-            described_class.find(current: path)
-          rescue SystemExit
-          end
-        end.to output(/#{expected_message}/).to_stderr
-      end
-
-      it 'exits' do
-        Reek::CLI::Silencer.silently do
-          expect do
-            described_class.find(current: path)
-          end.to raise_error(SystemExit)
-        end
-      end
-    end
   end
 
   describe '.load_from_file' do
     let(:sample_configuration_loaded) do
       {
-        'UncommunicativeVariableName' => { 'enabled' => false },
-        'UncommunicativeMethodName'   => { 'enabled' => false }
+        Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+          'UncommunicativeVariableName' => { 'enabled' => false },
+          'UncommunicativeMethodName'   => { 'enabled' => false }
+        }
       }
     end
 
     it 'loads the configuration from given file' do
-      configuration = described_class.load_from_file(CONFIG_PATH.join('full_mask.reek'))
+      configuration = described_class.load_from_file(CONFIGURATION_DIR.join('full_mask.reek'))
       expect(configuration).to eq(sample_configuration_loaded)
     end
+
+    context 'with exclude, accept and reject settings' do
+      context 'when configuring top level detectors' do
+        let(:configuration) do
+          described_class.
+            load_from_file(CONFIGURATION_DIR.join('accepts_rejects_and_excludes_for_detectors.reek.yml')).
+            fetch(Reek::Configuration::AppConfiguration::DETECTORS_KEY)
+        end
+
+        let(:expected) do
+          {
+            'UnusedPrivateMethod' => { 'exclude' => [/exclude regexp/] },
+            'UncommunicativeMethodName' => { 'reject' => ['reject name'],
+                                             'accept' => ['accept name'] },
+            'UncommunicativeModuleName' => { 'reject' => ['reject name 1', 'reject name 2'],
+                                             'accept' => ['accept name 1', 'accept name 2'] },
+            'UncommunicativeParameterName' => { 'reject' => ['reject name', /reject regexp/],
+                                                'accept' => ['accept name', /accept regexp/] },
+            'UncommunicativeVariableName' => { 'reject' => [/^reject regexp$/],
+                                               'accept' => [/accept(.*)regexp/] }
+          }
+        end
+
+        it 'converts marked strings to regexes' do
+          expect(configuration['UnusedPrivateMethod']).to eq(expected['UnusedPrivateMethod'])
+        end
+
+        it 'leaves regular single strings untouched' do
+          expect(configuration['UncommunicativeMethodName']).to eq(expected['UncommunicativeMethodName'])
+        end
+
+        it 'leaves regular multiple strings untouched' do
+          expect(configuration['UncommunicativeModuleName']).to eq(expected['UncommunicativeModuleName'])
+        end
+
+        it 'allows mixing of regular strings and marked strings' do
+          expect(configuration['UncommunicativeParameterName']).to eq(expected['UncommunicativeParameterName'])
+        end
+
+        it 'converts more complex marked strings correctly to regexes' do
+          expect(configuration['UncommunicativeVariableName']).to eq(expected['UncommunicativeVariableName'])
+        end
+      end
+
+      context 'when configuring directory directives' do
+        let(:directory_name) { 'app/controllers' }
+        let(:configuration) do
+          described_class.
+            load_from_file(CONFIGURATION_DIR.join('accepts_rejects_and_excludes_for_directory_directives.reek.yml')).
+            fetch(Reek::Configuration::AppConfiguration::DIRECTORIES_KEY)
+        end
+
+        let(:expected) do
+          {
+            directory_name => {
+              'UnusedPrivateMethod' => { 'exclude' => [/exclude regexp/] },
+              'UncommunicativeMethodName' => { 'reject' => ['reject name'],
+                                               'accept' => ['accept name'] },
+              'UncommunicativeModuleName' => { 'reject' => ['reject name 1', 'reject name 2'],
+                                               'accept' => ['accept name 1', 'accept name 2'] },
+              'UncommunicativeParameterName' => { 'reject' => ['reject name', /reject regexp/],
+                                                  'accept' => ['accept name', /accept regexp/] },
+              'UncommunicativeVariableName' => { 'reject' => [/^reject regexp$/],
+                                                 'accept' => [/accept(.*)regexp/] }
+            }
+          }
+        end
+
+        it 'converts marked strings to regexes' do
+          expect(configuration[directory_name]['UnusedPrivateMethod']).
+            to eq(expected[directory_name]['UnusedPrivateMethod'])
+        end
+
+        it 'leaves regular single strings untouched' do
+          expect(configuration[directory_name]['UncommunicativeMethodName']).
+            to eq(expected[directory_name]['UncommunicativeMethodName'])
+        end
+
+        it 'leaves regular multiple strings untouched' do
+          expect(configuration[directory_name]['UncommunicativeModuleName']).
+            to eq(expected[directory_name]['UncommunicativeModuleName'])
+        end
+
+        it 'allows mixing of regular strings and marked strings' do
+          expect(configuration[directory_name]['UncommunicativeParameterName']).
+            to eq(expected[directory_name]['UncommunicativeParameterName'])
+        end
+
+        it 'converts more complex marked strings correctly to regexes' do
+          expect(configuration[directory_name]['UncommunicativeVariableName']).
+            to eq(expected[directory_name]['UncommunicativeVariableName'])
+        end
+      end
+    end
+
+    it 'returns blank hash when no file is found' do
+      config = described_class.load_from_file(nil)
+
+      expect(config).to eq({})
+    end
   end
 
   private

data/spec/reek/configuration/default_directive_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Reek::Configuration::DefaultDirective do
     let(:directives) { {}.extend(described_class) }
 
     it 'adds a smell configuration' do
-      directives.add :UncommunicativeVariableName, enabled: false
+      directives.add(UncommunicativeVariableName: { enabled: false })
       expect(directives).to eq(Reek::SmellDetectors::UncommunicativeVariableName => { enabled: false })
     end
   end

data/spec/reek/configuration/directory_directives_spec.rb

@@ -1,4 +1,5 @@
 require_relative '../../spec_helper'
+require_lib 'reek/errors/config_file_error'
 require_lib 'reek/configuration/directory_directives'
 
 RSpec.describe Reek::Configuration::DirectoryDirectives do
@@ -13,13 +14,13 @@ RSpec.describe Reek::Configuration::DirectoryDirectives do
     end
     let(:source_via) { 'foo/bar/bang/dummy.rb' }
 
-    context 'our source is in a directory for which we have a directive' do
+    context 'when our source is in a directory for which we have a directive' do
       it 'returns the corresponding directive' do
         expect(directives.directive_for(source_via)).to eq(bang_config)
       end
     end
 
-    context 'our source is not in a directory for which we have a directive' do
+    context 'when our source is not in a directory for which we have a directive' do
       it 'returns nil' do
         expect(directives.directive_for('does/not/exist')).to eq(nil)
       end
@@ -31,13 +32,11 @@ RSpec.describe Reek::Configuration::DirectoryDirectives do
       {}.extend(described_class)
     end
 
-    context 'one of given paths is a file' do
-      let(:file_as_path) { SAMPLES_PATH.join('inline.rb') }
+    context 'when one of given paths is a file' do
+      let(:file_as_path) { SAMPLES_DIR.join('smelly_source').join('inline.rb') }
 
       it 'raises an error' do
-        Reek::CLI::Silencer.silently do
-          expect { directives.add(file_as_path, {}) }.to raise_error(SystemExit)
-        end
+        expect { directives.add(file_as_path => nil) }.to raise_error(Reek::Errors::ConfigFileError)
       end
     end
   end

data/spec/reek/configuration/excluded_paths_spec.rb

@@ -1,18 +1,18 @@
 require_relative '../../spec_helper'
+require_lib 'reek/errors/config_file_error'
 require_lib 'reek/configuration/excluded_paths'
 
 RSpec.describe Reek::Configuration::ExcludedPaths do
   describe '#add' do
     let(:exclusions) { [].extend(described_class) }
 
-    context 'one of given paths is a file' do
-      let(:file_as_path) { SAMPLES_PATH.join('inline.rb') }
-      let(:paths) { [SAMPLES_PATH, file_as_path] }
+    context 'when one of given paths is a file' do
+      let(:smelly_source_dir) { SAMPLES_DIR.join('smelly_source') }
+      let(:file_as_path) { smelly_source_dir.join('inline.rb') }
+      let(:paths) { [smelly_source_dir, file_as_path] }
 
       it 'raises an error if one of the given paths is a file' do
-        Reek::CLI::Silencer.silently do
-          expect { exclusions.add(paths) }.to raise_error(SystemExit)
-        end
+        expect { exclusions.add(paths) }.to raise_error(Reek::Errors::ConfigFileError)
       end
     end
   end

data/spec/reek/configuration/rake_task_converter_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../../spec_helper'
+require_lib 'reek/configuration/rake_task_converter'
+
+RSpec.describe Reek::Configuration::RakeTaskConverter do
+  describe 'convert' do
+    let(:configuration_for_smell_detector) do
+      {
+        'exclude' => [/Klass#foobar$/, /^Klass#omg$/],
+        'reject' => [/^[a-z]$/, /[0-9]$/, /[A-Z]/],
+        'accept' => [/^_$/]
+      }
+    end
+
+    let(:expected_exclude) { ['/Klass#foobar$/', '/^Klass#omg$/'] }
+    let(:expected_reject) { ['/^[a-z]$/', '/[0-9]$/', '/[A-Z]/'] }
+    let(:expected_accept) { ['/^_$/'] }
+
+    it 'converts exclude regexes to strings' do
+      converted_configuration = described_class.convert configuration_for_smell_detector
+      expect(converted_configuration['exclude']).to eq(expected_exclude)
+    end
+
+    it 'converts reject regexes to strings' do
+      converted_configuration = described_class.convert configuration_for_smell_detector
+      expect(converted_configuration['reject']).to eq(expected_reject)
+    end
+
+    it 'converts accept regexes to strings' do
+      converted_configuration = described_class.convert configuration_for_smell_detector
+      expect(converted_configuration['accept']).to eq(expected_accept)
+    end
+  end
+end

data/spec/reek/configuration/schema_validator_spec.rb

@@ -0,0 +1,165 @@
+require_relative '../../spec_helper'
+require_lib 'reek/configuration/schema_validator'
+require_lib 'reek/errors/config_file_error'
+
+RSpec.describe Reek::Configuration::SchemaValidator do
+  describe 'validate' do
+    subject(:validator) { described_class.new configuration }
+
+    context 'when configuration is valid' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+            'UncommunicativeVariableName' => { 'enabled' => false },
+            'UncommunicativeMethodName'   => { 'enabled' => false }
+          }
+        }
+      end
+
+      it 'returns nil' do
+        expect(validator.validate).to eq(nil)
+      end
+    end
+
+    context 'when detector is invalid' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+            'DoesNotExist' => { 'enabled' => false }
+          }
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/detectors/DoesNotExist\] key 'DoesNotExist:' is undefined}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'when `enabled` has a non-boolean value' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+            'FeatureEnvy' => { 'enabled' => 'foo' }
+          }
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/detectors/FeatureEnvy/enabled\] 'foo': not a boolean}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'when detector has an unknown option' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+            'DataClump' => { 'does_not_exist' => 42 }
+          }
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/detectors/DataClump/does_not_exist\] key 'does_not_exist:' is undefined}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'when `exclude`, `reject` and `accept`' do
+      %w(exclude reject accept).each do |attribute|
+        context 'when a scalar' do
+          let(:configuration) do
+            {
+              Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+                'UncommunicativeMethodName' => { attribute => 42 }
+              }
+            }
+          end
+
+          it 'raises an error' do
+            message = %r{\[/detectors/UncommunicativeMethodName/#{attribute}\] '42': not a sequence}
+            expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+          end
+        end
+
+        context 'when types are mixed' do
+          let(:configuration) do
+            {
+              Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+                'UncommunicativeMethodName' => { attribute => [42, 'foo'] }
+              }
+            }
+          end
+
+          it 'raises an error' do
+            message = %r{\[/detectors/UncommunicativeMethodName/#{attribute}/0\] '42': not a string}
+            expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+          end
+        end
+      end
+    end
+
+    context 'when `exclude_paths` is a scalar' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::EXCLUDE_PATHS_KEY => 42
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/exclude_paths\] '42': not a sequence}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'when `exclude_paths` mixes types' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::EXCLUDE_PATHS_KEY => [42, 'foo']
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/exclude_paths/0\] '42': not a string}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'with directory directives' do
+      context 'when bad detector' do
+        let(:configuration) do
+          {
+            Reek::Configuration::AppConfiguration::DIRECTORIES_KEY => {
+              'web_app/app/helpers' => {
+                'Bar' => { 'enabled' => false }
+              }
+            }
+          }
+        end
+
+        it 'raises an error' do
+          message = %r{\[/directories/web_app/app/helpers/Bar\] key 'Bar:' is undefined}
+          expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+        end
+      end
+
+      context 'when unknown attribute' do
+        let(:configuration) do
+          {
+            Reek::Configuration::AppConfiguration::DIRECTORIES_KEY => {
+              'web_app/app/controllers' => {
+                'NestedIterators' => { 'foo' => false }
+              }
+            }
+          }
+        end
+
+        it 'raises an error' do
+          message = %r{\[/directories/web_app/app/controllers/NestedIterators/foo\] key 'foo:' is undefined}
+          expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+        end
+      end
+    end
+  end
+end