reek 4.6.0 → 5.0.0

data/spec/reek/smell_detectors/uncommunicative_variable_name_spec.rb

@@ -29,7 +29,7 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeVariableName do
       and reek_of(:UncommunicativeVariableName, lines: [3], name: 'y')
   end
 
-  context 'instance variables' do
+  context 'when examining instance variables' do
     it 'does not report use of one-letter names' do
       src = 'class Alfa; def bravo; @x; end; end'
       expect(src).not_to reek_of(:UncommunicativeVariableName)
@@ -41,7 +41,7 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeVariableName do
     end
   end
 
-  context 'local variables' do
+  context 'when examining local variables' do
     it 'does not report single underscore as a variable name' do
       src = 'def alfa; _ = bravo(); end'
       expect(src).not_to reek_of(:UncommunicativeVariableName)
@@ -78,7 +78,7 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeVariableName do
     end
   end
 
-  context 'block parameters' do
+  context 'when examining block parameters' do
     it 'reports all relevant block parameters' do
       src = <<-EOS
         def alfa
@@ -159,9 +159,9 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeVariableName do
   describe '`accept` patterns' do
     let(:src) { 'def alfa; bravo2 = 42; end' }
 
-    # FIXME: Move the loop out of the it?
-    it 'make smelly names pass via regex / strings given by list / literal' do
-      [[/bravo2/], /bravo2/, ['bravo2'], 'bravo2'].each do |pattern|
+    it 'make smelly names pass' do
+      patterns = [/ravo2/, /bravo2/]
+      patterns.each do |pattern|
         expect(src).to reek_of(:UncommunicativeVariableName).
           and not_reek_of(:UncommunicativeVariableName).with_config('accept' => pattern)
       end
@@ -171,9 +171,9 @@ RSpec.describe Reek::SmellDetectors::UncommunicativeVariableName do
   describe '`reject` patterns' do
     let(:src) { 'def alfa; foobar = 42; end' }
 
-    # FIXME: Move the loop out of the it?
-    it 'reject smelly names via regex / strings given by list / literal' do
-      [[/foobar/], /foobar/, ['foobar'], 'foobar'].each do |pattern|
+    it 'reject smelly names' do
+      patterns = [/fooba/, /oobar/]
+      patterns.each do |pattern|
         expect(src).to not_reek_of(:UncommunicativeVariableName).
           and reek_of(:UncommunicativeVariableName).with_config('reject' => pattern)
       end

data/spec/reek/smell_detectors/unused_parameters_spec.rb

@@ -61,7 +61,7 @@ RSpec.describe Reek::SmellDetectors::UnusedParameters do
     expect(src).not_to reek_of(:UnusedParameters)
   end
 
-  context 'using super' do
+  context 'when using super' do
     it 'reports nothing with implicit arguments' do
       src = 'def alfa(*bravo); super; end'
       expect(src).not_to reek_of(:UnusedParameters)
@@ -83,7 +83,7 @@ RSpec.describe Reek::SmellDetectors::UnusedParameters do
     end
   end
 
-  context 'anonymous parameters' do
+  context 'with anonymous parameters' do
     it 'reports nothing for unused anonymous parameter' do
       src = 'def alfa(_); end'
       expect(src).not_to reek_of(:UnusedParameters)
@@ -95,7 +95,7 @@ RSpec.describe Reek::SmellDetectors::UnusedParameters do
     end
   end
 
-  context 'splatted parameters' do
+  context 'with splatted parameters' do
     it 'reports nothing for used splatted parameter' do
       src = 'def alfa(*bravo); bravo; end'
       expect(src).not_to reek_of(:UnusedParameters)

data/spec/reek/smell_detectors/unused_private_method_spec.rb

@@ -38,7 +38,7 @@ RSpec.describe Reek::SmellDetectors::UnusedPrivateMethod do
       and reek_of(:UnusedPrivateMethod, lines: [7], name: 'charlie')
   end
 
-  context 'unused private methods' do
+  context 'when a class has unused private methods' do
     it 'reports instance methods' do
       source = <<-EOF
         class Alfa
@@ -103,12 +103,23 @@ RSpec.describe Reek::SmellDetectors::UnusedPrivateMethod do
         to reek_of(:UnusedPrivateMethod, name: 'bravo', lines: [3]).
         and reek_of(:UnusedPrivateMethod, name: 'charlie', lines: [4])
     end
+
+    it 'reports instance methods defined as private with a modifier' do
+      source = <<-EOF
+        class Alfa
+          private def bravo; end
+        end
+      EOF
+
+      expect(source).
+        to reek_of(:UnusedPrivateMethod, name: 'bravo')
+    end
   end
 
-  describe 'configuring the detector via source code comment' do
+  context 'when the detector is configured via a source code comment' do
     it 'does not report methods we excluded' do
       source = <<-EOF
-        # :reek:UnusedPrivateMethod: { exclude: [ bravo ] }
+        # :reek:UnusedPrivateMethod { exclude: [ bravo ] }
         class Alfa
           private
           def bravo; end
@@ -122,8 +133,8 @@ RSpec.describe Reek::SmellDetectors::UnusedPrivateMethod do
     end
   end
 
-  context 'used private methods' do
-    it 'are not reported' do
+  context 'when a class has only used private methods' do
+    it 'reports nothing' do
       source = <<-EOF
         class Alfa
           def bravo
@@ -139,8 +150,8 @@ RSpec.describe Reek::SmellDetectors::UnusedPrivateMethod do
     end
   end
 
-  context 'unused protected methods' do
-    it 'are not reported' do
+  context 'when a class has unused protected methods' do
+    it 'reports nothing' do
       source = <<-EOF
         class Alfa
           protected
@@ -152,8 +163,8 @@ RSpec.describe Reek::SmellDetectors::UnusedPrivateMethod do
     end
   end
 
-  context 'unused public methods' do
-    it 'are not reported' do
+  context 'when a class has unused public methods' do
+    it 'reports nothing' do
       source = <<-EOF
         class Alfa
           def bravo; end
@@ -164,7 +175,7 @@ RSpec.describe Reek::SmellDetectors::UnusedPrivateMethod do
     end
   end
 
-  describe 'prevent methods from being reported' do
+  describe 'preventing methods from being reported' do
     let(:source) do
       <<-EOF
         class Alfa

data/spec/reek/smell_detectors/utility_function_spec.rb

@@ -98,7 +98,7 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
     expect(src).to reek_of(:UtilityFunction, context: 'simple')
   end
 
-  context 'Singleton methods' do
+  context 'when examining singleton methods' do
     ['class', 'module'].each do |scope|
       it "does not report for #{scope} with `class << self` notation" do
         src = "#{scope} Alfa; class << self; def bravo(charlie) charlie.to_s; end; end; end"
@@ -111,7 +111,7 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
       end
     end
 
-    context 'by using `module_function`' do
+    context 'when defined by using `module_function`' do
       it 'does not report UtilityFunction also when using multiple arguments' do
         src = <<-EOS
           class Alfa
@@ -194,7 +194,7 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
       { Reek::SmellDetectors::UtilityFunction::PUBLIC_METHODS_ONLY_KEY => true }
     end
 
-    context 'public methods' do
+    context 'when examining public methods' do
       it 'still reports UtilityFunction' do
         src = <<-EOS
           class Alfa
@@ -208,7 +208,7 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
       end
     end
 
-    context 'private methods' do
+    context 'when examining private methods' do
       it 'does not report UtilityFunction' do
         src = <<-EOS
           class Alfa
@@ -221,9 +221,21 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
 
         expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
+
+      it 'does not report UtilityFunction when private is used as a def modifier' do
+        src = <<-EOS
+          class Alfa
+            private def bravo(charlie)
+              charlie.delta.echo
+            end
+          end
+        EOS
+
+        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
+      end
     end
 
-    context 'protected methods' do
+    context 'when examining protected methods' do
       it 'does not report UtilityFunction' do
         src = <<-EOS
           class Alfa
@@ -236,6 +248,46 @@ RSpec.describe Reek::SmellDetectors::UtilityFunction do
 
         expect(src).not_to reek_of(:UtilityFunction).with_config(config)
       end
+
+      it 'does not report UtilityFunction when protected is used as a def modifier' do
+        src = <<-EOS
+          class Alfa
+            protected def bravo(charlie)
+              charlie.delta.echo
+            end
+          end
+        EOS
+
+        expect(src).not_to reek_of(:UtilityFunction).with_config(config)
+      end
+    end
+  end
+
+  describe 'disabling with a comment' do
+    it 'disables the method following the comment' do
+      src = <<-EOS
+        class Alfa
+          # :reek:UtilityFunction
+          def bravo(charlie)
+            charlie.delta.echo
+          end
+        end
+      EOS
+
+      expect(src).not_to reek_of(:UtilityFunction)
+    end
+
+    it 'disables a method when it has a visibility modifier' do
+      src = <<-EOS
+        class Alfa
+          # :reek:UtilityFunction
+          private def bravo(charlie)
+            charlie.delta.echo
+          end
+        end
+      EOS
+
+      expect(src).not_to reek_of(:UtilityFunction)
     end
   end
 end

data/spec/reek/smell_warning_spec.rb

@@ -7,7 +7,7 @@ RSpec.describe Reek::SmellWarning do
   let(:utility_function_detector) { build(:smell_detector, smell_type: 'UtilityFunction') }
   let(:uncommunicative_name_detector) { build(:smell_detector, smell_type: 'UncommunicativeVariableName') }
 
-  context 'sort order' do
+  describe 'sort order' do
     shared_examples_for 'first sorts ahead of second' do
       it 'hash differently' do
         expect(first.hash).not_to eq(second.hash)
@@ -26,21 +26,21 @@ RSpec.describe Reek::SmellWarning do
       end
     end
 
-    context 'smells differing only by detector' do
+    context 'when smells differ only by detector' do
       let(:first) { build(:smell_warning, smell_detector: duplication_detector) }
       let(:second) { build(:smell_warning, smell_detector: feature_envy_detector) }
 
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smells differing only by lines' do
+    context 'when smells differ only by lines' do
       let(:first) { build(:smell_warning, smell_detector: feature_envy_detector, lines: [2]) }
       let(:second) { build(:smell_warning, smell_detector: feature_envy_detector, lines: [3]) }
 
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smells differing only by context' do
+    context 'when smells differ only by context' do
       let(:first) { build(:smell_warning, smell_detector: duplication_detector, context: 'first') }
       let(:second) do
         build(:smell_warning, smell_detector: duplication_detector, context: 'second')
@@ -49,7 +49,7 @@ RSpec.describe Reek::SmellWarning do
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smells differing only by message' do
+    context 'when smells differ only by message' do
       let(:first) do
         build(:smell_warning, smell_detector: duplication_detector,
                               context: 'ctx', message: 'first message')
@@ -62,7 +62,7 @@ RSpec.describe Reek::SmellWarning do
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smell name takes precedence over message' do
+    context 'when smells differ by name and message' do
       let(:first) do
         build(:smell_warning, smell_detector: feature_envy_detector, message: 'second message')
       end
@@ -73,7 +73,7 @@ RSpec.describe Reek::SmellWarning do
       it_behaves_like 'first sorts ahead of second'
     end
 
-    context 'smells differing everywhere' do
+    context 'when smells differ everywhere' do
       let(:first) do
         build(:smell_warning, smell_detector: duplication_detector,
                               context: 'Dirty#a',
@@ -97,7 +97,7 @@ RSpec.describe Reek::SmellWarning do
     end
   end
 
-  context '#yaml_hash' do
+  describe '#yaml_hash' do
     let(:context_name) { 'Module::Class#method/block' }
     let(:lines) { [24, 513] }
     let(:message) { 'test message' }
@@ -135,6 +135,10 @@ RSpec.describe Reek::SmellWarning do
       expect(yaml['source']).to eq source
     end
 
+    it 'includes the documentation link' do
+      expect(yaml['documentation_link']).to eq Reek::DocumentationLink.build('FeatureEnvy')
+    end
+
     it 'includes the parameters' do
       parameters.each do |key, value|
         expect(yaml[key]).to eq value

data/spec/reek/source/source_code_spec.rb

@@ -6,71 +6,60 @@ RSpec.describe Reek::Source::SourceCode do
   describe '#syntax_tree' do
     it 'associates comments with the AST' do
       source = "# this is\n# a comment\ndef foo; end"
-      source_code = described_class.new(code: source, origin: '(string)')
+      source_code = described_class.new(source: source, origin: '(string)')
       result = source_code.syntax_tree
       expect(result.leading_comment).to eq "# this is\n# a comment"
     end
 
     it 'cleanly processes empty source' do
-      source_code = described_class.new(code: '', origin: '(string)')
+      source_code = described_class.new(source: '', origin: '(string)')
       result = source_code.syntax_tree
-      expect(result).to be_nil
+      expect(result.type).to eq :empty
     end
 
     it 'cleanly processes empty source with comments' do
       source = "# this is\n# a comment\n"
-      source_code = described_class.new(code: source, origin: '(string)')
+      source_code = described_class.new(source: source, origin: '(string)')
       result = source_code.syntax_tree
-      expect(result).to be_nil
+      expect(result.type).to eq :empty
     end
-  end
-
-  context 'when the parser fails' do
-    let(:source_name) { 'Test source' }
-    let(:error_message) { 'Error message' }
-    let(:parser) { class_double(Parser::Ruby23) }
-    let(:src) { described_class.new(code: '', origin: source_name, parser: parser) }
 
-    shared_examples_for 'handling and recording the error' do
-      it 'raises an informative error' do
-        expect { src.syntax_tree }.
-          to raise_error(/#{source_name}: #{error_class.name}: #{error_message}/)
-      end
+    it 'does not crash with sequences incompatible with UTF-8' do
+      source = '"\xFF"'
+      source_code = described_class.new(source: source, origin: '(string)')
+      result = source_code.syntax_tree
+      expect(result.children.first).to eq "\xFF"
     end
 
-    context 'with a Parser::SyntaxError' do
-      let(:error_class) { Parser::SyntaxError }
-      let(:diagnostic) { instance_double('Parser::Diagnostic', message: error_message) }
-
-      before do
-        allow(parser).to receive(:parse_with_comments).
-          and_raise error_class.new(diagnostic)
-      end
-
-      it_behaves_like 'handling and recording the error'
+    it 'returns a :lambda node for lambda expressions' do
+      source = '->() { }'
+      source_code = described_class.new(source: source, origin: '(string)')
+      result = source_code.syntax_tree
+      expect(result.children.first.type).to eq :lambda
     end
 
-    context 'with a Racc::ParseError' do
-      let(:error_class) { Racc::ParseError }
+    context 'when the parser fails with a Parser::SyntaxError' do
+      let(:src) { described_class.new(source: code) }
+      let(:code) { '== Invalid Syntax ==' }
 
-      before do
-        allow(parser).to receive(:parse_with_comments).
-          and_raise(error_class.new(error_message))
+      it 'raises the error' do
+        expect { src.syntax_tree }.to raise_error Parser::SyntaxError
       end
-
-      it_behaves_like 'handling and recording the error'
     end
 
-    context 'with a generic error' do
+    context 'when the parser fails with a generic error' do
+      let(:code) { '' }
+      let(:parser) { instance_double('Parser::Ruby25') }
+      let(:src) { described_class.new(source: code, parser: parser) }
       let(:error_class) { RuntimeError }
+      let(:error_message) { 'An error' }
 
       before do
-        allow(parser).to receive(:parse_with_comments).
-          and_raise(error_class.new(error_message))
+        allow(parser).to receive(:parse_with_comments).and_raise(error_class, error_message)
       end
 
       it 'raises the error' do
-        expect { src.syntax_tree }.to raise_error error_class
+        expect { src.syntax_tree }.to raise_error error_class, error_message
       end
     end
   end

data/spec/reek/source/source_locator_spec.rb

@@ -5,15 +5,15 @@ require_lib 'reek/source/source_locator'
 
 RSpec.describe Reek::Source::SourceLocator do
   describe '#sources' do
-    context 'applied to hidden directories' do
-      let(:path) { SAMPLES_PATH.join('source_with_hidden_directories') }
+    context 'when applied to hidden directories' do
+      let(:path) { SAMPLES_DIR.join('source_with_hidden_directories') }
 
       let(:expected_paths) do
-        [path.join('uncommunicative_parameter_name.rb')]
+        [path.join('not_hidden.rb')]
       end
 
       let(:paths_that_are_expected_to_be_ignored) do
-        [path.join('.hidden/uncommunicative_method_name.rb')]
+        [path.join('.hidden/hidden.rb')]
       end
 
       it 'does not scan hidden directories' do
@@ -30,15 +30,45 @@ RSpec.describe Reek::Source::SourceLocator do
     end
 
     # rubocop:disable RSpec/NestedGroups
-    context 'exclude paths' do
+    context 'with excluded paths' do
       let(:configuration) do
-        test_configuration_for(CONFIG_PATH.join('with_excluded_paths.reek'))
+        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_PATH.join('source_with_exclude_paths', 'ignore_me', 'uncommunicative_method_name.rb') }
+        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
@@ -64,7 +94,7 @@ RSpec.describe Reek::Source::SourceLocator do
       end
 
       context 'when path is a directory' do
-        let(:path) { SAMPLES_PATH.join('source_with_exclude_paths') }
+        let(:path) { SAMPLES_DIR.join('source_with_exclude_paths') }
 
         let(:expected_paths) do
           [path.join('nested/uncommunicative_parameter_name.rb')]
@@ -90,10 +120,10 @@ RSpec.describe Reek::Source::SourceLocator do
     end
     # rubocop:enable RSpec/NestedGroups
 
-    context 'non-Ruby paths' do
-      let(:path) { SAMPLES_PATH.join('source_with_non_ruby_files') }
+    context 'with non-Ruby paths' do
+      let(:path) { SAMPLES_DIR.join('source_with_non_ruby_files') }
       let(:expected_sources) do
-        [path.join('uncommunicative_parameter_name.rb')]
+        [path.join('ruby.rb')]
       end
       let(:paths_that_are_expected_to_be_ignored) do
         [
@@ -115,7 +145,7 @@ RSpec.describe Reek::Source::SourceLocator do
       end
     end
 
-    context 'passing "." or "./" as argument' do
+    context 'when passing "." or "./" as argument' do
       let(:expected_sources) do
         [Pathname.new('spec/spec_helper.rb'), Pathname.new('lib/reek.rb')]
       end