rubocop 0.29.1 → 0.30.0

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

@@ -1,81 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::AccessorMethodName do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for method get_... with no args' do
-    inspect_source(cop, ['def get_attr',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights).to eq(['get_attr'])
-  end
-
-  it 'registers an offense for singleton method get_... with no args' do
-    inspect_source(cop, ['def self.get_attr',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights).to eq(['get_attr'])
-  end
-
-  it 'accepts method get_something with args' do
-    inspect_source(cop, ['def get_something(arg)',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts singleton method get_something with args' do
-    inspect_source(cop, ['def self.get_something(arg)',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'registers an offense for method set_something with one arg' do
-    inspect_source(cop, ['def set_attr(arg)',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights).to eq(['set_attr'])
-  end
-
-  it 'registers an offense for singleton method set_... with one args' do
-    inspect_source(cop, ['def self.set_attr(arg)',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights).to eq(['set_attr'])
-  end
-
-  it 'accepts method set_something with no args' do
-    inspect_source(cop, ['def set_something',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts singleton method set_something with no args' do
-    inspect_source(cop, ['def self.set_something',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts method set_something with two args' do
-    inspect_source(cop, ['def set_something(arg1, arg2)',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts singleton method set_something with two args' do
-    inspect_source(cop, ['def self.get_something(arg1, arg2)',
-                         '  # ...',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-end

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

@@ -1,59 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::Alias do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for alias with symbol args' do
-    inspect_source(cop,
-                   'alias :ala :bala')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages)
-      .to eq(['Use `alias_method` instead of `alias`.'])
-  end
-
-  it 'autocorrects alias with symbol args' do
-    corrected = autocorrect_source(cop, ['alias :ala :bala'])
-    expect(corrected).to eq 'alias_method :ala, :bala'
-  end
-
-  it 'registers an offense for alias with bareword args' do
-    inspect_source(cop,
-                   'alias ala bala')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages)
-      .to eq(['Use `alias_method` instead of `alias`.'])
-  end
-
-  it 'autocorrects alias with bareword args' do
-    corrected = autocorrect_source(cop, ['alias ala bala'])
-    expect(corrected).to eq 'alias_method :ala, :bala'
-  end
-
-  it 'does not register an offense for alias_method' do
-    inspect_source(cop,
-                   'alias_method :ala, :bala')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for :alias' do
-    inspect_source(cop,
-                   '[:alias, :ala, :bala]')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for alias with gvars' do
-    inspect_source(cop,
-                   'alias $ala $bala')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts alias in an instance_exec block' do
-    inspect_source(cop,
-                   ['cli.instance_exec do',
-                    '  alias :old_trap_interrupt :trap_interrupt',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-end

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

@@ -1,123 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::AlignArray do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for misaligned array elements' do
-    inspect_source(cop, ['array = [',
-                         '  a,',
-                         '   b,',
-                         '  c,',
-                         '   d',
-                         ']'])
-    expect(cop.messages).to eq(['Align the elements of an array ' \
-                                'literal if they span more than ' \
-                                'one line.'] * 2)
-    expect(cop.highlights).to eq(%w(b d))
-  end
-
-  it 'accepts aligned array keys' do
-    inspect_source(cop, ['array = [',
-                         '  a,',
-                         '  b,',
-                         '  c,',
-                         '  d',
-                         ']'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts single line array' do
-    inspect_source(cop, 'array = [ a, b ]')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts several elements per line' do
-    inspect_source(cop, ['array = [ a, b,',
-                         '          c, d ]'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'auto-corrects alignment' do
-    new_source = autocorrect_source(cop, ['array = [',
-                                          '  a,',
-                                          '   b,',
-                                          '  c,',
-                                          ' d',
-                                          ']'])
-    expect(new_source).to eq(['array = [',
-                              '  a,',
-                              '  b,',
-                              '  c,',
-                              '  d',
-                              ']'].join("\n"))
-  end
-
-  it 'auto-corrects array within array with too much indentation' do
-    original_source = ['[:l1,',
-                       '  [:l2,',
-                       '',
-                       '    [:l3,',
-                       '     [:l4]]]]']
-    new_source = autocorrect_source(cop, original_source)
-    expect(new_source).to eq(['[:l1,',
-                              ' [:l2,',
-                              '',
-                              '  [:l3,',
-                              '   [:l4]]]]'].join("\n"))
-  end
-
-  it 'auto-corrects array within array with too little indentation' do
-    original_source = ['[:l1,',
-                       '[:l2,',
-                       '',
-                       '  [:l3,',
-                       '   [:l4]]]]']
-    new_source = autocorrect_source(cop, original_source)
-    expect(new_source).to eq(['[:l1,',
-                              ' [:l2,',
-                              '',
-                              '  [:l3,',
-                              '   [:l4]]]]'].join("\n"))
-  end
-
-  it 'auto-corrects only elements that begin a line' do
-    original_source = ['array = [:bar, {',
-                       '         whiz: 2, bang: 3 }, option: 3]']
-    new_source = autocorrect_source(cop, original_source)
-    expect(new_source).to eq(original_source.join("\n"))
-  end
-
-  it 'does not indent heredoc strings in autocorrect' do
-    original_source = ['var = [',
-                       "       { :type => 'something',",
-                       '         :sql => <<EOF',
-                       'Select something',
-                       'from atable',
-                       'EOF',
-                       '       },',
-                       "      { :type => 'something',",
-                       '        :sql => <<EOF',
-                       'Select something',
-                       'from atable',
-                       'EOF',
-                       '      }',
-                       ']']
-    new_source = autocorrect_source(cop, original_source)
-    expect(new_source).to eq(['var = [',
-                              "       { :type => 'something',",
-                              '         :sql => <<EOF',
-                              'Select something',
-                              'from atable',
-                              'EOF',
-                              '       },',
-                              "       { :type => 'something',",
-                              '         :sql => <<EOF',
-                              'Select something',
-                              'from atable',
-                              'EOF',
-                              '       }',
-                              ']'].join("\n"))
-  end
-end

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

@@ -1,411 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::AlignHash, :config do
-  subject(:cop) { described_class.new(config) }
-
-  shared_examples 'not on separate lines' do
-    it 'accepts single line hash' do
-      inspect_source(cop, 'func(a: 0, bb: 1)')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts several pairs per line' do
-      inspect_source(cop, ['func(a: 1, bb: 2,',
-                           '     ccc: 3, dddd: 4)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it "does not auto-correct pairs that don't start a line" do
-      source = ['render :json => {:a => messages,',
-                '                 :b => :json}, :status => 404']
-      new_source = autocorrect_source(cop, source)
-      expect(new_source).to eq(source.join("\n"))
-    end
-  end
-
-  context 'always inspect last argument hash' do
-    let(:cop_config) do
-      {
-        'EnforcedLastArgumentHashStyle' => 'always_inspect'
-      }
-    end
-
-    it 'registers offense for misaligned keys in implicit hash' do
-      inspect_source(cop, ['func(a: 0,',
-                           '  b: 1)'])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'registers offense for misaligned keys in explicit hash' do
-      inspect_source(cop, ['func({a: 0,',
-                           '  b: 1})'])
-      expect(cop.offenses.size).to eq(1)
-    end
-  end
-
-  context 'always ignore last argument hash' do
-    let(:cop_config) do
-      {
-        'EnforcedLastArgumentHashStyle' => 'always_ignore'
-      }
-    end
-
-    it 'accepts misaligned keys in implicit hash' do
-      inspect_source(cop, ['func(a: 0,',
-                           '  b: 1)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts misaligned keys in explicit hash' do
-      inspect_source(cop, ['func({a: 0,',
-                           '  b: 1})'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'ignore implicit last argument hash' do
-    let(:cop_config) do
-      {
-        'EnforcedLastArgumentHashStyle' => 'ignore_implicit'
-      }
-    end
-
-    it 'accepts misaligned keys in implicit hash' do
-      inspect_source(cop, ['func(a: 0,',
-                           '  b: 1)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers offense for misaligned keys in explicit hash' do
-      inspect_source(cop, ['func({a: 0,',
-                           '  b: 1})'])
-      expect(cop.offenses.size).to eq(1)
-    end
-  end
-
-  context 'ignore explicit last argument hash' do
-    let(:cop_config) do
-      {
-        'EnforcedLastArgumentHashStyle' => 'ignore_explicit'
-      }
-    end
-
-    it 'registers offense for misaligned keys in implicit hash' do
-      inspect_source(cop, ['func(a: 0,',
-                           '  b: 1)'])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'accepts misaligned keys in explicit hash' do
-      inspect_source(cop, ['func({a: 0,',
-                           '  b: 1})'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  let(:cop_config) do
-    {
-      'EnforcedHashRocketStyle' => 'key',
-      'EnforcedColonStyle' => 'key'
-    }
-  end
-
-  context 'with default configuration' do
-    it 'registers an offense for misaligned hash keys' do
-      inspect_source(cop, ['hash1 = {',
-                           '  a: 0,',
-                           '   bb: 1',
-                           '}',
-                           'hash2 = {',
-                           "  'ccc' => 2,",
-                           " 'dddd'  =>  2",
-                           '}'])
-      expect(cop.messages).to eq(['Align the elements of a hash ' \
-                                  'literal if they span more than ' \
-                                  'one line.'] * 2)
-      expect(cop.highlights).to eq(['bb: 1',
-                                    "'dddd'  =>  2"])
-    end
-
-    it 'registers an offense for misaligned mixed multiline hash keys' do
-      inspect_source(cop, ['hash = { a: 1, b: 2,',
-                           '        c: 3 }'])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'accepts aligned hash keys' do
-      inspect_source(cop, ['hash1 = {',
-                           '  a: 0,',
-                           '  bb: 1,',
-                           '}',
-                           'hash2 = {',
-                           "  'ccc' => 2,",
-                           "  'dddd'  =>  2",
-                           '}'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for separator alignment' do
-      inspect_source(cop, ['hash = {',
-                           "    'a' => 0,",
-                           "  'bbb' => 1",
-                           '}'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(["'bbb' => 1"])
-    end
-
-    context 'with implicit hash as last argument' do
-      it 'registers an offense for misaligned hash keys' do
-        inspect_source(cop, ['func(a: 0,',
-                             '  b: 1)'])
-        expect(cop.offenses.size).to eq(1)
-      end
-
-      it 'registers an offense for right alignment of keys' do
-        inspect_source(cop, ['func(a: 0,',
-                             '   bbb: 1)'])
-        expect(cop.offenses.size).to eq(1)
-      end
-
-      it 'accepts aligned hash keys' do
-        inspect_source(cop, ['func(a: 0,',
-                             '     b: 1)'])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'accepts an empty hash' do
-        inspect_source(cop, 'h = {}')
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    it 'auto-corrects alignment' do
-      new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
-                                            '     bb: 1,',
-                                            '           ccc: 2 }',
-                                            'hash2 = { :a   => 0,',
-                                            '     :bb  => 1,',
-                                            '          :ccc  =>2 }'
-                                           ])
-      expect(new_source).to eq(['hash1 = { a: 0,',
-                                '          bb: 1,',
-                                '          ccc: 2 }',
-                                'hash2 = { :a   => 0,',
-                                '          :bb  => 1,',
-                                # Separator and value are not corrected
-                                # in 'key' mode.
-                                '          :ccc  =>2 }'].join("\n"))
-    end
-
-    it 'auto-corrects alignment for mixed multiline hash keys' do
-      new_sources = autocorrect_source(cop, ['hash = { a: 1, b: 2,',
-                                             '        c: 3 }'])
-      expect(new_sources).to eq(['hash = { a: 1, b: 2,',
-                                 '         c: 3 }'].join("\n"))
-    end
-  end
-
-  include_examples 'not on separate lines'
-
-  context 'with table alignment configuration' do
-    let(:cop_config) do
-      {
-        'EnforcedHashRocketStyle' => 'table',
-        'EnforcedColonStyle' => 'table'
-      }
-    end
-
-    include_examples 'not on separate lines'
-
-    it 'accepts aligned hash keys' do
-      inspect_source(cop, ['hash1 = {',
-                           "  'a'   => 0,",
-                           "  'bbb' => 1",
-                           '}',
-                           'hash2 = {',
-                           '  a:   0,',
-                           '  bbb: 1',
-                           '}'
-                          ])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts an empty hash' do
-      inspect_source(cop, 'h = {}')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts a multiline array of single line hashes' do
-      inspect_source(cop, ['def self.scenarios_order',
-                           '    [',
-                           '      { before:   %w( l k ) },',
-                           '      { ending:   %w( m l ) },',
-                           '      { starting: %w( m n ) },',
-                           '      { after:    %w( n o ) }',
-                           '    ]',
-                           '  end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for misaligned hash values' do
-      inspect_source(cop, ['hash1 = {',
-                           "  'a'   =>  0,",
-                           "  'bbb' => 1",
-                           '}',
-                           'hash2 = {',
-                           '  a:   0,',
-                           '  bbb:1',
-                           '}'
-                          ])
-      expect(cop.highlights).to eq(["'a'   =>  0",
-                                    'bbb:1'])
-    end
-
-    it 'registers an offense for misaligned hash rockets' do
-      inspect_source(cop, ['hash = {',
-                           "  'a'   => 0,",
-                           "  'bbb'  => 1",
-                           '}'])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'auto-corrects alignment' do
-      new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
-                                            '     bb:   1,',
-                                            '           ccc: 2 }',
-                                            "hash2 = { 'a' => 0,",
-                                            "     'bb' =>   1,",
-                                            "           'ccc'  =>2 }"])
-      expect(new_source).to eq(['hash1 = { a:   0,',
-                                '          bb:  1,',
-                                '          ccc: 2 }',
-                                "hash2 = { 'a'   => 0,",
-                                "          'bb'  => 1,",
-                                "          'ccc' => 2 }"].join("\n"))
-    end
-  end
-
-  context 'with table+separator alignment configuration' do
-    let(:cop_config) do
-      {
-        'EnforcedHashRocketStyle' => 'table',
-        'EnforcedColonStyle' => 'separator'
-      }
-    end
-
-    it 'accepts a single method argument entry with colon' do
-      inspect_source(cop, 'merge(parent: nil)')
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'with invalid configuration' do
-    let(:cop_config) do
-      {
-        'EnforcedHashRocketStyle' => 'junk',
-        'EnforcedColonStyle' => 'junk'
-      }
-    end
-    it 'fails' do
-      src = ['hash = {',
-             '  a: 0,',
-             '  bb: 1',
-             '}']
-      expect { inspect_source(cop, src) }.to raise_error(RuntimeError)
-    end
-  end
-
-  context 'with separator alignment configuration' do
-    let(:cop_config) do
-      {
-        'EnforcedHashRocketStyle' => 'separator',
-        'EnforcedColonStyle' => 'separator'
-      }
-    end
-
-    it 'accepts aligned hash keys' do
-      inspect_source(cop, ['hash1 = {',
-                           '    a: 0,',
-                           '  bbb: 1',
-                           '}',
-                           'hash2 = {',
-                           "    'a' => 0,",
-                           "  'bbb' => 1",
-                           '}'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts an empty hash' do
-      inspect_source(cop, 'h = {}')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for misaligned hash values' do
-      inspect_source(cop, ['hash = {',
-                           "    'a' =>  0,",
-                           "  'bbb' => 1",
-                           '}'])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'registers an offense for misaligned hash rockets' do
-      inspect_source(cop, ['hash = {',
-                           "    'a'  => 0,",
-                           "  'bbb' =>  1",
-                           '}'])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    include_examples 'not on separate lines'
-
-    it 'auto-corrects alignment' do
-      new_source = autocorrect_source(cop, ['hash1 = { a: 0,',
-                                            '     bb:    1,',
-                                            '           ccc: 2 }',
-                                            'hash2 = { a => 0,',
-                                            '     bb =>    1,',
-                                            '           ccc  =>2 }'])
-      expect(new_source).to eq(['hash1 = { a: 0,',
-                                '         bb: 1,',
-                                '        ccc: 2 }',
-                                'hash2 = { a => 0,',
-                                '         bb => 1,',
-                                '        ccc => 2 }'].join("\n"))
-    end
-  end
-
-  context 'with different settings for => and :' do
-    let(:cop_config) do
-      {
-        'EnforcedHashRocketStyle' => 'key',
-        'EnforcedColonStyle' => 'separator'
-      }
-    end
-
-    it 'registers offenses for misaligned entries' do
-      inspect_source(cop, ['hash1 = {',
-                           '  a:   0,',
-                           '  bbb: 1',
-                           '}',
-                           'hash2 = {',
-                           "    'a' => 0,",
-                           "  'bbb' => 1",
-                           '}'])
-      expect(cop.highlights).to eq(['bbb: 1', "'bbb' => 1"])
-    end
-
-    it 'accepts aligned entries' do
-      inspect_source(cop, ['hash1 = {',
-                           '    a: 0,',
-                           '  bbb: 1',
-                           '}',
-                           'hash2 = {',
-                           "  'a' => 0,",
-                           "  'bbb' => 1",
-                           '}'])
-      expect(cop.offenses).to be_empty
-    end
-  end
-end