reek 6.0.3 → 6.1.0

data/spec/reek/configuration/configuration_file_finder_spec.rb

@@ -1,230 +0,0 @@
-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)
-      expect(found).to eq(path)
-    end
-
-    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: 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: 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
-      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 'skips files ending in .reek.yml in current dir' do
-      skip_if_a_config_in_tempdir
-
-      Dir.mktmpdir do |tempdir|
-        current = Pathname.new(tempdir)
-        bad_config = current.join('ignoreme.reek.yml')
-        FileUtils.touch bad_config
-        found = described_class.find(current: current)
-        expect(found).to be_nil
-      end
-    end
-
-    it 'returns the file in home if traversing from the current dir fails' do
-      skip_if_a_config_in_tempdir
-
-      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
-      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
-      skip_if_a_config_in_tempdir
-
-      Dir.mktmpdir do |tempdir|
-        current = Pathname.new(tempdir)
-        home = Pathname.new(tempdir)
-
-        found = described_class.find(current: current, home: home)
-
-        expect(found).to be_nil
-      end
-    end
-
-    it 'does not traverse up from :home' do
-      skip_if_a_config_in_tempdir
-
-      Dir.mktmpdir do |tempdir|
-        current = Pathname.new(tempdir)
-        home = SAMPLES_DIR.join('no_config_file')
-
-        found = described_class.find(current: current, home: home)
-
-        expect(found).to be_nil
-      end
-    end
-
-    it 'works with paths that need escaping' do
-      Dir.mktmpdir("ma\ngic d*r") do |tempdir|
-        config = Pathname.new("#{tempdir}/.reek.yml")
-        subdir = Pathname.new("#{tempdir}/ma\ngic subd*r")
-        FileUtils.touch config
-        FileUtils.mkdir subdir
-        found = described_class.find(current: subdir)
-        expect(found).to eq(config)
-      end
-    end
-  end
-
-  describe '.load_from_file' do
-    let(:sample_configuration_loaded) do
-      {
-        Reek::DETECTORS_KEY => {
-          'UncommunicativeVariableName' => { 'enabled' => false },
-          'UncommunicativeMethodName'   => { 'enabled' => false }
-        }
-      }
-    end
-
-    it 'loads the configuration from given file' do
-      configuration = described_class.load_from_file(CONFIGURATION_DIR.join('full_mask.reek'))
-      expect(configuration).to eq(sample_configuration_loaded)
-    end
-
-    it 'raises an error if it can not find the given file' do
-      Dir.mktmpdir do |tempdir|
-        path = Pathname.new(tempdir).join('does_not_exist.reek')
-        expect { described_class.load_from_file(path) }.
-          to raise_error(Reek::Errors::ConfigFileError, /Invalid configuration file/)
-      end
-    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::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::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
-
-  def skip_if_a_config_in_tempdir
-    found = described_class.find(current: Pathname.new(Dir.tmpdir))
-    skip "skipped: #{found} exists and would fail this test" if found
-  end
-end

data/spec/reek/configuration/default_directive_spec.rb

@@ -1,13 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/configuration/default_directive'
-
-RSpec.describe Reek::Configuration::DefaultDirective do
-  describe '#add' do
-    let(:directives) { {}.extend(described_class) }
-
-    it 'adds a smell configuration' do
-      directives.add(UncommunicativeVariableName: { enabled: false })
-      expect(directives).to eq(Reek::SmellDetectors::UncommunicativeVariableName => { enabled: false })
-    end
-  end
-end

data/spec/reek/configuration/directory_directives_spec.rb

@@ -1,122 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/errors/config_file_error'
-require_lib 'reek/configuration/directory_directives'
-
-RSpec.describe Reek::Configuration::DirectoryDirectives do
-  describe '#directive_for' do
-    let(:baz_config)  { { Reek::SmellDetectors::IrresponsibleModule => { enabled: false } } }
-    let(:bang_config) { { Reek::SmellDetectors::Attribute => { enabled: true } } }
-    let(:directives) do
-      {
-        Pathname.new('foo/bar/baz')  => baz_config,
-        Pathname.new('foo/bar/bang') => bang_config
-      }.extend(described_class)
-    end
-    let(:source_via) { 'foo/bar/bang/dummy.rb' }
-
-    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 '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
-    end
-  end
-
-  describe '#add' do
-    let(:directives) do
-      {}.extend(described_class)
-    end
-
-    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
-        expect { directives.add(file_as_path => nil) }.to raise_error(Reek::Errors::ConfigFileError)
-      end
-    end
-  end
-
-  describe '#best_match_for' do
-    let(:directives) do
-      {
-        Pathname.new('foo/bar/baz')    => {},
-        Pathname.new('foo/bar')        => {},
-        Pathname.new('bar/boo')        => {},
-        Pathname.new('bar/**/test/**') => {},
-        Pathname.new('bar/**/spec/*')  => {},
-        Pathname.new('bar/**/.spec/*') => {}
-      }.extend(described_class)
-    end
-
-    it 'returns the corresponding directory when source_base_dir is a leaf' do
-      source_base_dir = 'foo/bar/baz/bang'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit.to_s).to eq('foo/bar/baz')
-    end
-
-    it 'returns the corresponding directory when source_base_dir is in the middle of the tree' do
-      source_base_dir = 'foo/bar'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit.to_s).to eq('foo/bar')
-    end
-
-    it 'returns the corresponding directory when source_base_dir matches the Dir.glob like pattern' do
-      source_base_dir = 'bar/something/test'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit.to_s).to eq('bar/**/test/**')
-    end
-
-    it 'returns the corresponding directory when source_base_dir is a leaf of the Dir.glob like pattern' do
-      source_base_dir = 'bar/something/test/with/some/subdirectory'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit.to_s).to eq('bar/**/test/**')
-    end
-
-    it 'returns the corresponding directory when source_base_dir is a direct leaf of the Dir.glob like pattern' do
-      source_base_dir = 'bar/something/spec/direct'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit.to_s).to eq('bar/**/spec/*')
-    end
-
-    it 'returns the corresponding directory when source_base_dir contains a . character' do
-      source_base_dir = 'bar/something/.spec/direct'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit.to_s).to eq('bar/**/.spec/*')
-    end
-
-    it 'returns the corresponding directory when source_base_dir is an absolute_path' do
-      source_base_dir = Pathname.new('foo/bar').expand_path
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit.to_s).to eq('foo/bar')
-    end
-
-    it 'does not match an arbitrary directory when source_base_dir contains a character that could match the .' do
-      source_base_dir = 'bar/something/aspec/direct'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit.to_s).to eq('')
-    end
-
-    it 'returns nil when source_base_dir is a not direct leaf of the Dir.glob one-folder pattern' do
-      source_base_dir = 'bar/something/spec/with/some/subdirectory'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit).to be_nil
-    end
-
-    it 'returns nil we are on top of the tree and all other directories are below' do
-      source_base_dir = 'foo'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit).to be_nil
-    end
-
-    it 'returns nil when source_base_dir is not part of any directory directive at all' do
-      source_base_dir = 'non/existent'
-      hit = directives.send :best_match_for, source_base_dir
-      expect(hit).to be_nil
-    end
-  end
-end

data/spec/reek/configuration/excluded_paths_spec.rb

@@ -1,25 +0,0 @@
-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) }
-    let(:paths) do
-      %w(samples/directory_does_not_exist/
-         samples/source_with_non_ruby_files/
-         samples/**/ignore_me*)
-    end
-
-    let(:expected_exclude_paths) do
-      [Pathname('samples/source_with_non_ruby_files/'),
-       Pathname('samples/source_with_exclude_paths/ignore_me'),
-       Pathname('samples/source_with_exclude_paths/nested/ignore_me_as_well')]
-    end
-
-    it 'adds the given paths as Pathname' do
-      exclusions.add(paths)
-      expect(exclusions).to match_array expected_exclude_paths
-    end
-  end
-end

data/spec/reek/configuration/rake_task_converter_spec.rb

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

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