rubocop 0.21.0 → 0.22.0

data/spec/rubocop/cop/lint/unused_method_argument_spec.rb

@@ -5,136 +5,246 @@ require 'spec_helper'
 describe Rubocop::Cop::Lint::UnusedMethodArgument do
   subject(:cop) { described_class.new }
 
-  before do
-    inspect_source(cop, source)
-  end
+  context 'inspection' do
+    before do
+      inspect_source(cop, source)
+    end
+
+    context 'when a method takes multiple arguments' do
+      context 'and an argument is unused' do
+        let(:source) { <<-END }
+          def some_method(foo, bar)
+            puts bar
+          end
+        END
+
+        it 'registers an offense' do
+          expect(cop.offenses.size).to eq(1)
+          expect(cop.offenses.first.message).to eq(
+            'Unused method argument - `foo`. ' \
+            "If it's necessary, use `_` or `_foo` " \
+            "as an argument name to indicate that it won't be used."
+          )
+          expect(cop.offenses.first.severity.name).to eq(:warning)
+          expect(cop.offenses.first.line).to eq(1)
+          expect(cop.highlights).to eq(['foo'])
+        end
+      end
+
+      context 'and all the arguments are unused' do
+        let(:source) { <<-END }
+          def some_method(foo, bar)
+          end
+        END
+
+        it 'registers offenses and suggests the use of `*`' do
+          expect(cop.offenses.size).to eq(2)
+          expect(cop.offenses.first.message).to eq(
+            'Unused method argument - `foo`. ' \
+            "If it's necessary, use `_` or `_foo` " \
+            "as an argument name to indicate that it won't be used. " \
+            'You can also write as `some_method(*)` if you want the method ' \
+            "to accept any arguments but don't care about them.")
+        end
+      end
+    end
 
-  context 'when a method takes multiple arguments' do
-    context 'and an argument is unused' do
+    context 'when a singleton method argument is unused' do
       let(:source) { <<-END }
-        def some_method(foo, bar)
-          puts bar
+        def self.some_method(foo)
         end
       END
 
       it 'registers an offense' do
         expect(cop.offenses.size).to eq(1)
-        expect(cop.offenses.first.message).to eq(
-          'Unused method argument - `foo`. ' \
-          "If it's necessary, use `_` or `_foo` " \
-          "as an argument name to indicate that it won't be used."
-        )
-        expect(cop.offenses.first.severity.name).to eq(:warning)
         expect(cop.offenses.first.line).to eq(1)
         expect(cop.highlights).to eq(['foo'])
       end
     end
 
-    context 'and all the arguments are unused' do
+    context 'when an underscore-prefixed method argument is unused' do
       let(:source) { <<-END }
-        def some_method(foo, bar)
+        def some_method(_foo)
         end
       END
 
-      it 'registers offenses and suggests the use of `*`' do
-        expect(cop.offenses.size).to eq(2)
-        expect(cop.offenses.first.message).to eq(
-          'Unused method argument - `foo`. ' \
-          "If it's necessary, use `_` or `_foo` " \
-          "as an argument name to indicate that it won't be used. " \
-          'You can also write as `some_method(*)` if you want the method ' \
-          "to accept any arguments but don't care about them.")
+      it 'accepts' do
+        expect(cop.offenses).to be_empty
       end
     end
-  end
 
-  context 'when a singleton method argument is unused' do
-    let(:source) { <<-END }
-      def self.some_method(foo)
-      end
-    END
+    context 'when a method argument is used' do
+      let(:source) { <<-END }
+        def some_method(foo)
+          puts foo
+        end
+      END
 
-    it 'registers an offense' do
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.line).to eq(1)
-      expect(cop.highlights).to eq(['foo'])
+      it 'accepts' do
+        expect(cop.offenses).to be_empty
+      end
     end
-  end
 
-  context 'when an underscore-prefixed method argument is unused' do
-    let(:source) { <<-END }
-      def some_method(_foo)
+    context 'when a variable is unused' do
+      let(:source) { <<-END }
+        def some_method
+          foo = 1
+        end
+      END
+
+      it 'does not care' do
+        expect(cop.offenses).to be_empty
       end
-    END
+    end
+
+    context 'when a block argument is unused' do
+      let(:source) { <<-END }
+        1.times do |foo|
+        end
+      END
 
-    it 'accepts' do
-      expect(cop.offenses).to be_empty
+      it 'does not care' do
+        expect(cop.offenses).to be_empty
+      end
     end
-  end
 
-  context 'when a method argument is used' do
-    let(:source) { <<-END }
-      def some_method(foo)
-        puts foo
+    context 'in a method calling `super` without arguments' do
+      context 'when a method argument is not used explicitly' do
+        let(:source) { <<-END }
+          def some_method(foo)
+            super
+          end
+        END
+
+        it 'accepts since the arguments are guaranteed to be the same as ' \
+           "superclass' ones and the user has no control on them" do
+          expect(cop.offenses).to be_empty
+        end
       end
-    END
+    end
 
-    it 'accepts' do
-      expect(cop.offenses).to be_empty
+    context 'in a method calling `super` with arguments' do
+      context 'when a method argument is unused' do
+        let(:source) { <<-END }
+          def some_method(foo)
+            super(:something)
+          end
+        END
+
+        it 'registers an offense' do
+          expect(cop.offenses.size).to eq(1)
+          expect(cop.offenses.first.line).to eq(1)
+          expect(cop.highlights).to eq(['foo'])
+        end
+      end
     end
   end
 
-  context 'when a variable is unused' do
-    let(:source) { <<-END }
-      def some_method
-        foo = 1
+  context 'auto-correct' do
+    it 'fixes single' do
+      expect(autocorrect_source(cop, <<-SOURCE
+      def some_method(foo)
+        super(:something)
+      end
+      SOURCE
+      )).to eq(<<-CORRECTED_SOURCE
+      def some_method(_foo)
+        super(:something)
       end
-    END
+      CORRECTED_SOURCE
+      )
+    end
 
-    it 'does not care' do
-      expect(cop.offenses).to be_empty
+    it 'fixes multiple' do
+      expect(autocorrect_source(cop, <<-SOURCE
+      def some_method(foo, bar)
+        super(:something)
+      end
+      SOURCE
+      )).to eq(<<-CORRECTED_SOURCE
+      def some_method(_foo, _bar)
+        super(:something)
+      end
+      CORRECTED_SOURCE
+      )
     end
-  end
 
-  context 'when a block argument is unused' do
-    let(:source) { <<-END }
-      1.times do |foo|
+    it 'preserves whitespace' do
+      expect(autocorrect_source(cop, <<-SOURCE
+      def some_method(foo,
+          bar)
+        super(:something)
       end
-    END
+      SOURCE
+      )).to eq(<<-CORRECTED_SOURCE
+      def some_method(_foo,
+          _bar)
+        super(:something)
+      end
+      CORRECTED_SOURCE
+      )
+    end
 
-    it 'does not care' do
-      expect(cop.offenses).to be_empty
+    it 'preserves splat' do
+      expect(autocorrect_source(cop, <<-SOURCE
+      def some_method(foo, *bars, baz)
+        stuff(foo, baz)
+      end
+      SOURCE
+      )).to eq(<<-CORRECTED_SOURCE
+      def some_method(foo, *_bars, baz)
+        stuff(foo, baz)
+      end
+      CORRECTED_SOURCE
+      )
     end
-  end
 
-  context 'in a method calling `super` without arguments' do
-    context 'when a method argument is not used explicitly' do
-      let(:source) { <<-END }
-        def some_method(foo)
-          super
-        end
-      END
+    it 'preserves default' do
+      expect(autocorrect_source(cop, <<-SOURCE
+      def some_method(foo, bar = baz)
+        stuff(foo)
+      end
+      SOURCE
+      )).to eq(<<-CORRECTED_SOURCE
+      def some_method(foo, _bar = baz)
+        stuff(foo)
+      end
+      CORRECTED_SOURCE
+      )
+    end
 
-      it 'accepts since the arguments are guaranteed to be the same as ' \
-         "superclass' ones and the user has no control on them" do
-        expect(cop.offenses).to be_empty
+    it 'preserves block reference' do
+      expect(autocorrect_source(cop, <<-SOURCE
+      def some_method(foo, &baz)
+        stuff(foo)
+      end
+      SOURCE
+      )).to eq(<<-CORRECTED_SOURCE
+      def some_method(foo, &_baz)
+        stuff(foo)
       end
+      CORRECTED_SOURCE
+      )
     end
-  end
 
-  context 'in a method calling `super` with arguments' do
-    context 'when a method argument is unused' do
-      let(:source) { <<-END }
-        def some_method(foo)
-          super(:something)
-        end
-      END
+    it 'ignores used' do
+      original_source = <<-SOURCE
+      def some_method(foo, bar)
+        other_method(foo, bar)
+      end
+      SOURCE
 
-      it 'registers an offense' do
-        expect(cop.offenses.size).to eq(1)
-        expect(cop.offenses.first.line).to eq(1)
-        expect(cop.highlights).to eq(['foo'])
+      expect(autocorrect_source(cop, original_source)).to eq(original_source)
+    end
+
+    it 'ignores implicit super' do
+      original_source = <<-SOURCE
+      def some_method(foo, bar)
+        super
       end
+      SOURCE
+
+      expect(autocorrect_source(cop, original_source)).to eq(original_source)
     end
   end
 end

data/spec/rubocop/cop/lint/void_spec.rb

@@ -54,4 +54,12 @@ describe Rubocop::Cop::Lint::Void do
     end
   end
 
+  it 'accepts short call syntax' do
+    inspect_source(cop,
+                   ['lambda.(a)',
+                    'top'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
 end

data/spec/rubocop/cop/rails/delegate_spec.rb

@@ -120,6 +120,23 @@ describe Rubocop::Cop::Rails::Delegate do
     expect(cop.offenses).to be_empty
   end
 
+  it 'ignores delegation with assignment' do
+    inspect_source(cop,
+                   ['def new',
+                    '  @bar = Foo.new',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores delegation to constant' do
+    inspect_source(cop,
+                   ['FOO = []',
+                    'def size',
+                    '  FOO.size',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
   describe '#autocorrect' do
     context 'trivial delegation' do
       let(:source) do

data/spec/rubocop/cop/rails/output_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe Rubocop::Cop::Rails::Output do
   subject(:cop) { described_class.new }
 
-  it 'should record an offense for puts statements' do
+  it 'records an offense for puts statements' do
     source = ['p "edmond dantes"',
               'puts "sinbad"',
               'print "abbe busoni"',
@@ -14,7 +14,7 @@ describe Rubocop::Cop::Rails::Output do
     expect(cop.offenses.size).to eq(4)
   end
 
-  it 'should not record an offense for methods' do
+  it 'does not record an offense for methods' do
     source = ['obj.print',
               'something.p',
               'nothing.pp']
@@ -22,7 +22,7 @@ describe Rubocop::Cop::Rails::Output do
     expect(cop.offenses).to be_empty
   end
 
-  it 'should not record an offense for comments' do
+  it 'does not record an offense for comments' do
     source = ['# print "test"',
               '# p']
     inspect_source(cop, source)

data/spec/rubocop/cop/severity_spec.rb

@@ -73,23 +73,23 @@ describe Rubocop::Cop::Severity do
 
   describe 'constructs from code' do
     describe 'R' do
-      it { expect(Rubocop::Cop::Severity.new('R')).to eq(refactor) }
+      it { expect(described_class.new('R')).to eq(refactor) }
     end
 
     describe 'C' do
-      it { expect(Rubocop::Cop::Severity.new('C')).to eq(convention) }
+      it { expect(described_class.new('C')).to eq(convention) }
     end
 
     describe 'W' do
-      it { expect(Rubocop::Cop::Severity.new('W')).to eq(warning) }
+      it { expect(described_class.new('W')).to eq(warning) }
     end
 
     describe 'E' do
-      it { expect(Rubocop::Cop::Severity.new('E')).to eq(error) }
+      it { expect(described_class.new('E')).to eq(error) }
     end
 
     describe 'F' do
-      it { expect(Rubocop::Cop::Severity.new('F')).to eq(fatal) }
+      it { expect(described_class.new('F')).to eq(fatal) }
     end
   end
 

data/spec/rubocop/cop/style/align_parameters_spec.rb

@@ -183,6 +183,25 @@ describe Rubocop::Cop::Style::AlignParameters, :config do
       expect(cop.offenses).to be_empty
     end
 
+    context 'assigned methods' do
+      it 'accepts the first parameter being on a new row' do
+        inspect_source(cop, [' assigned_value = match(',
+                             '   a,',
+                             '   b,',
+                             '   c',
+                             ' )'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'accepts the first parameter being on method row' do
+        inspect_source(cop, [' assigned_value = match(a,',
+                             '                        b,',
+                             '                        c',
+                             '                  )'])
+        expect(cop.offenses).to be_empty
+      end
+    end
+
     it 'auto-corrects alignment' do
       new_source = autocorrect_source(cop, ['func(a,',
                                             '       b,',
@@ -291,5 +310,94 @@ describe Rubocop::Cop::Style::AlignParameters, :config do
       expect(autocorrect_source(cop, original_source))
         .to eq(correct_source.join("\n"))
     end
+
+    context 'multi-line method calls' do
+      it 'can handle existing indentation from multi-line method calls' do
+        inspect_source(cop, [' something',
+                             '   .method_name(',
+                             '     a,',
+                             '     b,',
+                             '     c',
+                             '   )'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'registers offences for double indentation from relevant method' do
+        inspect_source(cop, [' something',
+                             '   .method_name(',
+                             '       a,',
+                             '       b,',
+                             '       c',
+                             '   )'])
+        expect(cop.offenses.size).to eq(3)
+      end
+
+      it 'does not err on method call without a method name' do
+        inspect_source(cop, [' something',
+                             '   .(',
+                             '     a,',
+                             '     b,',
+                             '     c',
+                             '   )'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'autocorrects relative to position of relevant method call' do
+        original_source = [
+          ' something',
+          '   .method_name(',
+          '       a,',
+          '          b,',
+          '            c',
+          '   )'
+        ]
+        correct_source = [
+          ' something',
+          '   .method_name(',
+          '     a,',
+          '     b,',
+          '     c',
+          '   )'
+        ]
+        expect(autocorrect_source(cop, original_source))
+          .to eq(correct_source.join("\n"))
+      end
+    end
+
+    context 'assigned methods' do
+      it 'accepts the first parameter being on a new row' do
+        inspect_source(cop, [' assigned_value = match(',
+                             '   a,',
+                             '   b,',
+                             '   c',
+                             ' )'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'accepts the first parameter being on method row' do
+        inspect_source(cop, [' assigned_value = match(a,',
+                             '   b,',
+                             '   c',
+                             ' )'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'autocorrects even when first argument is in wrong position' do
+        original_source = [' assigned_value = match(',
+                           '         a,',
+                           '            b,',
+                           '                    c',
+                           ' )']
+
+        correct_source = [' assigned_value = match(',
+                          '   a,',
+                          '   b,',
+                          '   c',
+                          ' )']
+
+        expect(autocorrect_source(cop, original_source))
+          .to eq(correct_source.join("\n"))
+      end
+    end
   end
 end