rubocop 0.24.1 → 0.25.0

data/spec/rubocop/cop/{style → metrics}/while_until_modifier_spec.rb

@@ -7,7 +7,7 @@ describe RuboCop::Cop::Style::WhileUntilModifier do
 
   subject(:cop) { described_class.new(config) }
   let(:config) do
-    hash = { 'Style/LineLength' => { 'Max' => 80 } }
+    hash = { 'Metrics/LineLength' => { 'Max' => 80 } }
     RuboCop::Config.new(hash)
   end
 
@@ -76,7 +76,7 @@ describe RuboCop::Cop::Style::WhileUntilModifier do
   context 'when the maximum line length is specified by the cop itself' do
     let(:config) do
       hash = {
-        'Style/LineLength' => { 'Max' => 100 },
+        'Metrics/LineLength' => { 'Max' => 100 },
         'Style/WhileUntilModifier' => { 'MaxLineLength' => 80 }
       }
       RuboCop::Config.new(hash)

data/spec/rubocop/cop/rails/output_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe RuboCop::Cop::Rails::Output do
   subject(:cop) { described_class.new }
 
-  it 'records an offense for puts statements' do
+  it 'records an offense for methods without a receiver' do
     source = ['p "edmond dantes"',
               'puts "sinbad"',
               'print "abbe busoni"',
@@ -14,7 +14,7 @@ describe RuboCop::Cop::Rails::Output do
     expect(cop.offenses.size).to eq(4)
   end
 
-  it 'does not record an offense for methods' do
+  it 'does not record an offense for methods with a receiver' do
     source = ['obj.print',
               'something.p',
               'nothing.pp']
@@ -22,6 +22,12 @@ describe RuboCop::Cop::Rails::Output do
     expect(cop.offenses).to be_empty
   end
 
+  it 'does not record an offense for methods without arguments' do
+    source = %w(print pp puts)
+    inspect_source(cop, source)
+    expect(cop.offenses).to be_empty
+  end
+
   it 'does not record an offense for comments' do
     source = ['# print "test"',
               '# p']

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

@@ -16,6 +16,13 @@ describe RuboCop::Cop::Style::AlignHash, :config do
                            '     ccc: 3, dddd: 4)'])
       expect(cop.offenses).to be_empty
     end
+
+    it "does not auto-correct pairs that don't start a line" do
+      source = ['render :json => {:a => messages,',
+                '                 :b => :json}, :status => 404']
+      new_source = autocorrect_source(cop, source)
+      expect(new_source).to eq(source.join("\n"))
+    end
   end
 
   context 'always inspect last argument hash' do

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

@@ -2,56 +2,258 @@
 
 require 'spec_helper'
 
-describe RuboCop::Cop::Style::AndOr do
-  subject(:cop) { described_class.new }
-
-  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
+describe RuboCop::Cop::Style::AndOr, :config do
+  context 'when style is conditionals' do
+    cop_config = {
+      'EnforcedStyle' => 'conditionals'
+    }
 
-  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
+    subject(:cop) { described_class.new(config) }
+    let(:cop_config) { cop_config }
 
-  it 'accepts ||' do
-    inspect_source(cop,
-                   ['test if a || b'])
-    expect(cop.offenses).to be_empty
-  end
+    it 'does not warn on short-circuit (and)' do
+      inspect_source(cop,
+                     ['x = a + b and return x'])
+      expect(cop.offenses.size).to eq(0)
+    end
 
-  it 'accepts &&' do
-    inspect_source(cop,
-                   ['test if a && b'])
-    expect(cop.offenses).to be_empty
-  end
+    it 'does not warn on short-circuit (or)' do
+      inspect_source(cop,
+                     ['x = a + b or return x'])
+      expect(cop.offenses.size).to eq(0)
+    end
 
-  it 'auto-corrects "and" with &&' do
-    new_source = autocorrect_source(cop, 'true and false')
-    expect(new_source).to eq('true && false')
-  end
+    it 'does warn 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 '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 'does warn 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 'does warn 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 'does warn 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 'should handle boolean returning methods correctly' do
+      inspect_source(cop,
+                     ['1 if (not true) or false'])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages).to eq(['Use `||` instead of `or`.'])
+    end
+
+    it 'should handle recursion' do
+      inspect_source(cop,
+                     ['1 if (true and false) || (false or true)'])
+      expect(cop.offenses.size).to eq(2)
+    end
+
+    it 'should handle recursion' do
+      inspect_source(cop,
+                     ['1 if (true or false) && (false and true)'])
+      expect(cop.offenses.size).to eq(2)
+    end
 
-  it 'leaves *or* as is if auto-correction changes the meaning' do
-    src = "teststring.include? 'a' 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)
+  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

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

@@ -0,0 +1,132 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Style::BarePercentLiterals, :config do
+  subject(:cop) { described_class.new(config) }
+
+  shared_examples 'accepts other delimiters' do
+    it 'accepts __FILE__' do
+      inspect_source(cop, '__FILE__')
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts regular expressions' do
+      inspect_source(cop, '/%Q?/')
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts ""' do
+      inspect_source(cop, '""')
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts "" string with interpolation' do
+      inspect_source(cop, '"#{file}hi"')
+      expect(cop.offenses).to be_empty
+    end
+
+    it "accepts ''" do
+      inspect_source(cop, "'hi'")
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts %q' do
+      inspect_source(cop, '%q(hi)')
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts heredoc' do
+      inspect_source(cop, ['func <<END',
+                           'hi',
+                           'END'])
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  context 'when EnforcedStyle is percent_q' do
+    let(:cop_config) { { 'EnforcedStyle' => 'percent_q' } }
+
+    context 'and strings are static' do
+      it 'registers an offense for %()' do
+        inspect_source(cop, '%(hi)')
+        expect(cop.messages).to eq(['Use `%Q` instead of `%`.'])
+        expect(cop.highlights).to eq(['%('])
+      end
+
+      it 'auto-corrects' do
+        new_source = autocorrect_source(cop, '%(hi)')
+        expect(new_source).to eq('%Q(hi)')
+      end
+
+      it 'accepts %Q()' do
+        inspect_source(cop, '%Q(hi)')
+        expect(cop.offenses).to be_empty
+      end
+
+      include_examples 'accepts other delimiters'
+    end
+
+    context 'and strings are dynamic' do
+      it 'registers an offense for %()' do
+        inspect_source(cop, '%(#{x})')
+        expect(cop.messages).to eq(['Use `%Q` instead of `%`.'])
+      end
+
+      it 'auto-corrects' do
+        new_source = autocorrect_source(cop, '%(#{x})')
+        expect(new_source).to eq('%Q(#{x})')
+      end
+
+      it 'accepts %Q()' do
+        inspect_source(cop, '%Q(#{x})')
+        expect(cop.offenses).to be_empty
+      end
+
+      include_examples 'accepts other delimiters'
+    end
+  end
+
+  context 'when EnforcedStyle is bare_percent' do
+    let(:cop_config) { { 'EnforcedStyle' => 'bare_percent' } }
+
+    context 'and strings are static' do
+      it 'registers an offense for %Q()' do
+        inspect_source(cop, '%Q(hi)')
+        expect(cop.messages).to eq(['Use `%` instead of `%Q`.'])
+        expect(cop.highlights).to eq(['%Q('])
+      end
+
+      it 'auto-corrects' do
+        new_source = autocorrect_source(cop, '%Q(hi)')
+        expect(new_source).to eq('%(hi)')
+      end
+
+      it 'accepts %()' do
+        inspect_source(cop, '%(hi)')
+        expect(cop.offenses).to be_empty
+      end
+
+      include_examples 'accepts other delimiters'
+    end
+
+    context 'and strings are dynamic' do
+      it 'registers an offense for %Q()' do
+        inspect_source(cop, '%Q(#{x})')
+        expect(cop.messages).to eq(['Use `%` instead of `%Q`.'])
+      end
+
+      it 'auto-corrects' do
+        new_source = autocorrect_source(cop, '%Q(#{x})')
+        expect(new_source).to eq('%(#{x})')
+      end
+
+      it 'accepts %()' do
+        inspect_source(cop, '%(#{x})')
+        expect(cop.offenses).to be_empty
+      end
+
+      include_examples 'accepts other delimiters'
+    end
+  end
+end