reek 4.7.3 → 5.0.0

data/spec/reek/configuration/rake_task_converter_spec.rb

@@ -0,0 +1,33 @@
+require_relative '../../spec_helper'
+require_lib 'reek/configuration/rake_task_converter'
+
+RSpec.describe Reek::Configuration::RakeTaskConverter do
+  describe 'convert' do
+    let(:configuration_for_smell_detector) do
+      {
+        'exclude' => [/Klass#foobar$/, /^Klass#omg$/],
+        'reject' => [/^[a-z]$/, /[0-9]$/, /[A-Z]/],
+        'accept' => [/^_$/]
+      }
+    end
+
+    let(:expected_exclude) { ['/Klass#foobar$/', '/^Klass#omg$/'] }
+    let(:expected_reject) { ['/^[a-z]$/', '/[0-9]$/', '/[A-Z]/'] }
+    let(:expected_accept) { ['/^_$/'] }
+
+    it 'converts exclude regexes to strings' do
+      converted_configuration = described_class.convert configuration_for_smell_detector
+      expect(converted_configuration['exclude']).to eq(expected_exclude)
+    end
+
+    it 'converts reject regexes to strings' do
+      converted_configuration = described_class.convert configuration_for_smell_detector
+      expect(converted_configuration['reject']).to eq(expected_reject)
+    end
+
+    it 'converts accept regexes to strings' do
+      converted_configuration = described_class.convert configuration_for_smell_detector
+      expect(converted_configuration['accept']).to eq(expected_accept)
+    end
+  end
+end

data/spec/reek/configuration/schema_validator_spec.rb

@@ -0,0 +1,165 @@
+require_relative '../../spec_helper'
+require_lib 'reek/configuration/schema_validator'
+require_lib 'reek/errors/config_file_error'
+
+RSpec.describe Reek::Configuration::SchemaValidator do
+  describe 'validate' do
+    subject(:validator) { described_class.new configuration }
+
+    context 'when configuration is valid' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+            'UncommunicativeVariableName' => { 'enabled' => false },
+            'UncommunicativeMethodName'   => { 'enabled' => false }
+          }
+        }
+      end
+
+      it 'returns nil' do
+        expect(validator.validate).to eq(nil)
+      end
+    end
+
+    context 'when detector is invalid' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+            'DoesNotExist' => { 'enabled' => false }
+          }
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/detectors/DoesNotExist\] key 'DoesNotExist:' is undefined}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'when `enabled` has a non-boolean value' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+            'FeatureEnvy' => { 'enabled' => 'foo' }
+          }
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/detectors/FeatureEnvy/enabled\] 'foo': not a boolean}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'when detector has an unknown option' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+            'DataClump' => { 'does_not_exist' => 42 }
+          }
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/detectors/DataClump/does_not_exist\] key 'does_not_exist:' is undefined}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'when `exclude`, `reject` and `accept`' do
+      %w(exclude reject accept).each do |attribute|
+        context 'when a scalar' do
+          let(:configuration) do
+            {
+              Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+                'UncommunicativeMethodName' => { attribute => 42 }
+              }
+            }
+          end
+
+          it 'raises an error' do
+            message = %r{\[/detectors/UncommunicativeMethodName/#{attribute}\] '42': not a sequence}
+            expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+          end
+        end
+
+        context 'when types are mixed' do
+          let(:configuration) do
+            {
+              Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+                'UncommunicativeMethodName' => { attribute => [42, 'foo'] }
+              }
+            }
+          end
+
+          it 'raises an error' do
+            message = %r{\[/detectors/UncommunicativeMethodName/#{attribute}/0\] '42': not a string}
+            expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+          end
+        end
+      end
+    end
+
+    context 'when `exclude_paths` is a scalar' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::EXCLUDE_PATHS_KEY => 42
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/exclude_paths\] '42': not a sequence}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'when `exclude_paths` mixes types' do
+      let(:configuration) do
+        {
+          Reek::Configuration::AppConfiguration::EXCLUDE_PATHS_KEY => [42, 'foo']
+        }
+      end
+
+      it 'raises an error' do
+        message = %r{\[/exclude_paths/0\] '42': not a string}
+        expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+      end
+    end
+
+    context 'with directory directives' do
+      context 'when bad detector' do
+        let(:configuration) do
+          {
+            Reek::Configuration::AppConfiguration::DIRECTORIES_KEY => {
+              'web_app/app/helpers' => {
+                'Bar' => { 'enabled' => false }
+              }
+            }
+          }
+        end
+
+        it 'raises an error' do
+          message = %r{\[/directories/web_app/app/helpers/Bar\] key 'Bar:' is undefined}
+          expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+        end
+      end
+
+      context 'when unknown attribute' do
+        let(:configuration) do
+          {
+            Reek::Configuration::AppConfiguration::DIRECTORIES_KEY => {
+              'web_app/app/controllers' => {
+                'NestedIterators' => { 'foo' => false }
+              }
+            }
+          }
+        end
+
+        it 'raises an error' do
+          message = %r{\[/directories/web_app/app/controllers/NestedIterators/foo\] key 'foo:' is undefined}
+          expect { validator.validate }.to raise_error(Reek::Errors::ConfigFileError, message)
+        end
+      end
+    end
+  end
+end

data/spec/reek/context/code_context_spec.rb

@@ -3,7 +3,7 @@ require_lib 'reek/context/method_context'
 require_lib 'reek/context/module_context'
 
 RSpec.describe Reek::Context::CodeContext do
-  context 'name recognition' do
+  describe '#full_name' do
     let(:ctx)       { described_class.new(exp) }
     let(:exp)       { instance_double('Reek::AST::SexpExtensions::ModuleNode') }
     let(:exp_name)  { 'random_name' }
@@ -14,9 +14,54 @@ RSpec.describe Reek::Context::CodeContext do
       allow(exp).to receive(:full_name).and_return(full_name)
     end
 
+    it 'creates the correct full name' do
+      expect(ctx.full_name).to eq(full_name)
+    end
+
+    context 'when there is an outer' do
+      let(:outer_name) { 'another_random sting' }
+      let(:outer)      { described_class.new(instance_double('Reek::AST::Node')) }
+
+      before do
+        ctx.register_with_parent outer
+        allow(outer).to receive(:full_name).at_least(:once).and_return(outer_name)
+      end
+
+      it 'creates the correct full name' do
+        expect(ctx.full_name).to eq(full_name)
+      end
+
+      it 'passes the outer name to exp#full_name' do
+        ctx.full_name
+        expect(exp).to have_received(:full_name).with outer_name
+      end
+    end
+  end
+
+  describe '#name' do
+    let(:ctx)       { described_class.new(exp) }
+    let(:exp)       { instance_double('Reek::AST::SexpExtensions::ModuleNode') }
+    let(:exp_name)  { 'random_name' }
+
+    before do
+      allow(exp).to receive(:name).and_return(exp_name)
+    end
+
     it 'gets its short name from the exp' do
       expect(ctx.name).to eq(exp_name)
     end
+  end
+
+  describe '#matches?' do
+    let(:ctx)       { described_class.new(exp) }
+    let(:exp)       { instance_double('Reek::AST::SexpExtensions::ModuleNode') }
+    let(:exp_name)  { 'random_name' }
+    let(:full_name) { "::::::::::::::::::::#{exp_name}" }
+
+    before do
+      allow(exp).to receive(:name).and_return(exp_name)
+      allow(exp).to receive(:full_name).and_return(full_name)
+    end
 
     it 'does not match an empty list' do
       expect(ctx.matches?([])).to eq(false)
@@ -31,19 +76,30 @@ RSpec.describe Reek::Context::CodeContext do
     end
 
     it 'recognises its own short name' do
+      expect(ctx.matches?([exp_name])).to eq(true)
+    end
+
+    it 'recognises its own short name in a list' 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)
+      expect(ctx.matches?([/#{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
 
+    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
+
     context 'when there is an outer' do
-      let(:ctx)        { described_class.new(exp) }
       let(:outer_name) { 'another_random sting' }
       let(:outer)      { described_class.new(instance_double('Reek::AST::Node')) }
 
@@ -52,10 +108,6 @@ RSpec.describe Reek::Context::CodeContext do
         allow(outer).to receive(:full_name).at_least(:once).and_return(outer_name)
       end
 
-      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
@@ -66,98 +118,10 @@ RSpec.describe Reek::Context::CodeContext do
     end
   end
 
-  context 'enumerating syntax elements' do
-    context 'in an empty module' do
-      let(:ctx) do
-        src = 'module Emptiness; end'
-        ast = Reek::Source::SourceCode.from(src).syntax_tree
-        described_class.new(ast)
-      end
-
-      it 'yields no calls' do
-        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 }
-        expect(mods).to eq(1)
-      end
-
-      it "yields the module's full AST" do
-        ctx.each_node(:module, []) do |exp|
-          expect(exp).to eq(sexp(:module, sexp(:const, nil, :Emptiness), nil))
-        end
-      end
-
-      it 'returns an empty array of ifs when no block is passed' do
-        expect(ctx.each_node(:if, [])).to be_empty
-      end
-    end
-
-    context 'with a nested element' do
-      let(:ctx) do
-        src = "module Loneliness; def calloo; puts('hello') end; end"
-        ast = Reek::Source::SourceCode.from(src).syntax_tree
-        described_class.new(ast)
-      end
-
-      it 'yields no ifs' do
-        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)
-      end
-
-      it "yields the module's full AST" do
-        ctx.each_node(:module, []) do |exp|
-          expect(exp).to eq sexp(:module,
-                                 sexp(:const, nil, :Loneliness),
-                                 sexp(:def, :calloo,
-                                      sexp(:args),
-                                      sexp(:send, nil, :puts, sexp(:str, 'hello'))))
-        end
-      end
-
-      it 'yields one method' do
-        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.children.first).to eq(:calloo) }
-      end
-
-      it 'ignores the call inside the method if the traversal is pruned' do
-        expect(ctx.each_node(:send, [:def])).to be_empty
-      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
-      ast = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = described_class.new(ast)
-      expect(ctx.each_node(:if, []).length).to eq(3)
-    end
-  end
-
   describe '#config_for' do
     let(:src) do
       <<-EOS
-        # :reek:DuplicateMethodCall: { allow_calls: [ puts ] }')
+        # :reek:DuplicateMethodCall { allow_calls: [ puts ] }')
         def repeated_greeting
           puts 'Hello!'
           puts 'Hello!'

data/spec/reek/context/ghost_context_spec.rb

@@ -42,7 +42,7 @@ RSpec.describe Reek::Context::GhostContext do
       expect(ghost.children).to include child
     end
 
-    context 'if the grandparent is also a ghost' do
+    context 'when the grandparent is also a ghost' do
       let(:child_ghost) { described_class.new(nil) }
 
       before do

data/spec/reek/context/root_context_spec.rb

@@ -2,7 +2,7 @@ require_relative '../../spec_helper'
 require_lib 'reek/context/root_context'
 
 RSpec.describe Reek::Context::RootContext do
-  context 'full_name' do
+  describe '#full_name' do
     it 'reports full context' do
       ast = Reek::Source::SourceCode.from('foo = 1').syntax_tree
       root = described_class.new(ast)

data/spec/reek/documentation_link_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../spec_helper'
+
+RSpec.describe Reek::DocumentationLink do
+  describe '.build' do
+    it 'returns the correct link for a smell type' do
+      expect(described_class.build('FeatureEnvy')).
+        to eq "https://github.com/troessner/reek/blob/v#{Reek::Version::STRING}/docs/Feature-Envy.md"
+    end
+
+    it 'returns the correct link for general documentation' do
+      expect(described_class.build('Rake Task')).
+        to eq "https://github.com/troessner/reek/blob/v#{Reek::Version::STRING}/docs/Rake-Task.md"
+    end
+
+    it 'returns the correct link for subjects with abbreviations' do
+      expect(described_class.build('YAML Report')).
+        to eq "https://github.com/troessner/reek/blob/v#{Reek::Version::STRING}/docs/YAML-Report.md"
+    end
+  end
+end

data/spec/reek/errors/base_error_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../spec_helper'
+
+require_lib 'reek/errors/base_error'
+
+RSpec.describe Reek::Errors::BaseError do
+  let(:error) { described_class.new }
+
+  describe '#long_message' do
+    it 'returns the message' do
+      expect(error.long_message).to eq error.message
+    end
+  end
+end

data/spec/reek/examiner_spec.rb

@@ -46,7 +46,7 @@ RSpec.describe Reek::Examiner do
                           filter_by_smells: [],
                           configuration: configuration)
     end
-    let(:path) { CONFIG_PATH.join('partial_mask.reek') }
+    let(:path) { CONFIGURATION_DIR.join('partial_mask.reek') }
     let(:expected_first_smell) { 'UncommunicativeVariableName' }
 
     it_behaves_like 'one smell found'
@@ -58,27 +58,12 @@ RSpec.describe Reek::Examiner do
     it_behaves_like 'no smells found'
   end
 
-  describe '.new' do
-    context 'returns a proper Examiner' do
-      let(:source) { 'class C; def f; end; end' }
-      let(:examiner) do
-        described_class.new(source)
-      end
-
-      it 'has been run on the given source' do
-        expect(examiner.origin).to eq('string')
-      end
-
-      it 'has the right smells' do
-        smells = examiner.smells
-        expect(smells[0].message).to eq('has no descriptive comment')
-        expect(smells[1].message).to eq("has the name 'f'")
-        expect(smells[2].message).to eq("has the name 'C'")
-      end
+  describe '#origin' do
+    let(:source) { 'class C; def f; end; end' }
+    let(:examiner) { described_class.new(source) }
 
-      it 'has the right smell count' do
-        expect(examiner.smells_count).to eq(3)
-      end
+    it 'returns "string" for a string source' do
+      expect(examiner.origin).to eq('string')
     end
   end
 
@@ -92,7 +77,20 @@ RSpec.describe Reek::Examiner do
       expect(smell.message).to eq("calls 'bar.call_me()' 2 times")
     end
 
-    context 'source is empty' do
+    context 'with a source with three smells' do
+      let(:source) { 'class C; def f; end; end' }
+      let(:examiner) { described_class.new(source) }
+
+      it 'has the right smells' do
+        smells = examiner.smells
+        expect(smells.map(&:message)).
+          to eq ['has no descriptive comment',
+                 "has the name 'f'",
+                 "has the name 'C'"]
+      end
+    end
+
+    context 'when source only contains comments' do
       let(:source) do
         <<-EOS
             # Just a comment
@@ -129,21 +127,38 @@ RSpec.describe Reek::Examiner do
 
       it 'explains the origin of the error' do
         origin = 'string'
-        expect { examiner.smells }.to raise_error.with_message(/#{origin}/)
+        expect { examiner.smells }.
+          to raise_error.with_message("Source #{origin} cannot be processed by Reek.")
       end
 
       it 'explains what to do' do
-        explanation = 'Please double check your Reek configuration'
-        expect { examiner.smells }.to raise_error.with_message(/#{explanation}/)
+        explanation = 'It would be great if you could report this back to the Reek team'
+        expect { examiner.smells }.
+          to raise_error { |it| expect(it.long_message).to match(/#{explanation}/) }
       end
 
       it 'contains the original error message' do
         original = 'Looks like bad source'
-        expect { examiner.smells }.to raise_error.with_message(/#{original}/)
+        expect { examiner.smells }.
+          to raise_error { |it| expect(it.long_message).to match(/#{original}/) }
+      end
+
+      it 'shows the original exception class' do
+        expect { examiner.smells }.
+          to raise_error { |it| expect(it.long_message).to match(/ArgumentError/) }
       end
     end
   end
 
+  describe '#smells_count' do
+    let(:source) { 'class C; def f; end; end' }
+    let(:examiner) { described_class.new(source) }
+
+    it 'has the right smell count' do
+      expect(examiner.smells_count).to eq(3)
+    end
+  end
+
   context 'when the source causes the source buffer to crash' do
     let(:source) { 'I make the buffer crash' }
 
@@ -153,7 +168,7 @@ RSpec.describe Reek::Examiner do
       allow(Parser::Source::Buffer).to receive(:new).and_return(buffer)
     end
 
-    context 'if the error handler does not handle the error' do
+    context 'when the error handler does not handle the error' do
       let(:examiner) { described_class.new(source) }
 
       it 'does not raise an error during initialization' do
@@ -165,7 +180,7 @@ RSpec.describe Reek::Examiner do
       end
     end
 
-    context 'if the error handler handles the error' do
+    context 'when the error handler handles the error' do
       let(:handler) { instance_double(Reek::LoggingErrorHandler, handle: true) }
       let(:examiner) { described_class.new(source, error_handler: handler) }
 
@@ -180,10 +195,65 @@ RSpec.describe Reek::Examiner do
     end
   end
 
+  context 'with a source that triggers a syntax error' do
+    let(:examiner) { described_class.new(source) }
+    let(:source) do
+      <<-SRC.strip_heredoc
+      1 2 3
+      SRC
+    end
+
+    it 'does not raise an error during initialization' do
+      expect { examiner }.not_to raise_error
+    end
+
+    it 'raises an encoding error when asked for smells' do
+      expect { examiner.smells }.to raise_error Reek::Errors::SyntaxError
+    end
+
+    it 'explains the origin of the error' do
+      message = "Source 'string' cannot be processed by Reek due to a syntax error in the source file."
+      expect { examiner.smells }.to raise_error.with_message(/#{message}/)
+    end
+
+    it 'shows the original exception class' do
+      expect { examiner.smells }.
+        to raise_error { |it| expect(it.long_message).to match(/Parser::SyntaxError/) }
+    end
+  end
+
+  context 'with a source that triggers an encoding error' do
+    let(:examiner) { described_class.new(source) }
+    let(:source) do
+      <<-SRC.strip_heredoc
+      # encoding: US-ASCII
+      puts 'こんにちは世界'
+      SRC
+    end
+
+    it 'does not raise an error during initialization' do
+      expect { examiner }.not_to raise_error
+    end
+
+    it 'raises an encoding error when asked for smells' do
+      expect { examiner.smells }.to raise_error Reek::Errors::EncodingError
+    end
+
+    it 'explains the origin of the error' do
+      message = "Source 'string' cannot be processed by Reek due to an encoding error in the source file."
+      expect { examiner.smells }.to raise_error.with_message(/#{message}/)
+    end
+
+    it 'shows the original exception class' do
+      expect { examiner.smells }.
+        to raise_error { |it| expect(it.long_message).to match(/InvalidByteSequenceError/) }
+    end
+  end
+
   describe 'bad comment config' do
     let(:examiner) { described_class.new(source) }
 
-    context 'unknown smell detector' do
+    context 'with an unknown smell detector' do
       let(:source) do
         <<-EOS
           # :reek:DoesNotExist
@@ -209,7 +279,7 @@ RSpec.describe Reek::Examiner do
       end
     end
 
-    context 'garbage in detector config' do
+    context 'with garbage in detector config' do
       let(:source) do
         <<-EOS
           # :reek:UncommunicativeMethodName { thats: a: bad: config }