rubocop 0.21.0 → 0.22.0

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

@@ -149,8 +149,8 @@ describe Rubocop::Cop::Style::BlockNesting, :config do
     expect(cop.offenses.map(&:line)).to eq(lines)
     expect(cop.messages).to eq(
       ['Avoid more than 2 levels of block nesting.'] * lines.length)
-    if cop.offenses.size > 0
-      expect(cop.config_to_allow_offenses['Max']).to eq(max_to_allow)
-    end
+    return unless cop.offenses.size > 0
+
+    expect(cop.config_to_allow_offenses['Max']).to eq(max_to_allow)
   end
 end

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

@@ -6,11 +6,7 @@ describe Rubocop::Cop::Style::ClassAndModuleChildren, :config do
   subject(:cop) { described_class.new(config) }
 
   context 'nested style' do
-    let(:cop_config) do
-      {
-        'EnforcedStyle' => 'nested'
-      }
-    end
+    let(:cop_config) { { 'EnforcedStyle' => 'nested' } }
 
     it 'registers an offense for not nested classes' do
       inspect_source(cop, ['class FooClass::BarClass', 'end'])
@@ -62,11 +58,7 @@ describe Rubocop::Cop::Style::ClassAndModuleChildren, :config do
   end
 
   context 'compact style' do
-    let(:cop_config) do
-      {
-        'EnforcedStyle' => 'compact'
-      }
-    end
+    let(:cop_config) { { 'EnforcedStyle' => 'compact' } }
 
     it 'registers a offense for classes with nested children' do
       inspect_source(cop,
@@ -125,5 +117,15 @@ describe Rubocop::Cop::Style::ClassAndModuleChildren, :config do
                      ])
       expect(cop.offenses).to be_empty
     end
+
+    it 'accepts class / module with single method' do
+      inspect_source(cop,
+                     ['class FooClass',
+                      '  def bar_method',
+                      '  end',
+                      'end'
+                     ])
+      expect(cop.offenses).to be_empty
+    end
   end
 end

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

@@ -0,0 +1,174 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::CommentIndentation do
+  subject(:cop) { described_class.new }
+
+  context 'on outer level' do
+    it 'accepts a correctly indented comment' do
+      inspect_source(cop, '# comment')
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts a comment that follows code' do
+      inspect_source(cop, 'hello # comment')
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'accepts a documentation comment' do
+      inspect_source(cop, ['=begin',
+                           'Doc comment',
+                           '=end',
+                           '  hello',
+                           ' #',
+                           'hi'])
+      expect(cop.highlights).to eq(['#'])
+    end
+
+    it 'registers an offense for an incorrectly indented (1) comment' do
+      inspect_source(cop, ' # comment')
+      expect(cop.messages)
+        .to eq(['Incorrect indentation detected (column 1 instead of 0).'])
+      expect(cop.highlights).to eq(['# comment'])
+    end
+
+    it 'registers an offense for an incorrectly indented (2) comment' do
+      inspect_source(cop, '  # comment')
+      expect(cop.messages)
+        .to eq(['Incorrect indentation detected (column 2 instead of 0).'])
+    end
+
+    it 'registers an offense for each incorrectly indented comment' do
+      inspect_source(cop, ['# a',
+                           '  # b',
+                           '    # c',
+                           '# d',
+                           'def test; end'])
+      expect(cop.messages)
+        .to eq(['Incorrect indentation detected (column 0 instead of 2).',
+                'Incorrect indentation detected (column 2 instead of 4).',
+                'Incorrect indentation detected (column 4 instead of 0).'])
+    end
+  end
+
+  context 'around program structure keywords' do
+    it 'accepts correctly indented comments' do
+      inspect_source(cop, ['#',
+                           'def m',
+                           '  #',
+                           '  if a',
+                           '    #',
+                           '    b',
+                           '  # this is accepted',
+                           '  elsif aa',
+                           '    # this is accepted',
+                           '  else',
+                           '    #',
+                           '  end',
+                           '  #',
+                           '  case a',
+                           '  # this is accepted',
+                           '  when 0',
+                           '    #',
+                           '    b',
+                           '  end',
+                           '  # this is accepted',
+                           'rescue',
+                           '# this is accepted',
+                           'ensure',
+                           '  #',
+                           'end',
+                           '#'])
+      expect(cop.offenses).to eq([])
+    end
+
+    context 'with a blank line following the comment' do
+      it 'accepts a correctly indented comment' do
+        inspect_source(cop, ['def m',
+                             '  # comment',
+                             '',
+                             'end'])
+        expect(cop.offenses).to be_empty
+      end
+    end
+  end
+
+  context 'near various kinds of brackets' do
+    it 'accepts correctly indented comments' do
+      inspect_source(cop, ['#',
+                           'a = {',
+                           '  #',
+                           '  x: [',
+                           '    1',
+                           '    #',
+                           '  ],',
+                           '  #',
+                           '  y: func(',
+                           '          1',
+                           '          #',
+                           '          )',
+                           '  #',
+                           '}',
+                           '#'])
+      expect(cop.offenses).to eq([])
+    end
+
+    it 'is unaffected by closing bracket that does not begin a line' do
+      inspect_source(cop, ['#',
+                           'result = []'])
+      expect(cop.messages).to eq([])
+    end
+  end
+
+  it 'auto-corrects' do
+    new_source = autocorrect_source(cop, [' # comment',
+                                          'hash1 = { a: 0,',
+                                          '     # comment',
+                                          '          bb: 1,',
+                                          '          ccc: 2 }',
+                                          '  if a',
+                                          '  #',
+                                          '    b',
+                                          '  # this is accepted',
+                                          '  elsif aa',
+                                          '    # so is this',
+                                          '  elsif bb',
+                                          '#',
+                                          '  else',
+                                          '   #',
+                                          '  end',
+                                          '  case a',
+                                          '  # this is accepted',
+                                          '  when 0',
+                                          '    # so is this',
+                                          '  when 1',
+                                          '     #',
+                                          '    b',
+                                          '  end'])
+    expect(new_source).to eq(['# comment',
+                              'hash1 = { a: 0,',
+                              '          # comment',
+                              '          bb: 1,',
+                              '          ccc: 2 }',
+                              '  if a',
+                              '    #',
+                              '    b',
+                              '  # this is accepted',
+                              '  elsif aa',
+                              '    # so is this',
+                              '  elsif bb',
+                              '  #',
+                              '  else',
+                              '    #',
+                              '  end',
+                              '  case a',
+                              '  # this is accepted',
+                              '  when 0',
+                              '    # so is this',
+                              '  when 1',
+                              '    #',
+                              '    b',
+                              '  end'].join("\n"))
+  end
+end

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Rubocop::Cop::Style::EachWithObject do
+  subject(:cop) { described_class.new }
+
+  it 'finds inject and reduce with passed in and returned hash' do
+    inspect_source(cop,
+                   ['[].inject({}) do |a, e|',
+                    '  a[e] = 1',
+                    '  a',
+                    'end',
+                    '',
+                    '[].reduce({}) do |a, e|',
+                    '  a[e] = 1',
+                    '  a[e] = 1',
+                    '  a',
+                    'end'])
+    expect(cop.offenses.size).to eq(2)
+    expect(cop.offenses.map(&:line).sort).to eq([1, 6])
+    expect(cop.messages)
+      .to eq(['Use `each_with_object` instead of `inject`.',
+              'Use `each_with_object` instead of `reduce`.'])
+    expect(cop.highlights).to eq(%w(inject reduce))
+  end
+
+  it 'ignores inject and reduce with passed in, but not returned hash' do
+    inspect_source(cop,
+                   ['[].inject({}) do |a, e|',
+                    '  a + e',
+                    'end',
+                    '',
+                    '[].reduce({}) do |a, e|',
+                    '  a + e',
+                    'end'])
+    expect(cop.offenses).to be_empty
+  end
+
+  it 'ignores inject and reduce passed in symbol' do
+    inspect_source(cop, ['[].inject(:+)', '[].reduce(:+)'])
+    expect(cop.offenses).to be_empty
+  end
+end

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

@@ -29,11 +29,9 @@ describe Rubocop::Cop::Style::EndOfLine do
   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 }
+    let(:orig_encoding) { Encoding.default_external }
+    before(:each) { Encoding.default_external = Encoding::US_ASCII }
+    after(:each) { Encoding.default_external = orig_encoding }
 
     it 'does not crash on UTF-8 encoded non-ascii characters' do
       inspect_source_file(cop,

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

@@ -2,76 +2,154 @@
 
 require 'spec_helper'
 
-describe Rubocop::Cop::Style::GuardClause do
-  let(:cop) { described_class.new }
+describe Rubocop::Cop::Style::GuardClause, :config do
+  let(:cop) { described_class.new(config) }
+  let(:cop_config) { {} }
 
-  it 'reports an offense if method body is if without else' do
-    src = ['def func',
-           '  if something',
-           '    work',
-           '    work_more',
-           '  end',
-           'end']
-    inspect_source(cop, src)
-    expect(cop.offenses.size).to eq(1)
+  it 'reports an offense if method body is if / unless without else' do
+    inspect_source(cop,
+                   ['def func',
+                    '  if something',
+                    '    work',
+                    '  end',
+                    'end',
+                    '',
+                    'def func',
+                    '  unless something',
+                    '    work',
+                    '  end',
+                    'end'])
+    expect(cop.offenses.size).to eq(2)
+    expect(cop.offenses.map(&:line).sort).to eq([2, 8])
+    expect(cop.messages)
+      .to eq(['Use a guard clause instead of wrapping ' \
+              'the code inside a conditional expression.'] * 2)
+    expect(cop.highlights).to eq(%w(if unless))
   end
 
-  it 'reports an offense if method body ends with if without else' do
-    src = ['def func',
-           '  test',
-           '  if something',
-           '    work',
-           '    work_more',
-           '  end',
-           'end']
-    inspect_source(cop, src)
-    expect(cop.offenses.size).to eq(1)
+  it 'reports an offense if method body ends with if / unless without else' do
+    inspect_source(cop,
+                   ['def func',
+                    '  test',
+                    '  if something',
+                    '    work',
+                    '  end',
+                    'end',
+                    '',
+                    'def func',
+                    '  test',
+                    '  unless something',
+                    '    work',
+                    '  end',
+                    'end'])
+    expect(cop.offenses.size).to eq(2)
+    expect(cop.offenses.map(&:line).sort).to eq([3, 10])
+    expect(cop.messages)
+      .to eq(['Use a guard clause instead of wrapping ' \
+              'the code inside a conditional expression.'] * 2)
+    expect(cop.highlights).to eq(%w(if unless))
   end
 
-  it 'accepts a method which body is if with else' do
-    src = ['def func',
-           '  if something',
-           '    work',
-           '    work_more',
-           '  else',
-           '    test',
-           '  end',
-           'end']
-    inspect_source(cop, src)
+  it 'accepts a method which body is if / unless with else' do
+    inspect_source(cop,
+                   ['def func',
+                    '  if something',
+                    '    work',
+                    '  else',
+                    '    test',
+                    '  end',
+                    'end',
+                    '',
+                    'def func',
+                    '  unless something',
+                    '    work',
+                    '  else',
+                    '    test',
+                    '  end',
+                    'end'])
     expect(cop.offenses).to be_empty
   end
 
-  it 'accepts a method which body does not end with if' do
-    src = ['def func',
-           '  if something',
-           '    work',
-           '    work_more',
-           '  end',
-           '  test',
-           'end']
-    inspect_source(cop, src)
+  it 'accepts a method which body does not end with if / unless' do
+    inspect_source(cop,
+                   ['def func',
+                    '  if something',
+                    '    work',
+                    '  end',
+                    '  test',
+                    'end',
+                    '',
+                    'def func',
+                    '  unless something',
+                    '    work',
+                    '  end',
+                    '  test',
+                    'end'])
     expect(cop.offenses).to be_empty
   end
 
-  it 'accepts a method which body does not end with if' do
-    src = ['def func',
-           '  if something',
-           '    work',
-           '    work_more',
-           '  end',
-           '  test',
-           'end']
-    inspect_source(cop, src)
+  it 'accepts a method whose body is a modifier if / unless' do
+    inspect_source(cop,
+                   ['def func',
+                    '  work if something',
+                    'end',
+                    '',
+                    'def func',
+                    '  work if something',
+                    'end'])
     expect(cop.offenses).to be_empty
   end
 
-  it 'accepts a method whose body is an if with a one-line body' do
-    src = ['def func',
-           '  if something',
-           '    work',
-           '  end',
-           'end']
-    inspect_source(cop, src)
-    expect(cop.offenses).to be_empty
+  context 'MinBodyLength: 1' do
+    let(:cop_config) do
+      { 'EnforcedStyle' => 'MinBodyLength: 1' }
+    end
+
+    it 'reports an offense for if whose body has 1 line' do
+      inspect_source(cop,
+                     ['def func',
+                      '  if something',
+                      '    work',
+                      '  end',
+                      'end',
+                      '',
+                      'def func',
+                      '  unless something',
+                      '    work',
+                      '  end',
+                      'end'])
+      expect(cop.offenses.size).to eq(2)
+      expect(cop.offenses.map(&:line).sort).to eq([2, 8])
+      expect(cop.messages)
+        .to eq(['Use a guard clause instead of wrapping ' \
+                'the code inside a conditional expression.'] * 2)
+      expect(cop.highlights).to eq(%w(if unless))
+    end
+  end
+
+  context 'MinBodyLength: 4' do
+    let(:cop_config) do
+      { 'MinBodyLength' => 4 }
+    end
+
+    it 'accepts a method whose body has 3 line' do
+      inspect_source(cop,
+                     ['def func',
+                      '  if something',
+                      '    work',
+                      '    work',
+                      '    work',
+                      '  end',
+                      'end',
+                      '',
+                      'def func',
+                      '  unless something',
+                      '    work',
+                      '    work',
+                      '    work',
+                      '  end',
+                      'end'])
+      expect(cop.offenses).to be_empty
+    end
   end
 end