rubocop 0.29.1 → 0.30.0

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

@@ -1,66 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::SpaceBeforeFirstArg do
-  subject(:cop) { described_class.new }
-
-  context 'for method calls without parentheses' do
-    it 'registers an offense for method call with no space before the ' \
-       'first arg' do
-      inspect_source(cop, ['something?x',
-                           'a.something!y, z'])
-      expect(cop.messages)
-        .to eq(['Put space between the method name and the first ' \
-                'argument.'] * 2)
-      expect(cop.highlights).to eq(%w(x y))
-    end
-
-    it 'accepts a method call with space before the first arg' do
-      inspect_source(cop, ['something? x',
-                           'a.something! y, z'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts square brackets operator' do
-      inspect_source(cop, 'something[:x]')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts a method call with space before a multiline arg' do
-      inspect_source(cop, "something [\n  'foo',\n  'bar'\n]")
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts an assignment without space before first arg' do
-      inspect_source(cop, ['a.something=c',
-                           'a.something,b=c,d'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'auto-corrects method call with no space before the first arg' do
-      new_source = autocorrect_source(cop, ['something?x',
-                                            'a.something!y, z'])
-      expect(new_source).to eq(['something? x',
-                                'a.something! y, z'].join("\n"))
-    end
-  end
-
-  context 'for method calls with parentheses' do
-    it 'accepts a method call without space' do
-      inspect_source(cop, ['something?(x)',
-                           'a.something(y, z)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts a method call with space after the left parenthesis' do
-      inspect_source(cop, 'something?(  x  )')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts setter call' do
-      inspect_source(cop, 'self.class.controller_path=(path)')
-      expect(cop.offenses).to be_empty
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::StringConversionInInterpolation do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for #to_s in interpolation' do
-    inspect_source(cop, '"this is the #{result.to_s}"')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages)
-      .to eq(['Redundant use of `Object#to_s` in interpolation.'])
-  end
-
-  it 'detects #to_s in an interpolation with several expressions' do
-    inspect_source(cop, '"this is the #{top; result.to_s}"')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts #to_s with arguments in an interpolation' do
-    inspect_source(cop, '"this is a #{result.to_s(8)}"')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts interpolation without #to_s' do
-    inspect_source(cop, '"this is the #{result}"')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not explode on implicit receiver' do
-    inspect_source(cop, '"#{to_s}"')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages)
-      .to eq(['Use `self` instead of `Object#to_s` in interpolation.'])
-  end
-
-  it 'does not explode on empty interpolation' do
-    inspect_source(cop, '"this is #{} silly"')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'autocorrects by removing the redundant to_s' do
-    corrected = autocorrect_source(cop, ['"some #{something.to_s}"'])
-    expect(corrected).to eq '"some #{something}"'
-  end
-
-  it 'autocorrects implicit receiver by replacing to_s with self' do
-    corrected = autocorrect_source(cop, ['"some #{to_s}"'])
-    expect(corrected).to eq '"some #{self}"'
-  end
-end

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

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::Syntax do
-  describe '.offense_from_diagnostic' do
-    subject(:offense) { described_class.offense_from_diagnostic(diagnostic) }
-    let(:diagnostic) { Parser::Diagnostic.new(level, reason, args, location) }
-    let(:level) { :warning }
-    let(:reason) { :odd_hash }
-    let(:args) { [] }
-    let(:location) { double('location').as_null_object }
-
-    it 'returns an offense' do
-      expect(offense).to be_a(RuboCop::Cop::Offense)
-    end
-
-    it "sets diagnostic's level to offense's severity" do
-      expect(offense.severity).to eq(level)
-    end
-
-    it "sets diagnostic's message to offense's message" do
-      expect(offense.message).to eq('odd number of entries for a hash')
-    end
-
-    it "sets diagnostic's location to offense's location" do
-      expect(offense.location).to eq(location)
-    end
-
-    it 'sets Syntax as a cop name' do
-      expect(offense.cop_name).to eq('Syntax')
-    end
-  end
-end

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

@@ -1,179 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::UnderscorePrefixedVariableName do
-  subject(:cop) { described_class.new }
-
-  before do
-    inspect_source(cop, source)
-  end
-
-  context 'when an underscore-prefixed variable is used' do
-    let(:source) { <<-END }
-      def some_method
-        _foo = 1
-        puts _foo
-      end
-    END
-
-    it 'registers an offense' do
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.offenses.first.message)
-        .to eq('Do not use prefix `_` for a variable that is used.')
-      expect(cop.offenses.first.severity.name).to eq(:warning)
-      expect(cop.offenses.first.line).to eq(2)
-      expect(cop.highlights).to eq(['_foo'])
-    end
-  end
-
-  context 'when non-underscore-prefixed variable is used' do
-    let(:source) { <<-END }
-      def some_method
-        foo = 1
-        puts foo
-      end
-    END
-
-    it 'accepts' do
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'when an underscore-prefixed variable is reassigned' do
-    let(:source) { <<-END }
-      def some_method
-        _foo = 1
-        _foo = 2
-      end
-    END
-
-    it 'accepts' do
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'when an underscore-prefixed 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'])
-    end
-  end
-
-  context 'when an underscore-prefixed block argument is used' do
-    let(:source) { <<-END }
-      1.times do |_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'])
-    end
-  end
-
-  context 'when an underscore-prefixed variable in top-level scope is used' do
-    let(:source) { <<-END }
-      _foo = 1
-      puts _foo
-    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 variable is captured by a block' do
-    let(:source) { <<-END }
-      _foo = 1
-      1.times do
-        _foo = 2
-      end
-    END
-
-    it 'accepts' do
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'when an underscore-prefixed named capture variable is used' do
-    let(:source) { <<-END }
-      /(?<_foo>\\w+)/ =~ 'FOO'
-      puts _foo
-    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>\\w+)/'])
-    end
-  end
-
-  context 'in a method calling `super` without arguments' do
-    context 'when an underscore-prefixed argument is not used explicitly' do
-      let(:source) { <<-END }
-        def some_method(*_)
-          super
-        end
-      END
-
-      it 'accepts' do
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    context 'when an underscore-prefixed argument is used explicitly' do
-      let(:source) { <<-END }
-        def some_method(*_)
-          super
-          puts _
-        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(['_'])
-      end
-    end
-  end
-
-  context 'in a method calling `super` with arguments' do
-    context 'when an underscore-prefixed argument is not used' do
-      let(:source) { <<-END }
-        def some_method(*_)
-          super(:something)
-        end
-      END
-
-      it 'accepts' do
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    context 'when an underscore-prefixed argument is used explicitly' do
-      let(:source) { <<-END }
-        def some_method(*_)
-          super(*_)
-        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(['_'])
-      end
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::UnreachableCode do
-  subject(:cop) { described_class.new }
-
-  described_class::NODE_TYPES.each do |t|
-    it "registers an offense for #{t} before other statements" do
-      inspect_source(cop,
-                     ['foo = 5',
-                      "#{t}",
-                      'bar'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "accepts code with conditional #{t}" do
-      inspect_source(cop,
-                     ['foo = 5',
-                      "#{t} if test",
-                      'bar'
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-
-    it "accepts #{t} as the final expression" do
-      inspect_source(cop,
-                     ['foo = 5',
-                      "#{t} if test"
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  described_class::FLOW_COMMANDS.each do |t|
-    it "registers an offense for #{t} before other statements" do
-      inspect_source(cop,
-                     ['foo = 5',
-                      "#{t} something",
-                      'bar'
-                     ])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "accepts code with conditional #{t}" do
-      inspect_source(cop,
-                     ['foo = 5',
-                      "#{t} something if test",
-                      'bar'
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-
-    it "accepts #{t} as the final expression" do
-      inspect_source(cop,
-                     ['foo = 5',
-                      "#{t} something if test"
-                     ])
-      expect(cop.offenses).to be_empty
-    end
-  end
-end

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

@@ -1,231 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Lint::UnusedBlockArgument do
-  subject(:cop) { described_class.new }
-
-  context 'inspection' do
-    before do
-      inspect_source(cop, source)
-    end
-
-    context 'when a block takes multiple arguments' do
-      context 'and an argument is unused' do
-        let(:source) { <<-END }
-          hash = { foo: 'FOO', bar: 'BAR' }
-          hash.each do |key, value|
-            puts key
-          end
-        END
-
-        it 'registers an offense' do
-          expect(cop.offenses.size).to eq(1)
-          expect(cop.offenses.first.message).to eq(
-            'Unused block argument - `value`. ' \
-            "If it's necessary, use `_` or `_value` 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(2)
-          expect(cop.highlights).to eq(['value'])
-        end
-      end
-
-      context 'and all the arguments are unused' do
-        let(:source) { <<-END }
-          hash = { foo: 'FOO', bar: 'BAR' }
-          hash.each do |key, value|
-            puts :something
-          end
-        END
-
-        it 'registers offenses and suggests omitting them' do
-          expect(cop.offenses.size).to eq(2)
-          expect(cop.offenses.first.message).to eq(
-            'Unused block argument - `key`. ' \
-            "You can omit all the arguments if you don't care about them."
-          )
-          expect(cop.offenses.first.line).to eq(2)
-          expect(cop.highlights).to eq(%w(key value))
-        end
-      end
-    end
-
-    context 'when a block takes single argument' do
-      context 'and the argument is unused' do
-        let(:source) { <<-END }
-          1.times do |index|
-            puts :something
-          end
-        END
-
-        it 'registers an offense and suggests omitting that' do
-          expect(cop.offenses.size).to eq(1)
-          expect(cop.offenses.first.message).to eq(
-            'Unused block argument - `index`. ' \
-            "You can omit the argument if you don't care about it."
-          )
-          expect(cop.offenses.first.line).to eq(1)
-          expect(cop.highlights).to eq(['index'])
-        end
-      end
-    end
-
-    context 'when a block have a block local variable' do
-      context 'and the variable is unused' do
-        let(:source) { <<-END }
-          1.times do |index; block_local_variable|
-            puts index
-          end
-        END
-
-        it 'registers an offense' do
-          expect(cop.offenses.size).to eq(1)
-          expect(cop.offenses.first.message).to eq(
-            'Unused block local variable - `block_local_variable`.'
-          )
-          expect(cop.offenses.first.line).to eq(1)
-          expect(cop.highlights).to eq(['block_local_variable'])
-        end
-      end
-    end
-
-    context 'when a lambda block takes arguments' do
-      context 'and all the arguments are unused' do
-        let(:source) { <<-END }
-          -> (foo, bar) { do_something }
-        END
-
-        it 'registers offenses and suggests using a proc' do
-          expect(cop.offenses.size).to eq(2)
-          expect(cop.offenses.first.message).to eq(
-            'Unused block argument - `foo`. ' \
-            "If it's necessary, use `_` or `_foo` as an argument name " \
-            "to indicate that it won't be used. " \
-            'Also consider using a proc without arguments instead of a ' \
-            "lambda if you want it to accept any arguments but don't care " \
-            'about them.'
-
-          )
-          expect(cop.offenses.first.line).to eq(1)
-          expect(cop.highlights).to eq(%w(foo bar))
-        end
-      end
-
-      context 'and an arguments is unused' do
-        let(:source) { <<-END }
-          -> (foo, bar) { puts bar }
-        END
-
-        it 'registers an offense' do
-          expect(cop.offenses.size).to eq(1)
-          expect(cop.offenses.first.message).to eq(
-            'Unused block 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.line).to eq(1)
-          expect(cop.highlights).to eq(['foo'])
-        end
-      end
-    end
-
-    context 'when an underscore-prefixed block argument is not used' do
-      let(:source) { <<-END }
-        1.times do |_index|
-          puts 'foo'
-        end
-      END
-
-      it 'accepts' do
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    context 'when a method argument is not used' do
-      let(:source) { <<-END }
-        def some_method(foo)
-        end
-      END
-
-      it 'does not care' do
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    context 'when a variable is not used' do
-      let(:source) { <<-END }
-        1.times do
-          foo = 1
-        end
-      END
-
-      it 'does not care' do
-        expect(cop.offenses).to be_empty
-      end
-    end
-  end
-
-  context 'auto-correct' do
-    it 'fixes single' do
-      expect(autocorrect_source(cop, <<-SOURCE
-      arr.map { |foo| stuff }
-      SOURCE
-      )).to eq(<<-CORRECTED_SOURCE
-      arr.map { |_foo| stuff }
-      CORRECTED_SOURCE
-      )
-    end
-
-    it 'fixes multiple' do
-      expect(autocorrect_source(cop, <<-SOURCE
-      hash.map { |key, val| stuff }
-      SOURCE
-      )).to eq(<<-CORRECTED_SOURCE
-      hash.map { |_key, _val| stuff }
-      CORRECTED_SOURCE
-      )
-    end
-
-    it 'preserves whitespace' do
-      expect(autocorrect_source(cop, <<-SOURCE
-      hash.map { |key,
-                  val| stuff }
-      SOURCE
-      )).to eq(<<-CORRECTED_SOURCE
-      hash.map { |_key,
-                  _val| stuff }
-      CORRECTED_SOURCE
-      )
-    end
-
-    it 'preserves splat' do
-      expect(autocorrect_source(cop, <<-SOURCE
-      obj.method { |foo, *bars, baz| stuff(foo, baz) }
-      SOURCE
-      )).to eq(<<-CORRECTED_SOURCE
-      obj.method { |foo, *_bars, baz| stuff(foo, baz) }
-      CORRECTED_SOURCE
-      )
-    end
-
-    it 'preserves default' do
-      expect(autocorrect_source(cop, <<-SOURCE
-      obj.method { |foo, bar = baz| stuff(foo) }
-      SOURCE
-      )).to eq(<<-CORRECTED_SOURCE
-      obj.method { |foo, _bar = baz| stuff(foo) }
-      CORRECTED_SOURCE
-      )
-    end
-
-    it 'ignores used' do
-      original_source = <<-SOURCE
-      obj.method { |foo, baz| stuff(foo, baz) }
-      SOURCE
-
-      expect(autocorrect_source(cop, original_source)).to eq(original_source)
-    end
-  end
-end