rubocop 0.15.0 → 0.16.0

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

@@ -2,81 +2,237 @@
 
 require 'spec_helper'
 
-describe Rubocop::Cop::Style::CaseIndentation do
-  subject(:cop) { described_class.new }
-
-  it "registers an offence for a when clause that's deeper than case" do
-    source = ['case a',
-              '    when 0 then return',
-              '        case b',
-              '         when 1 then return',
-              '        end',
-              'end']
-    inspect_source(cop, source)
-    expect(cop.messages).to eq(
-      ['Indent when as deep as case.'] * 2)
-  end
+describe Rubocop::Cop::Style::CaseIndentation, :config do
+  subject(:cop) { described_class.new(config) }
 
-  it "accepts a when clause that's equally indented with case" do
-    source = ['y = case a',
-              '    when 0 then break',
-              '    when 0 then return',
-              '      z = case b',
-              '          when 1 then return',
-              '          when 1 then break',
-              '          end',
-              '    end',
-              'case c',
-              'when 2 then encoding',
-              'end',
-              '']
-    inspect_source(cop, source)
-    expect(cop.offences).to be_empty
-  end
+  context 'with IndentWhenRelativeTo: case' do
+    context 'with IndentOneStep: false' do
+      let(:cop_config) do
+        { 'IndentWhenRelativeTo' => 'case', 'IndentOneStep' => false }
+      end
 
-  it "doesn't get confused by strings with case in them" do
-    source = ['a = "case"',
-              'case x',
-              'when 0',
-              'end',
-              '']
-    inspect_source(cop, source)
-    expect(cop.messages).to be_empty
-  end
+      context 'regarding assignment where the right hand side is a case' do
+        it 'accepts a correcty indented assignment' do
+          source = ['output = case variable',
+                    "         when 'value1'",
+                    "           'output1'",
+                    '         else',
+                    "           'output2'",
+                    '         end']
+          inspect_source(cop, source)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'registers on offence for an assignment indented some other way' do
+          source = ['output = case variable',
+                    "  when 'value1'",
+                    "    'output1'",
+                    '  else',
+                    "    'output2'",
+                    'end']
+          inspect_source(cop, source)
+          expect(cop.messages).to eq(['Indent when as deep as case.'])
+        end
+      end
+
+      it "registers an offence for a when clause that's deeper than case" do
+        source = ['case a',
+                  '    when 0 then return',
+                  '    else',
+                  '        case b',
+                  '         when 1 then return',
+                  '        end',
+                  'end']
+        inspect_source(cop, source)
+        expect(cop.messages).to eq(['Indent when as deep as case.'] * 2)
+      end
+
+      it "accepts a when clause that's equally indented with case" do
+        source = ['y = case a',
+                  '    when 0 then break',
+                  '    when 0 then return',
+                  '    else',
+                  '      z = case b',
+                  '          when 1 then return',
+                  '          when 1 then break',
+                  '          end',
+                  '    end',
+                  'case c',
+                  'when 2 then encoding',
+                  'end',
+                  '']
+        inspect_source(cop, source)
+        expect(cop.offences).to be_empty
+      end
+
+      it "doesn't get confused by strings with case in them" do
+        source = ['a = "case"',
+                  'case x',
+                  'when 0',
+                  'end',
+                  '']
+        inspect_source(cop, source)
+        expect(cop.messages).to be_empty
+      end
+
+      it "doesn't get confused by symbols named case or when" do
+        source = ['KEYWORDS = { :case => true, :when => true }',
+                  'case type',
+                  'when 0',
+                  '  ParameterNode',
+                  'when 1',
+                  '  MethodCallNode',
+                  'end',
+                  '']
+        inspect_source(cop, source)
+        expect(cop.messages).to be_empty
+      end
+
+      it 'accepts correctly indented whens in complex combinations' do
+        source = ['each {',
+                  '  case state',
+                  '  when 0',
+                  '    case name',
+                  '    when :a',
+                  '    end',
+                  '  when 1',
+                  '    loop {',
+                  '      case name',
+                  '      when :b',
+                  '      end',
+                  '    }',
+                  '  end',
+                  '}',
+                  'case s',
+                  'when Array',
+                  'end',
+                  '']
+        inspect_source(cop, source)
+        expect(cop.messages).to be_empty
+      end
+    end
 
-  it "doesn't get confused by symbols named case or when" do
-    source = ['KEYWORDS = { :case => true, :when => true }',
-              'case type',
-              'when 0',
-              '  ParameterNode',
-              'when 1',
-              '  MethodCallNode',
-              'end',
-              '']
-    inspect_source(cop, source)
-    expect(cop.messages).to be_empty
+    context 'with IndentOneStep: true' do
+      let(:cop_config) do
+        { 'IndentWhenRelativeTo' => 'case', 'IndentOneStep' => true }
+      end
+
+      context 'regarding assignment where the right hand side is a case' do
+        it 'accepts a correcty indented assignment' do
+          source = ['output = case variable',
+                    "           when 'value1'",
+                    "             'output1'",
+                    '           else',
+                    "             'output2'",
+                    '         end']
+          inspect_source(cop, source)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'registers on offence for an assignment indented some other way' do
+          source = ['output = case variable',
+                    "         when 'value1'",
+                    "           'output1'",
+                    '         else',
+                    "           'output2'",
+                    '         end']
+          inspect_source(cop, source)
+          expect(cop.messages).to eq(['Indent when one step more than case.'])
+        end
+      end
+
+      it "accepts a when clause that's 2 spaces deeper than case" do
+        source = ['case a',
+                  '  when 0 then return',
+                  '  else',
+                  '        case b',
+                  '          when 1 then return',
+                  '        end',
+                  'end']
+        inspect_source(cop, source)
+        expect(cop.offences).to be_empty
+      end
+
+      it "registers an offence for  a when clause that's equally indented " +
+        'with case' do
+        source = ['y = case a',
+                  '    when 0 then break',
+                  '    when 0 then return',
+                  '      z = case b',
+                  '          when 1 then return',
+                  '          when 1 then break',
+                  '          end',
+                  '    end',
+                  'case c',
+                  'when 2 then encoding',
+                  'end',
+                  '']
+        inspect_source(cop, source)
+        expect(cop.messages)
+          .to eq(['Indent when one step more than case.'] * 5)
+      end
+    end
   end
 
-  it 'accepts correctly indented whens in complex combinations' do
-    source = ['each {',
-              '  case state',
-              '  when 0',
-              '    case name',
-              '    when :a',
-              '    end',
-              '  when 1',
-              '    loop {',
-              '      case name',
-              '      when :b',
-              '      end',
-              '    }',
-              '  end',
-              '}',
-              'case s',
-              'when Array',
-              'end',
-              '']
-    inspect_source(cop, source)
-    expect(cop.messages).to be_empty
+  context 'with IndentWhenRelativeTo: end' do
+    context 'with IndentOneStep: false' do
+      let(:cop_config) do
+        { 'IndentWhenRelativeTo' => 'end', 'IndentOneStep' => false }
+      end
+
+      context 'regarding assignment where the right hand side is a case' do
+        it 'accepts a correcty indented assignment' do
+          source = ['output = case variable',
+                    "when 'value1'",
+                    "  'output1'",
+                    'else',
+                    "  'output2'",
+                    'end']
+          inspect_source(cop, source)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'registers on offence for an assignment indented some other way' do
+          source = ['output = case variable',
+                    "  when 'value1'",
+                    "    'output1'",
+                    '  else',
+                    "    'output2'",
+                    'end']
+          inspect_source(cop, source)
+          expect(cop.messages).to eq(['Indent when as deep as end.'])
+        end
+      end
+    end
+
+    context 'with IndentOneStep: true' do
+      let(:cop_config) do
+        { 'IndentWhenRelativeTo' => 'end', 'IndentOneStep' => true }
+      end
+
+      context 'regarding assignment where the right hand side is a case' do
+        it 'accepts a correcty indented assignment' do
+          source = ['output = case variable',
+                    "  when 'value1'",
+                    "    'output1'",
+                    '  else',
+                    "    'output2'",
+                    'end']
+          inspect_source(cop, source)
+          expect(cop.offences).to be_empty
+        end
+
+        it 'registers on offence for an assignment indented some other way' do
+          source = ['output = case variable',
+                    "         when 'value1'",
+                    "           'output1'",
+                    '         else',
+                    "           'output2'",
+                    '         end']
+          inspect_source(cop, source)
+          expect(cop.messages).to eq(['Indent when one step more than end.'])
+        end
+      end
+    end
   end
 end

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

@@ -16,6 +16,8 @@ describe Rubocop::Cop::Style::ClassLength, :config do
                          '  a = 6',
                          'end'])
     expect(cop.offences.size).to eq(1)
+    expect(cop.messages).to eq(['Class definition is too long. [6/5]'])
+    expect(cop.config_to_allow_offences).to eq('Max' => 6)
   end
 
   it 'accepts a class with 5 lines' do

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

@@ -50,6 +50,12 @@ describe Rubocop::Cop::Style::ConstantName do
     expect(cop.offences).to be_empty
   end
 
+  it 'does not check if rhs is another constant' do
+    inspect_source(cop,
+                   ['Parser::CurrentRuby = Parser::Ruby20'])
+    expect(cop.offences).to be_empty
+  end
+
   it 'checks qualified const names' do
     inspect_source(cop,
                    ['::AnythingGoes = 30',

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

@@ -35,6 +35,7 @@ describe Rubocop::Cop::Style::CyclomaticComplexity, :config do
       expect(cop.messages)
         .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
       expect(cop.highlights).to eq(['def'])
+      expect(cop.config_to_allow_offences).to eq('Max' => 2)
     end
 
     it 'registers an offence for an unless modifier' do

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

@@ -80,4 +80,16 @@ describe Rubocop::Cop::Style::Documentation do
                    ])
     expect(cop.offences).to be_empty
   end
+
+  it 'does not raise an error for an implicit match conditional' do
+    pending
+    expect do
+      inspect_source(cop,
+                     ['class Test',
+                      '  if //',
+                      '  end',
+                      'end'
+                     ])
+    end.to_not raise_error
+  end
 end

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

@@ -29,6 +29,11 @@ describe Rubocop::Cop::Style::DotPosition, :config do
       inspect_source(cop, ['l.', '(1)'])
       expect(cop.offences.size).to eq(1)
     end
+
+    it 'does not err on method call on same line' do
+      inspect_source(cop, ['something.method_name'])
+      expect(cop.offences).to be_empty
+    end
   end
 
   context 'Trailing dots style' do
@@ -55,6 +60,11 @@ describe Rubocop::Cop::Style::DotPosition, :config do
       inspect_source(cop, ['l', '.(1)'])
       expect(cop.offences.size).to eq(1)
     end
+
+    it 'does not err on method call on same line' do
+      inspect_source(cop, ['something.method_name'])
+      expect(cop.offences).to be_empty
+    end
   end
 
   context 'Unknown style' do

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

@@ -14,6 +14,17 @@ describe Rubocop::Cop::Style::EmptyLinesAroundBody do
     expect(cop.offences.size).to eq(1)
   end
 
+  it 'autocorrects method body starting with a blank' do
+    corrected = autocorrect_source(cop,
+                                   ['def some_method',
+                                    '',
+                                    '  do_something',
+                                    'end'])
+    expect(corrected).to eq ['def some_method',
+                             '  do_something',
+                             'end'].join("\n")
+  end
+
   it 'registers an offence for class method body starting with a blank' do
     inspect_source(cop,
                    ['def Test.some_method',
@@ -23,6 +34,17 @@ describe Rubocop::Cop::Style::EmptyLinesAroundBody do
     expect(cop.offences.size).to eq(1)
   end
 
+  it 'autocorrects class method body starting with a blank' do
+    corrected = autocorrect_source(cop,
+                                   ['def Test.some_method',
+                                    '',
+                                    '  do_something',
+                                    'end'])
+    expect(corrected).to eq ['def Test.some_method',
+                             '  do_something',
+                             'end'].join("\n")
+  end
+
   it 'registers an offence for method body ending with a blank' do
     inspect_source(cop,
                    ['def some_method',

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

@@ -11,6 +11,12 @@ describe Rubocop::Cop::Style::EmptyLines do
     expect(cop.offences.size).to eq(2)
   end
 
+  it 'auto-corrects consecutive empty lines' do
+    corrected = autocorrect_source(cop,
+                                   ['test = 5', '', '', '', 'top'])
+    expect(corrected).to eq ['test = 5', '', 'top'].join("\n")
+  end
+
   it 'works when there are no tokens' do
     inspect_source(cop,
                    ['#comment'])

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

@@ -27,4 +27,21 @@ describe Rubocop::Cop::Style::EndOfLine do
       expect(cop.messages.size).to eq(1)
     end
   end
+
+  context 'when the default external encoding is US_ASCII' do
+    before(:each) do
+      @orig_encoding = Encoding.default_external
+      Encoding.default_external = Encoding::US_ASCII
+    end
+    after(:each) { Encoding.default_external = @orig_encoding }
+
+    it 'does not crash on UTF-8 encoded non-ascii characters' do
+      inspect_source_file(cop,
+                          ['# encoding: UTF-8',
+                           'class Epd::ReportsController < EpdAreaController',
+                           "  'terecht bij uw ROM-coördinator.'",
+                           'end'].join("\n"))
+      expect(cop.offences).to be_empty
+    end
+  end
 end