reek 6.0.1 → 6.0.5

data/spec/reek/source/source_locator_spec.rb

@@ -1,166 +0,0 @@
-require 'pathname'
-require_relative '../../spec_helper'
-require_lib 'reek/configuration/app_configuration'
-require_lib 'reek/source/source_locator'
-
-RSpec.describe Reek::Source::SourceLocator do
-  describe '#sources' do
-    context 'when applied to hidden directories' do
-      let(:path) { SAMPLES_DIR.join('source_with_hidden_directories') }
-
-      let(:expected_paths) do
-        [path.join('not_hidden.rb')]
-      end
-
-      let(:paths_that_are_expected_to_be_ignored) do
-        [path.join('.hidden/hidden.rb')]
-      end
-
-      it 'does not scan hidden directories' do
-        sources = described_class.new([path]).sources
-
-        expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
-      end
-
-      it 'scans directories that are not hidden' do
-        sources = described_class.new([path]).sources
-
-        expect(sources).to match_array expected_paths
-      end
-    end
-
-    context 'with excluded paths' do
-      let(:configuration) do
-        test_configuration_for(CONFIGURATION_DIR.join('with_excluded_paths.reek'))
-      end
-
-      let(:options) { instance_double('Reek::CLI::Options', force_exclusion?: false) }
-
-      context 'when the path is absolute' do
-        let(:path) do
-          SAMPLES_DIR.join('source_with_exclude_paths',
-                           'ignore_me',
-                           'uncommunicative_method_name.rb').expand_path
-        end
-
-        context 'when options.force_exclusion? is true' do
-          before do
-            allow(options).to receive(:force_exclusion?).and_return(true)
-          end
-
-          it 'excludes this file' do
-            sources = described_class.new([path], configuration: configuration, options: options).sources
-            expect(sources).not_to include(path)
-          end
-        end
-
-        context 'when options.force_exclusion? is false' do
-          before do
-            allow(options).to receive(:force_exclusion?).and_return(false)
-          end
-
-          it 'includes this file' do
-            sources = described_class.new([path], configuration: configuration, options: options).sources
-            expect(sources).to include(path)
-          end
-        end
-      end
-
-      context 'when the path is a file name in an excluded directory' do
-        let(:path) { SAMPLES_DIR.join('source_with_exclude_paths', 'ignore_me', 'uncommunicative_method_name.rb') }
-
-        context 'when options.force_exclusion? is true' do
-          before do
-            allow(options).to receive(:force_exclusion?).and_return(true)
-          end
-
-          it 'excludes this file' do
-            sources = described_class.new([path], configuration: configuration, options: options).sources
-            expect(sources).not_to include(path)
-          end
-        end
-
-        context 'when options.force_exclusion? is false' do
-          before do
-            allow(options).to receive(:force_exclusion?).and_return(false)
-          end
-
-          it 'includes this file' do
-            sources = described_class.new([path], configuration: configuration, options: options).sources
-            expect(sources).to include(path)
-          end
-        end
-      end
-
-      context 'when path is a directory or a file' do
-        let(:path) { SAMPLES_DIR.join('source_with_exclude_paths') }
-
-        let(:expected_paths) do
-          [path.join('nested/uncommunicative_variable_name.rb')]
-        end
-
-        let(:paths_that_are_expected_to_be_ignored) do
-          [
-            path.join('ignore_me/uncommunicative_method_name.rb'),
-            path.join('nested/ignore_me_as_well/irresponsible_module.rb'),
-            path.join('nested/uncommunicative_parameter_name.rb')
-          ]
-        end
-
-        it 'does not use excluded paths' do
-          sources = described_class.new([path], configuration: configuration, options: options).sources
-          expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
-        end
-
-        it 'scans directories and files that are not excluded' do
-          sources = described_class.new([path], configuration: configuration).sources
-          expect(sources).to eq expected_paths
-        end
-      end
-    end
-
-    context 'with non-Ruby paths' do
-      let(:path) { SAMPLES_DIR.join('source_with_non_ruby_files') }
-      let(:expected_sources) do
-        [path.join('ruby.rb')]
-      end
-      let(:paths_that_are_expected_to_be_ignored) do
-        [
-          path.join('gibberish'),
-          path.join('python_source.py')
-        ]
-      end
-
-      it 'uses Ruby source paths' do
-        sources = described_class.new([path]).sources
-
-        expect(sources).to include(*expected_sources)
-      end
-
-      it 'does not use non-Ruby source paths' do
-        sources = described_class.new([path]).sources
-
-        expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
-      end
-    end
-
-    context 'when passing "." or "./" as argument' do
-      let(:expected_sources) do
-        [Pathname.new('spec/spec_helper.rb'), Pathname.new('lib/reek.rb')]
-      end
-
-      it 'expands it correctly' do
-        sources_for_dot = described_class.new([Pathname.new('.')]).sources
-
-        expect(sources_for_dot).to include(*expected_sources)
-      end
-
-      it 'ignores the trailing slash' do
-        sources_for_dot       = described_class.new([Pathname.new('.')]).sources
-        sources_for_dot_slash = described_class.new([Pathname.new('./')]).sources
-
-        expect(sources_for_dot).to eq(sources_for_dot_slash)
-      end
-    end
-  end
-end

data/spec/reek/spec/should_reek_of_spec.rb

@@ -1,153 +0,0 @@
-require 'pathname'
-require_relative '../../spec_helper'
-require_lib 'reek/spec'
-
-RSpec.describe Reek::Spec::ShouldReekOf do
-  describe 'smell type selection' do
-    let(:ruby) { 'def double_thing() @other.thing.foo + @other.thing.foo end' }
-
-    it 'reports duplicate calls by smell type' do
-      expect(ruby).to reek_of(: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 '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).to be_matches(smelly_code)
-      end
-
-      it 'doesnt match a fragrant String' do
-        expect(matcher).not_to be_matches(clean_code)
-      end
-
-      it 're-calculates matches every time' do
-        matcher.matches? smelly_code
-        expect(matcher).not_to be_matches(clean_code)
-      end
-    end
-
-    context 'when checking code in a File' do
-      let(:matcher) { described_class.new(:UncommunicativeMethodName, name: 'x') }
-
-      it 'matches a smelly file' do
-        expect(matcher).to be_matches(SMELLY_FILE)
-      end
-
-      it 'doesnt match a fragrant file' do
-        expect(matcher).not_to be_matches(CLEAN_FILE)
-      end
-    end
-  end
-
-  describe 'smell types and smell details' 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' }
-
-      it 'raises ArgumentError' do
-        expect { matcher.matches?(smelly_code) }.to raise_error(ArgumentError)
-      end
-    end
-
-    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).to be_matches(smelly_code)
-      end
-    end
-
-    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).not_to be_matches(smelly_code)
-      end
-
-      it 'sets the proper error message' do
-        falsey_matcher.matches?(smelly_code)
-
-        expect(falsey_matcher.failure_message).to\
-          match('Expected string to reek of FeatureEnvy, but it didn\'t')
-      end
-
-      it 'sets the proper error message when negated' do
-        truthy_matcher.matches?(smelly_code)
-
-        expect(truthy_matcher.failure_message_when_negated).to\
-          match('Expected string not to reek of UncommunicativeVariableName, but it did')
-      end
-    end
-
-    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).not_to be_matches(smelly_code)
-      end
-
-      it 'sets the proper error message' do
-        matcher.matches?(smelly_code)
-        expected = <<~TEXT
-          Expected string to reek of DuplicateMethodCall (which it did) with smell details {:name=>"foo", :count=>15}, which it didn't.
-          The number of smell details I had to compare with the given one was 2 and here they are:
-          1.)
-          {"context"=>"double_thing", "lines"=>[1, 1], "message"=>"calls '@other.thing' 2 times", "source"=>"string", "name"=>"@other.thing", "count"=>2}
-          2.)
-          {"context"=>"double_thing", "lines"=>[1, 1], "message"=>"calls '@other.thing.foo' 2 times", "source"=>"string", "name"=>"@other.thing.foo", "count"=>2}
-        TEXT
-
-        expect(matcher.failure_message).to eq(expected)
-      end
-
-      it 'sets the proper error message when negated' do
-        matcher.matches?(smelly_code)
-
-        expect(matcher.failure_message_when_negated).to\
-          match('Expected string not to reek of DuplicateMethodCall with smell '\
-                  'details {:name=>"foo", :count=>15}, but it did')
-      end
-    end
-  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'
-
-      aggregate_failures do
-        expect(default_config[Reek::SmellConfiguration::ENABLED_KEY]).to be_falsy
-        expect(src).to reek_of(:UnusedPrivateMethod)
-      end
-    end
-  end
-
-  describe '#with_config' do
-    let(:matcher) { described_class.new(:UncommunicativeVariableName) }
-    let(:configured_matcher) { matcher.with_config('accept' => 'x') }
-
-    it 'uses the passed-in configuration for matching' do
-      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).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

@@ -1,91 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/spec'
-
-RSpec.describe Reek::Spec::ShouldReekOnlyOf do
-  let(:examiner) { instance_double('Reek::Examiner').as_null_object }
-  let(:expected_context_name) { 'SmellyClass#big_method' }
-  let(:expected_smell_type) { :NestedIterators }
-  let(:matcher) { described_class.new(expected_smell_type) }
-  let(:matcher_matches) { matcher.matches_examiner?(examiner) }
-
-  before do
-    allow(examiner).to receive(:smells) { smells }
-    matcher_matches
-  end
-
-  shared_examples_for 'no match' do
-    it 'does not match' do
-      expect(matcher_matches).to be_falsey
-    end
-
-    context 'when a match was expected' do
-      let(:source) { 'the_path/to_a/source_file.rb' }
-
-      before { allow(examiner).to receive(:origin).and_return(source) }
-
-      it 'reports the source' do
-        expect(matcher.failure_message).to match(source)
-      end
-
-      it 'reports the expected smell class' do
-        expect(matcher.failure_message).to match(expected_smell_type.to_s)
-      end
-    end
-  end
-
-  context 'with no smells' do
-    let(:smells) { [] }
-
-    it_behaves_like 'no match'
-  end
-
-  context 'with 1 non-matching smell' do
-    let(:smells) { [build_smell_warning(smell_type: 'ControlParameter')] }
-
-    it_behaves_like 'no match'
-  end
-
-  context 'with 2 non-matching smells' do
-    let(:smells) do
-      [
-        build_smell_warning(smell_type: 'ControlParameter'),
-        build_smell_warning(smell_type: 'FeatureEnvy')
-      ]
-    end
-
-    it_behaves_like 'no match'
-  end
-
-  context 'with 1 non-matching and 1 matching smell' do
-    let(:smells) do
-      [
-        build_smell_warning(smell_type: 'ControlParameter'),
-        build_smell_warning(smell_type: expected_smell_type.to_s,
-                              message: "message mentioning #{expected_context_name}")
-      ]
-    end
-
-    it_behaves_like 'no match'
-  end
-
-  context 'with 1 matching smell' do
-    let(:smells) do
-      [build_smell_warning(smell_type: expected_smell_type.to_s,
-                             message: "message mentioning #{expected_context_name}")]
-    end
-
-    it 'matches' do
-      expect(matcher_matches).to be_truthy
-    end
-
-    it 'reports the expected smell when no match was expected' do
-      expect(matcher.failure_message_when_negated).to match(expected_smell_type.to_s)
-    end
-
-    it 'reports the source when no match was expected' do
-      source = 'the_path/to_a/source_file.rb'
-      allow(examiner).to receive(:origin).and_return(source)
-      expect(matcher.failure_message_when_negated).to match(source)
-    end
-  end
-end

data/spec/reek/spec/should_reek_spec.rb

@@ -1,52 +0,0 @@
-require_relative '../../spec_helper'
-require_lib 'reek/spec'
-
-RSpec.describe Reek::Spec::ShouldReek do
-  describe 'checking code in a string' do
-    let(:matcher) { described_class.new }
-    let(:clean_code) { 'def good() true; end' }
-    let(:smelly_code) { 'def x() y = 4; end' }
-
-    it 'matches a smelly String' do
-      expect(matcher).to be_matches(smelly_code)
-    end
-
-    it 'doesnt match a fragrant String' do
-      expect(matcher).not_to be_matches(clean_code)
-    end
-
-    it 'reports the smells when should_not fails' do
-      matcher.matches?(smelly_code)
-      expect(matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
-    end
-  end
-
-  describe 'checking code in a File' do
-    context 'without masking' do
-      let(:matcher) { described_class.new }
-
-      it 'matches a smelly File' do
-        expect(matcher).to be_matches(SMELLY_FILE)
-      end
-
-      it 'doesnt match a fragrant File' do
-        expect(matcher).not_to be_matches(CLEAN_FILE)
-      end
-
-      it 'reports the smells when should_not fails' do
-        matcher.matches?(SMELLY_FILE)
-        expect(matcher.failure_message_when_negated).to match('UncommunicativeMethodName')
-      end
-    end
-
-    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).not_to be_matches(SMELLY_FILE)
-      end
-    end
-  end
-end