reek 4.6.0 → 5.0.0

data/spec/reek/context/code_context_spec.rb

@@ -3,8 +3,8 @@ require_lib 'reek/context/method_context'
 require_lib 'reek/context/module_context'
 
 RSpec.describe Reek::Context::CodeContext do
-  context 'name recognition' do
-    let(:ctx)       { described_class.new(nil, exp) }
+  describe '#full_name' 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}" }
@@ -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,31 +76,38 @@ 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(outer, exp) }
       let(:outer_name) { 'another_random sting' }
-      let(:outer)      { described_class.new(nil, instance_double('Reek::AST::Node')) }
+      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 '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(nil, 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(nil, 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(nil, 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!'
@@ -166,7 +130,7 @@ RSpec.describe Reek::Context::CodeContext do
     end
     let(:expression) { Reek::Source::SourceCode.from(src).syntax_tree }
     let(:outer) { nil }
-    let(:context) { described_class.new(outer, expression) }
+    let(:context) { described_class.new(expression) }
     let(:sniffer) { class_double('Reek::SmellDetectors::BaseDetector') }
 
     before do
@@ -181,7 +145,7 @@ RSpec.describe Reek::Context::CodeContext do
     end
 
     context 'when there is an outer context' do
-      let(:outer) { described_class.new(nil, instance_double('Reek::AST::Node')) }
+      let(:outer) { described_class.new(instance_double('Reek::AST::Node')) }
 
       before do
         allow(outer).to receive(:config_for).with(sniffer).and_return(
@@ -196,9 +160,9 @@ RSpec.describe Reek::Context::CodeContext do
   end
 
   describe '#register_with_parent' do
-    let(:context) { described_class.new(nil, instance_double('Reek::AST::Node')) }
-    let(:first_child) { described_class.new(context, instance_double('Reek::AST::Node')) }
-    let(:second_child) { described_class.new(context, instance_double('Reek::AST::Node')) }
+    let(:context) { described_class.new(instance_double('Reek::AST::Node')) }
+    let(:first_child) { described_class.new(instance_double('Reek::AST::Node')) }
+    let(:second_child) { described_class.new(instance_double('Reek::AST::Node')) }
 
     it "appends the element to the parent context's list of children" do
       first_child.register_with_parent context
@@ -209,9 +173,9 @@ RSpec.describe Reek::Context::CodeContext do
   end
 
   describe '#each' do
-    let(:context) { described_class.new(nil, instance_double('Reek::AST::Node')) }
-    let(:first_child) { described_class.new(context, instance_double('Reek::AST::Node')) }
-    let(:second_child) { described_class.new(context, instance_double('Reek::AST::Node')) }
+    let(:context) { described_class.new(instance_double('Reek::AST::Node')) }
+    let(:first_child) { described_class.new(instance_double('Reek::AST::Node')) }
+    let(:second_child) { described_class.new(instance_double('Reek::AST::Node')) }
 
     it 'yields each child' do
       first_child.register_with_parent context

data/spec/reek/context/ghost_context_spec.rb

@@ -4,53 +4,53 @@ require_lib 'reek/context/ghost_context'
 
 RSpec.describe Reek::Context::GhostContext do
   let(:exp) { instance_double('Reek::AST::Node') }
-  let(:parent) { Reek::Context::CodeContext.new(nil, exp) }
+  let(:parent) { Reek::Context::CodeContext.new(exp) }
 
   describe '#register_with_parent' do
     it 'does not append itself to its parent' do
-      ghost = described_class.new(parent, nil)
+      ghost = described_class.new(nil)
       ghost.register_with_parent(parent)
       expect(parent.children).not_to include ghost
     end
   end
 
   describe '#append_child_context' do
-    let(:ghost) { described_class.new(parent, nil) }
+    let(:ghost) { described_class.new(nil) }
 
     before do
       ghost.register_with_parent(parent)
     end
 
     it 'appends the child to the grandparent context' do
-      child = Reek::Context::CodeContext.new(ghost, sexp(:foo))
+      child = Reek::Context::CodeContext.new(sexp(:foo))
       child.register_with_parent(ghost)
 
       expect(parent.children).to include child
     end
 
     it "sets the child's parent to the grandparent context" do
-      child = Reek::Context::CodeContext.new(ghost, sexp(:foo))
+      child = Reek::Context::CodeContext.new(sexp(:foo))
       child.register_with_parent(ghost)
 
       expect(child.parent).to eq parent
     end
 
     it 'appends the child to the list of children' do
-      child = Reek::Context::CodeContext.new(ghost, sexp(:foo))
+      child = Reek::Context::CodeContext.new(sexp(:foo))
       child.register_with_parent(ghost)
 
       expect(ghost.children).to include child
     end
 
-    context 'if the grandparent is also a ghost' do
-      let(:child_ghost) { described_class.new(ghost, nil) }
+    context 'when the grandparent is also a ghost' do
+      let(:child_ghost) { described_class.new(nil) }
 
       before do
         child_ghost.register_with_parent(ghost)
       end
 
       it 'sets the childs parent to its remote ancestor' do
-        child = Reek::Context::CodeContext.new(child_ghost, sexp(:foo))
+        child = Reek::Context::CodeContext.new(sexp(:foo))
         child.register_with_parent(child_ghost)
 
         expect(child.parent).to eq parent

data/spec/reek/context/method_context_spec.rb

@@ -2,7 +2,7 @@ require_relative '../../spec_helper'
 require_lib 'reek/context/method_context'
 
 RSpec.describe Reek::Context::MethodContext do
-  let(:method_context) { described_class.new(nil, exp) }
+  let(:method_context) { described_class.new(exp, nil) }
 
   describe '#matches?' do
     let(:exp) { instance_double('Reek::AST::SexpExtensions::ModuleNode').as_null_object }
@@ -31,7 +31,7 @@ RSpec.describe Reek::Context::MethodContext do
   describe '#default_assignments' do
     def assignments_from(src)
       exp = Reek::Source::SourceCode.from(src).syntax_tree
-      ctx = Reek::Context::MethodContext.new(nil, exp)
+      ctx = Reek::Context::MethodContext.new(exp, nil)
       ctx.default_assignments
     end
 

data/spec/reek/context/module_context_spec.rb

@@ -32,9 +32,9 @@ RSpec.describe Reek::Context::ModuleContext do
     let(:first_def) { instance_double('Reek::AST::SexpExtensions::DefNode', name: :foo) }
     let(:second_def) { instance_double('Reek::AST::SexpExtensions::DefNode') }
 
-    let(:context) { described_class.new(nil, main_exp) }
-    let(:first_child) { Reek::Context::MethodContext.new(context, first_def) }
-    let(:second_child) { Reek::Context::MethodContext.new(context, second_def) }
+    let(:context) { described_class.new(main_exp) }
+    let(:first_child) { Reek::Context::MethodContext.new(first_def, main_exp) }
+    let(:second_child) { Reek::Context::MethodContext.new(second_def, main_exp) }
 
     it 'sets visibility on subsequent child contexts' do
       context.append_child_context first_child

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/context/statement_counter_spec.rb

@@ -3,6 +3,7 @@ require_lib 'reek/context/statement_counter'
 
 RSpec.describe Reek::Context::StatementCounter do
   let(:counter) { described_class.new }
+
   describe '#increase_by' do
     it 'does not increase if passed a falsy value' do
       counter.increase_by(nil)

data/spec/reek/context_builder_spec.rb

@@ -220,6 +220,26 @@ RSpec.describe Reek::ContextBuilder do
       described_class.new(syntax_tree(code)).context_tree
     end
 
+    it 'marks instance methods when using a def modifier' do
+      code = <<-EOS
+        class Foo
+          private def bar
+          end
+
+          def baz
+          end
+        end
+      EOS
+
+      root = context_tree_for(code)
+      module_context = root.children.first
+      method_contexts = module_context.children
+      aggregate_failures do
+        expect(method_contexts[0].visibility).to eq :private
+        expect(method_contexts[1].visibility).to eq :public
+      end
+    end
+
     it 'does not mark class methods with instance visibility' do
       code = <<-EOS
         class Foo

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

@@ -1,5 +1,6 @@
 require_relative '../spec_helper'
 require_lib 'reek/examiner'
+require_lib 'reek/logging_error_handler'
 
 RSpec.shared_examples_for 'no smells found' do
   it 'is not smelly' do
@@ -45,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'
@@ -57,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
 
@@ -91,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
@@ -107,7 +106,7 @@ RSpec.describe Reek::Examiner do
       end
     end
 
-    context 'with an incomprehensible source that causes Reek to crash' do
+    context 'with an incomprehensible source that causes the detectors to crash' do
       let(:source) { 'class C; def does_crash_reek; end; end' }
 
       let(:examiner) do
@@ -128,24 +127,133 @@ 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' }
+
+    before do
+      buffer = double
+      allow(buffer).to receive(:source=) { raise RuntimeError }
+      allow(Parser::Source::Buffer).to receive(:new).and_return(buffer)
+    end
+
+    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
+        expect { examiner }.not_to raise_error
       end
+
+      it 'raises an incomprehensible source error when asked for smells' do
+        expect { examiner.smells }.to raise_error Reek::Errors::IncomprehensibleSourceError
+      end
+    end
+
+    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) }
+
+      it 'does not raise an error when asked for smells' do
+        expect { examiner.smells }.not_to raise_error
+      end
+
+      it 'passes the wrapped error to the handler' do
+        examiner.smells
+        expect(handler).to have_received(:handle).with(Reek::Errors::IncomprehensibleSourceError)
+      end
+    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
@@ -171,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 }