rubocop 0.29.1 → 0.30.0

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

@@ -1,130 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Rails::ReadWriteAttribute do
-  subject(:cop) { described_class.new }
-
-  context 'read_attribute' do
-    it 'registers an offense' do
-      inspect_source(cop, 'res = read_attribute(:test)')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['read_attribute'])
-    end
-
-    it 'registers no offense with explicit receiver' do
-      inspect_source(cop, 'res = object.read_attribute(:test)')
-      expect(cop.offenses.size).to eq(0)
-    end
-  end
-
-  context 'write_attribute' do
-    it 'registers an offense' do
-      inspect_source(cop, 'write_attribute(:test, val)')
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.highlights).to eq(['write_attribute'])
-    end
-
-    it 'registers no offense with explicit receiver' do
-      inspect_source(cop, 'object.write_attribute(:test, val)')
-      expect(cop.offenses.size).to eq(0)
-    end
-  end
-
-  describe '#autocorrect' do
-    context 'write_attribute' do
-      it 'autocorrects symbol' do
-        source = 'write_attribute(:attr, var)'
-        corrected_source = 'self[:attr] = var'
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-
-      it 'autocorrects string' do
-        source = "write_attribute('attr', 'test')"
-        corrected_source = "self['attr'] = 'test'"
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-
-      it 'autocorrects without parentheses' do
-        source = "write_attribute 'attr', 'test'"
-        corrected_source = "self['attr'] = 'test'"
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-
-      it 'autocorrects expression' do
-        source = "write_attribute(:attr, 'test_' + postfix)"
-        corrected_source = "self[:attr] = 'test_' + postfix"
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-
-      it 'autocorrects multiline' do
-        source = [
-          'write_attribute(',
-          ':attr, ',
-          '(',
-          "'test_' + postfix",
-          ').to_sym',
-          ')'
-        ]
-        corrected_source = [
-          'self[:attr] = (',
-          "'test_' + postfix",
-          ').to_sym'
-        ].join("\n")
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-    end
-
-    context 'read_attribute' do
-      it 'autocorrects symbol' do
-        source = 'res = read_attribute(:test)'
-        corrected_source = 'res = self[:test]'
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-
-      it 'autocorrects string' do
-        source = "res = read_attribute('test')"
-        corrected_source = "res = self['test']"
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-
-      it 'autocorrects without parentheses' do
-        source = "res = read_attribute 'test'"
-        corrected_source = "res = self['test']"
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-
-      it 'autocorrects expression' do
-        source = "res = read_attribute('test_' + postfix)"
-        corrected_source = "res = self['test_' + postfix]"
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-
-      it 'autocorrects multiline' do
-        source = [
-          'res = read_attribute(',
-          '(',
-          "'test_' + postfix",
-          ').to_sym',
-          ')'
-        ]
-        corrected_source = [
-          'res = self[(',
-          "'test_' + postfix",
-          ').to_sym]'
-        ].join("\n")
-
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Rails::ScopeArgs do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense a scope with a method arg' do
-    inspect_source(cop,
-                   'scope :active, where(active: true)')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts a lambda arg' do
-    inspect_source(cop,
-                   'scope :active, -> { where(active: true) }')
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'accepts a proc arg' do
-    inspect_source(cop,
-                   'scope :active, proc { where(active: true) }')
-    expect(cop.offenses).to be_empty
-  end
-end

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

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Rails::Validation do
-  subject(:cop) { described_class.new }
-
-  described_class::BLACKLIST.each_with_index do |validation, number|
-    it "registers an offense for #{validation}" do
-      inspect_source(cop,
-                     "#{validation} :name")
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it "outputs the correct message for #{validation}" do
-      inspect_source(cop,
-                     "#{validation} :name")
-      expect(cop.offenses.first.message)
-        .to include(described_class::WHITELIST[number])
-    end
-  end
-
-  it 'accepts new style validations' do
-    inspect_source(cop,
-                   'validates :name')
-    expect(cop.offenses).to be_empty
-  end
-end

data/spec/rubocop/cop/severity_spec.rb

@@ -1,113 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Severity do
-  let(:refactor) { described_class.new(:refactor) }
-  let(:convention) { described_class.new(:convention) }
-  let(:warning) { described_class.new(:warning) }
-  let(:error) { described_class.new(:error) }
-  let(:fatal) { described_class.new(:fatal) }
-
-  it 'has a few required attributes' do
-    expect(convention.name).to eq(:convention)
-  end
-
-  it 'overrides #to_s' do
-    expect(convention.to_s).to eq('convention')
-  end
-
-  it 'redefines == to compare severities' do
-    expect(convention).to eq(:convention)
-    expect(convention).to eq(described_class.new(:convention))
-    expect(convention).not_to eq(:warning)
-  end
-
-  it 'is frozen' do
-    expect(convention).to be_frozen
-  end
-
-  describe '#code' do
-    describe 'refactor' do
-      it { expect(refactor.code).to eq('R') }
-    end
-
-    describe 'convention' do
-      it { expect(convention.code).to eq('C') }
-    end
-
-    describe 'warning' do
-      it { expect(warning.code).to eq('W') }
-    end
-
-    describe 'error' do
-      it { expect(error.code).to eq('E') }
-    end
-
-    describe 'fatal' do
-      it { expect(fatal.code).to eq('F') }
-    end
-  end
-
-  describe '#level' do
-    describe 'refactor' do
-      it { expect(refactor.level).to eq(1) }
-    end
-
-    describe 'convention' do
-      it { expect(convention.level).to eq(2) }
-    end
-
-    describe 'warning' do
-      it { expect(warning.level).to eq(3) }
-    end
-
-    describe 'error' do
-      it { expect(error.level).to eq(4) }
-    end
-
-    describe 'fatal' do
-      it { expect(fatal.level).to eq(5) }
-    end
-  end
-
-  describe 'constructs from code' do
-    describe 'R' do
-      it { expect(described_class.new('R')).to eq(refactor) }
-    end
-
-    describe 'C' do
-      it { expect(described_class.new('C')).to eq(convention) }
-    end
-
-    describe 'W' do
-      it { expect(described_class.new('W')).to eq(warning) }
-    end
-
-    describe 'E' do
-      it { expect(described_class.new('E')).to eq(error) }
-    end
-
-    describe 'F' do
-      it { expect(described_class.new('F')).to eq(fatal) }
-    end
-  end
-
-  describe 'Comparable' do
-    describe 'refactor' do
-      it { expect(refactor).to be < convention }
-    end
-
-    describe 'convention' do
-      it { expect(convention).to be < warning }
-    end
-
-    describe 'warning' do
-      it { expect(warning).to be < error }
-    end
-
-    describe 'error' do
-      it { expect(error).to be < fatal }
-    end
-  end
-end

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

@@ -1,421 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Style::AccessModifierIndentation do
-  subject(:cop) { described_class.new(config) }
-  let(:config) do
-    c = cop_config.merge('SupportedStyles' => %w(indent outdent))
-    RuboCop::Config
-      .new('Style/AccessModifierIndentation' => c,
-           'Style/IndentationWidth' => { 'Width' => indentation_width })
-  end
-  let(:indentation_width) { 2 }
-
-  context 'when EnforcedStyle is set to indent' do
-    let(:cop_config) { { 'EnforcedStyle' => 'indent' } }
-
-    it 'registers an offense for misaligned private' do
-      inspect_source(cop,
-                     ['class Test',
-                      '',
-                      'private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Indent access modifiers like `private`.'])
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'outdent')
-    end
-
-    it 'registers an offense for misaligned private in module' do
-      inspect_source(cop,
-                     ['module Test',
-                      '',
-                      ' private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Indent access modifiers like `private`.'])
-      # Not aligned according to `indent` or `outdent` style:
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers an offense for misaligned module_function in module' do
-      inspect_source(cop,
-                     ['module Test',
-                      '',
-                      ' module_function',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Indent access modifiers like `module_function`.'])
-      # Not aligned according to `indent` or `outdent` style:
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers an offense for correct + opposite alignment' do
-      inspect_source(cop,
-                     ['module Test',
-                      '',
-                      '  public',
-                      '',
-                      'private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Indent access modifiers like `private`.'])
-      # No EnforcedStyle can allow both alignments:
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers an offense for opposite + correct alignment' do
-      inspect_source(cop,
-                     ['module Test',
-                      '',
-                      'public',
-                      '',
-                      '  private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Indent access modifiers like `public`.'])
-      # No EnforcedStyle can allow both alignments:
-      expect(cop.config_to_allow_offenses).to eq('Enabled' => false)
-    end
-
-    it 'registers an offense for misaligned private in singleton class' do
-      inspect_source(cop,
-                     ['class << self',
-                      '',
-                      'private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Indent access modifiers like `private`.'])
-    end
-
-    it 'registers an offense for misaligned private in class ' \
-       'defined with Class.new' do
-      inspect_source(cop,
-                     ['Test = Class.new do',
-                      '',
-                      'private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Indent access modifiers like `private`.'])
-    end
-
-    it 'accepts misaligned private in blocks that are not recognized as ' \
-       'class/module definitions' do
-      inspect_source(cop,
-                     ['Test = func do',
-                      '',
-                      'private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'registers an offense for misaligned private in module ' \
-       'defined with Module.new' do
-      inspect_source(cop,
-                     ['Test = Module.new do',
-                      '',
-                      'private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Indent access modifiers like `private`.'])
-    end
-
-    it 'registers an offense for misaligned protected' do
-      inspect_source(cop,
-                     ['class Test',
-                      '',
-                      'protected',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Indent access modifiers like `protected`.'])
-    end
-
-    it 'accepts properly indented private' do
-      inspect_source(cop,
-                     ['class Test',
-                      '',
-                      '  private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts properly indented protected' do
-      inspect_source(cop,
-                     ['class Test',
-                      '',
-                      '  protected',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts an empty class' do
-      inspect_source(cop,
-                     ['class Test',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'handles properly nested classes' do
-      inspect_source(cop,
-                     ['class Test',
-                      '',
-                      '  class Nested',
-                      '',
-                      '  private',
-                      '',
-                      '    def a; end',
-                      '  end',
-                      '',
-                      '  protected',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages)
-        .to eq(['Indent access modifiers like `private`.'])
-    end
-
-    it 'auto-corrects incorrectly indented access modifiers' do
-      corrected = autocorrect_source(cop, ['class Test',
-                                           '',
-                                           'public',
-                                           ' private',
-                                           '   protected',
-                                           '',
-                                           '  def test; end',
-                                           'end'])
-      expect(corrected).to eq(['class Test',
-                               '',
-                               '  public',
-                               '  private',
-                               '  protected',
-                               '',
-                               '  def test; end',
-                               'end'].join("\n"))
-    end
-
-    context 'when 4 spaces per indent level are used' do
-      let(:indentation_width) { 4 }
-
-      it 'accepts properly indented private' do
-        inspect_source(cop,
-                       ['class Test',
-                        '',
-                        '    private',
-                        '',
-                        '    def test; end',
-                        'end'])
-        expect(cop.offenses).to be_empty
-      end
-    end
-  end
-
-  context 'when EnforcedStyle is set to outdent' do
-    let(:cop_config) { { 'EnforcedStyle' => 'outdent' } }
-    let(:indent_msg) { 'Outdent access modifiers like `private`.' }
-
-    it 'registers offense for private indented to method depth in a class' do
-      inspect_source(cop,
-                     ['class Test',
-                      '',
-                      '  private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq([indent_msg])
-      expect(cop.config_to_allow_offenses).to eq('EnforcedStyle' => 'indent')
-    end
-
-    it 'registers offense for private indented to method depth in a module' do
-      inspect_source(cop,
-                     ['module Test',
-                      '',
-                      '  private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq([indent_msg])
-    end
-
-    it 'registers offense for module fn indented to method depth in a module' do
-      inspect_source(cop,
-                     ['module Test',
-                      '',
-                      '  module_function',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-    end
-
-    it 'registers offense for private indented to method depth in singleton' \
-       'class' do
-      inspect_source(cop,
-                     ['class << self',
-                      '',
-                      '  private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq([indent_msg])
-    end
-
-    it 'registers offense for private indented to method depth in class ' \
-       'defined with Class.new' do
-      inspect_source(cop,
-                     ['Test = Class.new do',
-                      '',
-                      '  private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq([indent_msg])
-    end
-
-    it 'registers offense for private indented to method depth in module ' \
-       'defined with Module.new' do
-      inspect_source(cop,
-                     ['Test = Module.new do',
-                      '',
-                      '  private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq([indent_msg])
-    end
-
-    it 'accepts private indented to the containing class indent level' do
-      inspect_source(cop,
-                     ['class Test',
-                      '',
-                      'private',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'accepts protected indented to the containing class indent level' do
-      inspect_source(cop,
-                     ['class Test',
-                      '',
-                      'protected',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses).to be_empty
-    end
-
-    it 'handles properly nested classes' do
-      inspect_source(cop,
-                     ['class Test',
-                      '',
-                      '  class Nested',
-                      '',
-                      '    private',
-                      '',
-                      '    def a; end',
-                      '  end',
-                      '',
-                      'protected',
-                      '',
-                      '  def test; end',
-                      'end'])
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq([indent_msg])
-    end
-
-    it 'auto-corrects incorrectly indented access modifiers' do
-      corrected = autocorrect_source(cop, ['module M',
-                                           '  class Test',
-                                           '',
-                                           'public',
-                                           ' private',
-                                           '     protected',
-                                           '',
-                                           '    def test; end',
-                                           '  end',
-                                           'end'])
-      expect(corrected).to eq(['module M',
-                               '  class Test',
-                               '',
-                               '  public',
-                               '  private',
-                               '  protected',
-                               '',
-                               '    def test; end',
-                               '  end',
-                               'end'].join("\n"))
-    end
-
-    it 'auto-corrects private in complicated case' do
-      corrected = autocorrect_source(cop, ['class Hello',
-                                           '  def foo',
-                                           "    'hi'",
-                                           '  end',
-                                           '',
-                                           '  def bar',
-                                           '    Module.new do',
-                                           '',
-                                           '     private',
-                                           '',
-                                           '      def hi',
-                                           "        'bye'",
-                                           '      end',
-                                           '    end',
-                                           '  end',
-                                           'end'])
-      expect(corrected).to eq(['class Hello',
-                               '  def foo',
-                               "    'hi'",
-                               '  end',
-                               '',
-                               '  def bar',
-                               '    Module.new do',
-                               '',
-                               '    private',
-                               '',
-                               '      def hi',
-                               "        'bye'",
-                               '      end',
-                               '    end',
-                               '  end',
-                               'end'].join("\n"))
-    end
-  end
-end