reek 1.6.6 → 2.0.0

data/spec/reek/smells/uncommunicative_method_name_spec.rb

@@ -18,7 +18,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 smell_of(UncommunicativeMethodName)
+      expect(src).not_to reek_of(UncommunicativeMethodName)
     end
   end
 

data/spec/reek/smells/uncommunicative_module_name_spec.rb

@@ -19,15 +19,19 @@ describe UncommunicativeModuleName do
     it 'does not report one-word name' do
       expect("#{type} Helper; end").not_to reek_of(:UncommunicativeModuleName)
     end
+
     it 'reports one-letter name' do
-      expect("#{type} X; end").to reek_of(:UncommunicativeModuleName, /X/)
+      expect("#{type} X; end").to reek_of(:UncommunicativeModuleName,  name: 'X')
     end
+
     it 'reports name of the form "x2"' do
-      expect("#{type} X2; end").to reek_of(:UncommunicativeModuleName, /X2/)
+      expect("#{type} X2; end").to reek_of(:UncommunicativeModuleName,  name: 'X2')
     end
+
     it 'reports long name ending in a number' do
-      expect("#{type} Printer2; end").to reek_of(:UncommunicativeModuleName, /Printer2/)
+      expect("#{type} Printer2; end").to reek_of(:UncommunicativeModuleName,  name: 'Printer2')
     end
+
     it 'reports a bad scoped name' do
       src = "#{type} Foo::X; end"
       ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -19,50 +19,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 smell_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 smell_of(UncommunicativeParameterName,
-                                name: 'x')
+        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 smell_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 smell_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 smell_of(UncommunicativeParameterName,
-                                name: 'x2')
+        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 smell_of(UncommunicativeParameterName,
-                                name: 'param2')
+        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 smell_of(UncommunicativeParameterName)
+          not_to reek_of(UncommunicativeParameterName)
       end
 
       it 'reports used anonymous parameter' do
         expect("def #{host}help(_) basics(_) end").
-          to smell_of(UncommunicativeParameterName)
+          to reek_of(UncommunicativeParameterName)
       end
 
       it 'reports used parameters marked as unused' do
         expect("def #{host}help(_unused) basics(_unused) end").
-          to smell_of(UncommunicativeParameterName)
+          to reek_of(UncommunicativeParameterName)
       end
     end
   end

data/spec/reek/smells/uncommunicative_variable_name_spec.rb

@@ -22,37 +22,35 @@ describe UncommunicativeVariableName do
     end
     it 'reports one-letter fieldname in assignment' do
       src = 'class Thing; def simple(fred) @x = fred end end'
-      expect(src).to reek_of(:UncommunicativeVariableName, /@x/, /Thing/, /variable name/)
+      expect(src).to reek_of(:UncommunicativeVariableName,  name: '@x')
     end
   end
 
   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)
+        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 smell_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 smell_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 smell_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 smell_of(UncommunicativeVariableName,
-                              name: @bad_var)
+      expect(src).to reek_of(UncommunicativeVariableName,
+                             name: @bad_var)
     end
 
     it 'reports variable name only once' do
@@ -67,26 +65,24 @@ describe UncommunicativeVariableName do
 
     it 'reports a bad name inside a block' do
       src = 'def clean(text) text.each { q2 = 3 } end'
-      expect(src).to smell_of(UncommunicativeVariableName,
-                              name: 'q2')
+      expect(src).to reek_of(UncommunicativeVariableName, name: 'q2')
     end
 
     it 'reports variable name outside any method' do
-      expect('class Simple; x = jim(45); end').to reek_of(:UncommunicativeVariableName, /x/)
+      expect('class Simple; x = jim(45); end').to reek_of(:UncommunicativeVariableName,  name: 'x')
     end
   end
 
   context 'block parameter name' do
     it 'reports deep block parameter' do
-      src = <<EOS
-  def bad
-    unless @mod then
-      @sig.each { |x| x.to_s }
-    end
-  end
-EOS
-      expect(src).to smell_of(UncommunicativeVariableName,
-                              name: 'x')
+      src = <<-EOS
+        def bad
+          unless @mod then
+            @sig.each { |x| x.to_s }
+          end
+        end
+      EOS
+      expect(src).to reek_of(UncommunicativeVariableName, name: 'x')
     end
 
     it 'reports all relevant block parameters' do
@@ -95,9 +91,8 @@ EOS
           @foo.map { |x, y| x + y }
         end
       EOS
-      expect(src).to smell_of(UncommunicativeVariableName,
-                              { name: 'x' },
-                              { 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
@@ -106,8 +101,7 @@ EOS
         @foo.map { |x| x * 2 }
       end
       EOS
-      expect(src).to smell_of(UncommunicativeVariableName,
-                              name: 'x')
+      expect(src).to reek_of(UncommunicativeVariableName, name: 'x')
     end
 
     it 'reports splatted block parameters correctly' do
@@ -116,8 +110,7 @@ EOS
           @foo.map { |*y| y << 1 }
         end
       EOS
-      expect(src).to smell_of(UncommunicativeVariableName,
-                              name: 'y')
+      expect(src).to reek_of(UncommunicativeVariableName, name: 'y')
     end
 
     it 'reports nested block parameters' do
@@ -126,9 +119,8 @@ EOS
           @foo.map { |(x, y)| x + y }
         end
       EOS
-      expect(src).to smell_of(UncommunicativeVariableName,
-                              { name: 'x' },
-                              { 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
@@ -137,9 +129,8 @@ EOS
           @foo.map { |(x, *y)| x + y }
         end
       EOS
-      expect(src).to smell_of(UncommunicativeVariableName,
-                              { name: 'x' },
-                              { 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
@@ -148,10 +139,9 @@ EOS
           @foo.map { |(x, (y, z))| x + y + z }
         end
       EOS
-      expect(src).to smell_of(UncommunicativeVariableName,
-                              { name: 'x' },
-                              { name: 'y' },
-                              { 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
 

data/spec/reek/smells/unused_parameters_spec.rb

@@ -8,67 +8,66 @@ 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)
+      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 smell_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 smell_of(UnusedParameters,
-                              { name: 'num' },
-                              { 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 smell_of(UnusedParameters,
-                              name: 'quotient')
+      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 smell_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 smell_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 smell_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 smell_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 smell_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 smell_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 smell_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 smell_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 smell_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 smell_of(UnusedParameters)
+        not_to reek_of(UnusedParameters)
     end
   end
 end

data/spec/reek/smells/utility_function_spec.rb

@@ -22,27 +22,34 @@ describe UtilityFunction do
       end
     end
   end
+
   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)
       expect(@detector.examine_context(ctx)).to be_empty
     end
+
     it 'does not report literal' do
       expect('def simple() 3; end').not_to reek_of(:UtilityFunction)
     end
+
     it 'does not report instance variable reference' do
       expect('def simple() @yellow end').not_to reek_of(:UtilityFunction)
     end
+
     it 'does not report vcall' do
       expect('def simple() y end').not_to reek_of(:UtilityFunction)
     end
+
     it 'does not report references to self' do
       expect('def into; self; end').not_to reek_of(:UtilityFunction)
     end
+
     it 'recognises an ivar reference within a block' do
       expect('def clean(text) text.each { @fred = 3} end').not_to reek_of(:UtilityFunction)
     end
+
     it 'copes with nil superclass' do
       expect('class Object; def is_maybe?() false end end').not_to reek_of(:UtilityFunction)
     end
@@ -50,8 +57,9 @@ describe UtilityFunction do
 
   context 'with only one call' do
     it 'does not report a call to a parameter' do
-      expect('def simple(arga) arga.to_s end').not_to reek_of(:UtilityFunction, /simple/)
+      expect('def simple(arga) arga.to_s end').not_to reek_of(:UtilityFunction,  name: 'simple')
     end
+
     it 'does not report a call to a constant' do
       expect('def simple(arga) FIELDS[arga] end').not_to reek_of(:UtilityFunction)
     end
@@ -60,25 +68,30 @@ describe UtilityFunction do
   context 'with two or more calls' do
     it 'reports two calls' do
       src = 'def simple(arga) arga.to_s + arga.to_i end'
-      expect(src).to reek_of(:UtilityFunction, /simple/)
+      expect(src).to reek_of(:UtilityFunction,  name: '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)
     end
+
     it 'should count usages of self'do
       expect('def <=>(other) Options[:sort_order].compare(self, other) end').
         not_to reek_of(:UtilityFunction)
     end
+
     it 'should count self reference within a dstr' do
       expect('def as(alias_name); "#{self} as #{alias_name}".to_sym; end').
         not_to reek_of(:UtilityFunction)
     end
+
     it 'should count calls to self within a dstr' do
       expect('def to_sql; "\'#{self.gsub(/\'/, "\'\'")}\'"; end').
         not_to reek_of(:UtilityFunction)
     end
+
     it 'should report message chain' do
-      expect('def simple(arga) arga.b.c end').to reek_of(:UtilityFunction, /simple/)
+      expect('def simple(arga) arga.b.c end').to reek_of(:UtilityFunction,  name: 'simple')
     end
 
     it 'does not report a method that calls super' do
@@ -103,11 +116,11 @@ describe UtilityFunction do
 
   context 'when a smells is reported' do
     before :each do
-      src = <<EOS
-def simple(arga)
-  arga.b.c
-end
-EOS
+      src = <<-EOS
+        def simple(arga)
+          arga.b.c
+        end
+      EOS
       source = src.to_reek_source
       sniffer = Sniffer.new(source)
       mctx = CodeParser.new(sniffer).process_def(source.syntax_tree)

data/spec/reek/spec/should_reek_of_spec.rb

@@ -11,11 +11,13 @@ describe ShouldReekOf do
     end
 
     it 'reports duplicate calls to @other.thing' do
-      expect(@ruby).to reek_of(:Duplication, /@other.thing[^\.]/)
+      expect(@ruby).to reek_of(:Duplication,  name: '@other.thing')
     end
+
     it 'reports duplicate calls to @other.thing.foo' do
-      expect(@ruby).to reek_of(:Duplication, /@other.thing.foo/)
+      expect(@ruby).to reek_of(:Duplication,  name: '@other.thing.foo')
     end
+
     it 'does not report any feature envy' do
       expect(@ruby).not_to reek_of(:FeatureEnvy)
     end
@@ -25,7 +27,7 @@ describe ShouldReekOf do
     before :each do
       @clean_code = 'def good() true; end'
       @smelly_code = 'def x() y = 4; end'
-      @matcher = ShouldReekOf.new(:UncommunicativeVariableName, [/x/, /y/])
+      @matcher = ShouldReekOf.new(:UncommunicativeVariableName,  name: 'y')
     end
 
     it 'matches a smelly String' do
@@ -42,11 +44,22 @@ describe ShouldReekOf do
     end
   end
 
+  context 'passing in smell_details with unknown parameter name' do
+    before :each do
+      @smelly_code = 'def x() y = 4; end'
+      @matcher = ShouldReekOf.new(:UncommunicativeVariableName,  foo: 'y')
+    end
+
+    it 'raises ArgumentError' do
+      expect { @matcher.matches?(@smelly_code) }.to raise_error(ArgumentError)
+    end
+  end
+
   context 'checking code in a Dir' do
     before :each do
       @clean_dir = Dir['spec/samples/three_clean_files/*.rb']
       @smelly_dir = Dir['spec/samples/two_smelly_files/*.rb']
-      @matcher = ShouldReekOf.new(:UncommunicativeVariableName, [/Dirty/, /@s/])
+      @matcher = ShouldReekOf.new(:UncommunicativeVariableName, name: '@s')
     end
 
     it 'matches a smelly String' do
@@ -62,7 +75,7 @@ describe ShouldReekOf do
     before :each do
       @clean_file = File.new(Dir['spec/samples/three_clean_files/*.rb'][0])
       @smelly_file = File.new(Dir['spec/samples/two_smelly_files/*.rb'][0])
-      @matcher = ShouldReekOf.new(:UncommunicativeVariableName, [/Dirty/, /@s/])
+      @matcher = ShouldReekOf.new(:UncommunicativeVariableName, name: '@s')
     end
 
     it 'matches a smelly String' do