reek 4.2.3 → 4.2.4

data/spec/reek/examiner_spec.rb

@@ -43,23 +43,46 @@ RSpec.describe Reek::Examiner do
   context 'with a partially masked smelly File' do
     let(:configuration) { test_configuration_for(path) }
     let(:examiner) do
-      described_class.new(smelly_file,
+      described_class.new(SMELLY_FILE,
                           filter_by_smells: [],
                           configuration: configuration)
     end
-    let(:path) { SAMPLES_PATH.join('all_but_one_masked/masked.reek') }
-    let(:smelly_file) { Pathname.glob(SAMPLES_PATH.join('all_but_one_masked/d*.rb')).first }
+    let(:path) { CONFIG_PATH.join('partial_mask.reek') }
+    let(:expected_first_smell) { 'UncommunicativeVariableName' }
 
     it_should_behave_like 'one smell found'
   end
 
   context 'with a fragrant File' do
-    let(:clean_file) { Pathname.glob(SAMPLES_PATH.join('three_clean_files/*.rb')).first }
-    let(:examiner) { described_class.new(clean_file) }
+    let(:examiner) { described_class.new(CLEAN_FILE) }
 
     it_should_behave_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.description).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
+
+      it 'has the right smell count' do
+        expect(examiner.smells_count).to eq(3)
+      end
+    end
+  end
+
   describe '#smells' do
     it 'returns the detected smell warnings' do
       code     = 'def foo; bar.call_me(); bar.call_me(); end'
@@ -69,5 +92,61 @@ RSpec.describe Reek::Examiner do
       expect(smell).to be_a(Reek::Smells::SmellWarning)
       expect(smell.message).to eq('calls bar.call_me() 2 times')
     end
+
+    context 'source is empty' do
+      let(:source) do
+        <<-EOS
+            # Just a comment
+            # And another
+        EOS
+      end
+      let(:examiner) do
+        described_class.new(source)
+      end
+
+      it 'has no warnings' do
+        expect(examiner.smells).to eq([])
+      end
+    end
+
+    context 'with an incomprehensible source that causes Reek to crash' do
+      let(:source) { 'class C; def does_crash_reek; end; end' }
+
+      subject do
+        smell_repository = instance_double 'Reek::Smells::SmellRepository'
+        expect(smell_repository).to receive(:examine) do
+          raise ArgumentError, 'Looks like bad source'
+        end
+        class_double('Reek::Smells::SmellRepository').as_stubbed_const
+        allow(Reek::Smells::SmellRepository).to receive(:eligible_smell_types)
+        expect(Reek::Smells::SmellRepository).to receive(:new) { smell_repository }
+
+        examiner = described_class.new source
+        examiner
+      end
+
+      it 'has no warnings' do
+        Reek::CLI::Silencer.silently do
+          expect(subject.smells).to be_empty
+        end
+      end
+
+      describe 'message on STDERR' do
+        it 'contains the origin' do
+          origin = 'string'
+          expect { subject.smells }.to output(/#{origin}/).to_stderr
+        end
+
+        it 'explains what to do' do
+          explanation = 'It would be great if you could report this back to the Reek team'
+          expect { subject.smells }.to output(/#{explanation}/).to_stderr
+        end
+
+        it 'contains the original exception' do
+          original = '#<ArgumentError: Looks like bad source>'
+          expect { subject.smells }.to output(/#{original}/).to_stderr
+        end
+      end
+    end
   end
 end

data/spec/reek/report/json_report_spec.rb

@@ -46,8 +46,7 @@ RSpec.describe Reek::Report::JSONReport do
             "lines":          [1],
             "message":        "doesn't depend on instance state (maybe move it to another class?)",
             "smell_type":     "UtilityFunction",
-            "source":         "string",
-            "name":           "simple"
+            "source":         "string"
           }
         ]
       EOS
@@ -80,7 +79,6 @@ RSpec.describe Reek::Report::JSONReport do
               "message":        "doesn't depend on instance state (maybe move it to another class?)",
               "smell_type":     "UtilityFunction",
               "source":         "string",
-              "name":           "simple",
               "wiki_link":      "https://github.com/troessner/reek/blob/master/docs/Utility-Function.md"
             }
           ]

data/spec/reek/report/xml_report_spec.rb

@@ -15,10 +15,9 @@ RSpec.describe Reek::Report::XMLReport do
 
   context 'source with voliations' do
     it 'prints non-empty checkstyle XML' do
-      path = SAMPLES_PATH.join('two_smelly_files/dirty_one.rb')
-      xml_report.add_examiner Reek::Examiner.new(path)
+      xml_report.add_examiner Reek::Examiner.new(SMELLY_FILE)
       xml = SAMPLES_PATH.join('checkstyle.xml').read
-      xml = xml.gsub(path.to_s, path.expand_path.to_s)
+      xml = xml.gsub(SMELLY_FILE.to_s, SMELLY_FILE.expand_path.to_s)
       expect { xml_report.show }.to output(xml).to_stdout
     end
   end

data/spec/reek/report/yaml_report_spec.rb

@@ -46,7 +46,6 @@ RSpec.describe Reek::Report::YAMLReport do
   message:        "doesn't depend on instance state (maybe move it to another class?)"
   smell_type:     "UtilityFunction"
   source:         "string"
-  name:           "simple"
       EOS
 
       expect(result).to eq expected
@@ -75,7 +74,6 @@ RSpec.describe Reek::Report::YAMLReport do
   message:        "doesn't depend on instance state (maybe move it to another class?)"
   smell_type:     "UtilityFunction"
   source:         "string"
-  name:           "simple"
   wiki_link:      "https://github.com/troessner/reek/blob/master/docs/Utility-Function.md"
         EOS
 

data/spec/reek/smells/attribute_spec.rb

@@ -7,6 +7,17 @@ RSpec.describe Reek::Smells::Attribute do
 
   it_should_behave_like 'SmellDetector'
 
+  it 'reports the right values' do
+    src = <<-EOS
+      class Klass
+        attr_writer :my_attr
+      end
+    EOS
+    expect(src).to reek_of(:Attribute,
+                           lines: [2],
+                           message: 'is a writable attribute')
+  end
+
   context 'with no attributes' do
     it 'records nothing' do
       src = <<-EOS
@@ -34,7 +45,7 @@ RSpec.describe Reek::Smells::Attribute do
           attr_writer :my_attr
         end
       EOS
-      expect(src).to reek_of(:Attribute, name: 'my_attr')
+      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
     end
 
     it 'does not record writer attribute if suppressed with a preceding code comment' do
@@ -53,7 +64,7 @@ RSpec.describe Reek::Smells::Attribute do
           attr_writer :my_attr
         end
       EOS
-      expect(src).to reek_of(:Attribute, name: 'my_attr')
+      expect(src).to reek_of(:Attribute, context: 'Mod#my_attr')
     end
 
     it 'records accessor attribute' do
@@ -62,7 +73,7 @@ RSpec.describe Reek::Smells::Attribute do
           attr_accessor :my_attr
         end
       EOS
-      expect(src).to reek_of(:Attribute, name: 'my_attr')
+      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
     end
 
     it 'records attr defining a writer' do
@@ -71,7 +82,7 @@ RSpec.describe Reek::Smells::Attribute do
           attr :my_attr, true
         end
       EOS
-      expect(src).to reek_of(:Attribute, name: 'my_attr')
+      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
     end
 
     it "doesn't record protected attributes" do
@@ -110,7 +121,7 @@ RSpec.describe Reek::Smells::Attribute do
           attr_writer :my_attr
         end
       EOS
-      expect(src).to reek_of(:Attribute, name: 'my_attr')
+      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
     end
 
     it 'records attr_writer after switching visbility to public' do
@@ -121,7 +132,7 @@ RSpec.describe Reek::Smells::Attribute do
           public :my_attr
         end
       EOS
-      expect(src).to reek_of(:Attribute, name: 'my_attr')
+      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
     end
 
     it 'resets visibility in new contexts' do
@@ -135,7 +146,7 @@ RSpec.describe Reek::Smells::Attribute do
           attr_writer :attr1
         end
       '
-      expect(src).to reek_of(:Attribute)
+      expect(src).to reek_of(:Attribute, context: 'OtherKlass#attr1')
     end
 
     it 'records attr_writer defining a class attribute' do
@@ -146,7 +157,7 @@ RSpec.describe Reek::Smells::Attribute do
           end
         end
       EOS
-      expect(src).to reek_of(:Attribute, name: 'my_attr')
+      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
     end
 
     it 'does not record private class attributes' do
@@ -158,7 +169,7 @@ RSpec.describe Reek::Smells::Attribute do
           end
         end
       EOS
-      expect(src).not_to reek_of(:Attribute, name: 'my_attr')
+      expect(src).not_to reek_of(:Attribute)
     end
 
     it 'tracks visibility in metaclasses separately' do
@@ -170,7 +181,7 @@ RSpec.describe Reek::Smells::Attribute do
           end
         end
       EOS
-      expect(src).to reek_of(:Attribute, name: 'my_attr')
+      expect(src).to reek_of(:Attribute, context: 'Klass#my_attr')
     end
   end
 end

data/spec/reek/smells/boolean_parameter_spec.rb

@@ -7,24 +7,24 @@ RSpec.describe Reek::Smells::BooleanParameter do
     context 'in a method' do
       it 'reports a parameter defaulted to true' do
         src = 'def cc(arga = true); arga; end'
-        expect(src).to reek_of(:BooleanParameter, name: 'arga')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
       end
 
       it 'reports a parameter defaulted to false' do
         src = 'def cc(arga = false) end'
-        expect(src).to reek_of(:BooleanParameter, name: 'arga')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
       end
 
       it 'reports two parameters defaulted to booleans' do
         src = 'def cc(nowt, arga = true, argb = false, &blk) end'
-        expect(src).to reek_of(:BooleanParameter, name: 'arga')
-        expect(src).to reek_of(:BooleanParameter, name: 'argb')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'argb')
       end
 
       it 'reports keyword parameters defaulted to booleans' do
         src = 'def cc(arga: true, argb: false) end'
-        expect(src).to reek_of(:BooleanParameter, name: 'arga')
-        expect(src).to reek_of(:BooleanParameter, name: 'argb')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'argb')
       end
 
       it 'does not report regular parameters' do
@@ -51,18 +51,18 @@ RSpec.describe Reek::Smells::BooleanParameter do
     context 'in a singleton method' do
       it 'reports a parameter defaulted to true' do
         src = 'def self.cc(arga = true) end'
-        expect(src).to reek_of(:BooleanParameter, name: 'arga')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
       end
 
       it 'reports a parameter defaulted to false' do
         src = 'def fred.cc(arga = false) end'
-        expect(src).to reek_of(:BooleanParameter, name: 'arga')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
       end
 
       it 'reports two parameters defaulted to booleans' do
         src = 'def Module.cc(nowt, arga = true, argb = false, &blk) end'
-        expect(src).to reek_of(:BooleanParameter, name: 'arga')
-        expect(src).to reek_of(:BooleanParameter, name: 'argb')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'arga')
+        expect(src).to reek_of(:BooleanParameter, parameter: 'argb')
       end
     end
   end
@@ -76,14 +76,15 @@ RSpec.describe Reek::Smells::BooleanParameter do
       let(:warning) do
         src = 'def cc(arga = true) end'
         ctx = Reek::Context::MethodContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-        detector.inspect(ctx).first
+        detector.sniff(ctx).first
       end
 
       it_should_behave_like 'common fields set correctly'
 
       it 'reports the correct values' do
-        expect(warning.parameters[:name]).to eq('arga')
+        expect(warning.parameters[:parameter]).to eq('arga')
         expect(warning.lines).to eq([1])
+        expect(warning.message).to eq("has boolean parameter 'arga'")
       end
     end
   end

data/spec/reek/smells/class_variable_spec.rb

@@ -12,19 +12,19 @@ RSpec.describe Reek::Smells::ClassVariable do
   context 'with no class variables' do
     it 'records nothing in the class' do
       exp = sexp(:class, :Fred)
-      expect(detector.inspect(Reek::Context::CodeContext.new(nil, exp))).to be_empty
+      expect(detector.sniff(Reek::Context::CodeContext.new(nil, exp))).to be_empty
     end
 
     it 'records nothing in the module' do
       exp = sexp(:module, :Fred)
-      expect(detector.inspect(Reek::Context::CodeContext.new(nil, exp))).to be_empty
+      expect(detector.sniff(Reek::Context::CodeContext.new(nil, exp))).to be_empty
     end
   end
 
   context 'with one class variable' do
     shared_examples_for 'one variable found' do
       let(:ast) { Reek::Source::SourceCode.from(src).syntax_tree }
-      let(:smells) { detector.inspect(Reek::Context::CodeContext.new(nil, ast)) }
+      let(:smells) { detector.sniff(Reek::Context::CodeContext.new(nil, ast)) }
 
       it 'records only that class variable' do
         expect(smells.length).to eq(1)
@@ -85,7 +85,7 @@ RSpec.describe Reek::Smells::ClassVariable do
         end
       EOS
       ctx = Reek::Context::CodeContext.new(nil, Reek::Source::SourceCode.from(src).syntax_tree)
-      detector.inspect(ctx).first
+      detector.sniff(ctx).first
     end
 
     it_should_behave_like 'common fields set correctly'

data/spec/reek/smells/control_parameter_spec.rb

@@ -32,72 +32,72 @@ RSpec.describe Reek::Smells::ControlParameter do
   context 'parameter only used to determine code path' do
     it 'reports a ternary check on a parameter' do
       src = 'def simple(arga) arga ? @ivar : 3 end'
-      expect(src).to reek_of(:ControlParameter, name: 'arga')
+      expect(src).to reek_of(:ControlParameter, argument: 'arga')
     end
 
     it 'reports a couple inside a block' do
       src = 'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on an if statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') if arg end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on an unless statement modifier' do
       src = 'def simple(arg) args = {}; args.merge(\'a\' => \'A\') unless arg end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on if control expression' do
       src = 'def simple(arg) args = {}; if arg then args.merge(\'a\' => \'A\') end end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on if control expression with &&' do
       src = 'def simple(arg) if arg && true then puts "arg" end end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on if control expression with preceding &&' do
       src = 'def simple(arg) if true && arg then puts "arg" end end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on if control expression with two && conditions' do
       src = 'def simple(a) ag = {}; if a && true && true then puts "2" end end'
-      expect(src).to reek_of(:ControlParameter, name: 'a')
+      expect(src).to reek_of(:ControlParameter, argument: 'a')
     end
 
     it 'reports on if control expression with ||' do
       src = 'def simple(arg) args = {}; if arg || true then puts "arg" end end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on if control expression with or' do
       src = 'def simple(arg) args = {}; if arg or true then puts "arg" end end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on if control expression with if' do
       src = 'def simple(arg) args = {}; if (arg if true) then puts "arg" end end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on && notation' do
       src = 'def simple(arg) args = {}; arg && args.merge(\'a\' => \'A\') end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on || notation' do
       src = 'def simple(arg) args = {}; arg || args.merge(\'a\' => \'A\') end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on case statement' do
       src = 'def simple(arg) case arg when nil; nil when false; nil else nil end end'
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on nested if statements that are both control parameters' do
@@ -109,7 +109,7 @@ RSpec.describe Reek::Smells::ControlParameter do
           end
         end
       EOS
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on nested if statements where the inner if is a control parameter' do
@@ -121,7 +121,7 @@ RSpec.describe Reek::Smells::ControlParameter do
           end
         end
       EOS
-      expect(src).to reek_of(:ControlParameter, name: 'arg')
+      expect(src).to reek_of(:ControlParameter, argument: 'arg')
     end
 
     it 'reports on explicit comparison in the condition' do
@@ -277,9 +277,16 @@ RSpec.describe Reek::Smells::ControlParameter do
 
     it_should_behave_like 'common fields set correctly'
 
-    it 'has the correct fields' do
-      expect(warning.parameters[:name]).to eq('arg')
+    it 'reports the argument' do
+      expect(warning.parameters[:argument]).to eq('arg')
+    end
+
+    it 'reports the lines' do
       expect(warning.lines).to eq([3, 5])
     end
+
+    it 'has the right message' do
+      expect(warning.message).to eq('is controlled by argument arg')
+    end
   end
 end