reek 3.7.1 → 3.8.0

data/lib/reek/smells/unused_private_method.rb

@@ -0,0 +1,82 @@
+require_relative 'smell_detector'
+require_relative 'smell_warning'
+require_relative '../context/method_context'
+
+module Reek
+  module Smells
+    #
+    # Classes should use their private methods. Otherwise this is dead
+    # code which is confusing and bad for maintenance.
+    #
+    # See {file:docs/Unused-Private-Method.md} for details.
+    #
+    class UnusedPrivateMethod < SmellDetector
+      # Class for storing `hits` which are unused private methods
+      # we found in the given context. `name` and `line` are then used to
+      # construct SmellWarnings.
+      class Hit
+        attr_reader :name, :line
+
+        def initialize(context)
+          @name  = context.name
+          @line  = context.exp.line
+        end
+      end
+
+      def self.contexts
+        [:class]
+      end
+
+      #
+      # @param ctx [Context::ClassContext]
+      # @return [Array<SmellWarning>]
+      #
+      # :reek:FeatureEnvy
+      def inspect(ctx)
+        hits(ctx).map do |hit|
+          name = hit.name
+          smell_warning(
+            context: ctx,
+            lines: [hit.line],
+            message: "has the unused private instance method `#{name}`",
+            parameters: { name: name })
+        end
+      end
+
+      private
+
+      #
+      # @param ctx [Context::ClassContext]
+      # @return [Array<Hit>]
+      #
+      def hits(ctx)
+        unused_private_methods(ctx).map do |defined_method|
+          Hit.new(defined_method) unless ignore_method?(ctx, defined_method)
+        end.compact
+      end
+
+      #
+      # @param ctx [Context::ClassContext]
+      # @return [Array<Context::MethodContext]
+      #
+      # :reek:UtilityFunction
+      def unused_private_methods(ctx)
+        defined_private_methods = ctx.defined_instance_methods(visibility: :private)
+        called_method_names     = ctx.instance_method_calls.map(&:name)
+
+        defined_private_methods.select do |defined_method|
+          !called_method_names.include?(defined_method.name)
+        end
+      end
+
+      #
+      # @param ctx [Context::ClassContext]
+      # @return [Boolean]
+      #
+      def ignore_method?(ctx, method)
+        ignore_methods = value(EXCLUDE_KEY, ctx, DEFAULT_EXCLUDE_SET)
+        ignore_methods.any? { |ignore_method| method.name[ignore_method] }
+      end
+    end
+  end
+end

data/lib/reek/smells/utility_function.rb

@@ -59,7 +59,7 @@ module Reek
       # :reek:TooManyStatements: { max_statements: 6 }
       def inspect(ctx)
         return [] if ctx.singleton_method?
-        return [] if ctx.num_statements == 0
+        return [] if ctx.number_of_statements == 0
         return [] if ctx.references_self?
         return [] if num_helper_methods(ctx).zero?
         return [] if ignore_method?(ctx)

data/lib/reek/smells.rb

@@ -21,4 +21,5 @@ require_relative 'smells/uncommunicative_module_name'
 require_relative 'smells/uncommunicative_parameter_name'
 require_relative 'smells/uncommunicative_variable_name'
 require_relative 'smells/unused_parameters'
+require_relative 'smells/unused_private_method'
 require_relative 'smells/utility_function'

data/lib/reek/version.rb

@@ -6,6 +6,6 @@ module Reek
   # @public
   module Version
     # @public
-    STRING = '3.7.1'
+    STRING = '3.8.0'
   end
 end

data/spec/reek/ast/object_refs_spec.rb

@@ -13,9 +13,9 @@ RSpec.describe Reek::AST::ObjectRefs do
   context 'with references to a, b, and a' do
     context 'with no refs to self' do
       before(:each) do
-        refs.record_reference_to(:a)
-        refs.record_reference_to(:b)
-        refs.record_reference_to(:a)
+        refs.record_reference(name: :a)
+        refs.record_reference(name: :b)
+        refs.record_reference(name: :a)
       end
 
       it 'should report no refs to self' do
@@ -32,7 +32,7 @@ RSpec.describe Reek::AST::ObjectRefs do
 
       context 'with one reference to self' do
         before(:each) do
-          refs.record_reference_to(:self)
+          refs.record_reference(name: :self)
         end
 
         it 'should report 1 ref to self' do
@@ -53,13 +53,13 @@ RSpec.describe Reek::AST::ObjectRefs do
 
   context 'with many refs to self' do
     before(:each) do
-      refs.record_reference_to(:self)
-      refs.record_reference_to(:self)
-      refs.record_reference_to(:a)
-      refs.record_reference_to(:self)
-      refs.record_reference_to(:b)
-      refs.record_reference_to(:a)
-      refs.record_reference_to(:self)
+      refs.record_reference(name: :self)
+      refs.record_reference(name: :self)
+      refs.record_reference(name: :a)
+      refs.record_reference(name: :self)
+      refs.record_reference(name: :b)
+      refs.record_reference(name: :a)
+      refs.record_reference(name: :self)
     end
 
     it 'should report all refs to self' do
@@ -77,11 +77,11 @@ RSpec.describe Reek::AST::ObjectRefs do
 
   context 'when self is not the only max' do
     before(:each) do
-      refs.record_reference_to(:a)
-      refs.record_reference_to(:self)
-      refs.record_reference_to(:self)
-      refs.record_reference_to(:b)
-      refs.record_reference_to(:a)
+      refs.record_reference(name: :a)
+      refs.record_reference(name: :self)
+      refs.record_reference(name: :self)
+      refs.record_reference(name: :b)
+      refs.record_reference(name: :a)
     end
 
     it 'should report all refs to self' do
@@ -100,10 +100,10 @@ RSpec.describe Reek::AST::ObjectRefs do
 
   context 'when self is not among the max' do
     before(:each) do
-      refs.record_reference_to(:a)
-      refs.record_reference_to(:b)
-      refs.record_reference_to(:a)
-      refs.record_reference_to(:b)
+      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

data/spec/reek/cli/input_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../../spec_helper'
+require_lib 'reek/cli/input'
+
+RSpec.describe Reek::CLI::Input do
+  # dummy class which includes module under test
+  class DummyClass
+    include Reek::CLI::Input
+
+    def argv; end
+  end
+
+  subject { DummyClass.new }
+
+  describe '#sources' do
+    context 'when no source files given' do
+      before do
+        allow(subject).to receive(:argv).and_return([])
+      end
+
+      context 'and input was piped' do
+        before do
+          allow_any_instance_of(IO).to receive(:tty?).and_return(false)
+          expect(subject).to receive(:source_from_pipe).and_call_original
+        end
+
+        it 'should use source form pipe' do
+          expect(subject.sources).to_not be_empty
+        end
+      end
+
+      context 'and input was not piped' do
+        before do
+          allow_any_instance_of(IO).to receive(:tty?).and_return(true)
+          expect(subject).to receive(:working_directory_as_source).
+            and_call_original
+        end
+
+        it 'should use working directory as source' do
+          expect(subject.sources).to_not be_empty
+        end
+      end
+    end
+
+    context 'when source files given' do
+      before do
+        allow(subject).to receive(:argv).and_return(['.'])
+        expect(subject).to receive(:sources_from_argv).and_call_original
+      end
+
+      it 'should use sources from argv' do
+        expect(subject.sources).to_not be_empty
+      end
+    end
+  end
+end

data/spec/reek/code_comment_spec.rb

@@ -81,5 +81,15 @@ RSpec.describe Reek::CodeComment do
       config = described_class.new('# :reek: Duplication').config
       expect(config).not_to include('Duplication')
     end
+
+    it 'removes the configuration options from the comment' do
+      subject = described_class.new('
+        # Actual
+        # :reek:Duplication: { enabled: false }
+        # :reek:NestedIterators: { enabled: true }
+        # comment
+      ')
+      expect(subject.send(:sanitized_comment)).to eq('Actual comment')
+    end
   end
 end

data/spec/reek/context/code_context_spec.rb

@@ -17,21 +17,27 @@ RSpec.describe Reek::Context::CodeContext do
     it 'gets its short name from the exp' do
       expect(ctx.name).to eq(exp_name)
     end
+
     it 'does not match an empty list' do
       expect(ctx.matches?([])).to eq(false)
     end
+
     it 'does not match when its own short name is not given' do
       expect(ctx.matches?(['banana'])).to eq(false)
     end
+
     it 'does not let pipe-ended Strings make matching ignore the rest' do
       expect(ctx.matches?(['banana|'])).to eq(false)
     end
+
     it 'recognises its own short name' do
       expect(ctx.matches?(['banana', exp_name])).to eq(true)
     end
+
     it 'recognises its short name as a regex' do
       expect(ctx.matches?([/banana/, /#{exp_name}/])).to eq(true)
     end
+
     it 'does not blow up on []-ended Strings' do
       expect(ctx.matches?(['banana[]', exp_name])).to eq(true)
     end
@@ -49,9 +55,11 @@ RSpec.describe Reek::Context::CodeContext do
       it 'creates the correct full name' do
         expect(ctx.full_name).to eq(full_name)
       end
+
       it 'recognises its own full name' do
         expect(ctx.matches?(['banana', full_name])).to eq(true)
       end
+
       it 'recognises its full name as a regex' do
         expect(ctx.matches?([/banana/, /#{full_name}/])).to eq(true)
       end

data/spec/reek/context/module_context_spec.rb

@@ -12,18 +12,20 @@ RSpec.describe Reek::Context::ModuleContext do
   end
 
   it 'should not report module with empty class' do
-    expect('# module for test
-module Fred
-# module for test
- class Jim; end; end').not_to reek
+    expect('
+      # module for test
+      module Fred
+        # module for test
+        class Jim; end; end').not_to reek
   end
 end
 
 RSpec.describe Reek::Context::ModuleContext do
   it 'should recognise global constant' do
-    expect('# module for test
-module ::Global
-# module for test
- class Inside; end; end').not_to reek
+    expect('
+      # module for test
+      module ::Global
+        # module for test
+        class Inside; end; end').not_to reek
   end
 end

data/spec/reek/context_builder_spec.rb

@@ -0,0 +1,221 @@
+require_relative '../spec_helper'
+require_lib 'reek/context_builder'
+
+RSpec.describe Reek::ContextBuilder do
+  describe '#initialize' do
+    describe 'the structure of the context_tree' do
+      let(:walker) do
+        code = 'class Car; def drive; end; end'
+        described_class.new(syntax_tree(code))
+      end
+      let(:context_tree) { walker.context_tree }
+
+      it 'starts with a root node' do
+        expect(context_tree.type).to eq(:root)
+        expect(context_tree).to be_a(Reek::Context::RootContext)
+      end
+
+      it 'has one child' do
+        expect(context_tree.children.size).to eq(1)
+      end
+
+      describe 'the root node' do
+        let(:module_context) { context_tree.children.first }
+
+        it 'has one module_context' do
+          expect(module_context).to be_a(Reek::Context::ModuleContext)
+        end
+
+        it 'holds a reference to the parent context' do
+          expect(module_context.send(:context)).to eq(context_tree)
+        end
+
+        describe 'the module node' do
+          let(:method_context) { module_context.children.first }
+
+          it 'has one method_context' do
+            expect(method_context).to be_a(Reek::Context::MethodContext)
+            expect(module_context.children.size).to eq(1)
+          end
+
+          it 'holds a reference to the parent context' do
+            expect(method_context.send(:context)).to eq(module_context)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'statement counting' do
+    def tree(code)
+      described_class.new(syntax_tree(code)).context_tree
+    end
+
+    def number_of_statements_for(code)
+      tree(code).children.first.number_of_statements
+    end
+
+    it 'counts 1 assignment' do
+      code = 'def one() val = 4; end'
+      expect(number_of_statements_for(code)).to eq(1)
+    end
+
+    it 'counts 3 assignments' do
+      code = 'def one() val = 4; val = 4; val = 4; end'
+      expect(number_of_statements_for(code)).to eq(3)
+    end
+
+    it 'counts 1 attr assignment' do
+      code = 'def one() val[0] = 4; end'
+      expect(number_of_statements_for(code)).to eq(1)
+    end
+
+    it 'counts 1 increment assignment' do
+      code = 'def one() val += 4; end'
+      expect(number_of_statements_for(code)).to eq(1)
+    end
+
+    it 'counts 1 increment attr assignment' do
+      code = 'def one() val[0] += 4; end'
+      expect(number_of_statements_for(code)).to eq(1)
+    end
+
+    it 'counts 1 nested assignment' do
+      code = 'def one() val = fred = 4; end'
+      expect(number_of_statements_for(code)).to eq(1)
+    end
+
+    it 'counts returns' do
+      code = 'def one() val = 4; true; end'
+      expect(number_of_statements_for(code)).to eq(2)
+    end
+
+    it 'counts nil returns' do
+      code = 'def one() val = 4; nil; end'
+      expect(number_of_statements_for(code)).to eq(2)
+    end
+
+    context 'with control statements' do
+      it 'counts 3 statements in a conditional expression' do
+        code = 'def one() if val == 4; callee(); callee(); callee(); end; end'
+        expect(number_of_statements_for(code)).to eq(3)
+      end
+
+      it 'counts 3 statements in an else' do
+        code = <<-EOS
+          def one()
+            if val == 4
+              callee(); callee(); callee()
+            else
+              callee(); callee(); callee()
+            end
+          end
+        EOS
+
+        expect(number_of_statements_for(code)).to eq(6)
+      end
+
+      it 'does not count constant assignment with or equals' do
+        code = 'class Hi; CONST ||= 1; end'
+        expect(number_of_statements_for(code)).to eq(0)
+      end
+
+      it 'does not count multi constant assignment' do
+        code = 'class Hi; CONST, OTHER_CONST = 1, 2; end'
+        expect(number_of_statements_for(code)).to eq(0)
+      end
+
+      it 'does not count empty conditional expression' do
+        code = 'def one() if val == 4; ; end; end'
+        expect(number_of_statements_for(code)).to eq(0)
+      end
+
+      it 'does not count empty else' do
+        code = 'def one() if val == 4; ; else; ; end; end'
+        expect(number_of_statements_for(code)).to eq(0)
+      end
+
+      it 'counts extra statements in an if condition' do
+        code = 'def one() if begin val = callee(); val < 4 end; end; end'
+        expect(number_of_statements_for(code)).to eq(1)
+      end
+
+      it 'counts 3 statements in a while loop' do
+        code = 'def one() while val < 4; callee(); callee(); callee(); end; end'
+        expect(number_of_statements_for(code)).to eq(3)
+      end
+
+      it 'counts extra statements in a while condition' do
+        code = 'def one() while begin val = callee(); val < 4 end; end; end'
+        expect(number_of_statements_for(code)).to eq(1)
+      end
+
+      it 'counts 3 statements in a until loop' do
+        code = 'def one() until val < 4; callee(); callee(); callee(); end; end'
+        expect(number_of_statements_for(code)).to eq(3)
+      end
+
+      it 'counts 3 statements in a for loop' do
+        code = 'def one() for i in 0..4; callee(); callee(); callee(); end; end'
+        expect(number_of_statements_for(code)).to eq(3)
+      end
+
+      it 'counts 3 statements in a rescue' do
+        code = <<-EOS
+          def one()
+            begin
+              callee(); callee(); callee()
+            rescue
+              callee(); callee(); callee()
+            end
+          end
+        EOS
+        expect(number_of_statements_for(code)).to eq(6)
+      end
+
+      it 'counts 3 statements in a when' do
+        code = <<-EOS
+          def one()
+            case fred
+            when "hi" then callee(); callee()
+            when "lo" then callee()
+            end
+          end
+        EOS
+        expect(number_of_statements_for(code)).to eq(3)
+      end
+
+      it 'counts 3 statements in a case else' do
+        code = <<-EOS
+          def one()
+            case fred
+            when "hi" then callee(); callee(); callee()
+            else           callee(); callee(); callee()
+            end
+          end
+        EOS
+        expect(number_of_statements_for(code)).to eq(6)
+      end
+
+      it 'does not count empty case' do
+        code = 'def one() case fred; when "hi"; ; when "lo"; ; end; end'
+        expect(number_of_statements_for(code)).to eq(0)
+      end
+
+      it 'does not count empty case else' do
+        code = 'def one() case fred; when "hi"; ; else; ; end; end'
+        expect(number_of_statements_for(code)).to eq(0)
+      end
+
+      it 'counts 4 statements in an iterator' do
+        code = 'def one() fred.each do; callee(); callee(); callee(); end; end'
+        expect(number_of_statements_for(code)).to eq(4)
+      end
+
+      it 'counts 1 statement in a singleton method' do
+        code = 'def self.foo; callee(); end'
+        expect(number_of_statements_for(code)).to eq(1)
+      end
+    end
+  end
+end

data/spec/reek/examiner_spec.rb

@@ -14,9 +14,11 @@ RSpec.shared_examples_for 'one smell found' do
   it 'is smelly' do
     expect(examiner).to be_smelly
   end
+
   it 'reports the smell' do
     expect(examiner.smells.length).to eq(1)
   end
+
   it 'reports the correct smell' do
     expect(examiner.smells[0].smell_category).to eq(expected_first_smell)
   end
@@ -53,4 +55,15 @@ RSpec.describe Reek::Examiner do
 
     it_should_behave_like 'no smells found'
   end
+
+  describe '#smells' do
+    it 'returns the detected smell warnings' do
+      code     = 'def foo; bar.call_me(); bar.call_me(); end'
+      examiner = described_class.new code, ['DuplicateMethodCall']
+
+      smell = examiner.smells.first
+      expect(smell).to be_a(Reek::Smells::SmellWarning)
+      expect(smell.message).to eq('calls bar.call_me 2 times')
+    end
+  end
 end

data/spec/reek/smells/boolean_parameter_spec.rb

@@ -53,10 +53,12 @@ RSpec.describe Reek::Smells::BooleanParameter do
         src = 'def self.cc(arga = true) end'
         expect(src).to reek_of(:BooleanParameter, name: 'arga')
       end
+
       it 'reports a parameter defaulted to false' do
         src = 'def fred.cc(arga = false) end'
         expect(src).to reek_of(:BooleanParameter, name: 'arga')
       end
+
       it 'reports two parameters defaulted to booleans' do
         src = 'def Module.cc(nowt, arga = true, argb = false, &blk) end'
         expect(src).to reek_of(:BooleanParameter, name: 'arga')

data/spec/reek/smells/duplicate_method_call_spec.rb

@@ -1,7 +1,7 @@
 require_relative '../../spec_helper'
 require_lib 'reek/smells/duplicate_method_call'
 require_lib 'reek/context/code_context'
-require_lib 'reek/tree_walker'
+require_lib 'reek/context_builder'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::DuplicateMethodCall do

data/spec/reek/smells/feature_envy_spec.rb

@@ -190,7 +190,7 @@ RSpec.describe Reek::Smells::FeatureEnvy do
           @report = Report.new
           cf = SmellConfig.new
           cf = cf.load_local(@dir) if @dir
-          TreeWalker.new(@report, cf.smell_listeners).check_source(@source)
+          ContextBuilder.new(@report, cf.smell_listeners).check_source(@source)
         end
         @report
       end

data/spec/reek/smells/too_many_statements_spec.rb

@@ -46,10 +46,10 @@ RSpec.describe Reek::Smells::TooManyStatements do
   it_should_behave_like 'SmellDetector'
 
   context 'when the method has 30 statements' do
-    let(:num_statements) { 30 }
+    let(:number_of_statements) { 30 }
     let(:smells) do
       ctx = double('method_context').as_null_object
-      expect(ctx).to receive(:num_statements).and_return(num_statements)
+      expect(ctx).to receive(:number_of_statements).and_return(number_of_statements)
       expect(ctx).to receive(:config_for).with(described_class).and_return({})
       detector.inspect(ctx)
     end
@@ -59,7 +59,7 @@ RSpec.describe Reek::Smells::TooManyStatements do
     end
 
     it 'reports the number of statements' do
-      expect(smells[0].parameters[:count]).to eq(num_statements)
+      expect(smells[0].parameters[:count]).to eq(number_of_statements)
     end
 
     it 'reports the correct smell sub class' do