reek 1.3.8 → 1.4.0

data/spec/reek/smells/uncommunicative_parameter_name_spec.rb

@@ -15,54 +15,54 @@ describe UncommunicativeParameterName do
   it_should_behave_like 'SmellDetector'
 
   { 'obj.' => 'with a receiveer',
-    '' => 'without a receiver'}.each do |host, description|
+    '' => 'without a receiver' }.each do |host, description|
     context "in a method definition #{description}" do
       it 'does not recognise *' do
-        "def #{host}help(xray, *) basics(17) end".
-          should_not smell_of(UncommunicativeParameterName)
+        expect("def #{host}help(xray, *) basics(17) end").
+          not_to smell_of(UncommunicativeParameterName)
       end
 
       it "reports parameter's name" do
         src = "def #{host}help(x) basics(x) end"
-        src.should smell_of(UncommunicativeParameterName,
-                            {UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x'})
+        expect(src).to smell_of(UncommunicativeParameterName,
+                                UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x')
       end
 
-      it "does not report unused parameters" do
+      it 'does not report unused parameters' do
         src = "def #{host}help(x) basics(17) end"
-        src.should_not smell_of(UncommunicativeParameterName)
+        expect(src).not_to smell_of(UncommunicativeParameterName)
       end
 
       it 'does not report two-letter parameter names' do
-        "def #{host}help(ab) basics(ab) end".
-          should_not smell_of(UncommunicativeParameterName)
+        expect("def #{host}help(ab) basics(ab) end").
+          not_to smell_of(UncommunicativeParameterName)
       end
 
       it 'reports names of the form "x2"' do
         src = "def #{host}help(x2) basics(x2) end"
-        src.should smell_of(UncommunicativeParameterName,
-                            {UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x2'})
+        expect(src).to smell_of(UncommunicativeParameterName,
+                                UncommunicativeParameterName::PARAMETER_NAME_KEY => 'x2')
       end
 
       it 'reports long name ending in a number' do
         src = "def #{host}help(param2) basics(param2) end"
-        src.should smell_of(UncommunicativeParameterName,
-                            {UncommunicativeParameterName::PARAMETER_NAME_KEY => 'param2'})
+        expect(src).to smell_of(UncommunicativeParameterName,
+                                UncommunicativeParameterName::PARAMETER_NAME_KEY => 'param2')
       end
 
       it 'does not report unused anonymous parameter' do
-        "def #{host}help(_) basics(17) end".
-          should_not smell_of(UncommunicativeParameterName)
+        expect("def #{host}help(_) basics(17) end").
+          not_to smell_of(UncommunicativeParameterName)
       end
 
       it 'reports used anonymous parameter' do
-        "def #{host}help(_) basics(_) end".
-          should smell_of(UncommunicativeParameterName)
+        expect("def #{host}help(_) basics(_) end").
+          to smell_of(UncommunicativeParameterName)
       end
 
       it 'reports used parameters marked as unused' do
-        "def #{host}help(_unused) basics(_unused) end".
-          should smell_of(UncommunicativeParameterName)
+        expect("def #{host}help(_unused) basics(_unused) end").
+          to smell_of(UncommunicativeParameterName)
       end
     end
   end
@@ -78,8 +78,8 @@ describe UncommunicativeParameterName do
     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]
+      expect(@warning.smell[UncommunicativeParameterName::PARAMETER_NAME_KEY]).to eq('bad2')
+      expect(@warning.lines).to eq([1])
     end
   end
 end

data/spec/reek/smells/uncommunicative_variable_name_spec.rb

@@ -15,61 +15,61 @@ describe UncommunicativeVariableName do
 
   it_should_behave_like 'SmellDetector'
 
-  context "field name" do
+  context 'field name' do
     it 'does not report use of one-letter fieldname' do
       src = 'class Thing; def simple(fred) @x end end'
-      src.should_not smell_of(UncommunicativeVariableName)
+      expect(src).not_to smell_of(UncommunicativeVariableName)
     end
     it 'reports one-letter fieldname in assignment' do
       src = 'class Thing; def simple(fred) @x = fred end end'
-      src.should reek_of(:UncommunicativeVariableName, /@x/, /Thing/, /variable name/)
+      expect(src).to reek_of(:UncommunicativeVariableName, /@x/, /Thing/, /variable name/)
     end
   end
 
-  context "local variable name" do
+  context 'local variable name' do
     it 'does not report one-word variable name' do
-      'def help(fred) simple = jim(45) end'.should_not 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
-      'def help(fred) _ = jim(45) end'.should_not smell_of(UncommunicativeVariableName)
+      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'
-      src.should smell_of(UncommunicativeVariableName,
-        {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x')
     end
     it 'reports name of the form "x2"' do
       src = 'def simple(fred) x2 = jim(45) end'
-      src.should smell_of(UncommunicativeVariableName,
-        {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x2'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x2')
     end
     it 'reports long name ending in a number' do
       @bad_var = 'var123'
       src = "def simple(fred) #{@bad_var} = jim(45) end"
-      src.should smell_of(UncommunicativeVariableName,
-        {UncommunicativeVariableName::VARIABLE_NAME_KEY => @bad_var})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => @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)
-      smells.length.should == 1
-      smells[0].subclass.should == UncommunicativeVariableName::SMELL_SUBCLASS
-      smells[0].smell[UncommunicativeVariableName::VARIABLE_NAME_KEY].should == 'x'
-      smells[0].lines.should == [1,1]
+      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].lines).to eq([1, 1])
     end
     it 'reports a bad name inside a block' do
       src = 'def clean(text) text.each { q2 = 3 } end'
-      src.should smell_of(UncommunicativeVariableName,
-        {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'q2'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'q2')
     end
     it 'reports variable name outside any method' do
-      'class Simple; x = jim(45); end'.should reek_of(:UncommunicativeVariableName, /x/)
+      expect('class Simple; x = jim(45); end').to reek_of(:UncommunicativeVariableName, /x/)
     end
   end
 
-  context "block parameter name" do
-    it "reports deep block parameter" do
+  context 'block parameter name' do
+    it 'reports deep block parameter' do
       src = <<EOS
   def bad
     unless @mod then
@@ -77,73 +77,73 @@ describe UncommunicativeVariableName do
     end
   end
 EOS
-      src.should smell_of(UncommunicativeVariableName,
-        {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x')
     end
 
-    it "reports all relevant block parameters" do
+    it 'reports all relevant block parameters' do
       src = <<-EOS
         def bad
           @foo.map { |x, y| x + y }
         end
       EOS
-      src.should smell_of(UncommunicativeVariableName,
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'},
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x' },
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y')
     end
 
-    it "reports block parameters used outside of methods" do
+    it 'reports block parameters used outside of methods' do
       src = <<-EOS
       class Foo
         @foo.map { |x| x * 2 }
       end
       EOS
-      src.should smell_of(UncommunicativeVariableName,
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x')
     end
 
-    it "reports splatted block parameters correctly" do
+    it 'reports splatted block parameters correctly' do
       src = <<-EOS
         def bad
           @foo.map { |*y| y << 1 }
         end
       EOS
-      src.should smell_of(UncommunicativeVariableName,
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y')
     end
 
-    it "reports nested block parameters" do
+    it 'reports nested block parameters' do
       src = <<-EOS
         def bad
           @foo.map { |(x, y)| x + y }
         end
       EOS
-      src.should smell_of(UncommunicativeVariableName,
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'},
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x' },
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y')
     end
 
-    it "reports splatted nested block parameters" do
+    it 'reports splatted nested block parameters' do
       src = <<-EOS
         def bad
           @foo.map { |(x, *y)| x + y }
         end
       EOS
-      src.should smell_of(UncommunicativeVariableName,
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'},
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x' },
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y')
     end
 
-    it "reports deeply nested block parameters" do
+    it 'reports deeply nested block parameters' do
       src = <<-EOS
         def bad
           @foo.map { |(x, (y, z))| x + y + z }
         end
       EOS
-      src.should smell_of(UncommunicativeVariableName,
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x'},
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y'},
-                          {UncommunicativeVariableName::VARIABLE_NAME_KEY => 'z'})
+      expect(src).to smell_of(UncommunicativeVariableName,
+                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'x' },
+                              { UncommunicativeVariableName::VARIABLE_NAME_KEY => 'y' },
+                              UncommunicativeVariableName::VARIABLE_NAME_KEY => 'z')
     end
 
   end
@@ -167,8 +167,8 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the correct values' do
-      @warning.smell['variable_name'].should == 'x2'
-      @warning.lines.should == [3,5]
+      expect(@warning.smell['variable_name']).to eq('x2')
+      expect(@warning.lines).to eq([3, 5])
     end
   end
 
@@ -183,7 +183,7 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the fq context' do
-      @warning.context.should == 'self.bad'
+      expect(@warning.context).to eq('self.bad')
     end
   end
 end

data/spec/reek/smells/unused_parameters_spec.rb

@@ -10,57 +10,67 @@ describe UnusedParameters do
   context 'for methods' do
 
     it 'reports nothing for no parameters' do
-      'def simple; true end'.should_not smell_of(UnusedParameters)
+      expect('def simple; true end').not_to smell_of(UnusedParameters)
     end
 
     it 'reports nothing for used parameter' do
-      'def simple(sum); sum end'.should_not smell_of(UnusedParameters)
+      expect('def simple(sum); sum end').not_to smell_of(UnusedParameters)
     end
 
     it 'reports for 1 used and 2 unused parameter' do
       src = 'def simple(num,sum,denum); sum end'
-      src.should smell_of(UnusedParameters,
-                          {UnusedParameters::PARAMETER_KEY => 'num'},
-                          {UnusedParameters::PARAMETER_KEY => 'denum'})
+      expect(src).to smell_of(UnusedParameters,
+                              { UnusedParameters::PARAMETER_KEY => 'num' },
+                              UnusedParameters::PARAMETER_KEY => 'denum')
     end
 
     it 'reports for 3 used and 1 unused parameter' do
       src = 'def simple(num,sum,denum,quotient); num + denum + sum end'
-      src.should smell_of(UnusedParameters,
-                          {UnusedParameters::PARAMETER_KEY => 'quotient'})
+      expect(src).to smell_of(UnusedParameters,
+                              UnusedParameters::PARAMETER_KEY => 'quotient')
     end
 
     it 'reports nothing for used splatted parameter' do
-      'def simple(*sum); sum end'.should_not smell_of(UnusedParameters)
+      expect('def simple(*sum); sum end').not_to smell_of(UnusedParameters)
     end
 
     it 'reports nothing for unused anonymous parameter' do
-      'def simple(_); end'.should_not smell_of(UnusedParameters)
+      expect('def simple(_); end').not_to smell_of(UnusedParameters)
     end
 
     it 'reports nothing for named parameters prefixed with _' do
-      'def simple(_name); end'.should_not smell_of(UnusedParameters)
+      expect('def simple(_name); end').not_to smell_of(UnusedParameters)
     end
 
     it 'reports nothing for unused anonymous splatted parameter' do
-      'def simple(*); end'.should_not smell_of(UnusedParameters)
+      expect('def simple(*); end').not_to smell_of(UnusedParameters)
     end
 
     it 'reports nothing when using super with implicit arguments' do
-      'def simple(*args); super; end'.should_not smell_of(UnusedParameters)
+      expect('def simple(*args); super; end').not_to smell_of(UnusedParameters)
     end
 
     it 'reports something when using super explicitely passing no arguments' do
-      'def simple(*args); super(); end'.should smell_of(UnusedParameters)
+      expect('def simple(*args); super(); end').to smell_of(UnusedParameters)
     end
 
     it 'reports nothing when using super explicitely passing all arguments' do
-      'def simple(*args); super(*args); end'.should_not smell_of(UnusedParameters)
+      expect('def simple(*args); super(*args); end').not_to smell_of(UnusedParameters)
     end
 
     it 'reports nothing when using super in a nested context' do
-      'def simple(*args); call_other("something", super); end'.
-        should_not smell_of(UnusedParameters)
+      expect('def simple(*args); call_other("something", super); end').
+        not_to smell_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)
+    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)
     end
   end
 end

data/spec/reek/smells/utility_function_spec.rb

@@ -18,7 +18,7 @@ describe UtilityFunction do
       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)
-        @detector.examine_context(ctx).should be_empty
+        expect(@detector.examine_context(ctx)).to be_empty
       end
     end
   end
@@ -26,60 +26,60 @@ describe UtilityFunction do
     it 'does not report empty method' do
       src = 'def simple(arga) end'
       ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
-      @detector.examine_context(ctx).should be_empty
+      expect(@detector.examine_context(ctx)).to be_empty
     end
     it 'does not report literal' do
-      'def simple() 3; end'.should_not reek
+      expect('def simple() 3; end').not_to reek
     end
     it 'does not report instance variable reference' do
-      'def simple() @yellow end'.should_not reek
+      expect('def simple() @yellow end').not_to reek
     end
     it 'does not report vcall' do
-      'def simple() y end'.should_not reek
+      expect('def simple() y end').not_to reek
     end
     it 'does not report references to self' do
-      'def into; self; end'.should_not reek
+      expect('def into; self; end').not_to reek
     end
     it 'recognises an ivar reference within a block' do
-      'def clean(text) text.each { @fred = 3} end'.should_not reek
+      expect('def clean(text) text.each { @fred = 3} end').not_to reek
     end
     it 'copes with nil superclass' do
-      '# clean class for testing purposes
-class Object; def is_maybe?() false end end'.should_not reek
+      expect('# clean class for testing purposes
+class Object; def is_maybe?() false end end').not_to reek
     end
   end
 
   context 'with only one call' do
     it 'does not report a call to a parameter' do
-      'def simple(arga) arga.to_s end'.should_not reek_of(:UtilityFunction, /simple/)
+      expect('def simple(arga) arga.to_s end').not_to reek_of(:UtilityFunction, /simple/)
     end
     it 'does not report a call to a constant' do
-      'def simple(arga) FIELDS[arga] end'.should_not reek
+      expect('def simple(arga) FIELDS[arga] end').not_to reek
     end
   end
 
   context 'with two or more calls' do
     it 'reports two calls' do
-      'def simple(arga) arga.to_s + arga.to_i end'.should reek_of(:UtilityFunction, /simple/)
+      expect('def simple(arga) arga.to_s + arga.to_i end').to reek_of(:UtilityFunction, /simple/)
     end
     it 'counts a local call in a param initializer' do
-      'def simple(arga=local) arga.to_s end'.should_not reek_of(:UtilityFunction)
+      expect('def simple(arga=local) arga.to_s end').not_to reek_of(:UtilityFunction)
     end
     it 'should count usages of self'do
-      'def <=>(other) Options[:sort_order].compare(self, other) end'.should_not reek
+      expect('def <=>(other) Options[:sort_order].compare(self, other) end').not_to reek
     end
     it 'should count self reference within a dstr' do
-      'def as(alias_name); "#{self} as #{alias_name}".to_sym; end'.should_not reek
+      expect('def as(alias_name); "#{self} as #{alias_name}".to_sym; end').not_to reek
     end
     it 'should count calls to self within a dstr' do
-      'def to_sql; "\'#{self.gsub(/\'/, "\'\'")}\'"; end'.should_not reek
+      expect('def to_sql; "\'#{self.gsub(/\'/, "\'\'")}\'"; end').not_to reek
     end
     it 'should report message chain' do
-      'def simple(arga) arga.b.c end'.should reek_of(:UtilityFunction, /simple/)
+      expect('def simple(arga) arga.b.c end').to reek_of(:UtilityFunction, /simple/)
     end
 
     it 'does not report a method that calls super' do
-      'def child(arg) super; arg.to_s; end'.should_not reek
+      expect('def child(arg) super; arg.to_s; end').not_to reek
     end
 
     it 'should recognise a deep call' do
@@ -95,7 +95,7 @@ class Object; def is_maybe?() false end end'.should_not reek
     end
   end
 EOS
-      src.should_not reek
+      expect(src).not_to reek
     end
   end
 
@@ -115,7 +115,7 @@ EOS
     it_should_behave_like 'common fields set correctly'
 
     it 'reports the line number of the method' do
-      @warning.lines.should == [1]
+      expect(@warning.lines).to eq([1])
     end
   end
 end