rubocop 0.29.1 → 0.30.0

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

@@ -1,100 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::EmptyElse do
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    RuboCop::Config.new
-  end
-
-  context 'given an if-statement' do
-    context 'with a completely empty else-clause' do
-      it 'registers an offense' do
-        inspect_source(cop, 'if a; foo else end')
-        expect(cop.messages).to eq(['Redundant empty `else`-clause.'])
-      end
-    end
-
-    context 'with an else-clause containing only the literal nil' do
-      it 'registers an offense' do
-        inspect_source(cop, 'if a; foo elsif b; bar else nil end')
-        expect(cop.messages).to eq(['Redundant empty `else`-clause.'])
-      end
-    end
-
-    context 'with an else-clause with side-effects' do
-      it "doesn't register an offence" do
-        inspect_source(cop, 'if cond; foo else bar; nil end')
-        expect(cop.messages).to be_empty
-      end
-    end
-
-    context 'with no else-clause' do
-      it "doesn't register an offence" do
-        inspect_source(cop, 'if cond; foo end')
-        expect(cop.messages).to be_empty
-      end
-    end
-  end
-
-  context 'given an unless-statement' do
-    context 'with a completely empty else-clause' do
-      it 'registers an offense' do
-        inspect_source(cop, 'unless cond; foo else end')
-        expect(cop.messages).to eq(['Redundant empty `else`-clause.'])
-      end
-    end
-
-    context 'with an else-clause containing only the literal nil' do
-      it 'registers an offense' do
-        inspect_source(cop, 'unless cond; foo else nil end')
-        expect(cop.messages).to eq(['Redundant empty `else`-clause.'])
-      end
-    end
-
-    context 'with an else-clause with side-effects' do
-      it "doesn't register an offence" do
-        inspect_source(cop, 'unless cond; foo else bar; nil end')
-        expect(cop.messages).to be_empty
-      end
-    end
-
-    context 'with no else-clause' do
-      it "doesn't register an offence" do
-        inspect_source(cop, 'unless cond; foo end')
-        expect(cop.messages).to be_empty
-      end
-    end
-  end
-
-  context 'given a case statement' do
-    context 'with a completely empty else-clause' do
-      it 'registers an offense' do
-        inspect_source(cop, 'case v; when a; foo else end')
-        expect(cop.messages).to eq(['Redundant empty `else`-clause.'])
-      end
-    end
-
-    context 'with an else-clause containing only the literal nil' do
-      it 'registers an offense' do
-        inspect_source(cop, 'case v; when a; foo; when b; bar; else nil end')
-        expect(cop.messages).to eq(['Redundant empty `else`-clause.'])
-      end
-    end
-
-    context 'with an else-clause with side-effects' do
-      it "doesn't register an offence" do
-        inspect_source(cop, 'case v; when a; foo; else b; nil end')
-        expect(cop.messages).to be_empty
-      end
-    end
-
-    context 'with no else-clause' do
-      it "doesn't register an offence" do
-        inspect_source(cop, 'case v; when a; foo; when b; bar; end')
-        expect(cop.messages).to be_empty
-      end
-    end
-  end
-end

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

@@ -1,135 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::EmptyLineBetweenDefs, :config do
-  subject(:cop) { described_class.new(config) }
-  let(:cop_config) { { 'AllowAdjacentOneLineDefs' => false } }
-
-  it 'finds offenses in inner classes' do
-    source = ['class K',
-              '  def m',
-              '  end',
-              '  class J',
-              '    def n',
-              '    end',
-              '    def o',
-              '    end',
-              '  end',
-              '  # checks something',
-              '  def p',
-              '  end',
-              'end']
-    inspect_source(cop, source)
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([7])
-  end
-
-  # Only one def, so rule about empty line *between* defs does not
-  # apply.
-  it 'accepts a def that follows a line with code' do
-    source = ['x = 0',
-              'def m',
-              'end']
-    inspect_source(cop, source)
-    expect(cop.offenses).to be_empty
-  end
-
-  # Only one def, so rule about empty line *between* defs does not
-  # apply.
-  it 'accepts a def that follows code and a comment' do
-    source = ['  x = 0',
-              '  # 123',
-              '  def m',
-              '  end']
-    inspect_source(cop, source)
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts the first def without leading empty line in a class' do
-    source = ['class K',
-              '  def m',
-              '  end',
-              'end']
-    inspect_source(cop, source)
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a def that follows an empty line and then a comment' do
-    source = ['class A',
-              '  # calculates value',
-              '  def m',
-              '  end',
-              '',
-              '  private',
-              '  # calculates size',
-              '  def n',
-              '  end',
-              'end'
-             ]
-    inspect_source(cop, source)
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a def that is the first of a module' do
-    source = ['module Util',
-              '  public',
-              '  #',
-              '  def html_escape(s)',
-              '  end',
-              'end'
-             ]
-    inspect_source(cop, source)
-    expect(cop.messages).to be_empty
-  end
-
-  it 'accepts a nested def' do
-    source = ['def mock_model(*attributes)',
-              '  Class.new do',
-              '    def initialize(attrs)',
-              '    end',
-              '  end',
-              'end'
-             ]
-    inspect_source(cop, source)
-    expect(cop.messages).to be_empty
-  end
-
-  it 'registers an offense for adjacent one-liners by default' do
-    source = ['def a; end',
-              'def b; end']
-    inspect_source(cop, source)
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'auto-corrects adjacent one-liners by default' do
-    corrected = autocorrect_source(cop, ['  def a; end',
-                                         '  def b; end'])
-    expect(corrected).to eq(['  def a; end',
-                             '',
-                             '  def b; end'].join("\n"))
-  end
-
-  context 'when AllowAdjacentOneLineDefs is enabled' do
-    let(:cop_config) { { 'AllowAdjacentOneLineDefs' => true } }
-
-    it 'accepts adjacent one-liners' do
-      source = ['def a; end',
-                'def b; end']
-      inspect_source(cop, source)
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for adjacent defs if some are multi-line' do
-      source = ['def a; end',
-                'def b; end',
-                'def c', # Not a one-liner, so this is an offense.
-                'end',
-                # Also an offense since previous was multi-line:
-                'def d; end'
-               ]
-      inspect_source(cop, source)
-      expect(cop.offenses.map(&:line)).to eq([3, 5])
-    end
-  end
-end

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

@@ -1,178 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::EmptyLinesAroundAccessModifier do
-  subject(:cop) { described_class.new }
-
-  %w(private protected public module_function).each do |access_modifier|
-    it "requires blank line before #{access_modifier}" do
-      inspect_source(cop,
-                     ['class Test',
-                      '  something',
-                      "  #{access_modifier}",
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(["Keep a blank line before and after `#{access_modifier}`."])
-    end
-
-    it "requires blank line after #{access_modifier}" do
-      inspect_source(cop,
-                     ['class Test',
-                      '  something',
-                      '',
-                      "  #{access_modifier}",
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(["Keep a blank line before and after `#{access_modifier}`."])
-    end
-
-    it "ignores #{access_modifier} inside a method call" do
-      inspect_source(cop,
-                     ['class Test',
-                      '  def #{access_modifier}?',
-                      "    #{access_modifier}",
-                      '  end',
-                      'end'])
-      expect(cop.offenses.size).to eq(0)
-    end
-
-    it "ignores #{access_modifier} deep inside a method call" do
-      inspect_source(cop,
-                     ['class Test',
-                      "  def #{access_modifier}?",
-                      '    if true',
-                      "      #{access_modifier}",
-                      '    end',
-                      '  end',
-                      'end'])
-      expect(cop.offenses.size).to eq(0)
-    end
-
-    it "ignores #{access_modifier} with a right-hand-side condition" do
-      inspect_source(cop,
-                     ['class Test',
-                      "  def #{access_modifier}?",
-                      "    #{access_modifier} if true",
-                      '  end',
-                      'end'])
-      expect(cop.offenses.size).to eq(0)
-    end
-
-    it "autocorrects blank line before #{access_modifier}" do
-      corrected = autocorrect_source(cop,
-                                     ['class Test',
-                                      '  something',
-                                      "  #{access_modifier}",
-                                      '',
-                                      '  def test; end',
-                                      'end'])
-      expect(corrected).to eq(['class Test',
-                               '  something',
-                               '',
-                               "  #{access_modifier}",
-                               '',
-                               '  def test; end',
-                               'end'].join("\n"))
-    end
-
-    it 'autocorrects blank line after #{access_modifier}' do
-      corrected = autocorrect_source(cop,
-                                     ['class Test',
-                                      '  something',
-                                      '',
-                                      "  #{access_modifier}",
-                                      '  def test; end',
-                                      'end'])
-      expect(corrected).to eq(['class Test',
-                               '  something',
-                               '',
-                               "  #{access_modifier}",
-                               '',
-                               '  def test; end',
-                               'end'].join("\n"))
-    end
-
-    it 'accepts missing blank line when at the beginning of class/module' do
-      inspect_source(cop,
-                     ['class Test',
-                      "  #{access_modifier}",
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    context 'at the beginning of block' do
-      context 'for blocks defined with do' do
-        it 'accepts missing blank line' do
-          inspect_source(cop,
-                         ['included do',
-                          "  #{access_modifier}",
-                          '',
-                          '  def test; end',
-                          'end'])
-          expect(cop.offenses).to be_empty
-        end
-
-        it 'accepts missing blank line with arguments' do
-          inspect_source(cop,
-                         ['included do |foo|',
-                          "  #{access_modifier}",
-                          '',
-                          '  def test; end',
-                          'end'])
-          expect(cop.offenses).to be_empty
-        end
-      end
-
-      context 'for blocks defined with {}' do
-        it 'accepts missing blank line' do
-          inspect_source(cop,
-                         ['included {',
-                          "  #{access_modifier}",
-                          '',
-                          '  def test; end',
-                          '}'])
-          expect(cop.offenses).to be_empty
-        end
-
-        it 'accepts missing blank line with arguments' do
-          inspect_source(cop,
-                         ['included { |foo|',
-                          "  #{access_modifier}",
-                          '',
-                          '  def test; end',
-                          '}'])
-          expect(cop.offenses).to be_empty
-        end
-      end
-    end
-
-    it 'accepts missing blank line when at the end of block' do
-      inspect_source(cop,
-                     ['class Test',
-                      '  def test; end',
-                      '',
-                      "  #{access_modifier}",
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'recognizes blank lines with DOS style line endings' do
-      inspect_source(cop,
-                     ["class Test\r",
-                      "\r",
-                      "  #{access_modifier}\r",
-                      "\r",
-                      "  def test; end\r",
-                      "end\r"])
-      expect(cop.offenses.size).to eq(0)
-    end
-  end
-end

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

@@ -1,103 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::EmptyLinesAroundBlockBody, :config do
-  subject(:cop) { described_class.new(config) }
-
-  # Test blocks using both {} and do..end
-  [%w({ }), %w(do end)].each do |open, close|
-    context "when EnforcedStyle is no_empty_lines for #{open} #{close} block" do
-      let(:cop_config) { { 'EnforcedStyle' => 'no_empty_lines' } }
-
-      it 'registers an offense for block body starting with a blank' do
-        inspect_source(cop,
-                       ["some_method #{open}",
-                        '',
-                        '  do_something',
-                        "#{close}"])
-        expect(cop.messages)
-          .to eq(['Extra empty line detected at block body beginning.'])
-      end
-
-      it 'autocorrects block body containing only a blank' do
-        corrected = autocorrect_source(cop,
-                                       ["some_method #{open}",
-                                        '',
-                                        "#{close}"])
-        expect(corrected).to eq ["some_method #{open}",
-                                 "#{close}"].join("\n")
-      end
-
-      it 'registers an offense for block body ending with a blank' do
-        inspect_source(cop,
-                       ["some_method #{open}",
-                        '  do_something',
-                        '',
-                        "#{close}"])
-        expect(cop.messages)
-          .to eq(['Extra empty line detected at block body end.'])
-      end
-
-      it 'accepts block body starting with a line with spaces' do
-        inspect_source(cop,
-                       ["some_method #{open}",
-                        '  ',
-                        '  do_something',
-                        "#{close}"])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'is not fooled by single line blocks' do
-        inspect_source(cop,
-                       ["some_method #{open} do_something #{close}",
-                        '',
-                        'something_else'])
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    context "when EnforcedStyle is empty_lines for #{open} #{close} block" do
-      let(:cop_config) { { 'EnforcedStyle' => 'empty_lines' } }
-
-      it 'registers an offense for block body not starting or ending with a ' \
-         'blank' do
-        inspect_source(cop,
-                       ["some_method #{open}",
-                        '  do_something',
-                        "#{close}"])
-        expect(cop.messages).to eq(['Empty line missing at block body '\
-                                    'beginning.',
-                                    'Empty line missing at block body end.'])
-      end
-
-      it 'autocorrects block body containing nothing' do
-        corrected = autocorrect_source(cop,
-                                       ["some_method #{open}",
-                                        "#{close}"])
-        expect(corrected).to eq ["some_method #{open}",
-                                 '',
-                                 "#{close}"].join("\n")
-      end
-
-      it 'autocorrects beginning and end' do
-        new_source = autocorrect_source(cop,
-                                        ["some_method #{open}",
-                                         '  do_something',
-                                         "#{close}"])
-        expect(new_source).to eq(["some_method #{open}",
-                                  '',
-                                  '  do_something',
-                                  '',
-                                  "#{close}"].join("\n"))
-      end
-
-      it 'is not fooled by single line blocks' do
-        inspect_source(cop,
-                       ["some_method #{open} do_something #{close}",
-                        'something_else'])
-        expect(cop.offenses).to be_empty
-      end
-    end
-  end
-end