rubocop 0.29.1 → 0.30.0

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

@@ -1,184 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::FormatString, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when enforced style is sprintf' do
-    let(:cop_config) { { 'EnforcedStyle' => 'sprintf' } }
-    it 'registers an offense for a string followed by something' do
-      inspect_source(cop,
-                     'puts "%d" % 10')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `sprintf` over `String#%`.'])
-    end
-
-    it 'registers an offense for something followed by an array' do
-      inspect_source(cop,
-                     'puts x % [10, 11]')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `sprintf` over `String#%`.'])
-    end
-
-    it 'does not register an offense for numbers' do
-      inspect_source(cop,
-                     'puts 10 % 4')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'does not register an offense for ambiguous cases' do
-      inspect_source(cop,
-                     'puts x % 4')
-      expect(cop.offenses).to be_empty
-
-      inspect_source(cop,
-                     'puts x % Y')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'works if the first operand contains embedded expressions' do
-      inspect_source(cop,
-                     'puts "#{x * 5} %d #{@test}" % 10')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `sprintf` over `String#%`.'])
-    end
-
-    it 'registers an offense for format' do
-      inspect_source(cop,
-                     'format(something, a, b)')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `sprintf` over `format`.'])
-    end
-
-    it 'registers an offense for format with 2 arguments' do
-      inspect_source(cop,
-                     'format("%X", 123)')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `sprintf` over `format`.'])
-    end
-  end
-
-  context 'when enforced style is format' do
-    let(:cop_config) { { 'EnforcedStyle' => 'format' } }
-
-    it 'registers an offense for a string followed by something' do
-      inspect_source(cop,
-                     'puts "%d" % 10')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `format` over `String#%`.'])
-    end
-
-    it 'registers an offense for something followed by an array' do
-      inspect_source(cop,
-                     'puts x % [10, 11]')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `format` over `String#%`.'])
-    end
-
-    it 'does not register an offense for numbers' do
-      inspect_source(cop,
-                     'puts 10 % 4')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'does not register an offense for ambiguous cases' do
-      inspect_source(cop,
-                     'puts x % 4')
-      expect(cop.offenses).to be_empty
-
-      inspect_source(cop,
-                     'puts x % Y')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'works if the first operand contains embedded expressions' do
-      inspect_source(cop,
-                     'puts "#{x * 5} %d #{@test}" % 10')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `format` over `String#%`.'])
-    end
-
-    it 'registers an offense for sprintf' do
-      inspect_source(cop,
-                     'sprintf(something, a, b)')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `format` over `sprintf`.'])
-    end
-
-    it 'registers an offense for sprintf with 2 arguments' do
-      inspect_source(cop,
-                     "sprintf('%020d', 123)")
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `format` over `sprintf`.'])
-    end
-  end
-
-  context 'when enforced style is percent' do
-    let(:cop_config) { { 'EnforcedStyle' => 'percent' } }
-
-    it 'registers an offense for format' do
-      inspect_source(cop,
-                     'format(something, a, b)')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `String#%` over `format`.'])
-    end
-
-    it 'registers an offense for sprintf' do
-      inspect_source(cop,
-                     'sprintf(something, a, b)')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `String#%` over `sprintf`.'])
-    end
-
-    it 'registers an offense for sprintf with 3 arguments' do
-      inspect_source(cop,
-                     'format("%d %04x", 123, 123)')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Favor `String#%` over `format`.'])
-    end
-
-    it 'accepts format with 1 argument' do
-      inspect_source(cop,
-                     'format :xml')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts sprintf with 1 argument' do
-      inspect_source(cop,
-                     'sprintf :xml')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts format without arguments' do
-      inspect_source(cop,
-                     'format')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts sprintf without arguments' do
-      inspect_source(cop,
-                     'sprintf')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts String#%' do
-      inspect_source(cop,
-                     'puts "%d" % 10')
-      expect(cop.offenses).to be_empty
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::GlobalVars, :config do
-  cop_config = {
-    'AllowedVariables' => ['$allowed']
-  }
-
-  subject(:cop) { described_class.new(config) }
-  let(:cop_config) { cop_config }
-
-  it 'registers an offense for $custom' do
-    inspect_source(cop, 'puts $custom')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'allows user whitelisted variables' do
-    inspect_source(cop, 'puts $allowed')
-    expect(cop.offenses).to be_empty
-  end
-
-  described_class::BUILT_IN_VARS.each do |var|
-    it "does not register an offense for built-in variable #{var}" do
-      inspect_source(cop, "puts #{var}")
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  it 'does not register an offense for backrefs like $1' do
-    inspect_source(cop, 'puts $1')
-    expect(cop.offenses).to be_empty
-  end
-end

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

@@ -1,172 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::GuardClause, :config do
-  let(:cop) { described_class.new(config) }
-  let(:cop_config) { {} }
-
-  it 'reports an offense if method body is if / unless without else' do
-    inspect_source(cop,
-                   ['def func',
-                    '  if something',
-                    '    work',
-                    '  end',
-                    'end',
-                    '',
-                    'def func',
-                    '  unless something',
-                    '    work',
-                    '  end',
-                    'end'])
-    expect(cop.offenses.size).to eq(2)
-    expect(cop.offenses.map(&:line).sort).to eq([2, 8])
-    expect(cop.messages)
-      .to eq(['Use a guard clause instead of wrapping ' \
-              'the code inside a conditional expression.'] * 2)
-    expect(cop.highlights).to eq(%w(if unless))
-  end
-
-  it 'reports an offense if method body ends with if / unless without else' do
-    inspect_source(cop,
-                   ['def func',
-                    '  test',
-                    '  if something',
-                    '    work',
-                    '  end',
-                    'end',
-                    '',
-                    'def func',
-                    '  test',
-                    '  unless something',
-                    '    work',
-                    '  end',
-                    'end'])
-    expect(cop.offenses.size).to eq(2)
-    expect(cop.offenses.map(&:line).sort).to eq([3, 10])
-    expect(cop.messages)
-      .to eq(['Use a guard clause instead of wrapping ' \
-              'the code inside a conditional expression.'] * 2)
-    expect(cop.highlights).to eq(%w(if unless))
-  end
-
-  it 'accepts a method which body is if / unless with else' do
-    inspect_source(cop,
-                   ['def func',
-                    '  if something',
-                    '    work',
-                    '  else',
-                    '    test',
-                    '  end',
-                    'end',
-                    '',
-                    'def func',
-                    '  unless something',
-                    '    work',
-                    '  else',
-                    '    test',
-                    '  end',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a method which body does not end with if / unless' do
-    inspect_source(cop,
-                   ['def func',
-                    '  if something',
-                    '    work',
-                    '  end',
-                    '  test',
-                    'end',
-                    '',
-                    'def func',
-                    '  unless something',
-                    '    work',
-                    '  end',
-                    '  test',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a method whose body is a modifier if / unless' do
-    inspect_source(cop,
-                   ['def func',
-                    '  work if something',
-                    'end',
-                    '',
-                    'def func',
-                    '  work if something',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  context 'MinBodyLength: 1' do
-    let(:cop_config) do
-      { 'MinBodyLength' => 1 }
-    end
-
-    it 'reports an offense for if whose body has 1 line' do
-      inspect_source(cop,
-                     ['def func',
-                      '  if something',
-                      '    work',
-                      '  end',
-                      'end',
-                      '',
-                      'def func',
-                      '  unless something',
-                      '    work',
-                      '  end',
-                      'end'])
-      expect(cop.offenses.size).to eq(2)
-      expect(cop.offenses.map(&:line).sort).to eq([2, 8])
-      expect(cop.messages)
-        .to eq(['Use a guard clause instead of wrapping ' \
-                'the code inside a conditional expression.'] * 2)
-      expect(cop.highlights).to eq(%w(if unless))
-    end
-  end
-
-  context 'MinBodyLength: 4' do
-    let(:cop_config) do
-      { 'MinBodyLength' => 4 }
-    end
-
-    it 'accepts a method whose body has 3 line' do
-      inspect_source(cop,
-                     ['def func',
-                      '  if something',
-                      '    work',
-                      '    work',
-                      '    work',
-                      '  end',
-                      'end',
-                      '',
-                      'def func',
-                      '  unless something',
-                      '    work',
-                      '    work',
-                      '    work',
-                      '  end',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'Invalid MinBodyLength' do
-    let(:cop_config) do
-      { 'MinBodyLength' => -2 }
-    end
-
-    it 'fails with an error' do
-      source = ['def func',
-                '  if something',
-                '    work',
-                '  end',
-                'end']
-
-      expect { inspect_source(cop, source) }
-        .to raise_error('MinBodyLength needs to be a positive integer!')
-    end
-  end
-end

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

@@ -1,137 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::HashSyntax, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'configured to enforce ruby19 style' do
-    let(:config) do
-      RuboCop::Config.new('Style/HashSyntax' => {
-                            'EnforcedStyle'   => 'ruby19',
-                            'SupportedStyles' => %w(ruby19 hash_rockets)
-                          },
-                          'Style/SpaceAroundOperators' => {
-                            'Enabled' => true
-                          })
-    end
-
-    it 'registers offense for hash rocket syntax when new is possible' do
-      inspect_source(cop, 'x = { :a => 0 }')
-      expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
-      expect(cop.config_to_allow_offenses)
-        .to eq('EnforcedStyle' => 'hash_rockets')
-    end
-
-    it 'registers an offense for mixed syntax when new is possible' do
-      inspect_source(cop, 'x = { :a => 0, b: 1 }')
-      expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers an offense for hash rockets in method calls' do
-      inspect_source(cop, 'func(3, :a => 0)')
-      expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
-    end
-
-    it 'accepts hash rockets when keys have different types' do
-      inspect_source(cop, 'x = { :a => 0, "b" => 1 }')
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts hash rockets when keys have whitespaces in them' do
-      inspect_source(cop, 'x = { :"t o" => 0 }')
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts hash rockets when keys have special symbols in them' do
-      inspect_source(cop, 'x = { :"\tab" => 1 }')
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts hash rockets when keys start with a digit' do
-      inspect_source(cop, 'x = { :"1" => 1 }')
-      expect(cop.messages).to be_empty
-    end
-
-    it 'registers offense when keys start with an uppercase letter' do
-      inspect_source(cop, 'x = { :A => 0 }')
-      expect(cop.messages).to eq(['Use the new Ruby 1.9 hash syntax.'])
-    end
-
-    it 'accepts new syntax in a hash literal' do
-      inspect_source(cop, 'x = { a: 0, b: 1 }')
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts new syntax in method calls' do
-      inspect_source(cop, 'func(3, a: 0)')
-      expect(cop.messages).to be_empty
-    end
-
-    it 'auto-corrects old to new style' do
-      new_source = autocorrect_source(cop, '{ :a => 1, :b   =>  2}')
-      expect(new_source).to eq('{ a: 1, b: 2}')
-    end
-
-    it 'auto-corrects even if it interferes with SpaceAroundOperators' do
-      # Clobbering caused by two cops changing in the same range is dealt with
-      # by the auto-correct loop, so there's no reason to avoid a change.
-      new_source = autocorrect_source(cop, '{ :a=>1, :b=>2 }')
-      expect(new_source).to eq('{ a: 1, b: 2 }')
-    end
-
-    context 'with SpaceAroundOperators disabled' do
-      let(:config) do
-        RuboCop::Config.new('Style/HashSyntax' => {
-                              'EnforcedStyle'   => 'ruby19',
-                              'SupportedStyles' => %w(ruby19 hash_rockets)
-                            },
-                            'Style/SpaceAroundOperators' => {
-                              'Enabled' => false
-                            })
-      end
-
-      it 'auto-corrects even if there is no space around =>' do
-        new_source = autocorrect_source(cop, '{ :a=>1, :b=>2 }')
-        expect(new_source).to eq('{ a: 1, b: 2 }')
-      end
-    end
-  end
-
-  context 'configured to enforce hash rockets style' do
-    let(:cop_config) { { 'EnforcedStyle' => 'hash_rockets' } }
-
-    it 'registers offense for Ruby 1.9 style' do
-      inspect_source(cop, 'x = { a: 0 }')
-      expect(cop.messages).to eq(['Always use hash rockets in hashes.'])
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'ruby19')
-    end
-
-    it 'registers an offense for mixed syntax' do
-      inspect_source(cop, 'x = { :a => 0, b: 1 }')
-      expect(cop.messages).to eq(['Always use hash rockets in hashes.'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers an offense for 1.9 style in method calls' do
-      inspect_source(cop, 'func(3, a: 0)')
-      expect(cop.messages).to eq(['Always use hash rockets in hashes.'])
-    end
-
-    it 'accepts hash rockets in a hash literal' do
-      inspect_source(cop, 'x = { :a => 0, :b => 1 }')
-      expect(cop.messages).to be_empty
-    end
-
-    it 'accepts hash rockets in method calls' do
-      inspect_source(cop, 'func(3, :a => 0)')
-      expect(cop.messages).to be_empty
-    end
-
-    it 'auto-corrects new style to hash rockets' do
-      new_source = autocorrect_source(cop, '{ a: 1, b: 2}')
-      expect(new_source).to eq('{ :a => 1, :b => 2}')
-    end
-  end
-end