rubocop 0.21.0 → 0.22.0

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

@@ -7,7 +7,7 @@ describe Rubocop::Cop::Style::IfUnlessModifier do
 
   subject(:cop) { described_class.new(config) }
   let(:config) do
-    hash = { 'LineLength' => { 'Max' => 79 } }
+    hash = { 'LineLength' => { 'Max' => 80 } }
     Rubocop::Config.new(hash)
   end
 
@@ -15,8 +15,8 @@ describe Rubocop::Cop::Style::IfUnlessModifier do
     # This if statement fits exactly on one line if written as a
     # modifier.
     condition = 'a' * 38
-    body = 'b' * 35
-    expect("  #{body} if #{condition}".length).to eq(79)
+    body = 'b' * 36
+    expect("  #{body} if #{condition}".length).to eq(80)
 
     inspect_source(cop,
                    ["  if #{condition}",
@@ -101,13 +101,13 @@ describe Rubocop::Cop::Style::IfUnlessModifier do
       ]
     end
 
-    let(:body) { 'b' * 35 }
+    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(79)
+        expect("  #{body} if #{conditional}".length).to eq(80)
 
         inspect_source(cop, source)
         expect(cop.offenses.size).to eq(1)
@@ -118,7 +118,7 @@ describe Rubocop::Cop::Style::IfUnlessModifier do
       let(:conditional) { "/#{'a' * 37}/" }
 
       it 'accepts' do
-        expect("  #{body} if #{conditional}".length).to eq(80)
+        expect("  #{body} if #{conditional}".length).to eq(81)
 
         inspect_source(cop, source)
         expect(cop.offenses).to be_empty
@@ -129,7 +129,7 @@ describe Rubocop::Cop::Style::IfUnlessModifier do
       let(:config) do
         hash = {
           'LineLength' => { 'Max' => 100 },
-          'IfUnlessModifier' => { 'MaxLineLength' => 79 }
+          'IfUnlessModifier' => { 'MaxLineLength' => 80 }
         }
         Rubocop::Config.new(hash)
       end

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

@@ -33,6 +33,32 @@ describe Rubocop::Cop::Style::LineEndConcatenation do
     expect(cop.offenses.size).to eq(1)
   end
 
+  it 'registers multiple offenses when there are chained << methods' do
+    inspect_source(cop,
+                   ['top = "test#{x}" <<',
+                    '"top" <<',
+                    '"ubertop"'])
+    expect(cop.offenses.size).to eq(2)
+  end
+
+  it 'registers multiple offenses when there are chained concatenations' do
+    inspect_source(cop,
+                   ['top = "test#{x}" +',
+                    '"top" +',
+                    '"foo"'])
+    expect(cop.offenses.size).to eq(2)
+  end
+
+  it 'registers multiple offenses when there are chained concatenations' \
+     'combined with << calls' do
+    inspect_source(cop,
+                   ['top = "test#{x}" <<',
+                    '"top" +',
+                    '"foo" <<',
+                    '"bar"'])
+    expect(cop.offenses.size).to eq(3)
+  end
+
   it 'accepts string concat on the same line' do
     inspect_source(cop,
                    ['top = "test" + "top"'])
@@ -53,10 +79,58 @@ describe Rubocop::Cop::Style::LineEndConcatenation do
     expect(cop.offenses).to be_empty
   end
 
-  it 'autocorrects by replacing + with \\' do
+  it 'accepts string concat at line end for special strings like __FILE__' do
+    inspect_source(cop,
+                   ['top = __FILE__ +',
+                    '"top"'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'registers offenses only for the appropriate lines in chained concats' do
+    # only the last concatenation is an offense
+    inspect_source(cop,
+                   ['top = "test#{x}" + # comment',
+                    '"foo" +',
+                    '%(bar) +',
+                    '"baz" +',
+                    '"qux"'])
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'autocorrects in the simple case by replacing + with \\' do
     corrected = autocorrect_source(cop,
                                    ['top = "test" +',
                                     '"top"'])
     expect(corrected).to eq ['top = "test" \\', '"top"'].join("\n")
   end
+
+  it 'autocorrects for chained concatenations and << calls' do
+    corrected = autocorrect_source(cop,
+                                   ['top = "test#{x}" <<',
+                                    '"top" +',
+                                    '"ubertop" <<',
+                                    '"foo"'])
+
+    expect(corrected).to eq ['top = "test#{x}" \\',
+                             '"top" \\',
+                             '"ubertop" \\',
+                             '"foo"'].join("\n")
+  end
+
+  it 'autocorrects only the lines that should be autocorrected' do
+    corrected = autocorrect_source(cop,
+                                   ['top = "test#{x}" <<',
+                                    '"top" + # comment',
+                                    '"foo" +',
+                                    '"bar" +',
+                                    '%(baz) +',
+                                    '"qux"'])
+
+    expect(corrected).to eq ['top = "test#{x}" \\',
+                             '"top" + # comment',
+                             '"foo" \\',
+                             '"bar" +',
+                             '%(baz) +',
+                             '"qux"'].join("\n")
+  end
 end

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

@@ -4,17 +4,17 @@ require 'spec_helper'
 
 describe Rubocop::Cop::Style::LineLength, :config do
   subject(:cop) { described_class.new(config) }
-  let(:cop_config) { { 'Max' => 79 } }
+  let(:cop_config) { { 'Max' => 80 } }
 
-  it "registers an offense for a line that's 80 characters wide" do
-    inspect_source(cop, ['#' * 80])
+  it "registers an offense for a line that's 81 characters wide" do
+    inspect_source(cop, ['#' * 81])
     expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.first.message).to eq('Line is too long. [80/79]')
-    expect(cop.config_to_allow_offenses).to eq('Max' => 80)
+    expect(cop.offenses.first.message).to eq('Line is too long. [81/80]')
+    expect(cop.config_to_allow_offenses).to eq('Max' => 81)
   end
 
-  it "accepts a line that's 79 characters wide" do
-    inspect_source(cop, ['#' * 79])
+  it "accepts a line that's 80 characters wide" do
+    inspect_source(cop, ['#' * 80])
     expect(cop.offenses).to be_empty
   end
 end

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

@@ -90,9 +90,13 @@ describe Rubocop::Cop::Style::NegatedIf do
     expect(corrected).to eq 'something unless x.even?'
   end
 
+  it 'autocorrects by replacing parenthesized if not with unless' do
+    corrected = autocorrect_source(cop, 'something if (!x.even?)')
+    expect(corrected).to eq 'something unless (x.even?)'
+  end
+
   it 'autocorrects by replacing unless not with if' do
     corrected = autocorrect_source(cop, 'something unless !x.even?')
     expect(corrected).to eq 'something if x.even?'
   end
-
 end

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

@@ -0,0 +1,210 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::Next, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { {} }
+
+  it 'finds all kind of loops with condition at the end of the iteration' do
+    inspect_source(cop,
+                   ['3.downto(1) do',
+                    '  if o == 1',
+                    '    puts o',
+                    '  end',
+                    'end',
+                    '',
+                    '[].each do |o|',
+                    '  if o == 1',
+                    '    puts o',
+                    '  end',
+                    'end',
+                    '',
+                    '[].each_with_object({}) do |o, a|',
+                    '  if o == 1',
+                    '    a[o] = {}',
+                    '  end',
+                    'end',
+                    '',
+                    'for o in 1..3 do',
+                    '  if o == 1',
+                    '    puts o',
+                    '  end',
+                    'end',
+                    '',
+                    'loop do',
+                    '  if o == 1',
+                    '    puts o',
+                    '  end',
+                    'end',
+                    '',
+                    '{}.map do |k, v|',
+                    '  if v == 1',
+                    '    puts k',
+                    '  end',
+                    'end',
+                    '',
+                    '3.times do |o|',
+                    '  if o == 1',
+                    '    puts o',
+                    '  end',
+                    'end',
+                    '',
+                    'until false',
+                    '  if o == 1',
+                    '    puts o',
+                    '  end',
+                    'end',
+                    '',
+                    'while true',
+                    '  if o == 1',
+                    '    puts o',
+                    '  end',
+                    'end'])
+    expect(cop.offenses.size).to eq(9)
+    expect(cop.offenses.map(&:line).sort).to eq([1, 7, 13, 19, 25, 31, 37, 43,
+                                                 49])
+    expect(cop.messages) .to eq(['Use `next` to skip iteration.'] * 9)
+    expect(cop.highlights).to eq(%w(downto each each_with_object for loop map
+                                    times until while))
+  end
+
+  it 'finds loop with condition at the end in different styles' do
+    inspect_source(cop,
+                   ['[].each do |o|',
+                    '  if o == 1',
+                    '    puts o',
+                    '  end',
+                    'end',
+                    '',
+                    '[].each do |o|',
+                    '  puts o',
+                    '  if o == 1',
+                    '    puts o',
+                    '  end',
+                    'end',
+                    '',
+                    '[].each do |o|',
+                    '  unless o == 1',
+                    '    puts o',
+                    '  end',
+                    'end'])
+
+    expect(cop.offenses.size).to eq(3)
+    expect(cop.offenses.map(&:line).sort).to eq([1, 7, 14])
+    expect(cop.messages)
+      .to eq(['Use `next` to skip iteration.'] * 3)
+    expect(cop.highlights).to eq(['each'] * 3)
+  end
+
+  it 'ignores empty blocks' do
+    inspect_source(cop,
+                   ['[].each do', 'end',
+                    '[].each { }'])
+    expect(cop.offenses.size).to eq(0)
+  end
+
+  it 'ignores loops with conditional break' do
+    inspect_source(cop,
+                   ['loop do',
+                    "  puts ''",
+                    '  break if o == 1',
+                    'end',
+                    '',
+                    'loop do',
+                    '  break if o == 1',
+                    'end',
+                    '',
+                    'loop do',
+                    "  puts ''",
+                    '  break unless o == 1',
+                    'end',
+                    '',
+                    'loop do',
+                    '  break unless o == 1',
+                    'end'])
+    expect(cop.offenses.size).to eq(0)
+  end
+
+  context 'EnforcedStyle: skip_modifier_ifs' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'skip_modifier_ifs' }
+    end
+
+    it 'ignores modifier ifs' do
+      inspect_source(cop,
+                     ['[].each do |o|',
+                      '  puts o if o == 1',
+                      'end',
+                      '',
+                      '[].each do |o|',
+                      '  puts o unless o == 1',
+                      'end'])
+
+      expect(cop.offenses.size).to eq(0)
+    end
+  end
+
+  context 'EnforcedStyle: always' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'always' }
+    end
+
+    it 'ignores modifier ifs' do
+      inspect_source(cop,
+                     ['[].each do |o|',
+                      '  puts o if o == 1',
+                      'end',
+                      '',
+                      '[].each do |o|',
+                      '  puts o unless o == 1',
+                      'end'])
+
+      expect(cop.offenses.size).to eq(2)
+      expect(cop.offenses.map(&:line).sort).to eq([1, 5])
+      expect(cop.messages)
+        .to eq(['Use `next` to skip iteration.'] * 2)
+      expect(cop.highlights).to eq(['each'] * 2)
+    end
+  end
+
+  it 'ignores loops with conditions at the end with else' do
+    inspect_source(cop,
+                   ['[].each do |o|',
+                    '  if o == 1',
+                    '    puts o',
+                    '  else',
+                    "    puts 'no'",
+                    '  end',
+                    'end',
+                    '',
+                    '[].each do |o|',
+                    '  puts o',
+                    '  if o == 1',
+                    '    puts o',
+                    '  else',
+                    "    puts 'no'",
+                    '  end',
+                    'end',
+                    '',
+                    '[].each do |o|',
+                    '  unless o == 1',
+                    '    puts o',
+                    '  else',
+                    "    puts 'no'",
+                    '  end',
+                    'end'])
+
+    expect(cop.offenses.size).to eq(0)
+  end
+
+  it 'ignores loops with conditions at the end with ternary op' do
+    inspect_source(cop,
+                   ['[].each do |o|',
+                    '  o == x ? y : z',
+                    'end'
+                   ])
+
+    expect(cop.offenses.size).to eq(0)
+  end
+end

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

@@ -2,8 +2,14 @@
 
 require 'spec_helper'
 
-describe Rubocop::Cop::Style::NonNilCheck do
-  subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::NonNilCheck, :config do
+  subject(:cop) { described_class.new(config) }
+
+  let(:cop_config) do
+    {
+      'IncludeSemanticChanges' => false
+    }
+  end
 
   it 'registers an offense for != nil' do
     inspect_source(cop, 'x != nil')
@@ -11,16 +17,14 @@ describe Rubocop::Cop::Style::NonNilCheck do
     expect(cop.highlights).to eq(['!='])
   end
 
-  it 'registers an offense for !x.nil?' do
+  it 'does not register an offense for !x.nil?' do
     inspect_source(cop, '!x.nil?')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights).to eq(['!x.nil?'])
+    expect(cop.offenses).to be_empty
   end
 
-  it 'registers an offense for not x.nil?' do
+  it 'does not register an offense for not x.nil?' do
     inspect_source(cop, 'not x.nil?')
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.highlights).to eq(['not x.nil?'])
+    expect(cop.offenses).to be_empty
   end
 
   it 'does not register an offense if only expression in predicate' do
@@ -53,18 +57,45 @@ describe Rubocop::Cop::Style::NonNilCheck do
     expect(cop.offenses).to be_empty
   end
 
-  it 'autocorrects by removing != nil' do
+  it 'autocorrects by changing `!= nil` to `!x.nil?`' do
     corrected = autocorrect_source(cop, 'x != nil')
-    expect(corrected).to eq 'x'
+    expect(corrected).to eq '!x.nil?'
   end
 
-  it 'autocorrects by removing non-nil (!x.nil?) check' do
+  it 'does not autocorrect by removing non-nil (!x.nil?) check' do
     corrected = autocorrect_source(cop, '!x.nil?')
-    expect(corrected).to eq 'x'
+    expect(corrected).to eq '!x.nil?'
   end
 
   it 'does not blow up when autocorrecting implicit receiver' do
     corrected = autocorrect_source(cop, '!nil?')
-    expect(corrected).to eq 'self'
+    expect(corrected).to eq '!nil?'
+  end
+
+  context 'when allowing semantic changes' do
+    subject(:cop) { described_class.new(config) }
+
+    let(:cop_config) do
+      {
+        'IncludeSemanticChanges' => true
+      }
+    end
+
+    it 'registers an offense for `!x.nil?`' do
+      inspect_source(cop, '!x.nil?')
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.highlights).to eq(['!x.nil?'])
+    end
+
+    it 'registers an offense for `not x.nil?`' do
+      inspect_source(cop, 'not x.nil?')
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.highlights).to eq(['not x.nil?'])
+    end
+
+    it 'autocorrects by changing `x != nil` to `x`' do
+      corrected = autocorrect_source(cop, 'x != nil')
+      expect(corrected).to eq 'x'
+    end
   end
 end