reek 4.4.1 → 4.4.2

data/lib/reek/smells/prima_donna_method.rb

@@ -30,30 +30,31 @@ module Reek
       end
 
       def sniff(ctx)
-        ctx.node_instance_methods.map do |method_sexp|
-          check_for_smells(method_sexp, ctx)
-        end.compact
+        ctx.node_instance_methods.select do |method_sexp|
+          prima_donna_method?(method_sexp, ctx)
+        end.map do |method_sexp|
+          name = method_sexp.name
+          smell_warning(
+            context: ctx,
+            lines: [ctx.exp.line],
+            message: "has prima donna method '#{name}'",
+            parameters: { name: name.to_s })
+        end
       end
 
       private
 
-      # :reek:FeatureEnvy
-      # :reek:TooManyStatements: { max_statements: 6 }
-      def check_for_smells(method_sexp, ctx)
-        return unless method_sexp.ends_with_bang?
+      def prima_donna_method?(method_sexp, ctx)
+        return false unless method_sexp.ends_with_bang?
+        return false if version_without_bang_exists?(method_sexp, ctx)
+        true
+      end
 
-        version_without_bang = ctx.node_instance_methods.find do |sexp_item|
+      # :reek:UtilityFunction
+      def version_without_bang_exists?(method_sexp, ctx)
+        ctx.node_instance_methods.find do |sexp_item|
           sexp_item.name.to_s == method_sexp.name_without_bang
         end
-
-        return if version_without_bang
-
-        name = method_sexp.name
-        smell_warning(
-          context: ctx,
-          lines: [ctx.exp.line],
-          message: "has prima donna method '#{name}'",
-          parameters: { name: name })
       end
     end
   end

data/lib/reek/smells/smell_detector.rb

@@ -72,9 +72,8 @@ module Reek
       def smell_warning(options = {})
         context = options.fetch(:context)
         exp = context.exp
-        ctx_source = exp.loc.expression.source_buffer.name
         SmellWarning.new(self,
-                         source: ctx_source,
+                         source: exp.source,
                          context: context.full_name,
                          lines: options.fetch(:lines),
                          message: options.fetch(:message),
@@ -102,9 +101,27 @@ module Reek
           descendants << subclass
         end
 
+        #
+        # Returns all descendants of SmellDetector
+        #
+        # @return [Array<Constant>], e.g.:
+        #   [Reek::Smells::Attribute,
+        #    Reek::Smells::BooleanParameter,
+        #    Reek::Smells::ClassVariable,
+        #    ...]
+        #
         def descendants
           @descendants ||= []
         end
+
+        #
+        # @param detector [String] the detector in question, e.g. 'DuplicateMethodCall'
+        # @return [Boolean]
+        #
+        def valid_detector?(detector)
+          descendants.map { |descendant| descendant.to_s.split('::').last }.
+            include?(detector)
+        end
       end
     end
   end

data/lib/reek/smells/unused_private_method.rb

@@ -44,7 +44,7 @@ module Reek
             context: ctx,
             lines: [hit.line],
             message: "has the unused private instance method '#{name}'",
-            parameters: { name: name })
+            parameters: { name: name.to_s })
         end
       end
 

data/lib/reek/spec/should_reek_of.rb

@@ -9,6 +9,8 @@ module Reek
     # code smell.
     #
     class ShouldReekOf
+      include RSpec::Matchers::Composable
+
       # Variant of Examiner that doesn't swallow exceptions
       class UnsafeExaminer < Examiner
         def run

data/lib/reek/version.rb

@@ -7,6 +7,6 @@ module Reek
   # @public
   module Version
     # @public
-    STRING = '4.4.1'.freeze
+    STRING = '4.4.2'.freeze
   end
 end

data/spec/factories/factories.rb

@@ -52,4 +52,15 @@ FactoryGirl.define do
           parameters: parameters)
     end
   end
+
+  factory :code_comment, class: Reek::CodeComment do
+    comment ''
+    line 1
+    source 'string'
+    initialize_with do
+      new comment: comment,
+          line: line,
+          source: source
+    end
+  end
 end

data/spec/quality/reek_source_spec.rb

@@ -3,7 +3,7 @@ require_relative '../spec_helper'
 RSpec.describe 'Reek source code' do
   it 'has no smells' do
     Pathname.glob('lib/**/*.rb').each do |pathname|
-      expect(pathname).to_not reek
+      expect(pathname).not_to reek
     end
   end
 end

data/spec/reek/ast/node_spec.rb

@@ -75,4 +75,44 @@ RSpec.describe Reek::AST::Node do
       expect(sexp(:foo).length).to eq 1
     end
   end
+
+  describe '#line' do
+    context 'source from file' do
+      let(:file) { SAMPLES_PATH.join('smelly.rb') }
+      let(:ast) { Reek::Source::SourceCode.from(file).syntax_tree }
+
+      it 'returns the right line number' do
+        expect(ast.line).to eq(2)
+      end
+    end
+
+    context 'source from string' do
+      let(:source) { File.read(SAMPLES_PATH.join('smelly.rb')) }
+      let(:ast) { Reek::Source::SourceCode.from(source).syntax_tree }
+
+      it 'returns the right line number' do
+        expect(ast.line).to eq(2)
+      end
+    end
+  end
+
+  describe '#source' do
+    context 'source from file' do
+      let(:file) { SAMPLES_PATH.join('smelly.rb') }
+      let(:ast) { Reek::Source::SourceCode.from(file).syntax_tree }
+
+      it 'returns the file name' do
+        expect(ast.source).to eq(SAMPLES_PATH.join('smelly.rb').to_s)
+      end
+    end
+
+    context 'source from string' do
+      let(:source) { File.read(SAMPLES_PATH.join('smelly.rb')) }
+      let(:ast) { Reek::Source::SourceCode.from(source).syntax_tree }
+
+      it 'returns "string"' do
+        expect(ast.source).to eq('string')
+      end
+    end
+  end
 end

data/spec/reek/ast/object_refs_spec.rb

@@ -2,57 +2,16 @@ require_relative '../../spec_helper'
 require_lib 'reek/ast/object_refs'
 
 RSpec.describe Reek::AST::ObjectRefs do
-  let(:refs) { Reek::AST::ObjectRefs.new }
+  let(:refs) { described_class.new }
 
   context 'when empty' do
-    it 'should report no refs to self' do
+    it 'reports no refs to self' do
       expect(refs.references_to(:self)).to be_empty
     end
   end
 
-  context 'with references to a, b, and a' do
-    context 'with no refs to self' do
-      before(:each) do
-        refs.record_reference(name: :a)
-        refs.record_reference(name: :b)
-        refs.record_reference(name: :a)
-      end
-
-      it 'should report no refs to self' do
-        expect(refs.references_to(:self)).to be_empty
-      end
-
-      it 'should report :a as the max' do
-        expect(refs.most_popular).to include(:a)
-      end
-
-      it 'should not report self as the max' do
-        expect(refs.self_is_max?).to eq(false)
-      end
-
-      context 'with one reference to self' do
-        before(:each) do
-          refs.record_reference(name: :self)
-        end
-
-        it 'should report 1 ref to self' do
-          expect(refs.references_to(:self).size).to eq(1)
-        end
-
-        it 'should not report self among the max' do
-          expect(refs.most_popular).to include(:a)
-          expect(refs.most_popular).not_to include(:self)
-        end
-
-        it 'should not report self as the max' do
-          expect(refs.self_is_max?).to eq(false)
-        end
-      end
-    end
-  end
-
   context 'with many refs to self' do
-    before(:each) do
+    before do
       refs.record_reference(name: :self)
       refs.record_reference(name: :self)
       refs.record_reference(name: :a)
@@ -62,21 +21,21 @@ RSpec.describe Reek::AST::ObjectRefs do
       refs.record_reference(name: :self)
     end
 
-    it 'should report all refs to self' do
+    it 'reports all refs to self' do
       expect(refs.references_to(:self).size).to eq(4)
     end
 
-    it 'should report self among the max' do
+    it 'reports self among the max' do
       expect(refs.most_popular).to include(:self)
     end
 
-    it 'should report self as the max' do
+    it 'reports self as the max' do
       expect(refs.self_is_max?).to eq(true)
     end
   end
 
   context 'when self is not the only max' do
-    before(:each) do
+    before do
       refs.record_reference(name: :a)
       refs.record_reference(name: :self)
       refs.record_reference(name: :self)
@@ -84,38 +43,40 @@ RSpec.describe Reek::AST::ObjectRefs do
       refs.record_reference(name: :a)
     end
 
-    it 'should report all refs to self' do
+    it 'reports all refs to self' do
       expect(refs.references_to(:self).size).to eq(2)
     end
 
-    it 'should report self among the max' do
-      expect(refs.most_popular).to include(:a)
+    it 'reports self among the max' do
       expect(refs.most_popular).to include(:self)
     end
 
-    it 'should report self as the max' do
+    it 'reports the other max among the max' do
+      expect(refs.most_popular).to include(:a)
+    end
+
+    it 'reports self as the max' do
       expect(refs.self_is_max?).to eq(true)
     end
   end
 
-  context 'when self is not among the max' do
-    before(:each) do
+  context 'when self is not recorded' do
+    before do
       refs.record_reference(name: :a)
       refs.record_reference(name: :b)
       refs.record_reference(name: :a)
       refs.record_reference(name: :b)
     end
 
-    it 'should report all refs to self' do
+    it 'reports no refs to self' do
       expect(refs.references_to(:self).size).to eq(0)
     end
 
-    it 'should not report self among the max' do
-      expect(refs.most_popular).to include(:a)
-      expect(refs.most_popular).to include(:b)
+    it 'does not report self among the max' do
+      expect(refs.most_popular).not_to include(:self)
     end
 
-    it 'should not report self as the max' do
+    it 'does not report self as the max' do
       expect(refs.self_is_max?).to eq(false)
     end
   end

data/spec/reek/ast/sexp_extensions_spec.rb

@@ -402,60 +402,60 @@ end
 
 RSpec.describe Reek::AST::SexpExtensions::ModuleNode do
   context 'with a simple name' do
-    subject do
+    let(:exp) do
       Reek::Source::SourceCode.from('module Fred; end').syntax_tree
     end
 
     it 'has the correct #name' do
-      expect(subject.name).to eq 'Fred'
+      expect(exp.name).to eq 'Fred'
     end
 
     it 'has the correct #simple_name' do
-      expect(subject.simple_name).to eq 'Fred'
+      expect(exp.simple_name).to eq 'Fred'
     end
 
     it 'has a simple full_name' do
-      expect(subject.full_name('')).to eq 'Fred'
+      expect(exp.full_name('')).to eq 'Fred'
     end
 
     it 'has a fq full_name' do
-      expect(subject.full_name('Blimey::O::Reilly')).to eq 'Blimey::O::Reilly::Fred'
+      expect(exp.full_name('Blimey::O::Reilly')).to eq 'Blimey::O::Reilly::Fred'
     end
   end
 
   context 'with a scoped name' do
-    subject do
+    let(:exp) do
       Reek::Source::SourceCode.from('module Foo::Bar; end').syntax_tree
     end
 
     it 'has the correct #name' do
-      expect(subject.name).to eq 'Foo::Bar'
+      expect(exp.name).to eq 'Foo::Bar'
     end
 
     it 'has the correct #simple_name' do
-      expect(subject.simple_name).to eq 'Bar'
+      expect(exp.simple_name).to eq 'Bar'
     end
 
     it 'has a simple full_name' do
-      expect(subject.full_name('')).to eq 'Foo::Bar'
+      expect(exp.full_name('')).to eq 'Foo::Bar'
     end
 
-    it 'has a fq full_name' do
-      expect(subject.full_name('Blimey::O::Reilly')).to eq 'Blimey::O::Reilly::Foo::Bar'
+    it 'has a fully qualified full_name' do
+      expect(exp.full_name('Blimey::O::Reilly')).to eq 'Blimey::O::Reilly::Foo::Bar'
     end
   end
 
   context 'with a name scoped in a namespace that is not a constant' do
-    subject do
+    let(:exp) do
       Reek::Source::SourceCode.from('module foo::Bar; end').syntax_tree
     end
 
     it 'has the correct #name' do
-      expect(subject.name).to eq 'foo::Bar'
+      expect(exp.name).to eq 'foo::Bar'
     end
 
     it 'has the correct #simple_name' do
-      expect(subject.simple_name).to eq 'Bar'
+      expect(exp.simple_name).to eq 'Bar'
     end
   end
 end
@@ -463,12 +463,9 @@ end
 RSpec.describe Reek::AST::SexpExtensions::CasgnNode do
   describe '#defines_module?' do
     context 'with single assignment' do
-      subject do
-        sexp(:casgn, nil, :Foo)
-      end
-
       it 'does not define a module' do
-        expect(subject.defines_module?).to be_falsey
+        exp = sexp(:casgn, nil, :Foo)
+        expect(exp.defines_module?).to be_falsey
       end
     end
 

data/spec/reek/cli/application_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Reek::CLI::Application do
     it 'exits with default error code on invalid options' do
       call = lambda do
         Reek::CLI::Silencer.silently do
-          Reek::CLI::Application.new ['--foo']
+          described_class.new ['--foo']
         end
       end
       expect(call).to raise_error(SystemExit) do |error|
@@ -22,8 +22,8 @@ RSpec.describe Reek::CLI::Application do
   let(:configuration) { test_configuration_for(CONFIG_PATH.join('with_excluded_paths.reek')) }
 
   describe '#execute' do
-    let(:command) { double 'reek_command' }
-    let(:app) { Reek::CLI::Application.new [] }
+    let(:command) { instance_double 'Reek::CLI::Command::ReportCommand' }
+    let(:app) { described_class.new [] }
 
     before do
       allow(Reek::CLI::Command::ReportCommand).to receive(:new).and_return command
@@ -40,7 +40,7 @@ RSpec.describe Reek::CLI::Application do
           allow_any_instance_of(IO).to receive(:tty?).and_return(false)
         end
 
-        it 'should use source form pipe' do
+        it 'uses source form pipe' do
           app.execute
           expect(Reek::CLI::Command::ReportCommand).to have_received(:new).
             with(sources: [$stdin],
@@ -54,7 +54,7 @@ RSpec.describe Reek::CLI::Application do
           allow_any_instance_of(IO).to receive(:tty?).and_return(true)
         end
 
-        it 'should use working directory as source' do
+        it 'uses working directory as source' do
           expected_sources = Reek::Source::SourceLocator.new(['.']).sources
           app.execute
           expect(Reek::CLI::Command::ReportCommand).to have_received(:new).
@@ -62,37 +62,37 @@ RSpec.describe Reek::CLI::Application do
                  configuration: Reek::Configuration::AppConfiguration,
                  options: Reek::CLI::Options)
         end
-      end
 
-      context 'when source files are excluded through configuration' do
-        let(:app) { Reek::CLI::Application.new ['--config', 'some_file.reek'] }
+        context 'when source files are excluded through configuration' do
+          let(:app) { described_class.new ['--config', 'some_file.reek'] }
 
-        before do
-          allow(Reek::Configuration::AppConfiguration).
-            to receive(:from_path).
-            with(Pathname.new('some_file.reek')).
-            and_return configuration
-        end
+          before do
+            allow(Reek::Configuration::AppConfiguration).
+              to receive(:from_path).
+              with(Pathname.new('some_file.reek')).
+              and_return configuration
+          end
 
-        it 'should use configuration for excluded paths' do
-          expected_sources = Reek::Source::SourceLocator.
-            new(['.'], configuration: configuration).sources
-          expect(expected_sources).not_to include(path_excluded_in_configuration)
+          it 'uses configuration for excluded paths' do
+            expected_sources = Reek::Source::SourceLocator.
+              new(['.'], configuration: configuration).sources
+            expect(expected_sources).not_to include(path_excluded_in_configuration)
 
-          app.execute
+            app.execute
 
-          expect(Reek::CLI::Command::ReportCommand).to have_received(:new).
-            with(sources: expected_sources,
-                 configuration: configuration,
-                 options: Reek::CLI::Options)
+            expect(Reek::CLI::Command::ReportCommand).to have_received(:new).
+              with(sources: expected_sources,
+                   configuration: configuration,
+                   options: Reek::CLI::Options)
+          end
         end
       end
     end
 
     context 'when source files given' do
-      let(:app) { Reek::CLI::Application.new ['.'] }
+      let(:app) { described_class.new ['.'] }
 
-      it 'should use sources from argv' do
+      it 'uses sources from argv' do
         expected_sources = Reek::Source::SourceLocator.new(['.']).sources
         app.execute
         expect(Reek::CLI::Command::ReportCommand).to have_received(:new).