rubocop 0.29.1 → 0.30.0

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

@@ -1,278 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::UnusedMethodArgument do
-  subject(:cop) { described_class.new }
-
-  describe '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 required keyword argument is unused', ruby: 2.1 do
-      let(:source) { <<-END }
-        def self.some_method(foo, bar:)
-          puts foo
-        end
-      END
-
-      it 'registers an offense but does not suggest underscore-prefix' do
-        expect(cop.offenses.size).to eq(1)
-        expect(cop.highlights).to eq(['bar'])
-        expect(cop.offenses.first.message)
-          .to eq('Unused method argument - `bar`.')
-      end
-    end
-
-    context 'when an optional keyword argument is unused', ruby: 2 do
-      let(:source) { <<-END }
-        def self.some_method(foo, bar: 1)
-          puts foo
-        end
-      END
-
-      it 'registers an offense but does not suggest underscore-prefix' do
-        expect(cop.offenses.size).to eq(1)
-        expect(cop.highlights).to eq(['bar'])
-        expect(cop.offenses.first.message)
-          .to eq('Unused method argument - `bar`.')
-      end
-    end
-
-    context 'when a singleton method argument is unused' do
-      let(:source) { <<-END }
-        def self.some_method(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'])
-      end
-    end
-
-    context 'when an underscore-prefixed method argument is unused' do
-      let(:source) { <<-END }
-        def some_method(_foo)
-        end
-      END
-
-      it 'accepts' do
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    context 'when a method argument is used' do
-      let(:source) { <<-END }
-        def some_method(foo)
-          puts foo
-        end
-      END
-
-      it 'accepts' do
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    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
-
-    context 'when a block argument is unused' do
-      let(:source) { <<-END }
-        1.times do |foo|
-        end
-      END
-
-      it 'does not care' do
-        expect(cop.offenses).to be_empty
-      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 '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
-
-    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
-
-  describe 'auto-correction' do
-    let(:corrected_source) { autocorrect_source(cop, source) }
-
-    context 'when multiple arguments are unused' do
-      let(:source) { <<-END }
-        def some_method(foo, bar)
-        end
-      END
-
-      let(:expected_source) { <<-END }
-        def some_method(_foo, _bar)
-        end
-      END
-
-      it 'adds underscore-prefix to them' do
-        expect(corrected_source).to eq(expected_source)
-      end
-    end
-
-    context 'when only a part of arguments is unused' do
-      let(:source) { <<-END }
-        def some_method(foo, bar)
-          puts foo
-        end
-      END
-
-      let(:expected_source) { <<-END }
-        def some_method(foo, _bar)
-          puts foo
-        end
-      END
-
-      it 'modifies only the unused one' do
-        expect(corrected_source).to eq(expected_source)
-      end
-    end
-
-    context 'when there are some whitespaces around the argument' do
-      let(:source) { <<-END }
-        def some_method(foo,
-            bar)
-          puts foo
-        end
-      END
-
-      let(:expected_source) { <<-END }
-        def some_method(foo,
-            _bar)
-          puts foo
-        end
-      END
-
-      it 'preserves the whitespace' do
-        expect(corrected_source).to eq(expected_source)
-      end
-    end
-
-    context 'when a splat argument is unused' do
-      let(:source) { <<-END }
-        def some_method(foo, *bar)
-          puts foo
-        end
-      END
-
-      let(:expected_source) { <<-END }
-        def some_method(foo, *_bar)
-          puts foo
-        end
-      END
-
-      it 'preserves the splat' do
-        expect(corrected_source).to eq(expected_source)
-      end
-    end
-
-    context 'when an unused argument has default value' do
-      let(:source) { <<-END }
-        def some_method(foo, bar = 1)
-          puts foo
-        end
-      END
-
-      let(:expected_source) { <<-END }
-        def some_method(foo, _bar = 1)
-          puts foo
-        end
-      END
-
-      it 'preserves the default value' do
-        expect(corrected_source).to eq(expected_source)
-      end
-    end
-
-    context 'when a keyword argument is unused', ruby: 2 do
-      let(:source) { <<-END }
-        def some_method(foo, bar: 1)
-          puts foo
-        end
-      END
-
-      it 'ignores that since modifying the name changes the method interface' do
-        expect(corrected_source).to eq(source)
-      end
-    end
-  end
-end

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

@@ -1,192 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::UselessAccessModifier do
-  subject(:cop) { described_class.new }
-
-  context 'when an access modifier has no effect' do
-    let(:source) do
-      [
-        'class SomeClass',
-        '  def some_method',
-        '    puts 10',
-        '  end',
-        '  private',
-        '  def self.some_method',
-        '    puts 10',
-        '  end',
-        'end'
-      ]
-    end
-
-    it 'registers an offense' do
-      inspect_source(cop, source)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.message)
-        .to eq('Useless `private` access modifier.')
-      expect(cop.offenses.first.line).to eq(5)
-      expect(cop.highlights).to eq(['private'])
-    end
-  end
-
-  context 'when an access modifier has no methods' do
-    let(:source) do
-      [
-        'class SomeClass',
-        '  protected',
-        'end'
-      ]
-    end
-
-    it 'registers an offense' do
-      inspect_source(cop, source)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.message)
-        .to eq('Useless `protected` access modifier.')
-      expect(cop.offenses.first.line).to eq(2)
-      expect(cop.highlights).to eq(['protected'])
-    end
-  end
-
-  context 'when an access modifier is followed by attr_*' do
-    let(:source) do
-      [
-        'class SomeClass',
-        '  protected',
-        '  attr_accessor :some_property',
-        'end'
-      ]
-    end
-
-    it 'does not register an offense' do
-      inspect_source(cop, source)
-      expect(cop.offenses.size).to eq(0)
-    end
-  end
-
-  context 'when an access modifier is followed by a ' \
-    'class method defined on constant' do
-    let(:source) do
-      [
-        'class SomeClass',
-        '  protected',
-        '  def SomeClass.some_method',
-        '  end',
-        'end'
-      ]
-    end
-
-    it 'registers an offense' do
-      inspect_source(cop, source)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.message)
-        .to eq('Useless `protected` access modifier.')
-      expect(cop.offenses.first.line).to eq(2)
-      expect(cop.highlights).to eq(['protected'])
-    end
-  end
-
-  context 'when consecutive access modifiers' do
-    let(:source) do
-      [
-        'class SomeClass',
-        ' private',
-        ' private',
-        '  def some_method',
-        '    puts 10',
-        '  end',
-        '  def some_other_method',
-        '    puts 10',
-        '  end',
-        'end'
-      ]
-    end
-
-    it 'registers an offense' do
-      inspect_source(cop, source)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.message)
-        .to eq('Useless `private` access modifier.')
-      expect(cop.offenses.first.line).to eq(2)
-      expect(cop.highlights).to eq(['private'])
-    end
-  end
-
-  context 'when passing method as symbol' do
-    let(:source) do
-      [
-        'class SomeClass',
-        '  def some_method',
-        '    puts 10',
-        '  end',
-        '  private :some_method',
-        'end'
-      ]
-    end
-
-    it 'does not register an offense' do
-      inspect_source(cop, source)
-      expect(cop.offenses.size).to eq(0)
-    end
-  end
-
-  context 'when class is empty save modifier' do
-    let(:source) do
-      [
-        'class SomeClass',
-        '  private',
-        'end'
-      ]
-    end
-
-    it 'registers an offense' do
-      inspect_source(cop, source)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.message)
-        .to eq('Useless `private` access modifier.')
-      expect(cop.offenses.first.line).to eq(2)
-      expect(cop.highlights).to eq(['private'])
-    end
-  end
-
-  context 'when multiple class definitions in file but only one has offense' do
-    let(:source) do
-      [
-        'class SomeClass',
-        '  private',
-        'end',
-        'class SomeOtherClass',
-        'end'
-      ]
-    end
-
-    it 'registers an offense' do
-      inspect_source(cop, source)
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.message)
-        .to eq('Useless `private` access modifier.')
-      expect(cop.offenses.first.line).to eq(2)
-      expect(cop.highlights).to eq(['private'])
-    end
-  end
-
-  if RUBY_ENGINE == 'ruby' && RUBY_VERSION.start_with?('2.1')
-    context 'ruby 2.1 style modifiers' do
-      let(:source) do
-        [
-          'class SomeClass',
-          '  private def some_method',
-          '    puts 10',
-          '  end',
-          'end'
-        ]
-      end
-
-      it 'does not register an offense' do
-        inspect_source(cop, source)
-        expect(cop.offenses.size).to eq(0)
-      end
-    end
-  end
-end