rubocop 0.29.1 → 0.30.0

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

@@ -1,146 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::IfUnlessModifier do
-  include StatementModifierHelper
-
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    hash = { 'Metrics/LineLength' => { 'Max' => 80 } }
-    RuboCop::Config.new(hash)
-  end
-
-  it 'registers an offense for multiline if that fits on one line' do
-    # This if statement fits exactly on one line if written as a
-    # modifier.
-    condition = 'a' * 38
-    body = 'b' * 36
-    expect("  #{body} if #{condition}".length).to eq(80)
-
-    inspect_source(cop,
-                   ["  if #{condition}",
-                    "    #{body}",
-                    '  end'])
-    expect(cop.messages).to eq(
-      ['Favor modifier `if` usage when having a single-line' \
-       ' body. Another good alternative is the usage of control flow' \
-       ' `&&`/`||`.'])
-  end
-
-  it 'registers an offense for short multiline if near an else etc' do
-    inspect_source(cop,
-                   ['if x',
-                    '  y',
-                    'elsif x1',
-                    '  y1',
-                    'else',
-                    '  z',
-                    'end',
-                    'n = a ? 0 : 1',
-                    'm = 3 if m0',
-                    '',
-                    'if a',
-                    '  b',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it "accepts multiline if that doesn't fit on one line" do
-    check_too_long(cop, 'if')
-  end
-
-  it 'accepts multiline if whose body is more than one line' do
-    check_short_multiline(cop, 'if')
-  end
-
-  it 'registers an offense for multiline unless that fits on one line' do
-    inspect_source(cop, ['unless a',
-                         '  b',
-                         'end'])
-    expect(cop.messages).to eq(
-      ['Favor modifier `unless` usage when having a single-line' \
-       ' body. Another good alternative is the usage of control flow' \
-       ' `&&`/`||`.'])
-  end
-
-  it 'accepts code with EOL comment since user might want to keep it' do
-    inspect_source(cop, ['unless a',
-                         '  b # A comment',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts if-else-end' do
-    inspect_source(cop,
-                   'if args.last.is_a? Hash then args.pop else ' \
-                   'Hash.new end')
-    expect(cop.messages).to be_empty
-  end
-
-  it 'accepts an empty condition' do
-    check_empty(cop, 'if')
-    check_empty(cop, 'unless')
-  end
-
-  it 'accepts if/elsif' do
-    inspect_source(cop, ['if test',
-                         '  something',
-                         'elsif test2',
-                         '  something_else',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  context 'with implicit match conditional' do
-    let(:source) do
-      [
-        "  if #{conditional}",
-        "    #{body}",
-        '  end'
-      ]
-    end
-
-    let(:body) { 'b' * 36 }
-
-    context 'when a multiline if fits on one line' do
-      let(:conditional) { "/#{'a' * 36}/" }
-
-      it 'registers an offense' do
-        expect("  #{body} if #{conditional}".length).to eq(80)
-
-        inspect_source(cop, source)
-        expect(cop.offenses.size).to eq(1)
-      end
-    end
-
-    context "when a multiline if doesn't fit on one line" do
-      let(:conditional) { "/#{'a' * 37}/" }
-
-      it 'accepts' do
-        expect("  #{body} if #{conditional}".length).to eq(81)
-
-        inspect_source(cop, source)
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    context 'when the maximum line length is specified by the cop itself' do
-      let(:config) do
-        hash = {
-          'Metrics/LineLength' => { 'Max' => 100 },
-          'Style/IfUnlessModifier' => { 'MaxLineLength' => 80 }
-        }
-        RuboCop::Config.new(hash)
-      end
-
-      it "accepts multiline if that doesn't fit on one line" do
-        check_too_long(cop, 'if')
-      end
-
-      it "accepts multiline unless that doesn't fit on one line" do
-        check_too_long(cop, 'unless')
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::IfWithSemicolon do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for one line if/;/end' do
-    inspect_source(cop, 'if cond; run else dont end')
-    expect(cop.messages).to eq(
-      ['Do not use if x; Use the ternary operator instead.'])
-  end
-
-  it 'accepts one line if/then/end' do
-    inspect_source(cop, 'if cond then run else dont end')
-    expect(cop.messages).to be_empty
-  end
-
-  it 'can handle modifier conditionals' do
-    inspect_source(cop, ['class Hash',
-                         'end if RUBY_VERSION < "1.8.7"'])
-    expect(cop.messages).to be_empty
-  end
-end

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

@@ -1,173 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::IndentArray do
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    RuboCop::Config
-      .new('Style/IndentationWidth' => { 'Width' => indentation_width })
-  end
-  let(:indentation_width) { 2 }
-
-  it 'accepts multi-assignments' do
-    inspect_source(cop, 'a, b = b, a')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts correctly indented only element' do
-    inspect_source(cop,
-                   ['a << [',
-                    '  1',
-                    ']'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'registers an offense for incorrectly indented only element' do
-    inspect_source(cop,
-                   ['a << [',
-                    ' 1',
-                    ']'])
-    expect(cop.highlights).to eq(['1'])
-  end
-
-  it 'registers an offense for incorrectly indented closing bracket in an ' \
-     'empty array' do
-    inspect_source(cop,
-                   ['a << [',
-                    ' ]'])
-    expect(cop.messages)
-      .to eq(['Indent the right bracket the same as the start of the line ' \
-              'where the left bracket is.'])
-    expect(cop.highlights).to eq([']'])
-  end
-
-  context 'when the first element is not on its own line' do
-    it 'registers an offense for an incorrectly indented closing bracket' do
-      inspect_source(cop,
-                     ['a = [1,',
-                      '     2,',
-                      ']'])
-      expect(cop.highlights).to eq([']'])
-      expect(cop.messages)
-        .to eq(['Indent the right bracket the same as the left bracket.'])
-    end
-
-    it 'accepts closing bracket indented the same as opening bracket' do
-      inspect_source(cop,
-                     ['a = [1,',
-                      '     2,',
-                      '    ]'])
-      expect(cop.highlights).to eq([])
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  it 'auto-corrects incorrectly indented only element' do
-    corrected = autocorrect_source(cop, ['a << [',
-                                         ' 1',
-                                         ']'])
-    expect(corrected).to eq ['a << [',
-                             '  1',
-                             ']'].join("\n")
-  end
-
-  it 'accepts correctly indented first element' do
-    inspect_source(cop,
-                   ['[',
-                    '  x,',
-                    '  y',
-                    ']'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'registers an offense for incorrectly indented first element' do
-    inspect_source(cop,
-                   ['[',
-                    'x,',
-                    '  y',
-                    ']'])
-    expect(cop.highlights).to eq(['x'])
-  end
-
-  it 'accepts several elements per line' do
-    inspect_source(cop,
-                   ['a = [',
-                    '  1, 2',
-                    ']'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a first element on the same line as the left bracket' do
-    inspect_source(cop,
-                   ['a = ["a",',
-                    '     "b"]'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts single line array' do
-    inspect_source(cop, 'a = [1, 2]')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts an empty array' do
-    inspect_source(cop, 'a = []')
-    expect(cop.offenses).to be_empty
-  end
-
-  context 'when array is method argument' do
-    context 'and arguments are surrounded by parentheses' do
-      it 'accepts normal indentation for first argument' do
-        inspect_source(cop,
-                       ['func([',
-                        '  1',
-                        '])'])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'registers an offense for incorrect indentation' do
-        inspect_source(cop,
-                       ['func([',
-                        '      1',
-                        '     ])'])
-        expect(cop.messages)
-          .to eq(['Use 2 spaces for indentation in an array, relative to ' \
-                  'the start of the line where the left bracket is.',
-
-                  'Indent the right bracket the same as the start of the ' \
-                  'line where the left bracket is.'])
-      end
-
-      it 'accepts normal indentation for second argument' do
-        inspect_source(cop,
-                       ['body.should have_tag("input", [',
-                        '  :name])'])
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    context 'and arguments are not surrounded by parentheses' do
-      it 'accepts single line array' do
-        inspect_source(cop, 'func x, [1, 2]')
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'accepts a correctly indented multi-line array' do
-        inspect_source(cop,
-                       ['func x, [',
-                        '  1, 2]'])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'registers an offense for incorrectly indented multi-line array' do
-        inspect_source(cop,
-                       ['func x, [',
-                        '       1, 2]'])
-        expect(cop.messages)
-          .to eq(['Use 2 spaces for indentation in an array, relative to ' \
-                  'the start of the line where the left bracket is.'])
-        expect(cop.highlights).to eq(['1'])
-      end
-    end
-  end
-end

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

@@ -1,367 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::IndentHash do
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    supported_styles = {
-      'SupportedStyles' => %w(special_inside_parentheses consistent)
-    }
-    RuboCop::Config.new('Style/AlignHash' => align_hash_config,
-                        'Style/IndentHash' =>
-                        cop_config.merge(supported_styles),
-                        'Style/IndentationWidth' => { 'Width' => 2 })
-  end
-  let(:align_hash_config) do
-    {
-      'Enabled' => true,
-      'EnforcedColonStyle' => 'key',
-      'EnforcedHashRocketStyle' => 'key'
-    }
-  end
-  let(:cop_config) { { 'EnforcedStyle' => 'special_inside_parentheses' } }
-
-  shared_examples 'right brace' do
-    it 'registers an offense for incorrectly indented }' do
-      inspect_source(cop,
-                     ['a << {',
-                      '  }'])
-      expect(cop.highlights).to eq(['}'])
-      expect(cop.messages)
-        .to eq(['Indent the right brace the same as the start of the line ' \
-                'where the left brace is.'])
-      expect(cop.config_to_allow_offenses).to eq(nil)
-    end
-  end
-
-  context 'when the AlignHash style is separator for :' do
-    let(:align_hash_config) do
-      {
-        'Enabled' => true,
-        'EnforcedColonStyle' => 'separator',
-        'EnforcedHashRocketStyle' => 'key'
-      }
-    end
-
-    it 'accepts correctly indented first pair' do
-      inspect_source(cop,
-                     ['a << {',
-                      '    a: 1,',
-                      '  aaa: 222',
-                      '}'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for incorrectly indented first pair with :' do
-      inspect_source(cop,
-                     ['a << {',
-                      '       a: 1,',
-                      '     aaa: 222',
-                      '}'])
-      expect(cop.highlights).to eq(['a: 1'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    include_examples 'right brace'
-  end
-
-  context 'when the AlignHash style is separator for =>' do
-    let(:align_hash_config) do
-      {
-        'Enabled' => true,
-        'EnforcedColonStyle' => 'key',
-        'EnforcedHashRocketStyle' => 'separator'
-      }
-    end
-
-    it 'accepts correctly indented first pair' do
-      inspect_source(cop,
-                     ['a << {',
-                      "    'a' => 1,",
-                      "  'aaa' => 222",
-                      '}'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for incorrectly indented first pair with =>' do
-      inspect_source(cop,
-                     ['a << {',
-                      "   'a' => 1,",
-                      " 'aaa' => 222",
-                      '}'])
-      expect(cop.highlights).to eq(["'a' => 1"])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    include_examples 'right brace'
-  end
-
-  context 'when hash is operand' do
-    it 'accepts correctly indented first pair' do
-      inspect_source(cop,
-                     ['a << {',
-                      '  a: 1',
-                      '}'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for incorrectly indented first pair' do
-      inspect_source(cop,
-                     ['a << {',
-                      ' a: 1',
-                      '}'])
-      expect(cop.highlights).to eq(['a: 1'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'auto-corrects incorrectly indented first pair' do
-      corrected = autocorrect_source(cop, ['a << {',
-                                           ' a: 1',
-                                           '}'])
-      expect(corrected).to eq ['a << {',
-                               '  a: 1',
-                               '}'].join("\n")
-    end
-
-    include_examples 'right brace'
-  end
-
-  context 'when hash is argument to setter' do
-    it 'accepts correctly indented first pair' do
-      inspect_source(cop,
-                     ['   config.rack_cache = {',
-                      '     :metastore => "rails:/",',
-                      '     :entitystore => "rails:/",',
-                      '     :verbose => false',
-                      '   }'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for incorrectly indented first pair' do
-      inspect_source(cop,
-                     ['   config.rack_cache = {',
-                      '   :metastore => "rails:/",',
-                      '   :entitystore => "rails:/",',
-                      '   :verbose => false',
-                      '   }'])
-      expect(cop.highlights).to eq([':metastore => "rails:/"'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-  end
-
-  context 'when hash is right hand side in assignment' do
-    it 'registers an offense for incorrectly indented first pair' do
-      inspect_source(cop, ['a = {',
-                           '    a: 1,',
-                           '  b: 2,',
-                           ' c: 3',
-                           '}'])
-      expect(cop.messages)
-        .to eq(['Use 2 spaces for indentation in a hash, relative to the ' \
-                'start of the line where the left curly brace is.'])
-      expect(cop.highlights).to eq(['a: 1'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'auto-corrects incorrectly indented first pair' do
-      corrected = autocorrect_source(cop, ['a = {',
-                                           '    a: 1,',
-                                           '  b: 2,',
-                                           ' c: 3',
-                                           '}'])
-      expect(corrected).to eq ['a = {',
-                               '  a: 1,',
-                               '  b: 2,',
-                               ' c: 3',
-                               '}'].join("\n")
-    end
-
-    it 'accepts correctly indented first pair' do
-      inspect_source(cop,
-                     ['a = {',
-                      '  a: 1',
-                      '}'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts several pairs per line' do
-      inspect_source(cop,
-                     ['a = {',
-                      '  a: 1, b: 2',
-                      '}'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts a first pair on the same line as the left brace' do
-      inspect_source(cop,
-                     ['a = { "a" => 1,',
-                      '      "b" => 2 }'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts single line hash' do
-      inspect_source(cop,
-                     'a = { a: 1, b: 2 }')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts an empty hash' do
-      inspect_source(cop,
-                     'a = {}')
-      expect(cop.offenses).to be_empty
-    end
-  end
-
-  context 'when hash is method argument' do
-    context 'and arguments are surrounded by parentheses' do
-      context 'and EnforcedStyle is special_inside_parentheses' do
-        it 'accepts special indentation for first argument' do
-          inspect_source(cop,
-                         # Only the function calls are affected by
-                         # EnforcedStyle setting. Other indentation shall be
-                         # the same regardless of EnforcedStyle.
-                         ['h = {',
-                          '  a: 1',
-                          '}',
-                          'func({',
-                          '       a: 1',
-                          '     })',
-                          'func(x, {',
-                          '       a: 1',
-                          '     })',
-                          'h = { a: 1',
-                          '}',
-                          'func({ a: 1',
-                          '     })',
-                          'func(x, { a: 1',
-                          '     })'])
-          expect(cop.offenses).to be_empty
-        end
-
-        it 'registers an offense for incorrect indentation' do
-          inspect_source(cop,
-                         ['func({',
-                          '  a: 1',
-                          '})'])
-          expect(cop.messages)
-            .to eq(['Use 2 spaces for indentation in a hash, relative to the' \
-                    ' first position after the preceding left parenthesis.',
-
-                    'Indent the right brace the same as the first position ' \
-                    'after the preceding left parenthesis.'])
-          expect(cop.config_to_allow_offenses)
-            .to eq('EnforcedStyle' => 'consistent')
-        end
-
-        it 'auto-corrects incorrectly indented first pair' do
-          corrected = autocorrect_source(cop, ['func({',
-                                               '  a: 1',
-                                               '})'])
-          expect(corrected).to eq ['func({',
-                                   '       a: 1',
-                                   '     })'].join("\n")
-        end
-
-        it 'accepts special indentation for second argument' do
-          inspect_source(cop,
-                         ['body.should have_tag("input", :attributes => {',
-                          '                       :name => /q\[(id_eq)\]/ })'])
-          expect(cop.offenses).to be_empty
-        end
-
-        it 'accepts normal indentation for hash within hash' do
-          inspect_source(cop,
-                         ['scope = scope.where(',
-                          '  klass.table_name => {',
-                          '    reflection.type => model.base_class.sti_name',
-                          '  }',
-                          ')'])
-          expect(cop.offenses).to be_empty
-        end
-      end
-
-      context 'and EnforcedStyle is consistent' do
-        let(:cop_config) { { 'EnforcedStyle' => 'consistent' } }
-
-        it 'accepts normal indentation for first argument' do
-          inspect_source(cop,
-                         # Only the function calls are affected by
-                         # EnforcedStyle setting. Other indentation shall be
-                         # the same regardless of EnforcedStyle.
-                         ['h = {',
-                          '  a: 1',
-                          '}',
-                          'func({',
-                          '  a: 1',
-                          '})',
-                          'func(x, {',
-                          '  a: 1',
-                          '})',
-                          'h = { a: 1',
-                          '}',
-                          'func({ a: 1',
-                          '})',
-                          'func(x, { a: 1',
-                          '})'])
-          expect(cop.offenses).to be_empty
-        end
-
-        it 'registers an offense for incorrect indentation' do
-          inspect_source(cop,
-                         ['func({',
-                          '       a: 1',
-                          '     })'])
-          expect(cop.messages)
-            .to eq(['Use 2 spaces for indentation in a hash, relative to the' \
-                    ' start of the line where the left curly brace is.',
-
-                    'Indent the right brace the same as the start of the ' \
-                    'line where the left brace is.'])
-          expect(cop.config_to_allow_offenses)
-            .to eq('EnforcedStyle' => 'special_inside_parentheses')
-        end
-
-        it 'accepts normal indentation for second argument' do
-          inspect_source(cop,
-                         ['body.should have_tag("input", :attributes => {',
-                          '  :name => /q\[(id_eq)\]/ })'])
-          expect(cop.offenses).to be_empty
-        end
-      end
-    end
-
-    context 'and argument are not surrounded by parentheses' do
-      it 'accepts braceless hash' do
-        inspect_source(cop,
-                       'func a: 1, b: 2')
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'accepts single line hash with braces' do
-        inspect_source(cop,
-                       'func x, { a: 1, b: 2 }')
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'accepts a correctly indented multi-line hash with braces' do
-        inspect_source(cop,
-                       ['func x, {',
-                        '  a: 1, b: 2 }'])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'registers an offense for incorrectly indented multi-line hash ' \
-         'with braces' do
-        inspect_source(cop,
-                       ['func x, {',
-                        '       a: 1, b: 2 }'])
-        expect(cop.messages)
-          .to eq(['Use 2 spaces for indentation in a hash, relative to the ' \
-                  'start of the line where the left curly brace is.'])
-        expect(cop.highlights).to eq(['a: 1'])
-        expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-      end
-    end
-  end
-end