rubocop 0.29.1 → 0.30.0

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

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::WhenThen do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for when x;' do
-    inspect_source(cop, ['case a',
-                         'when b; c',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts when x then' do
-    inspect_source(cop, ['case a',
-                         'when b then c',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts ; separating statements in the body of when' do
-    inspect_source(cop, ['case a',
-                         'when b then c; d',
-                         'end',
-                         '',
-                         'case e',
-                         'when f',
-                         '  g; h',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'auto-corrects "when x;" with "when x then"' do
-    new_source = autocorrect_source(cop, ['case a',
-                                          'when b; c',
-                                          'end'])
-    expect(new_source).to eq(['case a',
-                              'when b then c',
-                              'end'].join("\n"))
-  end
-end

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

@@ -1,55 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::WhileUntilDo do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for do in multiline while' do
-    inspect_source(cop, ['while cond do',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for do in multiline until' do
-    inspect_source(cop, ['until cond do',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts do in single-line while' do
-    inspect_source(cop, 'while cond do something end')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts do in single-line until' do
-    inspect_source(cop, 'until cond do something end')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'it accepts multi-line while without do' do
-    inspect_source(cop, ['while cond',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'it accepts multi-line until without do' do
-    inspect_source(cop, ['until cond',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'auto-corrects the usage of "do" in multiline while' do
-    new_source = autocorrect_source(cop, ['while cond do',
-                                          'end'])
-    expect(new_source).to eq(['while cond',
-                              'end'].join("\n"))
-  end
-
-  it 'auto-corrects the usage of "do" in multiline until' do
-    new_source = autocorrect_source(cop, ['until cond do',
-                                          'end'])
-    expect(new_source).to eq(['until cond',
-                              'end'].join("\n"))
-  end
-end

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

@@ -1,93 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::WhileUntilModifier do
-  include StatementModifierHelper
-
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    hash = { 'Metrics/LineLength' => { 'Max' => 80 } }
-    RuboCop::Config.new(hash)
-  end
-
-  it "accepts multiline unless that doesn't fit on one line" do
-    check_too_long(cop, 'unless')
-  end
-
-  it 'accepts multiline unless whose body is more than one line' do
-    check_short_multiline(cop, 'unless')
-  end
-
-  it 'registers an offense for multiline while that fits on one line' do
-    check_really_short(cop, 'while')
-  end
-
-  it "accepts multiline while that doesn't fit on one line" do
-    check_too_long(cop, 'while')
-  end
-
-  it 'accepts multiline while whose body is more than one line' do
-    check_short_multiline(cop, 'while')
-  end
-
-  it 'accepts oneline while when condition has local variable assignment' do
-    inspect_source(cop, ['lines = %w{first second third}',
-                         'while (line = lines.shift)',
-                         '  puts line',
-                         'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'registers an offense for oneline while when assignment is in body' do
-    inspect_source(cop, ['while true',
-                         '  x = 0',
-                         'end'])
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for multiline until that fits on one line' do
-    check_really_short(cop, 'until')
-  end
-
-  it "accepts multiline until that doesn't fit on one line" do
-    check_too_long(cop, 'until')
-  end
-
-  it 'accepts multiline until whose body is more than one line' do
-    check_short_multiline(cop, 'until')
-  end
-
-  it 'accepts an empty condition' do
-    check_empty(cop, 'while')
-    check_empty(cop, 'until')
-  end
-
-  it 'accepts modifier while' do
-    inspect_source(cop, 'ala while bala')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts modifier until' do
-    inspect_source(cop, 'ala until bala')
-    expect(cop.offenses).to be_empty
-  end
-
-  context 'when the maximum line length is specified by the cop itself' do
-    let(:config) do
-      hash = {
-        'Metrics/LineLength' => { 'Max' => 100 },
-        'Style/WhileUntilModifier' => { 'MaxLineLength' => 80 }
-      }
-      RuboCop::Config.new(hash)
-    end
-
-    it "accepts multiline while that doesn't fit on one line" do
-      check_too_long(cop, 'while')
-    end
-
-    it "accepts multiline until that doesn't fit on one line" do
-      check_too_long(cop, 'until')
-    end
-  end
-end

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

@@ -1,117 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::WordArray, :config do
-  subject(:cop) { described_class.new(config) }
-  let(:cop_config) { { 'MinSize' => 0, 'WordRegex' => /\A[\p{Word}]+\z/ } }
-
-  it 'registers an offense for arrays of single quoted strings' do
-    inspect_source(cop,
-                   "['one', 'two', 'three']")
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.config_to_allow_offenses).to eq('MinSize' => 3)
-  end
-
-  it 'registers an offense for arrays of double quoted strings' do
-    inspect_source(cop,
-                   '["one", "two", "three"]')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for arrays of unicode word characters' do
-    inspect_source(cop,
-                   '["ВУЗ", "вуз", "中文网"]')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for arrays with character constants' do
-    inspect_source(cop,
-                   '["one", ?\n]')
-    expect(cop.offenses.size).to eq(1)
-  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 starting with %w' do
-    inspect_source(cop,
-                   '%w(one two three)')
-    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
-
-  it 'does not register an offense for array with allowed number of strings' do
-    cop_config['MinSize'] = 3
-
-    inspect_source(cop,
-                   '["one", "two", "three"]')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not register an offense for an array with comments in it' do
-    inspect_source(cop,
-                   ['[',
-                    '"foo", # comment here',
-                    '"bar", # this thing was done because of a bug',
-                    '"baz" # do not delete this line',
-                    ']'])
-
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'registers an offense for an array with comments outside of it' do
-    inspect_source(cop,
-                   ['[',
-                    '"foo",',
-                    '"bar",',
-                    '"baz"',
-                    '] # test'])
-
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  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
-
-  context 'with a custom WordRegex configuration' do
-    let(:cop_config) { { 'MinSize' => 0, 'WordRegex' => /\A[\w@.]+\z/ } }
-
-    it 'registers an offense for arrays of email addresses' do
-      inspect_source(cop, "['a@example.com', 'b@example.com']")
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'auto-corrects an array of email addresses' do
-      new_source = autocorrect_source(cop, "['a@example.com', 'b@example.com']")
-      expect(new_source).to eq('%w(a@example.com b@example.com)')
-    end
-  end
-end

data/spec/rubocop/cop/team_spec.rb

@@ -1,190 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Team do
-  subject(:team) { described_class.new(cop_classes, config, options) }
-  let(:cop_classes) { RuboCop::Cop::Cop.non_rails }
-  let(:config) { RuboCop::ConfigLoader.default_configuration }
-  let(:options) { nil }
-
-  describe '#autocorrect?' do
-    subject { team.autocorrect? }
-
-    context 'when the option argument of .new is omitted' do
-      subject { described_class.new(cop_classes, config).autocorrect? }
-      it { should be_falsey }
-    end
-
-    context 'when { auto_correct: true } is passed to .new' do
-      let(:options) { { auto_correct: true } }
-      it { should be_truthy }
-    end
-  end
-
-  describe '#debug?' do
-    subject { team.debug? }
-
-    context 'when the option argument of .new is omitted' do
-      subject { described_class.new(cop_classes, config).debug? }
-      it { should be_falsey }
-    end
-
-    context 'when { debug: true } is passed to .new' do
-      let(:options) { { debug: true } }
-      it { should be_truthy }
-    end
-  end
-
-  describe '#inspect_file', :isolated_environment do
-    include FileHelper
-
-    let(:file_path) { '/tmp/example.rb' }
-    let(:offenses) do
-      team.inspect_file(RuboCop::ProcessedSource.from_file(file_path))
-    end
-
-    before do
-      create_file(file_path, [
-        '#' * 90,
-        'puts test;'
-      ])
-    end
-
-    it 'returns offenses' do
-      expect(offenses).not_to be_empty
-      expect(offenses.all? { |o| o.is_a?(RuboCop::Cop::Offense) }).to be_truthy
-    end
-
-    context 'when Parser reports non-fatal warning for the file' do
-      before do
-        create_file(file_path, [
-          '# encoding: utf-8',
-          '#' * 90,
-          'puts *test'
-        ])
-      end
-
-      let(:cop_names) { offenses.map(&:cop_name) }
-
-      it 'returns Parser warning offenses' do
-        expect(cop_names).to include('Lint/AmbiguousOperator')
-      end
-
-      it 'returns offenses from cops' do
-        expect(cop_names).to include('Metrics/LineLength')
-      end
-    end
-
-    context 'when autocorrection is enabled' do
-      let(:options) { { auto_correct: true } }
-
-      before do
-        create_file(file_path, [
-          '# encoding: utf-8',
-          'puts "string"'
-        ])
-      end
-
-      it 'does autocorrection' do
-        team.inspect_file(RuboCop::ProcessedSource.from_file(file_path))
-        corrected_source = File.read(file_path)
-        expect(corrected_source).to eq([
-          '# encoding: utf-8',
-          "puts 'string'",
-          ''
-        ].join("\n"))
-      end
-
-      it 'still returns offenses' do
-        expect(offenses.first.cop_name).to eq('Style/StringLiterals')
-      end
-    end
-  end
-
-  describe '#cops' do
-    subject(:cops) { team.cops }
-
-    it 'returns cop instances' do
-      expect(cops).not_to be_empty
-      expect(cops.all? { |c| c.is_a?(RuboCop::Cop::Cop) }).to be_truthy
-    end
-
-    context 'when only some cop classes are passed to .new' do
-      let(:cop_classes) do
-        [RuboCop::Cop::Lint::Void, RuboCop::Cop::Metrics::LineLength]
-      end
-
-      it 'returns only instances of the classes' do
-        expect(cops.size).to eq(2)
-        cops.sort! { |a, b| a.name <=> b.name }
-        expect(cops[0].name).to eq('Lint/Void')
-        expect(cops[1].name).to eq('Metrics/LineLength')
-      end
-    end
-
-    context 'when some classes are disabled with config' do
-      let(:disabled_config) do
-        %w(
-          Lint/Void
-          Metrics/LineLength
-        ).each_with_object({}) do |cop_name, accum|
-          accum[cop_name] = { 'Enabled' => false }
-        end
-      end
-      let(:config) do
-        RuboCop::ConfigLoader.merge_with_default(disabled_config, '')
-      end
-      let(:cop_names) { cops.map(&:name) }
-
-      it 'does not return instances of the classes' do
-        expect(cops).not_to be_empty
-        expect(cop_names).not_to include('Lint/Void')
-        expect(cop_names).not_to include('Metrics/LineLength')
-      end
-    end
-  end
-
-  describe '#forces' do
-    subject(:forces) { team.forces }
-    let(:cop_classes) { RuboCop::Cop::Cop.non_rails }
-
-    it 'returns force instances' do
-      expect(forces).not_to be_empty
-
-      forces.each do |force|
-        expect(force).to be_a(RuboCop::Cop::Force)
-      end
-    end
-
-    context 'when a cop joined a force' do
-      let(:cop_classes) { [RuboCop::Cop::Lint::UselessAssignment] }
-
-      it 'returns the force' do
-        expect(forces.size).to eq(1)
-        expect(forces.first).to be_a(RuboCop::Cop::VariableForce)
-      end
-    end
-
-    context 'when multiple cops joined a same force' do
-      let(:cop_classes) do
-        [
-          RuboCop::Cop::Lint::UselessAssignment,
-          RuboCop::Cop::Lint::ShadowingOuterLocalVariable
-        ]
-      end
-
-      it 'returns only one force instance' do
-        expect(forces.size).to eq(1)
-      end
-    end
-
-    context 'when no cops joined force' do
-      let(:cop_classes) { [RuboCop::Cop::Style::For] }
-
-      it 'returns nothing' do
-        expect(forces).to be_empty
-      end
-    end
-  end
-end