rubocop 0.13.1 → 0.14.0

data/spec/rubocop/cop/lint/useless_comparison_spec.rb

@@ -2,35 +2,29 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Lint
-      describe UselessComparison do
-        subject(:cop) { UselessComparison.new }
+describe Rubocop::Cop::Lint::UselessComparison do
+  subject(:cop) { described_class.new }
 
-        UselessComparison::OPS.each do |op|
-          it "registers an offence for a simple comparison with #{op}" do
-            inspect_source(cop,
-                           ["5 #{op} 5",
-                            "a #{op} a"
-                           ])
-            expect(cop.offences.size).to eq(2)
-          end
-
-          it "registers an offence for a complex comparison with #{op}" do
-            inspect_source(cop,
-                           ["5 + 10 * 30 #{op} 5 + 10 * 30",
-                            "a.top(x) #{op} a.top(x)"
-                           ])
-            expect(cop.offences.size).to eq(2)
-          end
-        end
+  described_class::OPS.each do |op|
+    it "registers an offence for a simple comparison with #{op}" do
+      inspect_source(cop,
+                     ["5 #{op} 5",
+                      "a #{op} a"
+                     ])
+      expect(cop.offences.size).to eq(2)
+    end
 
-        it 'works with lambda.()' do
-          inspect_source(cop, ['a.(x) > a.(x)'])
-          expect(cop.offences.size).to eq(1)
-        end
-      end
+    it "registers an offence for a complex comparison with #{op}" do
+      inspect_source(cop,
+                     ["5 + 10 * 30 #{op} 5 + 10 * 30",
+                      "a.top(x) #{op} a.top(x)"
+                     ])
+      expect(cop.offences.size).to eq(2)
     end
   end
+
+  it 'works with lambda.()' do
+    inspect_source(cop, ['a.(x) > a.(x)'])
+    expect(cop.offences.size).to eq(1)
+  end
 end

data/spec/rubocop/cop/lint/useless_setter_call_spec.rb

@@ -2,141 +2,135 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Lint
-      describe UselessSetterCall do
-        subject(:cop) { UselessSetterCall.new }
+describe Rubocop::Cop::Lint::UselessSetterCall do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for def ending with lvar attr assignment' do
-          inspect_source(cop,
-                         ['def test',
-                          '  top = Top.new',
-                          '  top.attr = 5',
-                          'end'
-                         ])
-          expect(cop.offences.size).to eq(1)
-        end
-
-        it 'registers an offence for defs ending with lvar attr assignment' do
-          inspect_source(cop,
-                         ['def Top.test',
-                          '  top = Top.new',
-                          '  top.attr = 5',
-                          'end'
-                         ])
-          expect(cop.offences.size).to eq(1)
-        end
+  it 'registers an offence for def ending with lvar attr assignment' do
+    inspect_source(cop,
+                   ['def test',
+                    '  top = Top.new',
+                    '  top.attr = 5',
+                    'end'
+                   ])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts def ending with ivar assignment' do
-          inspect_source(cop,
-                         ['def test',
-                          '  something',
-                          '  @top = 5',
-                          'end'
-                         ])
-          expect(cop.offences).to be_empty
-        end
+  it 'registers an offence for defs ending with lvar attr assignment' do
+    inspect_source(cop,
+                   ['def Top.test',
+                    '  top = Top.new',
+                    '  top.attr = 5',
+                    'end'
+                   ])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts def ending ivar attr assignment' do
-          inspect_source(cop,
-                         ['def test',
-                          '  something',
-                          '  @top.attr = 5',
-                          'end'
-                         ])
-          expect(cop.offences).to be_empty
-        end
+  it 'accepts def ending with ivar assignment' do
+    inspect_source(cop,
+                   ['def test',
+                    '  something',
+                    '  @top = 5',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts def ending with argument attr assignment' do
-          inspect_source(cop,
-                         ['def test(some_arg)',
-                          '  unrelated_local_variable = Top.new',
-                          '  some_arg.attr = 5',
-                          'end'
-                         ])
-          expect(cop.offences).to be_empty
-        end
+  it 'accepts def ending ivar attr assignment' do
+    inspect_source(cop,
+                   ['def test',
+                    '  something',
+                    '  @top.attr = 5',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
 
-        context 'when a lvar has an object passed as argument ' +
-                'at the end of the method' do
-          it 'accepts the lvar attr assignment' do
-            inspect_source(cop,
-                           ['def test(some_arg)',
-                            '  @some_ivar = some_arg',
-                            '  @some_ivar.do_something',
-                            '  some_lvar = @some_ivar',
-                            '  some_lvar.do_something',
-                            '  some_lvar.attr = 5',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
-        end
+  it 'accepts def ending with argument attr assignment' do
+    inspect_source(cop,
+                   ['def test(some_arg)',
+                    '  unrelated_local_variable = Top.new',
+                    '  some_arg.attr = 5',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
 
-        context 'when a lvar has an object passed as argument ' +
-                'by multiple-assignment at the end of the method' do
-          it 'accepts the lvar attr assignment' do
-            inspect_source(cop,
-                           ['def test(some_arg)',
-                            '  _first, some_lvar, _third  = 1, some_arg, 3',
-                            '  some_lvar.attr = 5',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
-        end
+  context 'when a lvar has an object passed as argument ' +
+          'at the end of the method' do
+    it 'accepts the lvar attr assignment' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  @some_ivar = some_arg',
+                      '  @some_ivar.do_something',
+                      '  some_lvar = @some_ivar',
+                      '  some_lvar.do_something',
+                      '  some_lvar.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences).to be_empty
+    end
+  end
 
-        context 'when a lvar possibly has an object passed as argument ' +
-                'by logical-operator-assignment at the end of the method' do
-          it 'accepts the lvar attr assignment' do
-            inspect_source(cop,
-                           ['def test(some_arg)',
-                            '  some_lvar = nil',
-                            '  some_lvar ||= some_arg',
-                            '  some_lvar.attr = 5',
-                            'end'
-                           ])
-            expect(cop.offences).to be_empty
-          end
-        end
+  context 'when a lvar has an object passed as argument ' +
+          'by multiple-assignment at the end of the method' do
+    it 'accepts the lvar attr assignment' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  _first, some_lvar, _third  = 1, some_arg, 3',
+                      '  some_lvar.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences).to be_empty
+    end
+  end
 
-        context 'when a lvar does not have any object passed as argument ' +
-                'by binary-operator-assignment at the end of the method' do
-          it 'registers an offence' do
-            inspect_source(cop,
-                           ['def test(some_arg)',
-                            '  some_lvar = some_arg',
-                            '  some_lvar += some_arg',
-                            '  some_lvar.attr = 5',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
-        end
+  context 'when a lvar possibly has an object passed as argument ' +
+          'by logical-operator-assignment at the end of the method' do
+    it 'accepts the lvar attr assignment' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  some_lvar = nil',
+                      '  some_lvar ||= some_arg',
+                      '  some_lvar.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences).to be_empty
+    end
+  end
 
-        context 'when a lvar declared as an argument ' +
-                'is no longer the passed object at the end of the method' do
-          it 'registers an offence for the lvar attr assignment' do
-            inspect_source(cop,
-                           ['def test(some_arg)',
-                            '  some_arg = Top.new',
-                            '  some_arg.attr = 5',
-                            'end'
-                           ])
-            expect(cop.offences.size).to eq(1)
-          end
-        end
+  context 'when a lvar does not have any object passed as argument ' +
+          'by binary-operator-assignment at the end of the method' do
+    it 'registers an offence' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  some_lvar = some_arg',
+                      '  some_lvar += some_arg',
+                      '  some_lvar.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
 
-        it 'is not confused by operators ending with =' do
-          inspect_source(cop,
-                         ['def test',
-                          '  top.attr == 5',
-                          'end'
-                         ])
-          expect(cop.offences).to be_empty
-        end
-      end
+  context 'when a lvar declared as an argument ' +
+          'is no longer the passed object at the end of the method' do
+    it 'registers an offence for the lvar attr assignment' do
+      inspect_source(cop,
+                     ['def test(some_arg)',
+                      '  some_arg = Top.new',
+                      '  some_arg.attr = 5',
+                      'end'
+                     ])
+      expect(cop.offences.size).to eq(1)
     end
   end
+
+  it 'is not confused by operators ending with =' do
+    inspect_source(cop,
+                   ['def test',
+                    '  top.attr == 5',
+                    'end'
+                   ])
+    expect(cop.offences).to be_empty
+  end
 end

data/spec/rubocop/cop/lint/void_spec.rb

@@ -2,62 +2,56 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Lint
-      describe Void do
-        subject(:void_op) { Void.new }
-
-        Void::OPS.each do |op|
-          it "registers an offence for void op #{op} if not on last line" do
-            inspect_source(void_op,
-                           ["a #{op} b",
-                            "a #{op} b",
-                            "a #{op} b"
-                           ])
-            expect(void_op.offences.size).to eq(2)
-          end
-        end
-
-        Void::OPS.each do |op|
-          it "accepts void op #{op} if on last line" do
-            inspect_source(void_op,
-                           ['something',
-                            "a #{op} b"
-                           ])
-            expect(void_op.offences).to be_empty
-          end
-        end
-
-        Void::OPS.each do |op|
-          it "accepts void op #{op} by itself without a begin block" do
-            inspect_source(void_op, ["a #{op} b"])
-            expect(void_op.offences).to be_empty
-          end
-        end
-
-        %w(var @var @@var VAR).each do |var|
-          it "registers an offence for void var #{var} if not on last line" do
-            inspect_source(void_op,
-                           ["#{var} = 5",
-                            "#{var}",
-                            'top'
-                           ])
-            expect(void_op.offences.size).to eq(1)
-          end
-        end
-
-        %w(1 2.0 /test/ [1] {}).each do |lit|
-          it "registers an offence for void lit #{lit} if not on last line" do
-            inspect_source(void_op,
-                           ["#{lit}",
-                            'top'
-                           ])
-            expect(void_op.offences.size).to eq(1)
-          end
-        end
-
-      end
+describe Rubocop::Cop::Lint::Void do
+  subject(:cop) { described_class.new }
+
+  described_class::OPS.each do |op|
+    it "registers an offence for void op #{op} if not on last line" do
+      inspect_source(cop,
+                     ["a #{op} b",
+                      "a #{op} b",
+                      "a #{op} b"
+                     ])
+      expect(cop.offences.size).to eq(2)
     end
   end
+
+  described_class::OPS.each do |op|
+    it "accepts void op #{op} if on last line" do
+      inspect_source(cop,
+                     ['something',
+                      "a #{op} b"
+                     ])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  described_class::OPS.each do |op|
+    it "accepts void op #{op} by itself without a begin block" do
+      inspect_source(cop, ["a #{op} b"])
+      expect(cop.offences).to be_empty
+    end
+  end
+
+  %w(var @var @@var VAR).each do |var|
+    it "registers an offence for void var #{var} if not on last line" do
+      inspect_source(cop,
+                     ["#{var} = 5",
+                      "#{var}",
+                      'top'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
+
+  %w(1 2.0 /test/ [1] {}).each do |lit|
+    it "registers an offence for void lit #{lit} if not on last line" do
+      inspect_source(cop,
+                     ["#{lit}",
+                      'top'
+                     ])
+      expect(cop.offences.size).to eq(1)
+    end
+  end
+
 end

data/spec/rubocop/cop/offence_spec.rb

@@ -2,158 +2,128 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    describe Offence 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(:offence) do
-        Offence.new(:convention, location, 'message', 'CopName')
-      end
+describe Rubocop::Cop::Offence 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(:offence) do
+    described_class.new(:convention, location, 'message', 'CopName', true)
+  end
 
-      it 'has a few required attributes' do
-        expect(offence.severity).to eq(:convention)
-        expect(offence.line).to eq(1)
-        expect(offence.message).to eq('message')
-        expect(offence.cop_name).to eq('CopName')
-      end
+  it 'has a few required attributes' do
+    expect(offence.severity).to eq(:convention)
+    expect(offence.line).to eq(1)
+    expect(offence.message).to eq('message')
+    expect(offence.cop_name).to eq('CopName')
+    expect(offence.corrected?).to be_true
+  end
 
-      it 'overrides #to_s' do
-        expect(offence.to_s).to eq('C:  1:  1: message')
-      end
+  it 'overrides #to_s' do
+    expect(offence.to_s).to eq('C:  1:  1: message')
+  end
 
-      it 'does not blow up if a message contains %' do
-        offence = Offence.new(:convention, location, 'message % test',
-                              'CopName')
+  it 'does not blow up if a message contains %' do
+    offence = described_class.new(:convention, location, 'message % test',
+                                  'CopName')
 
-        expect(offence.to_s).to eq('C:  1:  1: message % test')
-      end
+    expect(offence.to_s).to eq('C:  1:  1: message % test')
+  end
 
-      it 'redefines == to compare offences based on their contents' do
-        o1 = Offence.new(:convention, location, 'message', 'CopName')
-        o2 = Offence.new(:convention, location, 'message', 'CopName')
+  it 'redefines == to compare offences 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_true
-      end
+    expect(o1 == o2).to be_true
+  end
+
+  it 'is frozen' do
+    expect(offence).to be_frozen
+  end
 
+  [:severity, :location, :line, :column, :message, :cop_name].each do |a|
+    describe "##{a}" do
       it 'is frozen' do
-        expect(offence).to be_frozen
+        expect(offence.send(a)).to be_frozen
       end
+    end
+  end
 
-      describe '.from_diagnostic' do
-        subject(:offence) { Offence.from_diagnostic(diagnostic) }
-        let(:diagnostic) { Parser::Diagnostic.new(level, message, location) }
-        let(:level) { :warning }
-        let(:message) { 'This is a message' }
-        let(:location) { double('location').as_null_object }
-
-        it 'returns an offence' do
-          expect(offence).to be_a(Offence)
-        end
-
-        it "sets diagnostic's level to offence's severity" do
-          expect(offence.severity).to eq(level)
-        end
-
-        it "sets diagnostic's message to offence's message" do
-          expect(offence.message).to eq(message)
-        end
-
-        it "sets diagnostic's location to offence's location" do
-          expect(offence.location).to eq(location)
-        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
 
-        it 'sets Sytanx as cop name' do
-          expect(offence.cop_name).to eq('Syntax')
-        end
-      end
+  describe '#severity_level' do
+    subject(:severity_level) do
+      described_class.new(severity, location, 'message', 'CopName')
+        .severity_level
+    end
 
-      [:severity, :location, :line, :column, :message, :cop_name].each do |a|
-        describe "##{a}" do
-          it 'is frozen' do
-            expect(offence.send(a)).to be_frozen
-          end
-        end
+    context 'when severity is :refactor' do
+      let(:severity) { :refactor }
+      it 'is 1' do
+        expect(severity_level).to eq(1)
       end
+    end
 
-      context 'when unknown severity is passed' do
-        it 'raises error' do
-          expect do
-            Offence.new(:foobar, location, 'message', 'CopName')
-          end.to raise_error(ArgumentError)
-        end
+    context 'when severity is :fatal' do
+      let(:severity) { :fatal }
+      it 'is 5' do
+        expect(severity_level).to eq(5)
       end
+    end
+  end
 
-      describe '#severity_level' do
-        subject(:severity_level) do
-          Offence.new(severity, location, 'message', 'CopName').severity_level
-        end
+  describe '#<=>' do
+    def offence(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
 
-        context 'when severity is :refactor' do
-          let(:severity) { :refactor }
-          it 'is 1' do
-            expect(severity_level).to eq(1)
-          end
-        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
 
-        context 'when severity is :fatal' do
-          let(:severity) { :fatal }
-          it 'is 5' do
-            expect(severity_level).to eq(5)
-          end
-        end
-      end
+    [
+      [{                           }, {                           }, 0],
 
-      describe '#<=>' do
-        def offence(hash = {})
-          attrs = {
-            sev:  :convention,
-            line: 5,
-            col:  5,
-            mes:  'message',
-            cop:  'CopName'
-          }.merge(hash)
-
-          Offence.new(
-            attrs[:sev],
-            location(attrs[:line], attrs[:col],
-                     %w(aaaaaa bbbbbb cccccc dddddd eeeeee ffffff)),
-            attrs[:mes],
-            attrs[:cop]
-          )
-        end
+      [{ line: 6                   }, { line: 5                   }, 1],
 
-        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
+      [{ line: 5, col: 6           }, { line: 5, col: 5           }, 1],
+      [{ line: 6, col: 4           }, { line: 5, col: 5           }, 1],
 
-        [
-          [{                           }, {                           }, 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_offence = offence(one)
-              other_offence = offence(other)
-              expect(an_offence <=> other_offence).to eq(expectation)
-            end
-          end
+      [{                  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_offence = offence(one)
+          other_offence = offence(other)
+          expect(an_offence <=> other_offence).to eq(expectation)
         end
       end
     end