reek 2.0.0 → 2.0.1

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -1,16 +1,11 @@
 require 'spec_helper'
 require 'reek/smells/uncommunicative_method_name'
 require 'reek/smells/smell_detector_shared'
-require 'reek/core/code_parser'
-require 'reek/core/sniffer'
 
-include Reek
-include Reek::Smells
-
-describe UncommunicativeMethodName do
-  before :each do
-    @source_name = 'wallamalloo'
-    @detector = UncommunicativeMethodName.new(@source_name)
+describe Reek::Smells::UncommunicativeMethodName do
+  before do
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector, smell_type: :UncommunicativeMethodName, source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -18,7 +13,7 @@ describe UncommunicativeMethodName do
   ['help', '+', '-', '/', '*'].each do |method_name|
     it "accepts the method name '#{method_name}'" do
       src = "def #{method_name}(fred) basics(17) end"
-      expect(src).not_to reek_of(UncommunicativeMethodName)
+      expect(src).not_to reek_of(:UncommunicativeMethodName)
     end
   end
 
@@ -26,7 +21,7 @@ describe UncommunicativeMethodName do
     context 'with a bad name' do
       before do
         src = "def #{method_name}; end"
-        ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+        ctx = Reek::Core::CodeContext.new(nil, src.to_reek_source.syntax_tree)
         smells = @detector.examine_context(ctx)
         @warning = smells[0]
       end

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -1,16 +1,12 @@
 require 'spec_helper'
 require 'reek/smells/uncommunicative_module_name'
 require 'reek/smells/smell_detector_shared'
-require 'reek/core/code_parser'
-require 'reek/core/sniffer'
+require 'reek/core/code_context'
 
-include Reek
-include Reek::Smells
-
-describe UncommunicativeModuleName do
-  before :each do
-    @source_name = 'classy'
-    @detector = UncommunicativeModuleName.new(@source_name)
+describe Reek::Smells::UncommunicativeModuleName do
+  before do
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector, smell_type: :UncommunicativeModuleName, source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -34,11 +30,11 @@ describe UncommunicativeModuleName do
 
     it 'reports a bad scoped name' do
       src = "#{type} Foo::X; end"
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = Reek::Core::CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
       expect(smells.length).to eq(1)
-      expect(smells[0].smell_category).to eq(UncommunicativeModuleName.smell_category)
-      expect(smells[0].smell_type).to eq(UncommunicativeModuleName.smell_type)
+      expect(smells[0].smell_category).to eq(Reek::Smells::UncommunicativeModuleName.smell_category)
+      expect(smells[0].smell_type).to eq(Reek::Smells::UncommunicativeModuleName.smell_type)
       expect(smells[0].parameters[:name]).to eq('X')
       expect(smells[0].context).to match(/#{smells[0].parameters[:name]}/)
     end
@@ -47,7 +43,7 @@ describe UncommunicativeModuleName do
   context 'accepting names' do
     it 'accepts Inline::C' do
       src = 'module Inline::C; end'
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = Reek::Core::CodeContext.new(nil, src.to_reek_source.syntax_tree)
       expect(@detector.examine_context(ctx)).to be_empty
     end
   end
@@ -55,7 +51,7 @@ describe UncommunicativeModuleName do
   context 'looking at the YAML' do
     before :each do
       src = 'module Printer2; end'
-      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = Reek::Core::CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
       @warning = smells[0]
     end

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -3,13 +3,12 @@ require 'reek/smells/uncommunicative_parameter_name'
 require 'reek/smells/smell_detector_shared'
 require 'reek/core/method_context'
 
-include Reek::Core
-include Reek::Smells
-
-describe UncommunicativeParameterName do
+describe Reek::Smells::UncommunicativeParameterName do
   before :each do
-    @source_name = 'wallamalloo'
-    @detector = UncommunicativeParameterName.new(@source_name)
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector,
+                      smell_type: :UncommunicativeParameterName,
+                      source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -19,50 +18,50 @@ describe UncommunicativeParameterName do
     context "in a method definition #{description}" do
       it 'does not recognise *' do
         expect("def #{host}help(xray, *) basics(17) end").
-          not_to reek_of(UncommunicativeParameterName)
+          not_to reek_of(:UncommunicativeParameterName)
       end
 
       it "reports parameter's name" do
         src = "def #{host}help(x) basics(x) end"
-        expect(src).to reek_of(UncommunicativeParameterName,
+        expect(src).to reek_of(:UncommunicativeParameterName,
                                name: 'x')
       end
 
       it 'does not report unused parameters' do
         src = "def #{host}help(x) basics(17) end"
-        expect(src).not_to reek_of(UncommunicativeParameterName)
+        expect(src).not_to reek_of(:UncommunicativeParameterName)
       end
 
       it 'does not report two-letter parameter names' do
         expect("def #{host}help(ab) basics(ab) end").
-          not_to reek_of(UncommunicativeParameterName)
+          not_to reek_of(:UncommunicativeParameterName)
       end
 
       it 'reports names of the form "x2"' do
         src = "def #{host}help(x2) basics(x2) end"
-        expect(src).to reek_of(UncommunicativeParameterName,
+        expect(src).to reek_of(:UncommunicativeParameterName,
                                name: 'x2')
       end
 
       it 'reports long name ending in a number' do
         src = "def #{host}help(param2) basics(param2) end"
-        expect(src).to reek_of(UncommunicativeParameterName,
+        expect(src).to reek_of(:UncommunicativeParameterName,
                                name: 'param2')
       end
 
       it 'does not report unused anonymous parameter' do
         expect("def #{host}help(_) basics(17) end").
-          not_to reek_of(UncommunicativeParameterName)
+          not_to reek_of(:UncommunicativeParameterName)
       end
 
       it 'reports used anonymous parameter' do
         expect("def #{host}help(_) basics(_) end").
-          to reek_of(UncommunicativeParameterName)
+          to reek_of(:UncommunicativeParameterName)
       end
 
       it 'reports used parameters marked as unused' do
         expect("def #{host}help(_unused) basics(_unused) end").
-          to reek_of(UncommunicativeParameterName)
+          to reek_of(:UncommunicativeParameterName)
       end
     end
   end
@@ -70,7 +69,7 @@ describe UncommunicativeParameterName do
   context 'looking at the smell result fields' do
     before :each do
       src = 'def bad(good, bad2, good_again); basics(good, bad2, good_again); end'
-      ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = Reek::Core::MethodContext.new(nil, src.to_reek_source.syntax_tree)
       @smells = @detector.examine_context(ctx)
       @warning = @smells[0]
     end

data/spec/reek/smells/uncommunicative_variable_name_spec.rb

@@ -1,16 +1,13 @@
 require 'spec_helper'
 require 'reek/smells/uncommunicative_variable_name'
 require 'reek/smells/smell_detector_shared'
-require 'reek/core/code_parser'
-require 'reek/core/sniffer'
 
-include Reek
-include Reek::Smells
-
-describe UncommunicativeVariableName do
+describe Reek::Smells::UncommunicativeVariableName do
   before :each do
-    @source_name = 'wallamalloo'
-    @detector = UncommunicativeVariableName.new(@source_name)
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector,
+                      smell_type: :UncommunicativeVariableName,
+                      source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -29,27 +26,27 @@ describe UncommunicativeVariableName do
   context 'local variable name' do
     it 'does not report one-word variable name' do
       expect('def help(fred) simple = jim(45) end').
-        not_to reek_of(UncommunicativeVariableName)
+        not_to reek_of(:UncommunicativeVariableName)
     end
 
     it 'does not report single underscore as a variable name' do
-      expect('def help(fred) _ = jim(45) end').not_to reek_of(UncommunicativeVariableName)
+      expect('def help(fred) _ = jim(45) end').not_to reek_of(:UncommunicativeVariableName)
     end
 
     it 'reports one-letter variable name' do
       src = 'def simple(fred) x = jim(45) end'
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'x')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
     end
 
     it 'reports name of the form "x2"' do
       src = 'def simple(fred) x2 = jim(45) end'
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'x2')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x2')
     end
 
     it 'reports long name ending in a number' do
       @bad_var = 'var123'
       src = "def simple(fred) #{@bad_var} = jim(45) end"
-      expect(src).to reek_of(UncommunicativeVariableName,
+      expect(src).to reek_of(:UncommunicativeVariableName,
                              name: @bad_var)
     end
 
@@ -58,14 +55,14 @@ describe UncommunicativeVariableName do
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
       expect(smells.length).to eq(1)
-      expect(smells[0].smell_type).to eq(UncommunicativeVariableName.smell_type)
+      expect(smells[0].smell_type).to eq(described_class.smell_type)
       expect(smells[0].parameters[:name]).to eq('x')
       expect(smells[0].lines).to eq([1, 1])
     end
 
     it 'reports a bad name inside a block' do
       src = 'def clean(text) text.each { q2 = 3 } end'
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'q2')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'q2')
     end
 
     it 'reports variable name outside any method' do
@@ -82,7 +79,7 @@ describe UncommunicativeVariableName do
           end
         end
       EOS
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'x')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
     end
 
     it 'reports all relevant block parameters' do
@@ -91,8 +88,8 @@ describe UncommunicativeVariableName do
           @foo.map { |x, y| x + y }
         end
       EOS
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'x')
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'y')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports block parameters used outside of methods' do
@@ -101,7 +98,7 @@ describe UncommunicativeVariableName do
         @foo.map { |x| x * 2 }
       end
       EOS
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'x')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
     end
 
     it 'reports splatted block parameters correctly' do
@@ -110,7 +107,7 @@ describe UncommunicativeVariableName do
           @foo.map { |*y| y << 1 }
         end
       EOS
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'y')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports nested block parameters' do
@@ -119,8 +116,8 @@ describe UncommunicativeVariableName do
           @foo.map { |(x, y)| x + y }
         end
       EOS
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'x')
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'y')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports splatted nested block parameters' do
@@ -129,8 +126,8 @@ describe UncommunicativeVariableName do
           @foo.map { |(x, *y)| x + y }
         end
       EOS
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'x')
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'y')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports deeply nested block parameters' do
@@ -139,23 +136,23 @@ describe UncommunicativeVariableName do
           @foo.map { |(x, (y, z))| x + y + z }
         end
       EOS
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'x')
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'y')
-      expect(src).to reek_of(UncommunicativeVariableName, name: 'z')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'x')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'y')
+      expect(src).to reek_of(:UncommunicativeVariableName, name: 'z')
     end
   end
 
   context 'when a smell is reported' do
     before :each do
-      src = <<EOS
-def bad
-  unless @mod then
-     x2 = xy.to_s
-     x2
-     x2 = 56
-  end
-end
-EOS
+      src = <<-EOS
+        def bad
+          unless @mod then
+             x2 = xy.to_s
+             x2
+             x2 = 56
+          end
+        end
+      EOS
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
       @smells = @detector.examine_context(ctx)
       @warning = @smells[0]

data/spec/reek/smells/unused_parameters_spec.rb

@@ -2,72 +2,69 @@ require 'spec_helper'
 require 'reek/smells/unused_parameters'
 require 'reek/smells/smell_detector_shared'
 
-include Reek
-include Reek::Smells
-
-describe UnusedParameters do
+describe Reek::Smells::UnusedParameters do
   context 'for methods' do
     it 'reports nothing for no parameters' do
-      expect('def simple; true end').not_to reek_of(UnusedParameters)
+      expect('def simple; true end').not_to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing for used parameter' do
-      expect('def simple(sum); sum end').not_to reek_of(UnusedParameters)
+      expect('def simple(sum); sum end').not_to reek_of(:UnusedParameters)
     end
 
     it 'reports for 1 used and 2 unused parameter' do
       src = 'def simple(num,sum,denum); sum end'
-      expect(src).to reek_of(UnusedParameters, name: 'num')
-      expect(src).to reek_of(UnusedParameters, name: 'denum')
+      expect(src).to reek_of(:UnusedParameters, name: 'num')
+      expect(src).to reek_of(:UnusedParameters, name: 'denum')
     end
 
     it 'reports for 3 used and 1 unused parameter' do
       src = 'def simple(num,sum,denum,quotient); num + denum + sum end'
-      expect(src).to reek_of(UnusedParameters,
+      expect(src).to reek_of(:UnusedParameters,
                              name: 'quotient')
     end
 
     it 'reports nothing for used splatted parameter' do
-      expect('def simple(*sum); sum end').not_to reek_of(UnusedParameters)
+      expect('def simple(*sum); sum end').not_to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing for unused anonymous parameter' do
-      expect('def simple(_); end').not_to reek_of(UnusedParameters)
+      expect('def simple(_); end').not_to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing for named parameters prefixed with _' do
-      expect('def simple(_name); end').not_to reek_of(UnusedParameters)
+      expect('def simple(_name); end').not_to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing for unused anonymous splatted parameter' do
-      expect('def simple(*); end').not_to reek_of(UnusedParameters)
+      expect('def simple(*); end').not_to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing when using super with implicit arguments' do
-      expect('def simple(*args); super; end').not_to reek_of(UnusedParameters)
+      expect('def simple(*args); super; end').not_to reek_of(:UnusedParameters)
     end
 
     it 'reports something when using super explicitely passing no arguments' do
-      expect('def simple(*args); super(); end').to reek_of(UnusedParameters)
+      expect('def simple(*args); super(); end').to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing when using super explicitely passing all arguments' do
-      expect('def simple(*args); super(*args); end').not_to reek_of(UnusedParameters)
+      expect('def simple(*args); super(*args); end').not_to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing when using super in a nested context' do
       expect('def simple(*args); call_other("something", super); end').
-        not_to reek_of(UnusedParameters)
+        not_to reek_of(:UnusedParameters)
     end
 
     it 'reports something when not using a keyword argument with splat' do
       expect('def simple(var, kw: :val, **args); @var, @kw = var, kw; end').
-        to reek_of(UnusedParameters)
+        to reek_of(:UnusedParameters)
     end
 
     it 'reports nothing when using a keyword argument with splat' do
       expect('def simple(var, kw: :val, **args); @var, @kw, @args = var, kw, args; end').
-        not_to reek_of(UnusedParameters)
+        not_to reek_of(:UnusedParameters)
     end
   end
 end

data/spec/reek/smells/utility_function_spec.rb

@@ -2,13 +2,10 @@ require 'spec_helper'
 require 'reek/smells/utility_function'
 require 'reek/smells/smell_detector_shared'
 
-include Reek
-include Reek::Smells
-
-describe UtilityFunction do
+describe Reek::Smells::UtilityFunction do
   before(:each) do
-    @source_name = 'loser'
-    @detector = UtilityFunction.new(@source_name)
+    @source_name = 'dummy_source'
+    @detector = build(:smell_detector, smell_type: :UtilityFunction, source: @source_name)
   end
 
   it_should_behave_like 'SmellDetector'
@@ -17,7 +14,7 @@ describe UtilityFunction do
     ['self', 'local_call', '$global'].each do |receiver|
       it 'ignores the receiver' do
         src = "def #{receiver}.simple(arga) arga.to_s + arga.to_i end"
-        ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
+        ctx = Reek::Core::MethodContext.new(nil, src.to_reek_source.syntax_tree)
         expect(@detector.examine_context(ctx)).to be_empty
       end
     end
@@ -26,7 +23,7 @@ describe UtilityFunction do
   context 'with no calls' do
     it 'does not report empty method' do
       src = 'def simple(arga) end'
-      ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
+      ctx = Reek::Core::MethodContext.new(nil, src.to_reek_source.syntax_tree)
       expect(@detector.examine_context(ctx)).to be_empty
     end
 
@@ -122,8 +119,8 @@ describe UtilityFunction do
         end
       EOS
       source = src.to_reek_source
-      sniffer = Sniffer.new(source)
-      mctx = CodeParser.new(sniffer).process_def(source.syntax_tree)
+      sniffer = Reek::Core::Sniffer.new(source)
+      mctx = Reek::Core::TreeWalker.new(sniffer).process_def(source.syntax_tree)
       @warning = @detector.examine_context(mctx)[0]   # SMELL: too cumbersome!
     end