rubocop 0.29.1 → 0.30.0

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

@@ -1,156 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Metrics::BlockNesting, :config do
-  subject(:cop) { described_class.new(config) }
-  let(:cop_config) { { 'Max' => 2 } }
-
-  it 'accepts `Max` levels of nesting' do
-    source = ['if a',
-              '  if b',
-              '    puts b',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [])
-  end
-
-  it 'registers an offense for `Max + 1` levels of `if` nesting' do
-    source = ['if a',
-              '  if b',
-              '    if c',
-              '      puts c',
-              '    end',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [3])
-  end
-
-  it 'registers one offense for `Max + 2` levels of `if` nesting' do
-    source = ['if a',
-              '  if b',
-              '    if c',
-              '      if d',
-              '        puts d',
-              '      end',
-              '    end',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [3], 4)
-  end
-
-  it 'registers 2 offenses' do
-    source = ['if a',
-              '  if b',
-              '    if c',
-              '      puts c',
-              '    end',
-              '  end',
-              '  if d',
-              '    if e',
-              '      puts e',
-              '    end',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [3, 8])
-  end
-
-  it 'registers an offense for nested `case`' do
-    source = ['if a',
-              '  if b',
-              '    case c',
-              '      when C',
-              '        puts C',
-              '    end',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [3])
-  end
-
-  it 'registers an offense for nested `while`' do
-    source = ['if a',
-              '  if b',
-              '    while c',
-              '      puts c',
-              '    end',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [3])
-  end
-
-  it 'registers an offense for nested modifier `while`' do
-    source = ['if a',
-              '  if b',
-              '    begin',
-              '      puts c',
-              '    end while c',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [3])
-  end
-
-  it 'registers an offense for nested `until`' do
-    source = ['if a',
-              '  if b',
-              '    until c',
-              '      puts c',
-              '    end',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [3])
-  end
-
-  it 'registers an offense for nested modifier `until`' do
-    source = ['if a',
-              '  if b',
-              '    begin',
-              '      puts c',
-              '    end until c',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [3])
-  end
-
-  it 'registers an offense for nested `for`' do
-    source = ['if a',
-              '  if b',
-              '    for c in [1,2] do',
-              '      puts c',
-              '    end',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [3])
-  end
-
-  it 'registers an offense for nested `rescue`' do
-    source = ['if a',
-              '  if b',
-              '    begin',
-              '      puts c',
-              '    rescue',
-              '      puts x',
-              '    end',
-              '  end',
-              'end']
-    expect_nesting_offenses(source, [5])
-  end
-
-  it 'accepts if/elsif' do
-    source = ['if a',
-              'elsif b',
-              'elsif c',
-              'elsif d',
-              'end']
-    expect_nesting_offenses(source, [])
-  end
-
-  def expect_nesting_offenses(source, lines, max_to_allow = 3)
-    inspect_source(cop, source)
-    expect(cop.offenses.map(&:line)).to eq(lines)
-    expect(cop.messages).to eq(
-      ['Avoid more than 2 levels of block nesting.'] * lines.length)
-    return unless cop.offenses.size > 0
-
-    expect(cop.config_to_allow_offenses['Max']).to eq(max_to_allow)
-  end
-end

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

@@ -1,131 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Metrics::ClassLength, :config do
-  subject(:cop) { described_class.new(config) }
-  let(:cop_config) { { 'Max' => 5, 'CountComments' => false } }
-
-  it 'rejects a class with more than 5 lines' do
-    inspect_source(cop, ['class Test',
-                         '  a = 1',
-                         '  a = 2',
-                         '  a = 3',
-                         '  a = 4',
-                         '  a = 5',
-                         '  a = 6',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages).to eq(['Class definition is too long. [6/5]'])
-    expect(cop.config_to_allow_offenses).to eq('Max' => 6)
-  end
-
-  it 'accepts a class with 5 lines' do
-    inspect_source(cop, ['class Test',
-                         '  a = 1',
-                         '  a = 2',
-                         '  a = 3',
-                         '  a = 4',
-                         '  a = 5',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a class with less than 5 lines' do
-    inspect_source(cop, ['class Test',
-                         '  a = 1',
-                         '  a = 2',
-                         '  a = 3',
-                         '  a = 4',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not count blank lines' do
-    inspect_source(cop, ['class Test',
-                         '  a = 1',
-                         '  a = 2',
-                         '  a = 3',
-                         '  a = 4',
-                         '',
-                         '',
-                         '  a = 7',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts empty classes' do
-    inspect_source(cop, ['class Test',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  context 'when a class has inner classes' do
-    it 'does not count lines of inner classes' do
-      inspect_source(cop, ['class NamespaceClass',
-                           '  class TestOne',
-                           '    a = 1',
-                           '    a = 2',
-                           '    a = 3',
-                           '    a = 4',
-                           '    a = 5',
-                           '  end',
-                           '  class TestTwo',
-                           '    a = 1',
-                           '    a = 2',
-                           '    a = 3',
-                           '    a = 4',
-                           '    a = 5',
-                           '  end',
-                           '  a = 1',
-                           '  a = 2',
-                           '  a = 3',
-                           '  a = 4',
-                           '  a = 5',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'rejects a class with 6 lines that belong to the class directly' do
-      inspect_source(cop, ['class NamespaceClass',
-                           '  class TestOne',
-                           '    a = 1',
-                           '    a = 2',
-                           '    a = 3',
-                           '    a = 4',
-                           '    a = 5',
-                           '  end',
-                           '  class TestTwo',
-                           '    a = 1',
-                           '    a = 2',
-                           '    a = 3',
-                           '    a = 4',
-                           '    a = 5',
-                           '  end',
-                           '  a = 1',
-                           '  a = 2',
-                           '  a = 3',
-                           '  a = 4',
-                           '  a = 5',
-                           '  a = 6',
-                           'end'])
-      expect(cop.offenses.size).to eq(1)
-    end
-  end
-
-  context 'when CountComments is enabled' do
-    before { cop_config['CountComments'] = true }
-
-    it 'also counts commented lines' do
-      inspect_source(cop, ['class Test',
-                           '  a = 1',
-                           '  #a = 2',
-                           '  a = 3',
-                           '  #a = 4',
-                           '  a = 5',
-                           '  a = 6',
-                           'end'])
-      expect(cop.offenses.size).to eq(1)
-    end
-  end
-end

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

@@ -1,204 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Metrics::CyclomaticComplexity, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when Max is 1' do
-    let(:cop_config) { { 'Max' => 1 } }
-
-    it 'accepts a method with no decision points' do
-      inspect_source(cop, ['def method_name',
-                           '  call_foo',
-                           'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts complex code outside of methods' do
-      inspect_source(cop,
-                     ['def method_name',
-                      '  call_foo',
-                      'end',
-                      '',
-                      'if first_condition then',
-                      '  call_foo if second_condition && third_condition',
-                      '  call_bar if fourth_condition || fifth_condition',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for an if modifier' do
-      inspect_source(cop, ['def self.method_name',
-                           '  call_foo if some_condition',
-                           'end'])
-      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_offenses).to eq('Max' => 2)
-    end
-
-    it 'registers an offense for an unless modifier' do
-      inspect_source(cop, ['def method_name',
-                           '  call_foo unless some_condition',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'registers an offense for an elsif block' do
-      inspect_source(cop, ['def method_name',
-                           '  if first_condition then',
-                           '    call_foo',
-                           '  elsif second_condition then',
-                           '    call_bar',
-                           '  else',
-                           '    call_bam',
-                           '  end',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [3/1]'])
-    end
-
-    it 'registers an offense for a ternary operator' do
-      inspect_source(cop, ['def method_name',
-                           '  value = some_condition ? 1 : 2',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'registers an offense for a while block' do
-      inspect_source(cop, ['def method_name',
-                           '  while some_condition do',
-                           '    call_foo',
-                           '  end',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'registers an offense for an until block' do
-      inspect_source(cop, ['def method_name',
-                           '  until some_condition do',
-                           '    call_foo',
-                           '  end',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'registers an offense for a for block' do
-      inspect_source(cop, ['def method_name',
-                           '  for i in 1..2 do',
-                           '    call_method',
-                           '  end',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'registers an offense for a rescue block' do
-      inspect_source(cop, ['def method_name',
-                           '  begin',
-                           '    call_foo',
-                           '  rescue Exception',
-                           '    call_bar',
-                           '  end',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'registers an offense for a case/when block' do
-      inspect_source(cop, ['def method_name',
-                           '  case value',
-                           '  when 1',
-                           '    call_foo',
-                           '  when 2',
-                           '    call_bar',
-                           '  end',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [3/1]'])
-    end
-
-    it 'registers an offense for &&' do
-      inspect_source(cop, ['def method_name',
-                           '  call_foo && call_bar',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'registers an offense for and' do
-      inspect_source(cop, ['def method_name',
-                           '  call_foo and call_bar',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'registers an offense for ||' do
-      inspect_source(cop, ['def method_name',
-                           '  call_foo || call_bar',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'registers an offense for or' do
-      inspect_source(cop, ['def method_name',
-                           '  call_foo or call_bar',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [2/1]'])
-    end
-
-    it 'deals with nested if blocks containing && and ||' do
-      inspect_source(cop,
-                     ['def method_name',
-                      '  if first_condition then',
-                      '    call_foo if second_condition && third_condition',
-                      '    call_bar if fourth_condition || fifth_condition',
-                      '  end',
-                      'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [6/1]'])
-    end
-
-    it 'counts only a single method' do
-      inspect_source(cop, ['def method_name_1',
-                           '  call_foo if some_condition',
-                           'end',
-                           '',
-                           'def method_name_2',
-                           '  call_foo if some_condition',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name_1 is too high. [2/1]',
-                'Cyclomatic complexity for method_name_2 is too high. [2/1]'])
-    end
-  end
-
-  context 'when Max is 2' do
-    let(:cop_config) { { 'Max' => 2 } }
-
-    it 'counts stupid nested if and else blocks' do
-      inspect_source(cop, ['def method_name',
-                           '  if first_condition then',
-                           '    call_foo',
-                           '  else',
-                           '    if second_condition then',
-                           '      call_bar',
-                           '    else',
-                           '      call_bam if third_condition',
-                           '    end',
-                           '    call_baz if fourth_condition',
-                           '  end',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Cyclomatic complexity for method_name is too high. [5/2]'])
-    end
-  end
-end