rubocop 0.20.1 → 0.21.0

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

@@ -5,6 +5,12 @@ require 'spec_helper'
 describe Rubocop::Cop::Style::RedundantBegin do
   subject(:cop) { described_class.new }
 
+  it 'reports an offense for single line def with redundant begin block' do
+    src = ['  def func; begin; x; y; rescue; z end end']
+    inspect_source(cop, src)
+    expect(cop.offenses.size).to eq(1)
+  end
+
   it 'reports an offense for def with redundant begin block' do
     src = ['def func',
            '  begin',
@@ -54,4 +60,30 @@ describe Rubocop::Cop::Style::RedundantBegin do
     inspect_source(cop, src)
     expect(cop.offenses).to be_empty
   end
+
+  it 'auto-corrects by removing redundant begin blocks' do
+    src = ['  def func',
+           '    begin',
+           '      foo',
+           '      bar',
+           '    rescue',
+           '      baz',
+           '    end',
+           '  end'].join("\n")
+    result_src = ['  def func',
+                  '    foo',
+                  '    bar',
+                  '  rescue',
+                  '    baz',
+                  '  end'].join("\n")
+    new_source = autocorrect_source(cop, src)
+    expect(new_source).to eq(result_src)
+  end
+
+  it 'auto-corrects by removing redundant begin blocks' do
+    src = '  def func; begin; x; y; rescue; z end end'
+    result_src = '  def func; x; y; rescue; z end'
+    new_source = autocorrect_source(cop, src)
+    expect(new_source).to eq(result_src)
+  end
 end

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

@@ -22,7 +22,6 @@ describe Rubocop::Cop::Style::RegexpLiteral, :config do
       expect(cop.messages)
         .to eq(['Use %r for regular expressions matching more ' \
                 "than 0 '/' characters."])
-      expect(cop.config_to_allow_offenses).to eq('MaxSlashes' => 1)
     end
 
     it 'accepts zero slashes in // regexp' do
@@ -35,13 +34,31 @@ describe Rubocop::Cop::Style::RegexpLiteral, :config do
       expect(cop.messages)
         .to eq(['Use %r only for regular expressions matching more ' \
                 "than 0 '/' characters."])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
     end
 
     it 'accepts %r regexp with one slash' do
       inspect_source(cop, ['x =~ %r(/home)'])
       expect(cop.offenses).to be_empty
     end
+
+    describe '--auto-gen-config' do
+      subject(:cop) { described_class.new(config, auto_gen_config: true) }
+
+      it 'sets MaxSlashes: 1 for one slash in // regexp' do
+        inspect_source(cop, ['x =~ /home\//'])
+        expect(cop.config_to_allow_offenses).to eq('MaxSlashes' => 1)
+      end
+
+      it 'disables the cop for zero slashes in %r regexp' do
+        inspect_source(cop, ['y =~ %r(etc)'])
+        expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
+      end
+
+      it 'generates nothing if there are no offenses' do
+        inspect_source(cop, ['x =~ %r(/home)'])
+        expect(cop.config_to_allow_offenses).to eq(nil)
+      end
+    end
   end
 
   context 'when MaxSlashes is 1' do
@@ -53,24 +70,23 @@ describe Rubocop::Cop::Style::RegexpLiteral, :config do
       expect(cop.messages)
         .to eq(['Use %r for regular expressions matching more ' \
                 "than 1 '/' character."] * 2)
-      expect(cop.config_to_allow_offenses).to eq('MaxSlashes' => 2)
     end
 
-    it 'registers offenses for slashes with too many and %r with too few' do
-      inspect_source(cop, ['x =~ /home\/\//',
+    it 'registers offenses for slashes with too many' do
+      inspect_source(cop, 'x =~ /home\/\/\//')
+      expect(cop.messages)
+        .to eq(['Use %r for regular expressions matching more ' \
+                "than 1 '/' character."])
+    end
+
+    it 'registers offenses for %r with too few' do
+      inspect_source(cop, ['x =~ /home\/\/\//',
                            'y =~ %r{home}'])
       expect(cop.messages)
         .to eq(['Use %r for regular expressions matching more ' \
                 "than 1 '/' character.",
                 'Use %r only for regular expressions matching more ' \
                 "than 1 '/' character."])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers offenses for %r with too few and slashes with too many' do
-      inspect_source(cop, ['y =~ %r{home}',
-                           'x =~ /home\/\//'])
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
     end
 
     it 'accepts zero or one slash in // regexp' do
@@ -92,7 +108,6 @@ describe Rubocop::Cop::Style::RegexpLiteral, :config do
       expect(cop.messages)
         .to eq(['Use %r only for regular expressions matching more ' \
                 "than 1 '/' character."] * 2)
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
     end
 
     it 'accepts %r regexp with two or more slashes' do
@@ -100,5 +115,60 @@ describe Rubocop::Cop::Style::RegexpLiteral, :config do
                            'y =~ %r(/////)'])
       expect(cop.offenses).to be_empty
     end
+
+    describe '--auto-gen-config' do
+      subject(:cop) { described_class.new(config, auto_gen_config: true) }
+
+      it 'sets MaxSlashes: 2 for two slashes in // and 3 in %r' do
+        inspect_source(cop, ['x =~ /home\/\//',
+                             'y =~ %r{/usr/lib/ext}'])
+        expect(cop.config_to_allow_offenses).to eq('MaxSlashes' => 2)
+      end
+
+      it 'sets MaxSlashes: 0 for one slash in %r regexp' do
+        inspect_source(cop, 'x =~ %r{/home}')
+        expect(cop.config_to_allow_offenses).to eq('MaxSlashes' => 0)
+      end
+
+      it 'disables the cop for zero or one slash in %r regexp' do
+        inspect_source(cop, ['x =~ %r(/home)',
+                             'y =~ %r(etc)'])
+        expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
+      end
+
+      it 'disables the cop for // with too many and %r with too few' do
+        inspect_source(cop, ['x =~ /home\/\/\//',
+                             'y =~ %r{home}'])
+        expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
+      end
+
+      it 'disables the cop for %r with too few and // with too many' do
+        inspect_source(cop, ['y =~ %r{home}',
+                             'x =~ /home\/\//'])
+        expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
+      end
+
+      context 'when Enabled has been set to false' do
+        before do
+          inspect_source(cop, ['x =~ /home\/\/\//',
+                               'y =~ %r{/home/}'])
+        end
+
+        it 'does not change it' do
+          inspect_source(cop, 'x =~ %r{/home}')
+          expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
+        end
+      end
+    end
+
+    context 'when --auto-gen-config is not given' do
+      subject(:cop) { described_class.new(config) }
+
+      it 'does not set MaxSlashes' do
+        inspect_source(cop, ['x =~ /home\/\//',
+                             'y =~ %r{/usr/lib/ext}'])
+        expect(cop.config_to_allow_offenses).to eq(nil)
+      end
+    end
   end
 end

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

@@ -61,7 +61,7 @@ describe Rubocop::Cop::Style::StringLiterals, :config do
     it 'accepts double quotes when they are needed' do
       src = ['a = "\n"',
              'b = "#{encode_severity}:' \
-             '#{sprintf("%3d", line_number)}: #{m}"',
+             '#{sprintf(\'%3d\', line_number)}: #{m}"',
              'c = "\'"',
              'd = "#@test"',
              'e = "#$test"',
@@ -95,10 +95,16 @@ describe Rubocop::Cop::Style::StringLiterals, :config do
       expect(cop.offenses).to be_empty
     end
 
-    it 'can handle double quotes within embedded expression' do
+    it 'detects unneeded double quotes within embedded expression' do
       src = ['"#{"A"}"']
       inspect_source(cop, src)
-      expect(cop.offenses).to be_empty
+      expect(cop.offenses.size).to eq(1)
+    end
+
+    it 'detects unneeded double quotes within concatenated string' do
+      src = ['"#{x}" \\', '"y"']
+      inspect_source(cop, src)
+      expect(cop.offenses.size).to eq(1)
     end
 
     it 'can handle a built-in constant parsed as string' do

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

@@ -2,37 +2,36 @@
 
 require 'spec_helper'
 
-describe Rubocop::Cop::Style::TrailingBlankLines do
+describe Rubocop::Cop::Style::TrailingBlankLines, :config do
   subject(:cop) { described_class.new(config) }
-  let(:config) do
-    Rubocop::Config.new('TrailingWhitespace' => { 'Enabled' => true })
-  end
 
-  it 'accepts final newline' do
-    inspect_source(cop, ['x = 0', ''])
-    expect(cop.offenses).to be_empty
-  end
+  context 'when EnforcedStyle is final_newline' do
+    let(:cop_config) { { 'EnforcedStyle' => 'final_newline' } }
 
-  it 'registers an offense for multiple trailing blank lines' do
-    inspect_source(cop, ['x = 0', '', '', '', ''])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages).to eq(['3 trailing blank lines detected.'])
-  end
+    it 'accepts final newline' do
+      inspect_source(cop, ['x = 0', ''])
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'auto-corrects unwanted blank lines' do
-    new_source = autocorrect_source(cop, ['x = 0', '', '', '', ''])
-    expect(new_source).to eq(['x = 0', ''].join("\n"))
-  end
+    it 'accepts an empty file' do
+      inspect_source(cop, '')
+      expect(cop.offenses).to be_empty
+    end
 
-  it 'does not auto-correct if it interferes with TrailingWhitespace' do
-    original = ['x = 0', '', '  ', '', '']
-    new_source = autocorrect_source(cop, original)
-    expect(new_source).to eq(original.join("\n"))
-  end
+    it 'registers an offense for multiple trailing blank lines' do
+      inspect_source(cop, ['x = 0', '', '', '', ''])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages).to eq(['3 trailing blank lines detected.'])
+    end
+
+    it 'registers an offense for no final newline' do
+      inspect_source(cop, ['x = 0'])
+      expect(cop.messages).to eq(['Final newline missing.'])
+    end
 
-  context 'with TrailingWhitespace disabled' do
-    let(:config) do
-      Rubocop::Config.new('TrailingWhitespace' => { 'Enabled' => false })
+    it 'auto-corrects unwanted blank lines' do
+      new_source = autocorrect_source(cop, ['x = 0', '', '', '', ''])
+      expect(new_source).to eq(['x = 0', ''].join("\n"))
     end
 
     it 'auto-corrects even if some lines have space' do
@@ -40,4 +39,45 @@ describe Rubocop::Cop::Style::TrailingBlankLines do
       expect(new_source).to eq(['x = 0', ''].join("\n"))
     end
   end
+
+  context 'when EnforcedStyle is final_blank_line' do
+    let(:cop_config) { { 'EnforcedStyle' => 'final_blank_line' } }
+
+    it 'registers an offense for final newline' do
+      inspect_source(cop, ['x = 0', ''])
+      expect(cop.messages).to eq(['Trailing blank line missing.'])
+    end
+
+    it 'registers an offense for multiple trailing blank lines' do
+      inspect_source(cop, ['x = 0', '', '', '', ''])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages)
+        .to eq(['3 trailing blank lines instead of 1 detected.'])
+    end
+
+    it 'registers an offense for no final newline' do
+      inspect_source(cop, ['x = 0'])
+      expect(cop.messages).to eq(['Final newline missing.'])
+    end
+
+    it 'accepts final blank line' do
+      inspect_source(cop, ['x = 0', '', ''])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'auto-corrects unwanted blank lines' do
+      new_source = autocorrect_source(cop, ['x = 0', '', '', '', ''])
+      expect(new_source).to eq(['x = 0', '', ''].join("\n"))
+    end
+
+    it 'auto-corrects missing blank line' do
+      new_source = autocorrect_source(cop, ['x = 0', ''])
+      expect(new_source).to eq(['x = 0', '', ''].join("\n"))
+    end
+
+    it 'auto-corrects missing newline' do
+      new_source = autocorrect_source(cop, ['x = 0'])
+      expect(new_source).to eq(['x = 0', '', ''].join("\n"))
+    end
+  end
 end

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

@@ -241,6 +241,16 @@ describe Rubocop::Cop::Style::TrivialAccessors, :config do
              .map(&:line).sort).to eq([1])
   end
 
+  it 'finds DSL-style trivial writer' do
+    inspect_source(cop,
+                   ['def foo(val)',
+                    ' @foo = val',
+                    'end'])
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.offenses
+             .map(&:line).sort).to eq([1])
+  end
+
   it 'finds trivial writer in a class' do
     inspect_source(cop,
                    ['class TrivialFoo',
@@ -415,4 +425,70 @@ describe Rubocop::Cop::Style::TrivialAccessors, :config do
       expect(cop.offenses).to be_empty
     end
   end
+
+  context 'with DSL writers allowed' do
+    let(:cop_config) { { 'AllowDSLWriters' => true } }
+
+    it 'does not find DSL-style writer' do
+      inspect_source(cop,
+                     ['def foo(val)',
+                      ' @foo = val',
+                      'end'])
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  describe '#autocorrect' do
+    context 'matching reader' do
+      let(:source) do
+        ['def foo',
+         '  @foo',
+         'end']
+      end
+
+      let(:corrected_source) { 'attr_reader :foo' }
+
+      it 'autocorrects' do
+        expect(autocorrect_source(cop, source)).to eq(corrected_source)
+      end
+    end
+
+    context 'matching non-DSL writer' do
+      let(:source) do
+        ['def foo=(f)',
+         '  @foo=f',
+         'end']
+      end
+
+      let(:corrected_source) { 'attr_writer :foo' }
+
+      it 'autocorrects' do
+        expect(autocorrect_source(cop, source)).to eq(corrected_source)
+      end
+    end
+
+    context 'matching DSL-style writer' do
+      let(:source) do
+        ['def foo(f)',
+         '  @foo=f',
+         'end']
+      end
+
+      it 'does not autocorrect' do
+        expect(autocorrect_source(cop, source)).to eq(source.join("\n"))
+      end
+    end
+
+    context 'explicit receiver writer' do
+      let(:source) do
+        ['def derp.foo=(f)',
+         '  @foo=f',
+         'end']
+      end
+
+      it 'does not autocorrect' do
+        expect(autocorrect_source(cop, source)).to eq(source.join("\n"))
+      end
+    end
+  end
 end

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

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::UnneededCapitalW do
+  subject(:cop) { described_class.new }
+
+  it 'registers no offense for normal arrays of strings' do
+    inspect_source(cop,
+                   ['["one", "two", "three"]'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'registers no offense for normal arrays of strings with interpolation' do
+    inspect_source(cop,
+                   ['["one", "two", "th#{ ?r }ee"]'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'registers an offense for misused %W' do
+    inspect_source(cop,
+                   ['%W(cat dog)'])
+    expect(cop.offenses.size).to eq(1)
+  end
+
+  it 'registers no offense for %W with interpolation' do
+    inspect_source(cop,
+                   ['%W(c#{ ?a }t dog)'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'registers no offense for %w without interpolation' do
+    inspect_source(cop,
+                   ['%w(cat dog)'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'registers no offense for %w with interpolation-like syntax' do
+    inspect_source(cop,
+                   ['%w(c#{ ?a }t dog)'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'registers no offense for arrays with character constants' do
+    inspect_source(cop,
+                   ['["one", ?\n]'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register an offense for array of non-words' do
+    inspect_source(cop,
+                   ['["one space", "two", "three"]'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register an offense for array containing non-string' do
+    inspect_source(cop,
+                   ['["one", "two", 3]'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register an offense for array with one element' do
+    inspect_source(cop,
+                   ['["three"]'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'does not register an offense for array with empty strings' do
+    inspect_source(cop,
+                   ['["", "two", "three"]'])
+    expect(cop.offenses).to be_empty
+  end
+
+  # TESTS FOR AUTOCORRECTION
+
+  # it 'auto-corrects an array of words' do
+  #   new_source = autocorrect_source(cop, "['one', %q(two), 'three']")
+  #   expect(new_source).to eq('%w(one two three)')
+  # end
+
+  # it 'auto-corrects an array of words and character constants' do
+  #   new_source = autocorrect_source(cop, '[%{one}, %Q(two), ?\n, ?\t]')
+  #   expect(new_source).to eq('%W(one two \n \t)')
+  # end
+end