reek 1.2.7.3 → 1.2.8

data/spec/reek/smells/long_yield_list_spec.rb

@@ -17,20 +17,24 @@ describe LongYieldList do
 
   context 'yield' do
     it 'should not report yield with no parameters' do
-      'def simple(arga, argb, &blk) f(3);yield; end'.should_not reek
+      src = 'def simple(arga, argb, &blk) f(3);yield; end'
+      src.should_not smell_of(LongYieldList)
     end
     it 'should not report yield with few parameters' do
-      'def simple(arga, argb, &blk) f(3);yield a,b; end'.should_not reek
+      src = 'def simple(arga, argb, &blk) f(3);yield a,b; end'
+      src.should_not smell_of(LongYieldList)
     end
     it 'should report yield with many parameters' do
-      'def simple(arga, argb, &blk) f(3);yield arga,argb,arga,argb; end'.should reek_only_of(:LongYieldList, /simple/, /yields/, /4/)
+      src = 'def simple(arga, argb, &blk) f(3);yield arga,argb,arga,argb; end'
+      src.should smell_of(LongYieldList, LongYieldList::PARAMETER_COUNT_KEY => 4)
     end
     it 'should not report yield of a long expression' do
-      'def simple(arga, argb, &blk) f(3);yield(if @dec then argb else 5+3 end); end'.should_not reek
+      src = 'def simple(arga, argb, &blk) f(3);yield(if @dec then argb else 5+3 end); end'
+      src.should_not smell_of(LongYieldList)
     end
   end
 
-  context 'looking at the YAML' do
+  context 'when a smells is reported' do
     before :each do
       src = <<EOS
 def simple(arga, argb, &blk)
@@ -38,20 +42,15 @@ def simple(arga, argb, &blk)
   yield(arga,argb,arga,argb)
   end
 EOS
-      source = src.to_reek_source
-      sniffer = Sniffer.new(source)
-      mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
-      @detector.examine_context(mctx)
-      @warning = @detector.smells_found.to_a[0]   # SMELL: too cumbersome!
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      @smells = @detector.examine_context(ctx)
+      @warning = @smells[0]
     end
 
     it_should_behave_like 'common fields set correctly'
 
-    it 'reports the number of parameters' do
+    it 'reports the correct values' do
       @warning.smell['parameter_count'].should == 4
-      # SMELL: many tests duplicate the names of the YAML fields
-    end
-    it 'reports the line number of the method' do
       @warning.lines.should == [3]
     end
   end

data/spec/reek/smells/nested_iterators_spec.rb

@@ -6,8 +6,23 @@ include Reek::Smells
 
 describe NestedIterators do
 
+  context 'with no iterators' do
+    it 'reports no smells' do
+      src = 'def fred() nothing = true; end'
+      src.should_not smell_of(NestedIterators)
+    end
+  end
+
+  context 'with one iterator' do
+    it 'reports no smells' do
+      src = 'def fred() nothing.each {|item| item}; end'
+      src.should_not smell_of(NestedIterators)
+    end
+  end
+
   it 'should report nested iterators in a method' do
-    'def bad(fred) @fred.each {|item| item.each {|ting| ting.ting} } end'.should reek_only_of(:NestedIterators)
+    src = 'def bad(fred) @fred.each {|item| item.each {|ting| ting.ting} } end'
+    src.should smell_of(NestedIterators)
   end
 
   it 'should not report method with successive iterators' do
@@ -17,7 +32,7 @@ def bad(fred)
   @jim.each {|ting| ting.each }
 end
 EOS
-    src.should_not reek
+    src.should_not smell_of(NestedIterators)
   end
 
   it 'should not report method with chained iterators' do
@@ -26,7 +41,7 @@ def chained
   @sig.keys.sort_by { |xray| xray.to_s }.each { |min| md5 << min.to_s }
 end
 EOS
-    src.should_not reek
+    src.should_not smell_of(NestedIterators)
   end
 
   it 'should report nested iterators only once per method' do
@@ -36,98 +51,100 @@ def bad(fred)
   @jim.each {|ting| ting.each {|piece| @hal.send} }
 end
 EOS
-    src.should reek_only_of(:NestedIterators)
+    src.should smell_of(NestedIterators, {}, {})
   end
+
+  context 'when the allowed nesting depth is 3' do
+    before :each do
+      @config = {NestedIterators::MAX_ALLOWED_NESTING_KEY => 3}
+    end
+
+    it 'should not report nested iterators 2 levels deep' do
+      src = <<EOS
+def bad(fred)
+  @fred.each {|one| one.each {|two| two.two} }
+end
+EOS
+      src.should_not smell_of(NestedIterators).with_config(@config)
+    end
+
+    it 'should not report nested iterators 3 levels deep' do
+      src = <<EOS
+def bad(fred)
+  @fred.each {|one| one.each {|two| two.each {|three| three.three} } }
 end
+EOS
+      src.should_not smell_of(NestedIterators).with_config(@config)
+    end
 
-describe NestedIterators do
-  before(:each) do
-    @detector = NestedIterators.new('cuckoo')
+    it 'should report nested iterators 4 levels deep' do
+      src = <<EOS
+def bad(fred)
+  @fred.each {|one| one.each {|two| two.each {|three| three.each {|four| four.four} } } }
+end
+EOS
+      src.should smell_of(NestedIterators).with_config(@config)
+    end
   end
 
-  it_should_behave_like 'SmellDetector'
+  context 'when ignoring iterators' do
+    before :each do
+      @config = {NestedIterators::IGNORE_ITERATORS_KEY => ['ignore_me']}
+    end
 
-  context 'find_deepest_iterators' do
-    context 'with no iterators' do
-      it 'returns an empty list' do
-        src = 'def fred() nothing = true; end'
-        source = src.to_reek_source
-        sniffer = Sniffer.new(source)
-        @mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
-        @detector.find_deepest_iterators(@mctx).should == []
-      end
+    it 'should not report nesting the ignored iterator inside another' do
+      src = 'def bad(fred) @fred.each {|item| item.ignore_me {|ting| ting.ting} } end'
+      src.should_not smell_of(NestedIterators).with_config(@config)
     end
 
-    context 'with one iterator' do
-      before :each do
-        src = 'def fred() nothing.each {|item| item}; end'
-        source = src.to_reek_source
-        sniffer = Sniffer.new(source)
-        mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
-        @result = @detector.find_deepest_iterators(mctx)
-      end
-      it 'returns a depth of 1' do
-        @result.should == []
-      end
+    it 'should not report nesting inside the ignored iterator' do
+      src = 'def bad(fred) @fred.ignore_me {|item| item.each {|ting| ting.ting} } end'
+      src.should_not smell_of(NestedIterators).with_config(@config)
     end
 
-    context 'with two non-nested iterators' do
-      before :each do
-        src = <<EOS
-def fred()
-  nothing.each do |item|
-    item
+    it 'should report nested iterators inside the ignored iterator' do
+      src = 'def bad(fred) @fred.ignore_me {|item| item.each {|ting| ting.each {|other| other.other} } } end'
+      src.should smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
+    end
+
+    it 'should report nested iterators outside the ignored iterator' do
+      src = 'def bad(fred) @fred.each {|item| item.each {|ting| ting.ignore_me {|other| other.other} } } end'
+      src.should smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
+    end
+
+    it 'should report nested iterators with the ignored iterator between them' do
+      src = 'def bad(fred) @fred.each {|item| item.ignore_me {|ting| ting.ting {|other| other.other} } } end'
+      src.should smell_of(NestedIterators, NestedIterators::NESTING_DEPTH_KEY => 2).with_config(@config)
+    end
   end
-  again.each {|thing| }
 end
-EOS
-        source = src.to_reek_source
-        sniffer = Sniffer.new(source)
-        mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
-        @result = @detector.find_deepest_iterators(mctx)
-      end
-      it 'returns both iterators' do
-        @result.length.should == 0
-      end
-    end
 
-    context 'with one nested iterator' do
-      before :each do
-        src = <<EOS
+describe NestedIterators do
+  before(:each) do
+    @source_name = 'cuckoo'
+    @detector = NestedIterators.new(@source_name)
+  end
+
+  it_should_behave_like 'SmellDetector'
+
+  context 'when a smell is reported' do
+    before :each do
+      src = <<EOS
 def fred()
   nothing.each do |item|
     again.each {|thing| item }
   end
 end
 EOS
-        source = src.to_reek_source
-        sniffer = Sniffer.new(source)
-        @mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
-        @result = @detector.find_deepest_iterators(@mctx)
-      end
-      it 'returns only the deepest iterator' do
-        @result.length.should == 1
-      end
-      it 'has depth of 2' do
-        @result[0][1].should == 2
-      end
-      it 'refers to the innermost exp' do
-        @result[0][0].line.should == 3
-      end
-
-      context 'when reporting yaml' do
-        before :each do
-          @detector.examine_context(@mctx)
-          warning = @detector.smells_found.to_a[0]   # SMELL: too cumbersome!
-          @yaml = warning.to_yaml
-        end
-        it 'reports the depth' do
-          @yaml.should match(/depth:\s*2/)
-        end
-        it 'reports the deepest line number' do
-          @yaml.should match(/lines:[\s-]*3/)
-        end
-      end
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      @warning = @detector.examine_context(ctx)[0]
+    end
+
+    it_should_behave_like 'common fields set correctly'
+
+    it 'reports correct values' do
+      @warning.smell[NestedIterators::NESTING_DEPTH_KEY].should == 2
+      @warning.lines.should == [3]
     end
   end
 end

data/spec/reek/smells/smell_detector_shared.rb

@@ -7,14 +7,16 @@ shared_examples_for 'SmellDetector' do
   context 'exception matching follows the context' do
     before :each do
       @ctx = mock('context')
+#      @ctx.should_receive(:exp).and_return(nil)
+      @ctx.should_receive(:config).and_return({})
     end
     it 'when false' do
-      @ctx.should_receive(:matches?).and_return(false)
+      @ctx.should_receive(:matches?).at_least(:once).and_return(false)
       @detector.exception?(@ctx).should == false
     end
 
     it 'when true' do
-      @ctx.should_receive(:matches?).and_return(true)
+      @ctx.should_receive(:matches?).at_least(:once).and_return(true)
       @detector.exception?(@ctx).should == true
     end
   end

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -17,42 +17,25 @@ describe UncommunicativeMethodName do
 
   ['help', '+', '-', '/', '*'].each do |method_name|
     it "accepts the method name '#{method_name}'" do
-      "def #{method_name}(fred) basics(17) end".should_not reek
+      "def #{method_name}(fred) basics(17) end".should_not smell_of(UncommunicativeMethodName)
     end
   end
 
   ['x', 'x2', 'method2'].each do |method_name|
     context 'with a bad name' do
       before :each do
-        @full_name = 'anything you like'
-        ctx = mock('method', :null_object => true)
-        ctx.should_receive(:name).and_return(method_name)
-        ctx.should_receive(:full_name).at_least(:once).and_return(@full_name)
-        ctx.should_receive(:exp).and_return(ast(:defn))
-        @detector.examine_context(ctx)
-        @smells = @detector.smells_found.to_a
+        src = 'def x() end'
+        ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+        @smells = @detector.examine_context(ctx)
+        @warning = @smells[0]
       end
 
-      it 'records only that attribute' do
-        @smells.length.should == 1
-      end
-      it 'reports the attribute name' do
-        @smells[0].smell[UncommunicativeMethodName::METHOD_NAME_KEY].should == method_name
-      end
-      it 'reports the declaration line number' do
+      it_should_behave_like 'common fields set correctly'
+
+      it 'reports the correct values' do
+        @smells[0].smell[UncommunicativeMethodName::METHOD_NAME_KEY].should == 'x'
         @smells[0].lines.should == [1]
-      end
-      it 'reports the correct smell class' do
-        @smells[0].smell_class.should == UncommunicativeMethodName::SMELL_CLASS
-      end
-      it 'reports the correct smell subclass' do
-        @smells[0].subclass.should == UncommunicativeMethodName::SMELL_SUBCLASS
-      end
-      it 'reports the context fq name' do
-        @smells[0].context.should == @full_name
-      end
-      it 'reports the source name' do
-        @smells[0].source.should == @source_name
+        @smells[0].context.should == 'x'
       end
     end
   end

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -28,40 +28,39 @@ describe UncommunicativeModuleName do
     it 'reports long name ending in a number' do
       "#{type} Printer2; end".should reek_of(:UncommunicativeModuleName, /Printer2/)
     end
+    it 'reports a bad scoped name' do
+      src = "#{type} Foo::X; end"
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      smells = @detector.examine_context(ctx)
+      smells.length.should == 1
+      smells[0].smell_class.should == UncommunicativeModuleName::SMELL_CLASS
+      smells[0].subclass.should == UncommunicativeModuleName::SMELL_SUBCLASS
+      smells[0].smell[UncommunicativeModuleName::MODULE_NAME_KEY].should == 'X'
+      smells[0].context.should match(/#{smells[0].smell[UncommunicativeModuleName::MODULE_NAME_KEY]}/)
+    end
   end
 
   context 'accepting names' do
     it 'accepts Inline::C' do
-      ctx = mock('context')
-      ctx.should_receive(:full_name).and_return('Inline::C')
-      @detector.accept?(ctx).should == true
+      src = 'module Inline::C; end'
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      @detector.examine_context(ctx).should be_empty
     end
   end
 
   context 'looking at the YAML' do
     before :each do
       src = 'module Printer2; end'
-      source = src.to_reek_source
-      sniffer = Core::Sniffer.new(source)
-      @mctx = Core::CodeParser.new(sniffer).process_module(source.syntax_tree)
-      @detector.examine(@mctx)
-      warning = @detector.smells_found.to_a[0]   # SMELL: too cumbersome!
-      @yaml = warning.to_yaml
-    end
-    it 'reports the source' do
-      @yaml.should match(/source:\s*#{@source_name}/)
-    end
-    it 'reports the class' do
-      @yaml.should match(/class:\s*UncommunicativeName/)
-    end
-    it 'reports the subclass' do
-      @yaml.should match(/subclass:\s*UncommunicativeModuleName/)
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      smells = @detector.examine_context(ctx)
+      @warning = smells[0]
     end
-    it 'reports the variable name' do
-      @yaml.should match(/module_name:\s*Printer2/)
-    end
-    it 'reports the line number of the declaration' do
-      @yaml.should match(/lines:\s*- 1/)
+
+    it_should_behave_like 'common fields set correctly'
+
+    it 'reports the correct values' do
+      @warning.smell[UncommunicativeModuleName::MODULE_NAME_KEY].should == 'Printer2'
+      @warning.lines.should == [1]
     end
   end
 end

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -17,17 +17,38 @@ describe UncommunicativeParameterName do
   context "parameter name" do
     ['obj.', ''].each do |host|
       it 'does not recognise *' do
-        "def #{host}help(xray, *) basics(17) end".should_not reek
+        "def #{host}help(xray, *) basics(17) end".should_not smell_of(UncommunicativeParameterName)
       end
       it "reports parameter's name" do
-        "def #{host}help(x) basics(17) end".should reek_only_of(:UncommunicativeParameterName, /x/, /parameter name/)
+        src = "def #{host}help(x) basics(17) end"
+        src.should smell_of(UncommunicativeParameterName, {UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x'})
       end
-      it 'reports name of the form "x2"' do
-        "def #{host}help(x2) basics(17) end".should reek_only_of(:UncommunicativeParameterName, /x2/, /parameter name/)
-        #SMELL: should match either the class or the subclass!
+
+      context 'with a name of the form "x2"' do
+        before :each do
+          @bad_param = 'x2'
+          src = "def #{host}help(#{@bad_param}) basics(17) end"
+          ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+          @smells = @detector.examine_context(ctx)
+        end
+        it 'reports only 1 smell' do
+          @smells.length.should == 1
+        end
+        it 'reports uncommunicative parameter name' do
+          @smells[0].subclass.should == UncommunicativeParameterName::SMELL_SUBCLASS
+        end
+        it 'reports the parameter name' do
+          @smells[0].smell[UncommunicativeParameterName::PARAMETER_NAME_KEY].should == @bad_param
+        end
       end
       it 'reports long name ending in a number' do
-        "def #{host}help(param1) basics(17) end".should reek_only_of(:UncommunicativeParameterName, /param1/, /parameter name/)
+        @bad_param = 'param2'
+        src = "def #{host}help(#{@bad_param}) basics(17) end"
+        ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+        smells = @detector.examine_context(ctx)
+        smells.length.should == 1
+        smells[0].subclass.should == UncommunicativeParameterName::SMELL_SUBCLASS
+        smells[0].smell[UncommunicativeParameterName::PARAMETER_NAME_KEY].should == @bad_param
       end
     end
   end
@@ -35,27 +56,16 @@ describe UncommunicativeParameterName do
   context 'looking at the YAML' do
     before :each do
       src = 'def bad(good, bad2, good_again) end'
-      source = src.to_reek_source
-      sniffer = Sniffer.new(source)
-      @mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
-      @detector.examine(@mctx)
-      warning = @detector.smells_found.to_a[0]   # SMELL: too cumbersome!
-      @yaml = warning.to_yaml
-    end
-    it 'reports the source' do
-      @yaml.should match(/source:\s*#{@source_name}/)
-    end
-    it 'reports the class' do
-      @yaml.should match(/class:\s*UncommunicativeName/)
-    end
-    it 'reports the subclass' do
-      @yaml.should match(/subclass:\s*UncommunicativeParameterName/)
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      @smells = @detector.examine_context(ctx)
+      @warning = @smells[0]
     end
-    it 'reports the variable name' do
-      @yaml.should match(/parameter_name:\s*bad2/)
-    end
-    it 'reports the line number of the declaration' do
-      @yaml.should match(/lines:\s*- 1/)
+
+    it_should_behave_like 'common fields set correctly'
+
+    it 'reports the correct values' do
+      @warning.smell[UncommunicativeParameterName::PARAMETER_NAME_KEY].should == 'bad2'
+      @warning.lines.should == [1]
     end
   end
 end