rubocop 0.29.1 → 0.30.0

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

@@ -1,431 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::AlignParameters do
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    RuboCop::Config.new('Style/AlignParameters' => cop_config,
-                        'Style/IndentationWidth' => {
-                          'Width' => indentation_width
-                        })
-  end
-  let(:indentation_width) { 2 }
-
-  context 'aligned with first parameter' do
-    let(:cop_config) do
-      {
-        'EnforcedStyle' => 'with_first_parameter'
-      }
-    end
-
-    it 'registers an offense for parameters with single indent' do
-      inspect_source(cop, ['function(a,',
-                           '  if b then c else d end)'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['if b then c else d end'])
-    end
-
-    it 'registers an offense for parameters with double indent' do
-      inspect_source(cop, ['function(a,',
-                           '    if b then c else d end)'])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'accepts multiline []= method call' do
-      inspect_source(cop, ['Test.config["something"] =',
-                           ' true'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts correctly aligned parameters' do
-      inspect_source(cop, ['function(a,',
-                           '         0, 1,',
-                           '         (x + y),',
-                           '         if b then c else d end)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts calls that only span one line' do
-      inspect_source(cop, 'find(path, s, @special[sexp[0]])')
-      expect(cop.offenses).to be_empty
-    end
-
-    it "doesn't get confused by a symbol argument" do
-      inspect_source(cop, ['add_offense(index,',
-                           '            MSG % kind)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it "doesn't get confused by splat operator" do
-      inspect_source(cop, ['func1(*a,',
-                           '      *b,',
-                           '      c)',
-                           'func2(a,',
-                           '     *b,',
-                           '      c)',
-                           'func3(*a)'
-                          ])
-      expect(cop.offenses.map(&:to_s))
-        .to eq(['C:  5:  6: Align the parameters of a method call if ' \
-                'they span more than one line.'])
-      expect(cop.highlights).to eq(['*b'])
-    end
-
-    it "doesn't get confused by extra comma at the end" do
-      inspect_source(cop, ['func1(a,',
-                           '     b,)'])
-      expect(cop.offenses.map(&:to_s))
-        .to eq(['C:  2:  6: Align the parameters of a method call if ' \
-                'they span more than one line.'])
-      expect(cop.highlights).to eq(['b'])
-    end
-
-    it 'can handle a correctly aligned string literal as first argument' do
-      inspect_source(cop, ['add_offense(x,',
-                           '            a)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle a string literal as other argument' do
-      inspect_source(cop, ['add_offense(',
-                           '            "", a)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it "doesn't get confused by a line break inside a parameter" do
-      inspect_source(cop, ['read(path, { headers:    true,',
-                           '             converters: :numeric })'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it "doesn't get confused by symbols with embedded expressions" do
-      inspect_source(cop, 'send(:"#{name}_comments_path")')
-      expect(cop.offenses).to be_empty
-    end
-
-    it "doesn't get confused by regexen with embedded expressions" do
-      inspect_source(cop, 'a(/#{name}/)')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts braceless hashes' do
-      inspect_source(cop, ['run(collection, :entry_name => label,',
-                           '                :paginator  => paginator)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts the first parameter being on a new row' do
-      inspect_source(cop, ['  match(',
-                           '    a,',
-                           '    b',
-                           '  )'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle heredoc strings' do
-      inspect_source(cop, ['class_eval(<<-EOS, __FILE__, __LINE__ + 1)',
-                           '            def run_#{name}_callbacks(*args)',
-                           '              a = 1',
-                           '              return value',
-                           '            end',
-                           '            EOS'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle a method call within a method call' do
-      inspect_source(cop, ['a(a1,',
-                           '  b(b1,',
-                           '    b2),',
-                           '  a2)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle a call embedded in a string' do
-      inspect_source(cop, 'model("#{index(name)}", child)')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle do-end' do
-      inspect_source(cop, ['      run(lambda do |e|',
-                           "        w = e['warden']",
-                           '      end)'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle a call with a block inside another call' do
-      src = ['new(table_name,',
-             '    exec_query("info(\'#{row[\'name\']}\')").map { |col|',
-             "      col['name']",
-             '    })']
-      inspect_source(cop, src)
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle a ternary condition with a block reference' do
-      inspect_source(cop, 'cond ? a : func(&b)')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle parentheses used with no parameters' do
-      inspect_source(cop, 'func()')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle a multiline hash as second parameter' do
-      inspect_source(cop, ['tag(:input, {',
-                           '  :value => value',
-                           '})'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle method calls without parentheses' do
-      inspect_source(cop, 'a(b c, d)')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'can handle other method calls without parentheses' do
-      src = 'chars(Unicode.apply_mapping @wrapped_string, :uppercase)'
-      inspect_source(cop, src)
-      expect(cop.offenses).to be_empty
-    end
-
-    context 'assigned methods' do
-      it 'accepts the first parameter being on a new row' do
-        inspect_source(cop, [' assigned_value = match(',
-                             '   a,',
-                             '   b,',
-                             '   c',
-                             ' )'])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'accepts the first parameter being on method row' do
-        inspect_source(cop, [' assigned_value = match(a,',
-                             '                        b,',
-                             '                        c',
-                             '                  )'])
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    it 'auto-corrects alignment' do
-      new_source = autocorrect_source(cop, ['func(a,',
-                                            '       b,',
-                                            'c)'])
-      expect(new_source).to eq(['func(a,',
-                                '     b,',
-                                '     c)'].join("\n"))
-    end
-
-    it 'auto-corrects each line of a multi-line parameter to the right' do
-      new_source =
-        autocorrect_source(cop,
-                           ['create :transaction, :closed,',
-                            '      account:          account,',
-                            '      open_price:       1.29,',
-                            '      close_price:      1.30'])
-      expect(new_source)
-        .to eq(['create :transaction, :closed,',
-                '       account:          account,',
-                '       open_price:       1.29,',
-                '       close_price:      1.30'].join("\n"))
-    end
-
-    it 'auto-corrects each line of a multi-line parameter to the left' do
-      new_source =
-        autocorrect_source(cop,
-                           ['create :transaction, :closed,',
-                            '         account:          account,',
-                            '         open_price:       1.29,',
-                            '         close_price:      1.30'])
-      expect(new_source)
-        .to eq(['create :transaction, :closed,',
-                '       account:          account,',
-                '       open_price:       1.29,',
-                '       close_price:      1.30'].join("\n"))
-    end
-
-    it 'auto-corrects only parameters that begin a line' do
-      original_source = ['foo(: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 crash in autocorrect on dynamic string in parameter value' do
-      src = ['class MyModel < ActiveRecord::Base',
-             '  has_many :other_models,',
-             '    class_name: "legacy_name",',
-             '    order: "#{leagacy_name.table_name}.published DESC"',
-             '',
-             'end']
-      new_source = autocorrect_source(cop, src)
-      expect(new_source)
-        .to eq ['class MyModel < ActiveRecord::Base',
-                '  has_many :other_models,',
-                '           class_name: "legacy_name",',
-                '           order: "#{leagacy_name.table_name}.published DESC"',
-                '',
-                'end'].join("\n")
-    end
-  end
-
-  context 'aligned with fixed indentation' do
-    let(:cop_config) do
-      {
-        'EnforcedStyle' => 'with_fixed_indentation'
-      }
-    end
-
-    let(:correct_source) do
-      [
-        'create :transaction, :closed,',
-        '  account:     account,',
-        '  open_price:  1.29,',
-        '  close_price: 1.30'
-      ]
-    end
-
-    it 'does not autocorrect correct source' do
-      expect(autocorrect_source(cop, correct_source))
-        .to eq(correct_source.join("\n"))
-    end
-
-    it 'autocorrects by outdenting when indented too far' do
-      original_source = [
-        'create :transaction, :closed,',
-        '       account:     account,',
-        '       open_price:  1.29,',
-        '       close_price: 1.30'
-      ]
-
-      expect(autocorrect_source(cop, original_source))
-        .to eq(correct_source.join("\n"))
-    end
-
-    it 'autocorrects by indenting when not indented' do
-      original_source = [
-        'create :transaction, :closed,',
-        'account:     account,',
-        'open_price:  1.29,',
-        'close_price: 1.30'
-      ]
-
-      expect(autocorrect_source(cop, original_source))
-        .to eq(correct_source.join("\n"))
-    end
-
-    it 'autocorrects when first line is indented' do
-      original_source = [
-        '  create :transaction, :closed,',
-        '  account:     account,',
-        '  open_price:  1.29,',
-        '  close_price: 1.30'
-      ]
-
-      correct_source = [
-        '  create :transaction, :closed,',
-        '    account:     account,',
-        '    open_price:  1.29,',
-        '    close_price: 1.30'
-      ]
-
-      expect(autocorrect_source(cop, original_source))
-        .to eq(correct_source.join("\n"))
-    end
-
-    context 'multi-line method calls' do
-      it 'can handle existing indentation from multi-line method calls' do
-        inspect_source(cop, [' something',
-                             '   .method_name(',
-                             '     a,',
-                             '     b,',
-                             '     c',
-                             '   )'])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'registers offenses for double indentation from relevant method' do
-        inspect_source(cop, [' something',
-                             '   .method_name(',
-                             '       a,',
-                             '       b,',
-                             '       c',
-                             '   )'])
-        expect(cop.offenses.size).to eq(3)
-      end
-
-      it 'does not err on method call without a method name' do
-        inspect_source(cop, [' something',
-                             '   .(',
-                             '     a,',
-                             '     b,',
-                             '     c',
-                             '   )'])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'autocorrects relative to position of relevant method call' do
-        original_source = [
-          ' something',
-          '   .method_name(',
-          '       a,',
-          '          b,',
-          '            c',
-          '   )'
-        ]
-        correct_source = [
-          ' something',
-          '   .method_name(',
-          '     a,',
-          '     b,',
-          '     c',
-          '   )'
-        ]
-        expect(autocorrect_source(cop, original_source))
-          .to eq(correct_source.join("\n"))
-      end
-    end
-
-    context 'assigned methods' do
-      context 'with IndentationWidth:Width set to 4' do
-        let(:indentation_width) { 4 }
-
-        it 'accepts the first parameter being on a new row' do
-          inspect_source(cop, [' assigned_value = match(',
-                               '     a,',
-                               '     b,',
-                               '     c',
-                               ' )'])
-          expect(cop.offenses).to be_empty
-        end
-
-        it 'accepts the first parameter being on method row' do
-          inspect_source(cop, [' assigned_value = match(a,',
-                               '     b,',
-                               '     c',
-                               ' )'])
-          expect(cop.offenses).to be_empty
-        end
-
-        it 'autocorrects even when first argument is in wrong position' do
-          original_source = [' assigned_value = match(',
-                             '         a,',
-                             '            b,',
-                             '                    c',
-                             ' )']
-
-          correct_source = [' assigned_value = match(',
-                            '     a,',
-                            '     b,',
-                            '     c',
-                            ' )']
-
-          expect(autocorrect_source(cop, original_source))
-            .to eq(correct_source.join("\n"))
-        end
-      end
-    end
-  end
-end

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

@@ -1,235 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::AndOr, :config do
-  context 'when style is conditionals' do
-    cop_config = {
-      'EnforcedStyle' => 'conditionals'
-    }
-
-    subject(:cop) { described_class.new(config) }
-    let(:cop_config) { cop_config }
-
-    %w(and or).each do |operator|
-      it "accepts \"#{operator}\" outside of conditional" do
-        inspect_source(cop, "x = a + b #{operator} return x")
-        expect(cop.offenses).to be_empty
-      end
-
-      {
-        'if'                     => 'if %{conditional}; %{body}; end',
-        'while'                  => 'while %{conditional}; %{body}; end',
-        'until'                  => 'until %{conditional}; %{body}; end',
-        'post-conditional while' => 'begin; %{body}; end while %{conditional}',
-        'post-conditional until' => 'begin; %{body}; end until %{conditional}'
-      }.each do |type, snippet_format|
-        it "registers an offense for \"#{operator}\" in #{type} conditional" do
-          elements = {
-            conditional: "a #{operator} b",
-            body:        'do_something'
-          }
-          source = format(snippet_format, elements)
-
-          inspect_source(cop, source)
-          expect(cop.offenses.size).to eq(1)
-        end
-
-        it "accepts \"#{operator}\" in #{type} body" do
-          elements = {
-            conditional: 'some_condition',
-            body:        "do_something #{operator} return"
-          }
-          source = format(snippet_format, elements)
-
-          inspect_source(cop, source)
-          expect(cop.offenses).to be_empty
-        end
-      end
-    end
-
-    %w(&& ||).each do |operator|
-      it "accepts #{operator} inside of conditional" do
-        inspect_source(cop, "test if a #{operator} b")
-        expect(cop.offenses).to be_empty
-      end
-
-      it "accepts #{operator} outside of conditional" do
-        inspect_source(cop, "x = a #{operator} b")
-        expect(cop.offenses).to be_empty
-      end
-    end
-  end
-
-  context 'when style is always' do
-    cop_config = {
-      'EnforcedStyle' => 'always'
-    }
-
-    subject(:cop) { described_class.new(config) }
-    let(:cop_config) { cop_config }
-
-    it 'registers an offense for "or"' do
-      inspect_source(cop, 'test if a or b')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `||` instead of `or`.'])
-    end
-
-    it 'registers an offense for "and"' do
-      inspect_source(cop, 'test if a and b')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `&&` instead of `and`.'])
-    end
-
-    it 'accepts ||' do
-      inspect_source(cop, 'test if a || b')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts &&' do
-      inspect_source(cop, 'test if a && b')
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'auto-corrects "and" with &&' do
-      new_source = autocorrect_source(cop, 'true and false')
-      expect(new_source).to eq('true && false')
-    end
-
-    it 'auto-corrects "or" with ||' do
-      new_source = autocorrect_source(cop, ['x = 12345',
-                                            'true or false'])
-      expect(new_source).to eq(['x = 12345',
-                                'true || false'].join("\n"))
-    end
-
-    it 'auto-corrects "or" with || inside def' do
-      new_source = autocorrect_source(cop, ['def z(a, b)',
-                                            '  return true if a or b',
-                                            'end'])
-      expect(new_source).to eq(['def z(a, b)',
-                                '  return true if a || b',
-                                'end'].join("\n"))
-    end
-
-    it 'leaves *or* as is if auto-correction changes the meaning' do
-      src = "x = y or teststring.include? 'b'"
-      new_source = autocorrect_source(cop, src)
-      expect(new_source).to eq(src)
-    end
-
-    it 'leaves *and* as is if auto-correction changes the meaning' do
-      src = 'x = a + b and return x'
-      new_source = autocorrect_source(cop, src)
-      expect(new_source).to eq(src)
-    end
-
-    it 'warns on short-circuit (and)' do
-      inspect_source(cop, 'x = a + b and return x')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `&&` instead of `and`.'])
-    end
-
-    it 'also warns on non short-circuit (and)' do
-      inspect_source(cop, 'x = a + b if a and b')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `&&` instead of `and`.'])
-    end
-
-    it 'also warns on non short-circuit (and) (unless)' do
-      inspect_source(cop, 'x = a + b unless a and b')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `&&` instead of `and`.'])
-    end
-
-    it 'warns on short-circuit (or)' do
-      inspect_source(cop, 'x = a + b or return x')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `||` instead of `or`.'])
-    end
-
-    it 'also warns on non short-circuit (or)' do
-      inspect_source(cop, 'x = a + b if a or b')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `||` instead of `or`.'])
-    end
-
-    it 'also warns on non short-circuit (or) (unless)' do
-      inspect_source(cop, 'x = a + b unless a or b')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `||` instead of `or`.'])
-    end
-
-    it 'also warns on while (or)' do
-      inspect_source(cop, 'x = a + b while a or b')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `||` instead of `or`.'])
-    end
-
-    it 'also warns on until (or)' do
-      inspect_source(cop, 'x = a + b until a or b')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Use `||` instead of `or`.'])
-    end
-
-    it 'auto-corrects "or" with || in method calls' do
-      new_source = autocorrect_source(cop, 'method a or b')
-      expect(new_source).to eq('method(a) || b')
-    end
-
-    it 'auto-corrects "or" with || in method calls (2)' do
-      new_source = autocorrect_source(cop, 'method a,b or b')
-      expect(new_source).to eq('method(a,b) || b')
-    end
-
-    it 'auto-corrects "or" with || in method calls (3)' do
-      new_source = autocorrect_source(cop, 'obj.method a or b')
-      expect(new_source).to eq('obj.method(a) || b')
-    end
-
-    it 'auto-corrects "or" with || in method calls (4)' do
-      new_source = autocorrect_source(cop, 'obj.method a,b or b')
-      expect(new_source).to eq('obj.method(a,b) || b')
-    end
-
-    it 'auto-corrects "or" with || and doesn\'t add extra parenthesis' do
-      new_source = autocorrect_source(cop, 'method(a, b) or b')
-      expect(new_source).to eq('method(a, b) || b')
-    end
-
-    it 'auto-corrects "or" with || and add parenthesis on left expr' do
-      new_source = autocorrect_source(cop, 'b or method a,b')
-      expect(new_source).to eq('b || method(a,b)')
-    end
-
-    it 'auto-corrects "and" with && in method calls' do
-      new_source = autocorrect_source(cop, 'method a and b')
-      expect(new_source).to eq('method(a) && b')
-    end
-
-    it 'auto-corrects "and" with && in method calls (2)' do
-      new_source = autocorrect_source(cop, 'method a,b and b')
-      expect(new_source).to eq('method(a,b) && b')
-    end
-
-    it 'auto-corrects "and" with && in method calls (3)' do
-      new_source = autocorrect_source(cop, 'obj.method a and b')
-      expect(new_source).to eq('obj.method(a) && b')
-    end
-
-    it 'auto-corrects "and" with && in method calls (4)' do
-      new_source = autocorrect_source(cop, 'obj.method a,b and b')
-      expect(new_source).to eq('obj.method(a,b) && b')
-    end
-
-    it 'auto-corrects "and" with && and doesn\'t add extra parenthesis' do
-      new_source = autocorrect_source(cop, 'method(a, b) and b')
-      expect(new_source).to eq('method(a, b) && b')
-    end
-
-    it 'auto-corrects "and" with && and add parenthesis on left expr' do
-      new_source = autocorrect_source(cop, 'b and method a,b')
-      expect(new_source).to eq('b && method(a,b)')
-    end
-  end
-end