reek 6.0.1 → 6.0.5

data/spec/reek/configuration/app_configuration_spec.rb

@@ -1,195 +0,0 @@
-require 'pathname'
-require_relative '../../spec_helper'
-require_lib 'reek/configuration/app_configuration'
-require_lib 'reek/configuration/directory_directives'
-require_lib 'reek/configuration/default_directive'
-require_lib 'reek/configuration/excluded_paths'
-
-RSpec.describe Reek::Configuration::AppConfiguration do
-  describe 'factory methods' do
-    around do |example|
-      Dir.mktmpdir do |tmp|
-        Dir.chdir(tmp) do
-          example.run
-        end
-      end
-    end
-
-    let(:expected_exclude_file_names) do
-      %w(exclude_me.rb exclude_me_too.rb)
-    end
-
-    let(:expected_exclude_directories) do
-      %w(directory_with_trailing_slash/ directory_without_trailing_slash)
-    end
-
-    let(:expected_excluded_paths) do
-      (expected_exclude_file_names + expected_exclude_directories).map { |path| Pathname(path) }
-    end
-
-    let(:expected_default_directive) do
-      { Reek::SmellDetectors::IrresponsibleModule => { 'enabled' => false } }
-    end
-
-    let(:expected_directory_directives) do
-      { Pathname('directory_with_some_ruby_files') => {
-        Reek::SmellDetectors::UtilityFunction => { 'enabled' => false }
-      } }
-    end
-
-    describe '#from_path' do
-      let(:configuration_path) { 'config.reek' }
-      let(:configuration) do
-        <<~YAML
-          ---
-          detectors:
-            IrresponsibleModule:
-              enabled: false
-          directories:
-            "directory_with_some_ruby_files":
-              UtilityFunction:
-                enabled: false
-          exclude_paths:
-            - "exclude_me.rb"
-            - "exclude_me_too.rb"
-            - "directory_with_trailing_slash/"
-            - "directory_without_trailing_slash"
-        YAML
-      end
-
-      before do
-        File.write configuration_path, configuration
-        FileUtils.touch expected_exclude_file_names
-        FileUtils.mkdir expected_exclude_directories
-      end
-
-      it 'properly loads configuration and processes it' do
-        config = described_class.from_path configuration_path
-
-        expect(config.send(:excluded_paths)).to eq(expected_excluded_paths)
-        expect(config.send(:default_directive)).to eq(expected_default_directive)
-        expect(config.send(:directory_directives)).to eq(expected_directory_directives)
-      end
-    end
-
-    describe '#from_hash' do
-      before do
-        FileUtils.touch expected_exclude_file_names
-        FileUtils.mkdir expected_exclude_directories
-      end
-
-      let(:default_directive_value) do
-        { Reek::DETECTORS_KEY => {
-          'IrresponsibleModule' => { 'enabled' => false }
-        } }
-      end
-
-      let(:directory_directives_value) do
-        { Reek::DIRECTORIES_KEY => {
-          'directory_with_some_ruby_files' => {
-            'UtilityFunction' => { 'enabled' => false }
-          }
-        } }
-      end
-
-      let(:exclude_paths_value) do
-        { Reek::EXCLUDE_PATHS_KEY => (expected_exclude_file_names + expected_exclude_directories) }
-      end
-
-      let(:combined_value) do
-        directory_directives_value.
-          merge(default_directive_value).
-          merge(exclude_paths_value)
-      end
-
-      it 'sets the configuration a unified simple data structure' do
-        config = described_class.from_hash(combined_value)
-
-        expect(config.send(:excluded_paths)).to eq(expected_excluded_paths)
-        expect(config.send(:default_directive)).to eq(expected_default_directive)
-        expect(config.send(:directory_directives)).to eq(expected_directory_directives)
-      end
-    end
-  end
-
-  describe '#default' do
-    it 'returns a blank AppConfiguration' do
-      config = described_class.default
-      expect(config).to be_instance_of described_class
-      expect(config.send(:excluded_paths)).to eq([])
-      expect(config.send(:default_directive)).to eq({})
-      expect(config.send(:directory_directives)).to eq({})
-    end
-  end
-
-  describe '#directive_for' do
-    context 'with multiple directory directives and no default directive present' do
-      let(:source_via) { 'samples/some_files/dummy1.rb' }
-      let(:baz_config)  { { IrresponsibleModule: { enabled: false } } }
-      let(:bang_config) { { Attribute: { enabled: true } } }
-      let(:expected_result) { { Reek::SmellDetectors::Attribute => { enabled: true } } }
-
-      let(:directory_directives) do
-        {
-          Reek::DIRECTORIES_KEY => {
-            'samples/some_files'  => bang_config,
-            'samples/other_files' => baz_config
-          }
-        }
-      end
-
-      it 'returns the corresponding directive' do
-        configuration = described_class.from_hash directory_directives
-        expect(configuration.directive_for(source_via)).to eq expected_result
-      end
-    end
-
-    context 'with directory directive and default directive present' do
-      let(:directory) { 'spec/samples/two_smelly_files/' }
-      let(:source_via) { "#{directory}/dummy.rb" }
-
-      let(:configuration_as_hash) do
-        {
-          Reek::DIRECTORIES_KEY => {
-            directory => { TooManyStatements: { max_statements: 8 } }
-          },
-          Reek::DETECTORS_KEY   => {
-            IrresponsibleModule: { enabled: false },
-            TooManyStatements:   { max_statements: 15 }
-          }
-        }
-      end
-
-      it 'returns the directory directive with the default directive reverse-merged' do
-        configuration = described_class.from_hash configuration_as_hash
-        actual = configuration.directive_for(source_via)
-
-        expect(actual[Reek::SmellDetectors::IrresponsibleModule]).to be_truthy
-        expect(actual[Reek::SmellDetectors::TooManyStatements]).to be_truthy
-        expect(actual[Reek::SmellDetectors::TooManyStatements][:max_statements]).to eq(8)
-      end
-    end
-
-    context 'with a path not covered by a directory directive but a default directive present' do
-      let(:source_via) { 'samples/some_files/dummy.rb' }
-
-      let(:configuration_as_hash) do
-        {
-          Reek::DETECTORS_KEY   => {
-            IrresponsibleModule: { enabled: false }
-          },
-          Reek::DIRECTORIES_KEY => {
-            'samples/other_files' => { Attribute: { enabled: false } }
-          }
-        }
-      end
-
-      let(:expected_result) { { Reek::SmellDetectors::IrresponsibleModule => { enabled: false } } }
-
-      it 'returns the default directive' do
-        configuration = described_class.from_hash configuration_as_hash
-        expect(configuration.directive_for(source_via)).to eq expected_result
-      end
-    end
-  end
-end

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