rubocop 0.24.1 → 0.25.0

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

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::BlockEndNewline do
+  subject(:cop) { described_class.new }
+
+  it 'does not register an offense for a one-liner' do
+    inspect_source(cop, ['test do foo end'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'does not register an offense for multiline blocks with newlines before '\
+     'the end' do
+    inspect_source(cop,
+                   ['test do',
+                    '  foo',
+                    'end'])
+    expect(cop.messages).to be_empty
+  end
+
+  it 'registers an offense when multiline block end is not on its own line' do
+    inspect_source(cop,
+                   ['test do',
+                    '  foo end'
+                   ])
+    expect(cop.messages)
+      .to eq(['Expression at 2, 7 should be on its own line.'])
+  end
+
+  it 'registers an offense when multiline block } is not on its own line' do
+    inspect_source(cop,
+                   ['test {',
+                    '  foo }'
+                   ])
+    expect(cop.messages)
+      .to eq(['Expression at 2, 7 should be on its own line.'])
+  end
+
+  it 'autocorrects a do/end block where the end is not on its own line' do
+    src =  ['test do',
+            '  foo end']
+
+    new_source = autocorrect_source(cop, src)
+
+    expect(new_source).to eq(['test do',
+                              '  foo ',
+                              'end'].join("\n"))
+  end
+
+  it 'autocorrects a {} block where the } is not on its own line' do
+    src =  ['test {',
+            '  foo }']
+
+    new_source = autocorrect_source(cop, src)
+
+    expect(new_source).to eq(['test {',
+                              '  foo ',
+                              '}'].join("\n"))
+  end
+end

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

@@ -32,6 +32,40 @@ describe RuboCop::Cop::Style::EmptyLinesAroundAccessModifier do
         .to eq(["Keep a blank line before and after `#{access_modifier}`."])
     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',

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

@@ -54,4 +54,12 @@ describe RuboCop::Cop::Style::EndOfLine do
 
     include_examples 'iso-8859-15'
   end
+
+  context 'when source is a string' do
+    it 'registers an offence' do
+      inspect_source(cop, ["x=0\r"])
+
+      expect(cop.messages).to eq(['Carriage return character detected.'])
+    end
+  end
 end

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

@@ -102,7 +102,7 @@ describe RuboCop::Cop::Style::GuardClause, :config do
 
   context 'MinBodyLength: 1' do
     let(:cop_config) do
-      { 'EnforcedStyle' => 'MinBodyLength: 1' }
+      { 'MinBodyLength' => 1 }
     end
 
     it 'reports an offense for if whose body has 1 line' do

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

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::MultilineBlockLayout do
+  subject(:cop) { described_class.new }
+
+  it 'registers an offense for missing newline in do/end block w/o params' do
+    inspect_source(cop,
+                   ['test do foo',
+                    'end'
+                   ])
+    expect(cop.messages)
+      .to eq(['Block body expression is on the same line as the block start.'])
+  end
+
+  it 'registers an offense for missing newline in {} block w/o params' do
+    inspect_source(cop,
+                   ['test { foo',
+                    '}'
+                   ])
+    expect(cop.messages)
+      .to eq(['Block body expression is on the same line as the block start.'])
+  end
+
+  it 'registers an offense for missing newline in do/end block with params' do
+    inspect_source(cop,
+                   ['test do |x| foo',
+                    'end'
+                   ])
+    expect(cop.messages)
+      .to eq(['Block body expression is on the same line as the block start.'])
+  end
+
+  it 'registers an offense for missing newline in {} block with params' do
+    inspect_source(cop,
+                   ['test { |x| foo',
+                    '}'
+                   ])
+    expect(cop.messages)
+      .to eq(['Block body expression is on the same line as the block start.'])
+  end
+
+  it 'does not register an offense for one-line do/end blocks' do
+    inspect_source(cop, 'test do foo end')
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register an offense for one-line {} blocks' do
+    inspect_source(cop, 'test { foo }')
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register offenses when there is a newline for do/end block' do
+    inspect_source(cop,
+                   ['test do',
+                    '  foo',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not error out when the block is empty' do
+    inspect_source(cop,
+                   ['test do |x|',
+                    'end'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register offenses when there is a newline for {} block' do
+    inspect_source(cop,
+                   ['test {',
+                    '  foo',
+                    '}'
+                   ])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'registers offenses for lambdas as expected' do
+    inspect_source(cop,
+                   ['-> (x) do foo',
+                    '  bar',
+                    'end'
+                   ])
+    expect(cop.messages)
+      .to eq(['Block body expression is on the same line as the block start.'])
+  end
+
+  it 'auto-corrects a do/end block with params that is missing newlines' do
+    src = ['test do |foo| bar',
+           'end']
+
+    new_source = autocorrect_source(cop, src)
+
+    expect(new_source).to eq(['test do |foo| ',
+                              '  bar',
+                              'end'].join("\n"))
+  end
+
+  it 'auto-corrects a do/end block with a mult-line body' do
+    src = ['test do |foo| bar',
+           '  test',
+           'end']
+
+    new_source = autocorrect_source(cop, src)
+
+    expect(new_source).to eq(['test do |foo| ',
+                              '  bar',
+                              '  test',
+                              'end'].join("\n"))
+  end
+
+  it 'auto-corrects a {} block with params that is missing newlines' do
+    src = ['test { |foo| bar',
+           '}']
+
+    new_source = autocorrect_source(cop, src)
+
+    expect(new_source).to eq(['test { |foo| ',
+                              '  bar',
+                              '}'].join("\n"))
+  end
+
+  it 'autocorrects in more complex case with lambda and assignment, and '\
+     'aligns the next line two spaces out from the start of the block' do
+    src = ['x = -> (y) { foo',
+           '  bar',
+           '}']
+
+    new_source = autocorrect_source(cop, src)
+
+    expect(new_source).to eq(['x = -> (y) { ',
+                              '      foo',
+                              '  bar',
+                              '}'].join("\n"))
+  end
+end

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

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe RuboCop::Cop::Style::Next, :config do
   subject(:cop) { described_class.new(config) }
-  let(:cop_config) { {} }
+  let(:cop_config) { { 'MinBodyLength' => 1 } }
 
   it 'finds all kind of loops with condition at the end of the iteration' do
     # TODO: Split this long example into multiple examples.
@@ -173,7 +173,7 @@ describe RuboCop::Cop::Style::Next, :config do
       { 'EnforcedStyle' => 'always' }
     end
 
-    it 'ignores modifier ifs' do
+    it 'does not ignore modifier ifs' do
       inspect_source(cop,
                      ['[].each do |o|',
                       '  puts o if o == 1',
@@ -251,6 +251,35 @@ describe RuboCop::Cop::Style::Next, :config do
                     '  if true',
                     '  end',
                     'end'])
-    expect(cop.offenses.size).to eq(1)
+    expect(cop.offenses).to be_empty
+  end
+
+  context 'MinBodyLength: 3' do
+    let(:cop_config) do
+      { 'MinBodyLength' => 3 }
+    end
+
+    it 'accepts if whose body has 1 line' do
+      inspect_source(cop,
+                     ['arr.each do |e|',
+                      '  if something',
+                      '    work',
+                      '  end',
+                      'end'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'reports an offense for if whose body has 3 lines' do
+      inspect_source(cop,
+                     ['arr.each do |e|',
+                      '  if something',
+                      '    work',
+                      '    work',
+                      '    work',
+                      '  end',
+                      'end'])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.highlights).to eq(['each'])
+    end
   end
 end

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

@@ -258,5 +258,39 @@ describe RuboCop::Cop::Style::PercentLiteralDelimiters, :config do
       new_source = autocorrect_source(cop, ['%w(', 'some', 'words', ')'])
       expect(new_source).to eq("%w[\nsome\nwords\n]")
     end
+
+    it 'preserves indentation when correcting a multiline array' do
+      original_source = [
+        '  array = %w(',
+        '    first',
+        '    second',
+        '  )'
+      ]
+      corrected_source = [
+        '  array = %w[',
+        '    first',
+        '    second',
+        '  ]'
+      ].join("\n")
+      new_source = autocorrect_source(cop, original_source)
+      expect(new_source).to eq(corrected_source)
+    end
+
+    it 'preserves irregular indentation when correcting a multiline array' do
+      original_source = [
+        '  array = %w(',
+        '    first',
+        '  second',
+        ')'
+      ]
+      corrected_source = [
+        '  array = %w[',
+        '    first',
+        '  second',
+        ']'
+      ].join("\n")
+      new_source = autocorrect_source(cop, original_source)
+      expect(new_source).to eq(corrected_source)
+    end
   end
 end

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

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::PercentQLiterals, :config do
+  subject(:cop) { described_class.new(config) }
+
+  shared_examples 'accepts quote characters' do
+    it 'accepts single quotes' do
+      inspect_source(cop, ["'hi'"])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts double quotes' do
+      inspect_source(cop, ['"hi"'])
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  shared_examples 'accepts any q string with backslash t' do
+    context 'with special characters' do
+      it 'accepts %q' do
+        inspect_source(cop, ['%q(\t)'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'accepts %Q' do
+        inspect_source(cop, ['%Q(\t)'])
+        expect(cop.offenses).to be_empty
+      end
+    end
+  end
+
+  context 'when EnforcedStyle is lower_case_q' do
+    let(:cop_config) { { 'EnforcedStyle' => 'lower_case_q' } }
+
+    context 'without interpolation' do
+      it 'accepts %q' do
+        inspect_source(cop, ['%q(hi)'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'registers offense for %Q' do
+        inspect_source(cop, ['%Q(hi)'])
+        expect(cop.messages)
+          .to eq(['Do not use `%Q` unless interpolation is needed.  Use `%q`.'])
+        expect(cop.highlights).to eq(['%Q('])
+      end
+
+      it 'auto-corrects' do
+        new_source = autocorrect_source(cop, '%Q(hi)')
+        expect(new_source).to eq('%q(hi)')
+      end
+
+      include_examples 'accepts quote characters'
+      include_examples 'accepts any q string with backslash t'
+    end
+
+    context 'with interpolation' do
+      it 'accepts %Q' do
+        inspect_source(cop, ['%Q(#{1 + 2})'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'accepts %q' do
+        # This is most probably a mistake, but not this cop's responisibility.
+        inspect_source(cop, ['%q(#{1 + 2})'])
+        expect(cop.offenses).to be_empty
+      end
+
+      include_examples 'accepts quote characters'
+    end
+  end
+
+  context 'when EnforcedStyle is upper_case_q' do
+    let(:cop_config) { { 'EnforcedStyle' => 'upper_case_q' } }
+
+    context 'without interpolation' do
+      it 'registers offense for %q' do
+        inspect_source(cop, ['%q(hi)'])
+        expect(cop.messages).to eq(['Use `%Q` instead of `%q`.'])
+        expect(cop.highlights).to eq(['%q('])
+      end
+
+      it 'accepts %Q' do
+        inspect_source(cop, ['%Q(hi)'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'auto-corrects' do
+        new_source = autocorrect_source(cop, '%q[hi]')
+        expect(new_source).to eq('%Q[hi]')
+      end
+
+      include_examples 'accepts quote characters'
+      include_examples 'accepts any q string with backslash t'
+    end
+
+    context 'with interpolation' do
+      it 'accepts %Q' do
+        inspect_source(cop, ['%Q(#{1 + 2})'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'accepts %q' do
+        # It's strange if interpolation syntax appears inside a static string,
+        # but we can't be sure if it's a mistake or not. Changing it to %Q
+        # would alter semantics, so we leave it as it is.
+        inspect_source(cop, ['%q(#{1 + 2})'])
+        expect(cop.offenses).to be_empty
+      end
+
+      it 'does not auto-correct' do
+        source = '%q(#{1 + 2})'
+        new_source = autocorrect_source(cop, source)
+        expect(new_source).to eq(source)
+      end
+
+      include_examples 'accepts quote characters'
+    end
+  end
+end