reek 3.0.4 → 3.1

data/spec/reek/smells/utility_function_spec.rb

@@ -1,11 +1,12 @@
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/smells/utility_function'
+require_relative '../../../lib/reek/examiner'
 require_relative 'smell_detector_shared'
 
 RSpec.describe Reek::Smells::UtilityFunction do
   describe 'a detector' do
     before(:each) do
-      @source_name = 'dummy_source'
+      @source_name = 'string'
       @detector = build(:smell_detector,
                         smell_type: :UtilityFunction,
                         source: @source_name)
@@ -20,9 +21,7 @@ RSpec.describe Reek::Smells::UtilityFunction do
           arga.b.c
         end
         EOS
-        source = Reek::Source::SourceCode.from(src)
-        mctx = Reek::TreeWalker.new.process_def(source.syntax_tree)
-        @warning = @detector.examine_context(mctx)[0]   # SMELL: too cumbersome!
+        @warning = Reek::Examiner.new(src, ['UtilityFunction']).smells[0]
       end
 
       it_should_behave_like 'common fields set correctly'
@@ -74,11 +73,56 @@ RSpec.describe Reek::Smells::UtilityFunction do
           class C
             def m1(a) a.to_s; end
             def m2(a) a.to_s; end
-            module_function :m1, m2
+            module_function :m1, :m2
           end
           EOS
         expect(src).not_to reek_of(:UtilityFunction)
       end
+
+      it 'does not report module functions defined by earlier modifier' do
+        src = <<-EOF
+          module M
+            module_function
+            def simple(a) a.to_s; end
+          end
+        EOF
+        expect(src).not_to reek_of(:UtilityFunction)
+      end
+
+      it 'reports functions preceded by canceled modifier' do
+        src = <<-EOF
+          module M
+            module_function
+            public
+            def simple(a) a.to_s; end
+          end
+        EOF
+        expect(src).to reek_of(:UtilityFunction)
+      end
+
+      it 'does not report when module_function is called in separate scope' do
+        src = <<-EOF
+          class C
+            def m(a) a.to_s; end
+            begin
+              module_function :m
+            end
+          end
+        EOF
+        expect(src).not_to reek_of(:UtilityFunction)
+      end
+
+      it 'does not report when module_function modifier is called in separate scope' do
+        src = <<-EOF
+          class C
+            begin
+              module_function
+            end
+            def m(a) a.to_s; end
+          end
+        EOF
+        expect(src).not_to reek_of(:UtilityFunction)
+      end
     end
   end
 

data/spec/reek/source/source_locator_spec.rb

@@ -1,87 +1,83 @@
+require 'pathname'
 require_relative '../../spec_helper'
+require_relative '../../../lib/reek/configuration/app_configuration'
 require_relative '../../../lib/reek/source/source_locator'
 
 RSpec.describe Reek::Source::SourceLocator do
   describe '#sources' do
     context 'applied to hidden directories' do
-      let(:path) { 'spec/samples/source_with_hidden_directories' }
-      let(:expected_files) do
-        ['spec/samples/source_with_hidden_directories/uncommunicative_parameter_name.rb']
+      let(:path) { SAMPLES_PATH.join('source_with_hidden_directories') }
+      let(:expected_paths) do
+        [SAMPLES_PATH.join('source_with_hidden_directories/uncommunicative_parameter_name.rb')]
       end
-      let(:files_that_are_expected_to_be_ignored) do
-        ['spec/samples/source_with_hidden_directories/.hidden/uncommunicative_method_name.rb']
+      let(:paths_that_are_expected_to_be_ignored) do
+        [SAMPLES_PATH.join('source_with_hidden_directories/.hidden/\
+          uncommunicative_parameter_nameicative_method_name.rb')]
       end
 
       it 'does not scan hidden directories' do
         sources = described_class.new([path]).sources
 
-        expect(sources.map(&:path)).
-          not_to include(*files_that_are_expected_to_be_ignored)
-
-        expect(sources.map(&:path)).to eq expected_files
+        expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
+        expect(sources).to eq expected_paths
       end
     end
 
     context 'exclude paths' do
-      let(:config) { 'spec/samples/configuration/with_excluded_paths.reek' }
-      let(:path) { 'spec/samples/source_with_exclude_paths' }
-      let(:files_that_are_expected_to_be_ignored) do
+      let(:configuration) do
+        test_configuration_for(SAMPLES_PATH.join('configuration/with_excluded_paths.reek'))
+      end
+      let(:path) { SAMPLES_PATH.join('source_with_exclude_paths') }
+      let(:paths_that_are_expected_to_be_ignored) do
         [
-          'spec/samples/source_with_exclude_paths/ignore_me/uncommunicative_method_name.rb',
-          'spec/samples/source_with_exclude_paths/nested/ignore_me_as_well/irresponsible_module.rb'
+          SAMPLES_PATH.join('source_with_exclude_paths/ignore_me/uncommunicative_method_name.rb'),
+          SAMPLES_PATH.join('source_with_exclude_paths/nested/' \
+                            'ignore_me_as_well/irresponsible_module.rb')
         ]
       end
 
       it 'does not use excluded paths' do
-        with_test_config(config) do
-          sources = described_class.new([path]).sources
-
-          expect(sources.map(&:path).sort).
-            not_to include(*files_that_are_expected_to_be_ignored)
+        sources = described_class.new([path], configuration: configuration).sources
+        expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
 
-          expect(sources.map(&:path).sort).to eq [
-            'spec/samples/source_with_exclude_paths/nested/uncommunicative_parameter_name.rb'
-          ]
-        end
+        expect(sources).to eq [
+          SAMPLES_PATH.join('source_with_exclude_paths/nested/uncommunicative_parameter_name.rb')
+        ]
       end
     end
 
-    context 'non-ruby files' do
-      let(:path) { 'spec/samples/source_with_non_ruby_files' }
-      let(:expected_files) do
-        ['spec/samples/source_with_non_ruby_files/uncommunicative_parameter_name.rb']
+    context 'non-ruby paths' do
+      let(:path) { SAMPLES_PATH.join('source_with_non_ruby_files') }
+      let(:expected_sources) do
+        [SAMPLES_PATH.join('source_with_non_ruby_files/uncommunicative_parameter_name.rb')]
       end
-      let(:files_that_are_expected_to_be_ignored) do
+      let(:paths_that_are_expected_to_be_ignored) do
         [
-          'spec/samples/source_with_non_ruby_files/gibberish',
-          'spec/samples/source_with_non_ruby_files/python_source.py'
+          SAMPLES_PATH.join('source_with_non_ruby_files/gibberish'),
+          SAMPLES_PATH.join('source_with_non_ruby_files/python_source.py')
         ]
       end
 
-      it 'does only use ruby source files' do
+      it 'does only use ruby source paths' do
         sources = described_class.new([path]).sources
 
-        expect(sources.map(&:path)).
-          not_to include(*files_that_are_expected_to_be_ignored)
+        expect(sources).not_to include(*paths_that_are_expected_to_be_ignored)
 
-        expect(sources.map(&:path)).to eq expected_files
+        expect(sources).to eq expected_sources
       end
     end
 
     context 'passing "." or "./" as argument' do
-      let(:expected_files) do
-        [
-          'spec/spec_helper.rb',
-          'lib/reek.rb'
-        ]
+      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(['.']).sources
-        sources_for_dot_slash = described_class.new(['./']).sources
+        sources_for_dot       = described_class.new([Pathname.new('.')]).sources
+        sources_for_dot_slash = described_class.new([Pathname.new('./')]).sources
 
-        expect(sources_for_dot.map(&:path)).to include(*expected_files)
-        expect(sources_for_dot.map(&:path)).to eq(sources_for_dot_slash.map(&:path))
+        expect(sources_for_dot).to include(*expected_sources)
+        expect(sources_for_dot).to eq(sources_for_dot_slash)
       end
     end
   end

data/spec/reek/spec/should_reek_of_spec.rb

@@ -1,3 +1,4 @@
+require 'pathname'
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/spec'
 
@@ -56,8 +57,8 @@ RSpec.describe Reek::Spec::ShouldReekOf do
 
   context 'checking code in a File' do
     before :each do
-      @clean_file = File.new(Dir['spec/samples/three_clean_files/*.rb'][0])
-      @smelly_file = File.new(Dir['spec/samples/two_smelly_files/*.rb'][0])
+      @clean_file = Pathname.glob("#{SAMPLES_PATH}/three_clean_files/*.rb").first
+      @smelly_file = Pathname.glob("#{SAMPLES_PATH}/two_smelly_files/*.rb").first
       @matcher = Reek::Spec::ShouldReekOf.new(:UncommunicativeVariableName,
                                               name: '@s')
     end

data/spec/reek/spec/should_reek_spec.rb

@@ -2,9 +2,8 @@ require_relative '../../spec_helper'
 require_relative '../../../lib/reek/spec'
 
 RSpec.describe Reek::Spec::ShouldReek do
-  let(:matcher) { Reek::Spec::ShouldReek.new }
-
   describe 'checking code in a string' do
+    let(:matcher) { Reek::Spec::ShouldReek.new }
     let(:clean_code) { 'def good() true; end' }
     let(:smelly_code) { 'def x() y = 4; end' }
 
@@ -23,27 +22,36 @@ RSpec.describe Reek::Spec::ShouldReek do
   end
 
   describe 'checking code in a File' do
-    let(:clean_file) { File.new('spec/samples/three_clean_files/clean_one.rb') }
-    let(:smelly_file) { File.new('spec/samples/two_smelly_files/dirty_one.rb') }
-    let(:masked_file) { File.new('spec/samples/clean_due_to_masking/dirty_one.rb') }
+    let(:clean_file) { SAMPLES_PATH.join('three_clean_files/clean_one.rb') }
+    let(:smelly_file) { SAMPLES_PATH.join('two_smelly_files/dirty_one.rb') }
+    let(:masked_file) { SAMPLES_PATH.join('clean_due_to_masking/dirty_one.rb') }
 
-    it 'matches a smelly File' do
-      expect(matcher.matches?(smelly_file)).to be_truthy
-    end
+    context 'matcher without masking' do
+      let(:matcher) { Reek::Spec::ShouldReek.new }
 
-    it 'doesnt match a fragrant File' do
-      expect(matcher.matches?(clean_file)).to be_falsey
-    end
+      it 'matches a smelly File' do
+        expect(matcher.matches?(smelly_file)).to be_truthy
+      end
 
-    it 'masks smells using the relevant configuration' do
-      with_test_config('spec/samples/clean_due_to_masking/masked.reek') do
-        expect(matcher.matches?(masked_file)).to be_falsey
+      it 'doesnt match a fragrant File' do
+        expect(matcher.matches?(clean_file)).to be_falsey
+      end
+
+      it 'reports the smells when should_not fails' do
+        matcher.matches?(smelly_file)
+        expect(matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
       end
     end
 
-    it 'reports the smells when should_not fails' do
-      matcher.matches?(smelly_file)
-      expect(matcher.failure_message_when_negated).to match('UncommunicativeVariableName')
+    context 'matcher without masking' do
+      let(:path) { SAMPLES_PATH.join('clean_due_to_masking/masked.reek') }
+      let(:configuration) { test_configuration_for(path) }
+      let(:matcher) { Reek::Spec::ShouldReek.new configuration }
+      let(:masked_file) { SAMPLES_PATH.join('clean_due_to_masking/dirty_one.rb') }
+
+      it 'masks smells using the relevant configuration' do
+        expect(matcher.matches?(masked_file)).to be_falsey
+      end
     end
   end
 end

data/spec/reek/tree_walker_spec.rb

@@ -1,34 +1,225 @@
 require_relative '../spec_helper'
 require_relative '../../lib/reek/tree_walker'
+require_relative '../../lib/reek/source/source_code'
 
-RSpec.describe Reek::TreeWalker, 'with no method definitions' do
-  it 'reports no problems for empty source code' do
-    expect('').not_to reek
-  end
-  it 'reports no problems for empty class' do
-    expect('# clean class for testing purposes
-class Fred; end').not_to reek
+# Dummy repository to inject into TreeWalker in order to count statements in
+# all contexts.
+class TestSmellRepository
+  attr_reader :num_statements
+  def examine(context)
+    @num_statements = context.num_statements
   end
 end
 
-RSpec.describe Reek::TreeWalker, 'with a global method definition' do
-  it 'reports no problems for simple method' do
-    src = 'def Outermost::fred() true; end'
-    expect(src).not_to reek
-  end
+def process_method(source)
+  exp = Reek::Source::SourceCode.from(source).syntax_tree
+  repository = TestSmellRepository.new
+  Reek::TreeWalker.new(repository, exp).walk
+  repository
 end
 
-RSpec.describe Reek::TreeWalker, 'when a yield is the receiver' do
-  it 'reports no problems' do
-    src = <<EOS
-def values(*args)
-  @to_sql += case
-    when block_given? then yield.to_sql
-    else args.to_sql
-  end
-  self
+def process_singleton_method(source)
+  exp = Reek::Source::SourceCode.from(source).syntax_tree
+  repository = TestSmellRepository.new
+  Reek::TreeWalker.new(repository, exp).walk
+  repository
 end
-EOS
-    expect(src).not_to reek
+
+RSpec.describe Reek::TreeWalker, 'statement counting' do
+  it 'counts 1 assignment' do
+    method = process_method('def one() val = 4; end')
+    expect(method.num_statements).to eq(1)
+  end
+
+  it 'counts 3 assignments' do
+    method = process_method('def one() val = 4; val = 4; val = 4; end')
+    expect(method.num_statements).to eq(3)
+  end
+
+  it 'counts 1 attr assignment' do
+    method = process_method('def one() val[0] = 4; end')
+    expect(method.num_statements).to eq(1)
+  end
+
+  it 'counts 1 increment assignment' do
+    method = process_method('def one() val += 4; end')
+    expect(method.num_statements).to eq(1)
+  end
+
+  it 'counts 1 increment attr assignment' do
+    method = process_method('def one() val[0] += 4; end')
+    expect(method.num_statements).to eq(1)
+  end
+
+  it 'counts 1 nested assignment' do
+    method = process_method('def one() val = fred = 4; end')
+    expect(method.num_statements).to eq(1)
+  end
+
+  it 'counts returns' do
+    method = process_method('def one() val = 4; true; end')
+    expect(method.num_statements).to eq(2)
+  end
+
+  it 'counts nil returns' do
+    method = process_method('def one() val = 4; nil; end')
+    expect(method.num_statements).to eq(2)
+  end
+
+  context 'with control statements' do
+    it 'counts 1 statement in a conditional expression' do
+      method = process_method('def one() if val == 4; callee(); end; end')
+      expect(method.num_statements).to eq(1)
+    end
+
+    it 'counts 3 statements in a conditional expression' do
+      method = process_method('def one() if val == 4; callee(); callee(); callee(); end; end')
+      expect(method.num_statements).to eq(3)
+    end
+
+    it 'counts 1 statements in an else' do
+      method = process_method('def one() if val == 4; callee(); else; callee(); end; end')
+      expect(method.num_statements).to eq(2)
+    end
+
+    it 'counts 3 statements in an else' do
+      method = process_method('
+        def one()
+          if val == 4
+            callee(); callee(); callee()
+          else
+            callee(); callee(); callee()
+          end
+        end
+                              ')
+      expect(method.num_statements).to eq(6)
+    end
+
+    it 'does not count empty conditional expression' do
+      method = process_method('def one() if val == 4; ; end; end')
+      expect(method.num_statements).to eq(0)
+    end
+
+    it 'does not count empty else' do
+      method = process_method('def one() if val == 4; ; else; ; end; end')
+      expect(method.num_statements).to eq(0)
+    end
+
+    it 'counts extra statements in an if condition' do
+      method = process_method('def one() if begin val = callee(); val < 4 end; end; end')
+      expect(method.num_statements).to eq(1)
+    end
+
+    it 'counts 1 statement in a while loop' do
+      method = process_method('def one() while val < 4; callee(); end; end')
+      expect(method.num_statements).to eq(1)
+    end
+
+    it 'counts 3 statements in a while loop' do
+      source = 'def one() while val < 4; callee(); callee(); callee(); end; end'
+      expect(process_method(source).num_statements).to eq(3)
+    end
+
+    it 'counts extra statements in a while condition' do
+      method = process_method('def one() while begin val = callee(); val < 4 end; end; end')
+      expect(method.num_statements).to eq(1)
+    end
+
+    it 'counts 1 statement in a until loop' do
+      method = process_method('def one() until val < 4; callee(); end; end')
+      expect(method.num_statements).to eq(1)
+    end
+
+    it 'counts 3 statements in a until loop' do
+      source = 'def one() until val < 4; callee(); callee(); callee(); end; end'
+      expect(process_method(source).num_statements).to eq(3)
+    end
+
+    it 'counts 1 statement in a for loop' do
+      method = process_method('def one() for i in 0..4; callee(); end; end')
+      expect(method.num_statements).to eq(1)
+    end
+
+    it 'counts 3 statements in a for loop' do
+      source = 'def one() for i in 0..4; callee(); callee(); callee(); end; end'
+      expect(process_method(source).num_statements).to eq(3)
+    end
+
+    it 'counts 1 statement in a rescue' do
+      method = process_method('def one() begin; callee(); rescue; callee(); end; end')
+      expect(method.num_statements).to eq(2)
+    end
+
+    it 'counts 3 statements in a rescue' do
+      method = process_method('
+        def one()
+          begin
+            callee(); callee(); callee()
+          rescue
+            callee(); callee(); callee()
+          end
+        end
+                              ')
+      expect(method.num_statements).to eq(6)
+    end
+
+    it 'counts 1 statement in a when' do
+      method = process_method('def one() case fred; when "hi"; callee(); end; end')
+      expect(method.num_statements).to eq(1)
+    end
+
+    it 'counts 3 statements in a when' do
+      method = process_method('
+        def one()
+          case fred
+          when "hi" then callee(); callee()
+          when "lo" then callee()
+          end
+        end
+                              ')
+      expect(method.num_statements).to eq(3)
+    end
+
+    it 'counts 1 statement in a case else' do
+      source = 'def one() case fred; when "hi"; callee(); else; callee(); end; end'
+      expect(process_method(source).num_statements).to eq(2)
+    end
+
+    it 'counts 3 statements in a case else' do
+      method = process_method('
+        def one()
+          case fred
+          when "hi" then callee(); callee(); callee()
+          else           callee(); callee(); callee()
+          end
+        end
+                              ')
+      expect(method.num_statements).to eq(6)
+    end
+
+    it 'does not count empty case' do
+      method = process_method('def one() case fred; when "hi"; ; when "lo"; ; end; end')
+      expect(method.num_statements).to eq(0)
+    end
+
+    it 'does not count empty case else' do
+      method = process_method('def one() case fred; when "hi"; ; else; ; end; end')
+      expect(method.num_statements).to eq(0)
+    end
+
+    it 'counts 2 statement in an iterator' do
+      method = process_method('def one() fred.each do; callee(); end; end')
+      expect(method.num_statements).to eq(2)
+    end
+
+    it 'counts 4 statements in an iterator' do
+      source = 'def one() fred.each do; callee(); callee(); callee(); end; end'
+      expect(process_method(source).num_statements).to eq(4)
+    end
+
+    it 'counts 1 statement in a singleton method' do
+      method = process_singleton_method('def self.foo; callee(); end')
+      expect(method.num_statements).to eq(1)
+    end
   end
 end