reek 3.2.1 → 3.3.0

data/spec/reek/cli/warning_collector_spec.rb

@@ -3,26 +3,22 @@ require_relative '../../../lib/reek/cli/warning_collector'
 require_relative '../../../lib/reek/smells/smell_warning'
 
 RSpec.describe Reek::CLI::WarningCollector do
-  before(:each) do
-    @collector = described_class.new
-  end
+  let(:collector) { described_class.new }
 
   context 'when empty' do
     it 'reports no warnings' do
-      expect(@collector.warnings).to eq([])
+      expect(collector.warnings).to eq([])
     end
   end
 
   context 'with one warning' do
-    before :each do
-      @warning = Reek::Smells::SmellWarning.new(Reek::Smells::FeatureEnvy.new(''),
-                                                context: 'fred',
-                                                lines:   [1, 2, 3],
-                                                message: 'hello')
-      @collector.found_smell(@warning)
-    end
     it 'reports that warning' do
-      expect(@collector.warnings).to eq([@warning])
+      warning = Reek::Smells::SmellWarning.new(Reek::Smells::FeatureEnvy.new(''),
+                                               context: 'fred',
+                                               lines:   [1, 2, 3],
+                                               message: 'hello')
+      collector.found_smell(warning)
+      expect(collector.warnings).to eq([warning])
     end
   end
 end

data/spec/reek/code_comment_spec.rb

@@ -3,14 +3,12 @@ require_relative '../../lib/reek/code_comment'
 
 RSpec.describe Reek::CodeComment do
   context 'with an empty comment' do
-    before :each do
-      @comment = described_class.new('')
-    end
+    let(:comment) { described_class.new('') }
     it 'is not descriptive' do
-      expect(@comment).not_to be_descriptive
+      expect(comment).not_to be_descriptive
     end
     it 'has an empty config' do
-      expect(@comment.config).to be_empty
+      expect(comment.config).to be_empty
     end
   end
 

data/spec/reek/configuration/app_configuration_spec.rb

@@ -1,13 +1,19 @@
 require 'pathname'
 require_relative '../../spec_helper'
 require_relative '../../../lib/reek/configuration/app_configuration'
-require_relative '../../../lib/reek/smells/smell_repository'
-require_relative '../../../lib/reek/source/source_code'
+require_relative '../../../lib/reek/configuration/directory_directives'
+require_relative '../../../lib/reek/configuration/default_directive'
+require_relative '../../../lib/reek/configuration/excluded_paths'
 
 RSpec.describe Reek::Configuration::AppConfiguration do
-  describe '#initialize' do
-    let(:full_configuration_path) { SAMPLES_PATH.join('configuration/full_configuration.reek') }
-    let(:expected_exclude_paths) do
+  describe '#new' do
+    it 'raises NotImplementedError' do
+      expect { subject }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe 'factory methods' do
+    let(:expected_excluded_paths) do
       [SAMPLES_PATH.join('two_smelly_files'),
        SAMPLES_PATH.join('source_with_non_ruby_files')]
     end
@@ -19,13 +25,28 @@ RSpec.describe Reek::Configuration::AppConfiguration do
         { Reek::Smells::UtilityFunction => { 'enabled' => false } } }
     end
 
-    it 'properly loads configuration and processes it' do
-      finder = Reek::Configuration::ConfigurationFileFinder
-      allow(finder).to receive(:find_by_cli).and_return full_configuration_path
+    describe '#from_path' do
+      let(:full_configuration_path) { SAMPLES_PATH.join('configuration/full_configuration.reek') }
+
+      it 'properly loads configuration and processes it' do
+        config = described_class.from_path full_configuration_path
+
+        expect(config.send(:excluded_paths)).to eq(expected_excluded_paths)
+        expect(config.send(:default_directive)).to eq(expected_default_directive)
+        expect(config.send(:directory_directives)).to eq(expected_directory_directives)
+      end
+    end
+
+    describe '#from_map' do
+      it 'properly sets the configuration' do
+        config = described_class.from_map(directory_directives: expected_directory_directives,
+                                          default_directive: expected_default_directive,
+                                          excluded_paths: expected_excluded_paths)
 
-      expect(subject.exclude_paths).to eq(expected_exclude_paths)
-      expect(subject.default_directive).to eq(expected_default_directive)
-      expect(subject.directory_directives).to eq(expected_directory_directives)
+        expect(config.send(:excluded_paths)).to eq(expected_excluded_paths)
+        expect(config.send(:default_directive)).to eq(expected_default_directive)
+        expect(config.send(:directory_directives)).to eq(expected_directory_directives)
+      end
     end
   end
 
@@ -43,64 +64,29 @@ RSpec.describe Reek::Configuration::AppConfiguration do
       let(:source_via) { 'foo/bar/bang/dummy.rb' }
 
       it 'returns the corresponding directive' do
-        allow(subject).to receive(:directory_directives).and_return directory_directives
-        expect(subject.directive_for(source_via)).to eq(bang_config)
+        configuration = described_class.from_map directory_directives: directory_directives
+        expect(configuration.directive_for(source_via)).to eq(bang_config)
       end
     end
 
     context 'our source is not in a directory for which we have a directive' do
-      let(:baz_config)  { { Reek::Smells::IrresponsibleModule => { enabled: false } } }
+      let(:irresponsible_module_config) do
+        { Reek::Smells::IrresponsibleModule => { enabled: false } }
+      end
+      let(:attribute_config) { { Reek::Smells::Attribute => { enabled: false } } }
       let(:default_directive) do
-        { Reek::Smells::Attribute => { enabled: true } }
+        irresponsible_module_config
       end
       let(:directory_directives) do
-        { Pathname.new('foo/bar/baz')  => baz_config }
+        { Pathname.new('foo/bar/baz') => attribute_config }
       end
       let(:source_via) { 'foo/bar/bang/dummy.rb' }
 
       it 'returns the default directive' do
-        allow(subject).to receive(:directory_directives).and_return directory_directives
-        allow(subject).to receive(:default_directive).and_return default_directive
-        expect(subject.directive_for(source_via)).to eq(default_directive)
+        configuration = described_class.from_map directory_directives: directory_directives,
+                                                 default_directive: default_directive
+        expect(configuration.directive_for(source_via)).to eq(irresponsible_module_config)
       end
     end
   end
-
-  describe '#best_directory_match_for' do
-    let(:directory_directives) do
-      {
-        Pathname.new('foo/bar/baz')  => {},
-        Pathname.new('foo/bar')      => {},
-        Pathname.new('bar/boo')      => {}
-      }
-    end
-
-    before do
-      allow(subject).to receive(:directory_directives).and_return directory_directives
-    end
-
-    it 'returns the corresponding directory when source_base_dir is a leaf' do
-      source_base_dir = 'foo/bar/baz/bang'
-      hit = subject.send :best_directory_match_for, source_base_dir
-      expect(hit.to_s).to eq('foo/bar/baz')
-    end
-
-    it 'returns the corresponding directory when source_base_dir is in the middle of the tree' do
-      source_base_dir = 'foo/bar'
-      hit = subject.send :best_directory_match_for, source_base_dir
-      expect(hit.to_s).to eq('foo/bar')
-    end
-
-    it 'returns nil we are on top at the top of the and all other directories are below' do
-      source_base_dir = 'foo'
-      hit = subject.send :best_directory_match_for, source_base_dir
-      expect(hit).to be_nil
-    end
-
-    it 'returns nil when there source_base_dir is not part of any directory directive at all' do
-      source_base_dir = 'non/existent'
-      hit = subject.send :best_directory_match_for, source_base_dir
-      expect(hit).to be_nil
-    end
-  end
 end

data/spec/reek/configuration/configuration_file_finder_spec.rb

@@ -7,16 +7,14 @@ require_relative '../../spec_helper'
 
 RSpec.describe Reek::Configuration::ConfigurationFileFinder do
   describe '.find' do
-    it 'returns the config_file if it’s set' do
-      config_file = double
-      options = double(config_file: config_file)
-      found = described_class.find(options: options)
-      expect(found).to eq(config_file)
+    it 'returns the path if it’s set' do
+      path = Pathname.new 'foo/bar'
+      found = described_class.find(path: path)
+      expect(found).to eq(path)
     end
 
     it 'returns the file in current dir if config_file is nil' do
-      options = double(config_file: nil)
-      found = described_class.find(options: options, current: SAMPLES_PATH)
+      found = described_class.find(current: SAMPLES_PATH)
       expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
     end
 

data/spec/reek/configuration/default_directive_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/configuration/default_directive'
+
+RSpec.describe Reek::Configuration::DefaultDirective do
+  describe '#add' do
+    subject { {}.extend(described_class) }
+
+    it 'adds a smell configuration' do
+      subject.add :UncommunicativeVariableName, enabled: false
+      expect(subject).to eq(Reek::Smells::UncommunicativeVariableName => { enabled: false })
+    end
+  end
+end

data/spec/reek/configuration/directory_directives_spec.rb

@@ -0,0 +1,89 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/configuration/directory_directives'
+
+RSpec.describe Reek::Configuration::DirectoryDirectives do
+  describe '#directive_for' do
+    let(:baz_config)  { { Reek::Smells::IrresponsibleModule => { enabled: false } } }
+    let(:bang_config) { { Reek::Smells::Attribute => { enabled: true } } }
+    subject do
+      {
+        Pathname.new('foo/bar/baz')  => baz_config,
+        Pathname.new('foo/bar/bang') => bang_config
+      }.extend(described_class)
+    end
+    let(:source_via) { 'foo/bar/bang/dummy.rb' }
+
+    context 'our source is in a directory for which we have a directive' do
+      it 'returns the corresponding directive' do
+        expect(subject.directive_for(source_via)).to eq(bang_config)
+      end
+    end
+
+    context 'our source is not in a directory for which we have a directive' do
+      it 'returns nil' do
+        expect(subject.directive_for('does/not/exist')).to eq(nil)
+      end
+    end
+  end
+
+  describe '#add' do
+    subject do
+      {}.extend(described_class)
+    end
+    let(:empty_config) { Hash.new }
+
+    context 'one of given paths does not exist' do
+      let(:bogus_path) { Pathname('does/not/exist') }
+
+      it 'raises an error' do
+        Reek::CLI::Silencer.silently(stderr: true) do
+          expect { subject.add(bogus_path, {}) }.to raise_error(SystemExit)
+        end
+      end
+    end
+
+    context 'one of given paths is a file' do
+      let(:file_as_path) { SAMPLES_PATH.join('inline.rb') }
+
+      it 'raises an error' do
+        Reek::CLI::Silencer.silently(stderr: true) do
+          expect { subject.add(file_as_path, {}) }.to raise_error(SystemExit)
+        end
+      end
+    end
+  end
+
+  describe '#best_match_for' do
+    subject do
+      {
+        Pathname.new('foo/bar/baz')  => {},
+        Pathname.new('foo/bar')      => {},
+        Pathname.new('bar/boo')      => {}
+      }.extend(described_class)
+    end
+
+    it 'returns the corresponding directory when source_base_dir is a leaf' do
+      source_base_dir = 'foo/bar/baz/bang'
+      hit = subject.send :best_match_for, source_base_dir
+      expect(hit.to_s).to eq('foo/bar/baz')
+    end
+
+    it 'returns the corresponding directory when source_base_dir is in the middle of the tree' do
+      source_base_dir = 'foo/bar'
+      hit = subject.send :best_match_for, source_base_dir
+      expect(hit.to_s).to eq('foo/bar')
+    end
+
+    it 'returns nil we are on top of the tree and all other directories are below' do
+      source_base_dir = 'foo'
+      hit = subject.send :best_match_for, source_base_dir
+      expect(hit).to be_nil
+    end
+
+    it 'returns nil when source_base_dir is not part of any directory directive at all' do
+      source_base_dir = 'non/existent'
+      hit = subject.send :best_match_for, source_base_dir
+      expect(hit).to be_nil
+    end
+  end
+end

data/spec/reek/configuration/excluded_paths_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../../spec_helper'
+require_relative '../../../lib/reek/configuration/excluded_paths'
+
+RSpec.describe Reek::Configuration::ExcludedPaths do
+  describe '#add' do
+    subject { [].extend(described_class) }
+
+    context 'one of the given paths does not exist' do
+      let(:bogus_path) { Pathname('does/not/exist') }
+      let(:paths) { [SAMPLES_PATH, bogus_path] }
+
+      it 'raises an error' do
+        Reek::CLI::Silencer.silently(stderr: true) do
+          expect { subject.add(paths) }.to raise_error(SystemExit)
+        end
+      end
+    end
+
+    context 'one of given paths is a file' do
+      let(:file_as_path) { SAMPLES_PATH.join('inline.rb') }
+      let(:paths) { [SAMPLES_PATH, file_as_path] }
+
+      it 'raises an error if one of the given paths is a file' do
+        Reek::CLI::Silencer.silently(stderr: true) do
+          expect { subject.add(paths) }.to raise_error(SystemExit)
+        end
+      end
+    end
+  end
+end

data/spec/reek/context/code_context_spec.rb

@@ -4,107 +4,109 @@ require_relative '../../../lib/reek/context/module_context'
 
 RSpec.describe Reek::Context::CodeContext do
   context 'name recognition' do
+    let(:ctx)       { Reek::Context::CodeContext.new(nil, exp) }
+    let(:exp)       { double('exp') }
+    let(:exp_name)  { 'random_name' }
+    let(:full_name) { "::::::::::::::::::::#{exp_name}" }
+
     before :each do
-      @exp_name = 'random_name'    # SMELL: could use a String.random here
-      @full_name = "::::::::::::::::::::#{@exp_name}"
-      @exp = double('exp')
-      allow(@exp).to receive(:name).and_return(@exp_name)
-      allow(@exp).to receive(:full_name).and_return(@full_name)
-      @ctx = Reek::Context::CodeContext.new(nil, @exp)
+      allow(exp).to receive(:name).and_return(exp_name)
+      allow(exp).to receive(:full_name).and_return(full_name)
     end
+
     it 'gets its short name from the exp' do
-      expect(@ctx.name).to eq(@exp_name)
+      expect(ctx.name).to eq(exp_name)
     end
     it 'does not match an empty list' do
-      expect(@ctx.matches?([])).to eq(false)
+      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)
+      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)
+      expect(ctx.matches?(['banana|'])).to eq(false)
     end
     it 'recognises its own short name' do
-      expect(@ctx.matches?(['banana', @exp_name])).to eq(true)
+      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)
+      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)
+      expect(ctx.matches?(['banana[]', exp_name])).to eq(true)
     end
 
     context 'when there is an outer' do
-      let(:outer) { double('outer') }
+      let(:ctx)        { Reek::Context::CodeContext.new(outer, exp) }
+      let(:outer_name) { 'another_random sting' }
+      let(:outer)      { double('outer') }
+
       before :each do
-        @outer_name = 'another_random sting'
-        allow(outer).to receive(:full_name).at_least(:once).and_return(@outer_name)
+        allow(outer).to receive(:full_name).at_least(:once).and_return(outer_name)
         allow(outer).to receive(:config).and_return({})
-        @ctx = Reek::Context::CodeContext.new(outer, @exp)
       end
+
       it 'creates the correct full name' do
-        expect(@ctx.full_name).to eq("#{@full_name}")
+        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)
+        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)
+        expect(ctx.matches?([/banana/, /#{full_name}/])).to eq(true)
       end
     end
   end
 
   context 'enumerating syntax elements' do
     context 'in an empty module' do
-      before :each do
-        @module_name = 'Emptiness'
-        src = "module #{@module_name}; end"
+      let(:ctx) do
+        src = 'module Emptiness; end'
         ast = Reek::Source::SourceCode.from(src).syntax_tree
-        @ctx = Reek::Context::CodeContext.new(nil, ast)
+        Reek::Context::CodeContext.new(nil, ast)
       end
 
       it 'yields no calls' do
-        @ctx.each_node(:send, []) { |exp| raise "#{exp} yielded by empty module!" }
+        ctx.each_node(:send, []) { |exp| raise "#{exp} yielded by empty module!" }
       end
 
       it 'yields one module' do
         mods = 0
-        @ctx.each_node(:module, []) { |_exp| mods += 1 }
+        ctx.each_node(:module, []) { |_exp| mods += 1 }
         expect(mods).to eq(1)
       end
 
       it "yields the module's full AST" do
-        @ctx.each_node(:module, []) do |exp|
-          expect(exp).to eq(s(:module, s(:const, nil, @module_name.to_sym), nil))
+        ctx.each_node(:module, []) do |exp|
+          expect(exp).to eq(s(:module, s(:const, nil, :Emptiness), nil))
         end
       end
 
       context 'with no block' do
         it 'returns an empty array of ifs' do
-          expect(@ctx.each_node(:if, [])).to be_empty
+          expect(ctx.each_node(:if, [])).to be_empty
         end
       end
     end
 
     context 'with a nested element' do
-      before :each do
-        @module_name = 'Loneliness'
-        @method_name = 'calloo'
-        src = "module #{@module_name}; def #{@method_name}; puts('hello') end; end"
+      let(:ctx) do
+        src = "module Loneliness; def calloo; puts('hello') end; end"
         ast = Reek::Source::SourceCode.from(src).syntax_tree
-        @ctx = Reek::Context::CodeContext.new(nil, ast)
+        Reek::Context::CodeContext.new(nil, ast)
       end
+
       it 'yields no ifs' do
-        @ctx.each_node(:if, []) { |exp| raise "#{exp} yielded by empty module!" }
+        ctx.each_node(:if, []) { |exp| raise "#{exp} yielded by empty module!" }
       end
       it 'yields one module' do
-        expect(@ctx.each_node(:module, []).length).to eq(1)
+        expect(ctx.each_node(:module, []).length).to eq(1)
       end
 
       it "yields the module's full AST" do
-        @ctx.each_node(:module, []) do |exp|
+        ctx.each_node(:module, []) do |exp|
           expect(exp).to eq s(:module,
-                              s(:const, nil, @module_name.to_sym),
+                              s(:const, nil, :Loneliness),
                               s(:def, :calloo,
                                 s(:args),
                                 s(:send, nil, :puts, s(:str, 'hello'))))
@@ -112,37 +114,36 @@ RSpec.describe Reek::Context::CodeContext do
       end
 
       it 'yields one method' do
-        expect(@ctx.each_node(:def, []).length).to eq(1)
+        expect(ctx.each_node(:def, []).length).to eq(1)
       end
 
       it "yields the method's full AST" do
-        @ctx.each_node(:def, []) { |exp| expect(exp[1]).to eq(@method_name.to_sym) }
+        ctx.each_node(:def, []) { |exp| expect(exp[1]).to eq(:calloo) }
       end
 
       context 'pruning the traversal' do
         it 'ignores the call inside the method' do
-          expect(@ctx.each_node(:send, [:def])).to be_empty
+          expect(ctx.each_node(:send, [:def])).to be_empty
         end
       end
     end
 
     it 'finds 3 ifs in a class' do
-      src = <<EOS
-class Scrunch
-  def first
-    return @field == :sym ? 0 : 3;
-  end
-  def second
-    if @field == :sym
-      @other += " quarts"
-    end
-  end
-  def third
-    raise 'flu!' unless @field == :sym
-  end
-end
-EOS
-
+      src = <<-EOS
+        class Scrunch
+          def first
+            return @field == :sym ? 0 : 3;
+          end
+          def second
+            if @field == :sym
+              @other += " quarts"
+            end
+          end
+          def third
+            raise 'flu!' unless @field == :sym
+          end
+        end
+      EOS
       ast = Reek::Source::SourceCode.from(src).syntax_tree
       ctx = Reek::Context::CodeContext.new(nil, ast)
       expect(ctx.each_node(:if, []).length).to eq(3)
@@ -152,11 +153,11 @@ EOS
   describe '#config_for' do
     let(:src) do
       <<-EOS
-      # :reek:DuplicateMethodCall: { allow_calls: [ puts ] }')
-      def repeated_greeting
-        puts 'Hello!'
-        puts 'Hello!'
-      end
+        # :reek:DuplicateMethodCall: { allow_calls: [ puts ] }')
+        def repeated_greeting
+          puts 'Hello!'
+          puts 'Hello!'
+        end
       EOS
     end
     let(:expression) { Reek::Source::SourceCode.from(src).syntax_tree }