rubocop 0.29.1 → 0.30.0

data/spec/rubocop/cop/offense_spec.rb

@@ -1,133 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Offense do
-  let(:location) do
-    source_buffer = Parser::Source::Buffer.new('test', 1)
-    source_buffer.source = "a\n"
-    Parser::Source::Range.new(source_buffer, 0, 1)
-  end
-  subject(:offense) do
-    described_class.new(:convention, location, 'message', 'CopName', true)
-  end
-
-  it 'has a few required attributes' do
-    expect(offense.severity).to eq(:convention)
-    expect(offense.line).to eq(1)
-    expect(offense.message).to eq('message')
-    expect(offense.cop_name).to eq('CopName')
-    expect(offense.corrected?).to be_truthy
-  end
-
-  it 'overrides #to_s' do
-    expect(offense.to_s).to eq('C:  1:  1: message')
-  end
-
-  it 'does not blow up if a message contains %' do
-    offense = described_class.new(:convention, location, 'message % test',
-                                  'CopName')
-
-    expect(offense.to_s).to eq('C:  1:  1: message % test')
-  end
-
-  it 'redefines == to compare offenses based on their contents' do
-    o1 = described_class.new(:convention, location, 'message', 'CopName')
-    o2 = described_class.new(:convention, location, 'message', 'CopName')
-
-    expect(o1 == o2).to be_truthy
-  end
-
-  it 'is frozen' do
-    expect(offense).to be_frozen
-  end
-
-  [:severity, :location, :message, :cop_name].each do |a|
-    describe "##{a}" do
-      it 'is frozen' do
-        expect(offense.send(a)).to be_frozen
-      end
-    end
-  end
-
-  context 'when unknown severity is passed' do
-    it 'raises error' do
-      expect do
-        described_class.new(:foobar, location, 'message', 'CopName')
-      end.to raise_error(ArgumentError)
-    end
-  end
-
-  describe '#severity_level' do
-    subject(:severity_level) do
-      described_class.new(severity, location, 'message', 'CopName')
-        .severity.level
-    end
-
-    context 'when severity is :refactor' do
-      let(:severity) { :refactor }
-      it 'is 1' do
-        expect(severity_level).to eq(1)
-      end
-    end
-
-    context 'when severity is :fatal' do
-      let(:severity) { :fatal }
-      it 'is 5' do
-        expect(severity_level).to eq(5)
-      end
-    end
-  end
-
-  describe '#<=>' do
-    def offense(hash = {})
-      attrs = {
-        sev:  :convention,
-        line: 5,
-        col:  5,
-        mes:  'message',
-        cop:  'CopName'
-      }.merge(hash)
-
-      described_class.new(
-        attrs[:sev],
-        location(attrs[:line], attrs[:col],
-                 %w(aaaaaa bbbbbb cccccc dddddd eeeeee ffffff)),
-        attrs[:mes],
-        attrs[:cop]
-      )
-    end
-
-    def location(line, column, source)
-      source_buffer = Parser::Source::Buffer.new('test', 1)
-      source_buffer.source = source.join("\n")
-      begin_pos = source[0...(line - 1)].reduce(0) do |a, e|
-        a + e.length + "\n".length
-      end + column
-      Parser::Source::Range.new(source_buffer, begin_pos, begin_pos + 1)
-    end
-
-    # We want a nice table layout, so we allow space inside empty hashes.
-    # rubocop:disable Style/SpaceInsideHashLiteralBraces
-    [
-      [{                           }, {                           }, 0],
-
-      [{ line: 6                   }, { line: 5                   }, 1],
-
-      [{ line: 5, col: 6           }, { line: 5, col: 5           }, 1],
-      [{ line: 6, col: 4           }, { line: 5, col: 5           }, 1],
-
-      [{                  cop: 'B' }, {                  cop: 'A' }, 1],
-      [{ line: 6,         cop: 'A' }, { line: 5,         cop: 'B' }, 1],
-      [{          col: 6, cop: 'A' }, {          col: 5, cop: 'B' }, 1]
-    ].each do |one, other, expectation|
-      context "when receiver has #{one} and other has #{other}" do
-        it "returns #{expectation}" do
-          an_offense = offense(one)
-          other_offense = offense(other)
-          expect(an_offense <=> other_offense).to eq(expectation)
-        end
-      end
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'tempfile'
-
-describe RuboCop::Cop::Rails::ActionFilter, :config do
-  subject(:cop) { described_class.new(config) }
-
-  context 'when style is action' do
-    let(:cop_config) { { 'EnforcedStyle' => 'action' } }
-
-    described_class::FILTER_METHODS.each do |method|
-      it "registers an offense for #{method}" do
-        inspect_source_file(cop, "#{method} :name")
-        expect(cop.offenses.size).to eq(1)
-      end
-
-      it "registers an offense for #{method} with block" do
-        inspect_source_file(cop, "#{method} { |controller| something }")
-        expect(cop.offenses.size).to eq(1)
-      end
-    end
-
-    described_class::ACTION_METHODS.each do |method|
-      it "accepts #{method}" do
-        inspect_source_file(cop, "#{method} :something")
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    it 'auto-corrects to preferred method' do
-      new_source = autocorrect_source_file(cop, 'before_filter :test')
-      expect(new_source).to eq('before_action :test')
-    end
-  end
-
-  context 'when style is filter' do
-    let(:cop_config) { { 'EnforcedStyle' => 'filter' } }
-
-    described_class::ACTION_METHODS.each do |method|
-      it "registers an offense for #{method}" do
-        inspect_source_file(cop, "#{method} :name")
-        expect(cop.offenses.size).to eq(1)
-      end
-
-      it "registers an offense for #{method} with block" do
-        inspect_source_file(cop, "#{method} { |controller| something }")
-        expect(cop.offenses.size).to eq(1)
-      end
-    end
-
-    described_class::FILTER_METHODS.each do |method|
-      it "accepts #{method}" do
-        inspect_source_file(cop, "#{method} :something")
-        expect(cop.offenses).to be_empty
-      end
-    end
-
-    it 'auto-corrects to preferred method' do
-      new_source = autocorrect_source_file(cop, 'before_action :test')
-      expect(new_source).to eq('before_filter :test')
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Rails::DefaultScope do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for default scope with a lambda arg' do
-    inspect_source(cop,
-                   'default_scope -> { something }')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for default scope with a proc arg' do
-    inspect_source(cop,
-                   'default_scope proc { something }')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for default scope with a proc(Proc.new) arg' do
-    inspect_source(cop,
-                   'default_scope Proc.new { something }')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'registers an offense for non blocks' do
-    inspect_source(cop,
-                   'default_scope order: "position"')
-    expect(cop.offenses.size).to eq(1)
-  end
-
-  it 'accepts a block arg' do
-    inspect_source(cop,
-                   'default_scope { something }')
-    expect(cop.offenses).to be_empty
-  end
-end

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

@@ -1,177 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Rails::Delegate do
-  subject(:cop) { described_class.new }
-
-  it 'finds trivial delegate' do
-    inspect_source(cop,
-                   ['def foo',
-                    '  bar.foo',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses
-            .map(&:line).sort).to eq([1])
-    expect(cop.messages)
-      .to eq(['Use `delegate` to define delegations.'])
-    expect(cop.highlights).to eq(['def'])
-  end
-
-  it 'finds trivial delegate with arguments' do
-    inspect_source(cop,
-                   ['def foo(baz)',
-                    '  bar.foo(baz)',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses
-            .map(&:line).sort).to eq([1])
-    expect(cop.messages)
-      .to eq(['Use `delegate` to define delegations.'])
-    expect(cop.highlights).to eq(['def'])
-  end
-
-  it 'finds trivial delegate with prefix' do
-    inspect_source(cop,
-                   ['def bar_foo',
-                    '  bar.foo',
-                    'end'])
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses
-            .map(&:line).sort).to eq([1])
-    expect(cop.messages)
-      .to eq(['Use `delegate` to define delegations.'])
-    expect(cop.highlights).to eq(['def'])
-  end
-
-  it 'ignores class methods' do
-    inspect_source(cop,
-                   ['def self.fox',
-                    '  new.fox',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores non trivial delegate' do
-    inspect_source(cop,
-                   ['def fox',
-                    '  bar.foo.fox',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores trivial delegate with mismatched arguments' do
-    inspect_source(cop,
-                   ['def fox(baz)',
-                    '  bar.fox(foo)',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores trivial delegate with mismatched arguments' do
-    inspect_source(cop,
-                   ['def fox(foo = nil)',
-                    '  bar.fox(foo || 5)',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores trivial delegate with mismatched arguments' do
-    inspect_source(cop,
-                   ['def fox(a, baz)',
-                    '  bar.fox(a)',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores trivial delegate with other prefix' do
-    inspect_source(cop,
-                   ['def fox_foo',
-                    '  bar.foo',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores methods with arguments' do
-    inspect_source(cop,
-                   ['def fox(bar)',
-                    '  bar.fox',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores private delegations' do
-    inspect_source(cop,
-                   ['  private def fox', # leading spaces are on purpose
-                    '    bar.fox',
-                    '  end',
-                    '  ',
-                    '    private',
-                    '  ',
-                    '  def fox',
-                    '    bar.fox',
-                    '  end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores protected delegations' do
-    inspect_source(cop,
-                   ['  protected def fox', # leading spaces are on purpose
-                    '    bar.fox',
-                    '  end',
-                    '  ',
-                    '  protected',
-                    '  ',
-                    '  def fox',
-                    '    bar.fox',
-                    '  end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores delegation with assignment' do
-    inspect_source(cop,
-                   ['def new',
-                    '  @bar = Foo.new',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'ignores delegation to constant' do
-    inspect_source(cop,
-                   ['FOO = []',
-                    'def size',
-                    '  FOO.size',
-                    'end'])
-    expect(cop.offenses).to be_empty
-  end
-
-  describe '#autocorrect' do
-    context 'trivial delegation' do
-      let(:source) do
-        ['def bar',
-         '  foo.bar',
-         'end']
-      end
-
-      let(:corrected_source) { 'delegate :bar, to: :foo' }
-
-      it 'autocorrects' do
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-    end
-
-    context 'trivial delegation with prefix' do
-      let(:source) do
-        ['def foo_bar',
-         '  foo.bar',
-         'end']
-      end
-
-      let(:corrected_source) { 'delegate :bar, to: :foo, prefix: true' }
-
-      it 'autocorrects' do
-        expect(autocorrect_source(cop, source)).to eq(corrected_source)
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Rails::HasAndBelongsToMany do
-  subject(:cop) { described_class.new }
-
-  it 'registers an offense for has_and_belongs_to_many' do
-    inspect_source(cop,
-                   'has_and_belongs_to_many :groups')
-    expect(cop.offenses.size).to eq(1)
-  end
-end

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

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe RuboCop::Cop::Rails::Output do
-  subject(:cop) { described_class.new }
-
-  it 'records an offense for methods without a receiver' do
-    source = ['p "edmond dantes"',
-              'puts "sinbad"',
-              'print "abbe busoni"',
-              'pp "monte cristo"']
-    inspect_source(cop, source)
-    expect(cop.offenses.size).to eq(4)
-  end
-
-  it 'does not record an offense for methods with a receiver' do
-    source = ['obj.print',
-              'something.p',
-              'nothing.pp']
-    inspect_source(cop, source)
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not record an offense for methods without arguments' do
-    source = %w(print pp puts)
-    inspect_source(cop, source)
-    expect(cop.offenses).to be_empty
-  end
-
-  it 'does not record an offense for comments' do
-    source = ['# print "test"',
-              '# p']
-    inspect_source(cop, source)
-    expect(cop.offenses).to be_empty
-  end
-end