reek 1.5.1 → 1.6.0

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -25,7 +25,7 @@ describe UncommunicativeParameterName do
       it "reports parameter's name" do
         src = "def #{host}help(x) basics(x) end"
         expect(src).to smell_of(UncommunicativeParameterName,
-                                UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x')
+                                name: 'x')
       end
 
       it 'does not report unused parameters' do
@@ -41,13 +41,13 @@ describe UncommunicativeParameterName do
       it 'reports names of the form "x2"' do
         src = "def #{host}help(x2) basics(x2) end"
         expect(src).to smell_of(UncommunicativeParameterName,
-                                UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x2')
+                                name: 'x2')
       end
 
       it 'reports long name ending in a number' do
         src = "def #{host}help(param2) basics(param2) end"
         expect(src).to smell_of(UncommunicativeParameterName,
-                                UncommunicativeParameterName::PARAMETER_NAME_KEY => 'param2')
+                                name: 'param2')
       end
 
       it 'does not report unused anonymous parameter' do
@@ -78,7 +78,7 @@ describe UncommunicativeParameterName do
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the correct values' do
-      expect(@warning.smell[UncommunicativeParameterName::PARAMETER_NAME_KEY]).to eq('bad2')
+      expect(@warning.parameters[:name]).to eq('bad2')
       expect(@warning.lines).to eq([1])
     end
   end

data/spec/reek/smells/uncommunicative_variable_name_spec.rb

@@ -28,41 +28,49 @@ 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 smell_of(UncommunicativeVariableName)
+      expect('def help(fred) simple = jim(45) end').
+        not_to smell_of(UncommunicativeVariableName)
     end
+
     it 'does not report single underscore as a variable name' do
       expect('def help(fred) _ = jim(45) end').not_to smell_of(UncommunicativeVariableName)
     end
+
     it 'reports one-letter variable name' do
       src = 'def simple(fred) x = jim(45) end'
       expect(src).to smell_of(UncommunicativeVariableName,
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x')
+                              name: 'x')
     end
+
     it 'reports name of the form "x2"' do
       src = 'def simple(fred) x2 = jim(45) end'
       expect(src).to smell_of(UncommunicativeVariableName,
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x2')
+                              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 smell_of(UncommunicativeVariableName,
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => @bad_var)
+                              name: @bad_var)
     end
+
     it 'reports variable name only once' do
       src = 'def simple(fred) x = jim(45); x = y end'
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
       smells = @detector.examine_context(ctx)
       expect(smells.length).to eq(1)
-      expect(smells[0].subclass).to eq(UncommunicativeVariableName::SMELL_SUBCLASS)
-      expect(smells[0].smell[UncommunicativeVariableName::VARIABLE_NAME_KEY]).to eq('x')
+      expect(smells[0].smell_type).to eq(UncommunicativeVariableName.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 smell_of(UncommunicativeVariableName,
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'q2')
+                              name: 'q2')
     end
+
     it 'reports variable name outside any method' do
       expect('class Simple; x = jim(45); end').to reek_of(:UncommunicativeVariableName, /x/)
     end
@@ -78,7 +86,7 @@ describe UncommunicativeVariableName do
   end
 EOS
       expect(src).to smell_of(UncommunicativeVariableName,
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x')
+                              name: 'x')
     end
 
     it 'reports all relevant block parameters' do
@@ -88,8 +96,8 @@ EOS
         end
       EOS
       expect(src).to smell_of(UncommunicativeVariableName,
-                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x' },
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y')
+                              { name: 'x' },
+                              { name: 'y' })
     end
 
     it 'reports block parameters used outside of methods' do
@@ -99,7 +107,7 @@ EOS
       end
       EOS
       expect(src).to smell_of(UncommunicativeVariableName,
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x')
+                              name: 'x')
     end
 
     it 'reports splatted block parameters correctly' do
@@ -109,7 +117,7 @@ EOS
         end
       EOS
       expect(src).to smell_of(UncommunicativeVariableName,
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y')
+                              name: 'y')
     end
 
     it 'reports nested block parameters' do
@@ -119,8 +127,8 @@ EOS
         end
       EOS
       expect(src).to smell_of(UncommunicativeVariableName,
-                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x' },
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y')
+                              { name: 'x' },
+                              { name: 'y' })
     end
 
     it 'reports splatted nested block parameters' do
@@ -130,8 +138,8 @@ EOS
         end
       EOS
       expect(src).to smell_of(UncommunicativeVariableName,
-                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x' },
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y')
+                              { name: 'x' },
+                              { name: 'y' })
     end
 
     it 'reports deeply nested block parameters' do
@@ -141,11 +149,10 @@ EOS
         end
       EOS
       expect(src).to smell_of(UncommunicativeVariableName,
-                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x' },
-                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y' },
-                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'z')
+                              { name: 'x' },
+                              { name: 'y' },
+                              { name: 'z' })
     end
-
   end
 
   context 'when a smell is reported' do
@@ -167,7 +174,7 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the correct values' do
-      expect(@warning.smell['variable_name']).to eq('x2')
+      expect(@warning.parameters[:name]).to eq('x2')
       expect(@warning.lines).to eq([3, 5])
     end
   end

data/spec/reek/smells/unused_parameters_spec.rb

@@ -6,9 +6,7 @@ include Reek
 include Reek::Smells
 
 describe UnusedParameters do
-
   context 'for methods' do
-
     it 'reports nothing for no parameters' do
       expect('def simple; true end').not_to smell_of(UnusedParameters)
     end
@@ -20,14 +18,14 @@ describe UnusedParameters do
     it 'reports for 1 used and 2 unused parameter' do
       src = 'def simple(num,sum,denum); sum end'
       expect(src).to smell_of(UnusedParameters,
-                              { UnusedParameters::PARAMETER_KEY => 'num' },
-                              UnusedParameters::PARAMETER_KEY => 'denum')
+                              { name: 'num' },
+                              { 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 smell_of(UnusedParameters,
-                              UnusedParameters::PARAMETER_KEY => 'quotient')
+                              name: 'quotient')
     end
 
     it 'reports nothing for used splatted parameter' do

data/spec/reek/smells/utility_function_spec.rb

@@ -59,7 +59,8 @@ describe UtilityFunction do
 
   context 'with two or more calls' do
     it 'reports two calls' do
-      expect('def simple(arga) arga.to_s + arga.to_i end').to reek_of(:UtilityFunction, /simple/)
+      src = 'def simple(arga) arga.to_s + arga.to_i end'
+      expect(src).to reek_of(:UtilityFunction, /simple/)
     end
     it 'counts a local call in a param initializer' do
       expect('def simple(arga=local) arga.to_s end').not_to reek_of(:UtilityFunction)

data/spec/reek/source/code_comment_spec.rb

@@ -45,7 +45,10 @@ describe CodeComment do
       expect(config['NestedIterators']['enabled']).to be_truthy
     end
     it 'parses multiple hashed options' do
-      config = CodeComment.new("# :reek:Duplication: { enabled: false }\n:reek:nested_iterators: { enabled: true }").config
+      config = CodeComment.new('
+        # :reek:Duplication: { enabled: false }
+        :reek:nested_iterators: { enabled: true }
+      ').config
       expect(config).to include('Duplication', 'NestedIterators')
       expect(config['Duplication']).to include('enabled')
       expect(config['Duplication']['enabled']).to be_falsey
@@ -53,7 +56,9 @@ describe CodeComment do
       expect(config['NestedIterators']['enabled']).to be_truthy
     end
     it 'parses multiple hashed options on the same line' do
-      config = CodeComment.new('# :reek:Duplication: { enabled: false } and :reek:nested_iterators: { enabled: true }').config
+      config = CodeComment.new('
+        #:reek:Duplication: { enabled: false } and :reek:nested_iterators: { enabled: true }
+      ').config
       expect(config).to include('Duplication', 'NestedIterators')
       expect(config['Duplication']).to include('enabled')
       expect(config['Duplication']['enabled']).to be_falsey

data/spec/reek/source/reference_collector_spec.rb

@@ -4,7 +4,6 @@ require 'reek/source/reference_collector'
 include Reek::Source
 
 describe ReferenceCollector do
-
   context 'counting refs to self' do
     def refs_to_self(src)
       ReferenceCollector.new(src.to_reek_source.syntax_tree).num_refs_to_self

data/spec/reek/source/sexp_extensions_spec.rb

@@ -24,7 +24,6 @@ describe SexpExtensions::DefNode do
     it 'includes no marker in its full name with empty outer scope' do
       expect(@node.full_name('')).to eq 'hello'
     end
-
   end
 
   context 'with 1 parameter' do
@@ -48,7 +47,6 @@ describe SexpExtensions::DefNode do
     it 'includes no marker in its full name with empty outer scope' do
       expect(@node.full_name('')).to eq 'hello'
     end
-
   end
 
   context 'with a block parameter' do
@@ -74,7 +72,6 @@ describe SexpExtensions::DefNode do
     it 'includes no marker in its full name with empty outer scope' do
       expect(@node.full_name('')).to eq 'hello'
     end
-
   end
 
   context 'with 1 defaulted parameter' do
@@ -99,7 +96,6 @@ describe SexpExtensions::DefNode do
     it 'includes no marker in its full name with empty outer scope' do
       expect(@node.full_name('')).to eq 'hello'
     end
-
   end
 
   context 'with a body with 2 statements' do
@@ -160,7 +156,6 @@ describe SexpExtensions::DefsNode do
     it 'includes no marker in its full name with empty outer scope' do
       expect(@node.full_name('')).to eq 'obj.hello'
     end
-
   end
 
   context 'with 1 parameter' do
@@ -184,7 +179,6 @@ describe SexpExtensions::DefsNode do
     it 'includes no marker in its full name with empty outer scope' do
       expect(@node.full_name('')).to eq 'obj.hello'
     end
-
   end
 
   context 'with a block' do
@@ -210,7 +204,6 @@ describe SexpExtensions::DefsNode do
     it 'includes no marker in its full name with empty outer scope' do
       expect(@node.full_name('')).to eq 'obj.hello'
     end
-
   end
 
   context 'with 1 defaulted parameter' do
@@ -235,7 +228,6 @@ describe SexpExtensions::DefsNode do
     it 'includes no marker in its full name with empty outer scope' do
       expect(@node.full_name('')).to eq 'obj.hello'
     end
-
   end
 
   context 'with a body with 2 statements' do
@@ -254,9 +246,7 @@ describe SexpExtensions::DefsNode do
       b = @node.body
       expect(b.class.included_modules.first).to eq SexpNode
     end
-
   end
-
 end
 
 describe SexpExtensions::SendNode do
@@ -268,7 +258,6 @@ describe SexpExtensions::SendNode do
     it 'has no argument names' do
       expect(@node.arg_names).to eq []
     end
-
   end
 
   context 'with 1 literal parameter' do
@@ -279,7 +268,6 @@ describe SexpExtensions::SendNode do
     it 'has 1 argument name' do
       expect(@node.arg_names).to eq [:param]
     end
-
   end
 
   context 'with 2 literal parameters' do
@@ -290,9 +278,7 @@ describe SexpExtensions::SendNode do
     it 'has 2 argument names' do
       expect(@node.arg_names).to eq [:x, :y]
     end
-
   end
-
 end
 
 describe SexpExtensions::BlockNode do
@@ -304,7 +290,6 @@ describe SexpExtensions::BlockNode do
     it 'has no parameter names' do
       expect(@node.parameter_names).to eq []
     end
-
   end
 
   context 'with 1 parameter' do

data/spec/reek/source/source_code_spec.rb

@@ -11,6 +11,18 @@ describe SourceCode do
       result = source_code.syntax_tree
       expect(result.comments).to eq "# this is\n# a comment"
     end
+
+    it 'cleanly processes empty source' do
+      source_code = SourceCode.new('', '(string)')
+      result = source_code.syntax_tree
+      expect(result).to be_nil
+    end
+
+    it 'cleanly processes empty source with comments' do
+      source_code = SourceCode.new("# this is\n# a comment\n", '(string)')
+      result = source_code.syntax_tree
+      expect(result).to be_nil
+    end
   end
 
   context 'when the parser fails' do
@@ -31,7 +43,7 @@ describe SourceCode do
       end
 
       it 'returns an empty syntax tree' do
-        expect(src.syntax_tree).to eq(s(:empty))
+        expect(src.syntax_tree).to be_nil
       end
 
       it 'records the syntax error' do

data/spec/reek/spec/should_reek_only_of_spec.rb

@@ -6,9 +6,9 @@ include Reek::Spec
 
 describe ShouldReekOnlyOf do
   before :each do
-    @expected_smell_class = :NestedIterators
+    @expected_smell_type = :NestedIterators
     @expected_context_name = 'SmellyClass#big_method'
-    @matcher = ShouldReekOnlyOf.new(@expected_smell_class, [/#{@expected_context_name}/])
+    @matcher = ShouldReekOnlyOf.new(@expected_smell_type, [/#{@expected_context_name}/])
     @examiner = double('examiner').as_null_object
     expect(@examiner).to receive(:smells) { smells }
     @match = @matcher.matches_examiner?(@examiner)
@@ -27,7 +27,7 @@ describe ShouldReekOnlyOf do
         expect(@matcher.failure_message).to match(@source)
       end
       it 'reports the expected smell class' do
-        expect(@matcher.failure_message).to match(@expected_smell_class.to_s)
+        expect(@matcher.failure_message).to match(@expected_smell_type.to_s)
       end
     end
   end
@@ -41,18 +41,23 @@ describe ShouldReekOnlyOf do
   end
 
   context 'with 1 non-matching smell' do
+    let(:control_couple_detector) { build(:smell_detector, smell_type: 'ControlParameter') }
+
     def smells
-      [SmellWarning.new('ControlCouple', 'context', [1], 'any old message')]
+      [build(:smell_warning, smell_detector: control_couple_detector)]
     end
 
     it_should_behave_like 'no match'
   end
 
   context 'with 2 non-matching smells' do
+    let(:control_couple_detector) { build(:smell_detector, smell_type: 'ControlParameter') }
+    let(:feature_envy_detector) { build(:smell_detector, smell_type: 'FeatureEnvy') }
+
     def smells
       [
-        SmellWarning.new('ControlCouple', 'context', [1], 'any old message'),
-        SmellWarning.new('FeatureEnvy', 'context', [1], 'any old message')
+        build(:smell_warning, smell_detector: control_couple_detector),
+        build(:smell_warning, smell_detector: feature_envy_detector)
       ]
     end
 
@@ -60,10 +65,14 @@ describe ShouldReekOnlyOf do
   end
 
   context 'with 1 non-matching and 1 matching smell' do
+    let(:control_couple_detector) { build(:smell_detector, smell_type: 'ControlParameter') }
+
     def smells
+      detector = build(:smell_detector, smell_type: @expected_smell_type.to_s)
       [
-        SmellWarning.new('ControlCouple', 'context', [1], 'any old message'),
-        SmellWarning.new(@expected_smell_class.to_s, 'context', [1], "message mentioning #{@expected_context_name}")
+        build(:smell_warning, smell_detector: control_couple_detector),
+        build(:smell_warning, smell_detector: detector,
+                              message: "message mentioning #{@expected_context_name}")
       ]
     end
 
@@ -72,13 +81,16 @@ describe ShouldReekOnlyOf do
 
   context 'with 1 matching smell' do
     def smells
-      [SmellWarning.new(@expected_smell_class.to_s, nil, [1], "message mentioning #{@expected_context_name}")]
+      detector = build(:smell_detector, smell_type: @expected_smell_type.to_s)
+
+      [build(:smell_warning, smell_detector: detector,
+                             message: "message mentioning #{@expected_context_name}")]
     end
     it 'matches' do
       expect(@match).to be_truthy
     end
     it 'reports the expected smell when no match was expected' do
-      expect(@matcher.failure_message_when_negated).to match(@expected_smell_class.to_s)
+      expect(@matcher.failure_message_when_negated).to match(@expected_smell_type.to_s)
     end
     it 'reports the source when no match was expected' do
       source = 'the_path/to_a/source_file.rb'