rubocop 0.8.3 → 0.9.0

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Lint
+      describe Void do
+        let(: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
+    end
+  end
+end

data/spec/rubocop/cops/offence_spec.rb

@@ -5,32 +5,129 @@ require 'spec_helper'
 module Rubocop
   module Cop
     describe Offence do
-      it 'has a few required attributes' do
-        offence = Offence.new(:convention, 1, 'message')
+      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
 
+      it 'has a few required attributes' do
         expect(offence.severity).to eq(:convention)
-        expect(offence.line_number).to eq(1)
+        expect(offence.line).to eq(1)
         expect(offence.message).to eq('message')
+        expect(offence.cop_name).to eq('CopName')
       end
 
       it 'overrides #to_s' do
-        offence = Offence.new(:convention, 1, 'message')
-
-        expect(offence.to_s).to eq('C:  1: message')
+        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, 1, 'message % test')
+        offence = Offence.new(:convention, location, 'message % test',
+                              'CopName')
 
-        expect(offence.to_s).to eq('C:  1: message % test')
+        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(:test, 1, 'message')
-        o2 = Offence.new(:test, 1, 'message')
+        o1 = Offence.new(:convention, location, 'message', 'CopName')
+        o2 = Offence.new(:convention, location, 'message', 'CopName')
 
         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.send(a)).to be_frozen
+          end
+        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
+      end
+
+      describe '#severity_level' do
+        subject(:severity_level) do
+          Offence.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 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
+
+        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
+
+        [
+          [{                           }, {                           }, 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
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Rails
+      describe Validation do
+        let(:val) { Validation.new }
+
+        Validation::BLACKLIST.each do |validation|
+          it "registers an offence for #{validation}" do
+            inspect_source(val,
+                           ["#{validation} :name"])
+            expect(val.offences.size).to eq(1)
+          end
+        end
+
+        it 'accepts sexy validations' do
+          inspect_source(val,
+                         ['validates :name'])
+          expect(val.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/access_control_spec.rb

@@ -0,0 +1,142 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe AccessControl do
+        let(:a) { AccessControl.new }
+
+        it 'registers an offence for misaligned private' do
+          inspect_source(a,
+                         ['class Test',
+                           '',
+                           'private',
+                           '',
+                           '  def test; end',
+                           'end'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([format(AccessControl::INDENT_MSG, 'private')])
+        end
+
+        it 'registers an offence for misaligned private in module' do
+          inspect_source(a,
+                         ['module Test',
+                          '',
+                          'private',
+                          '',
+                          '  def test; end',
+                          'end'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([format(AccessControl::INDENT_MSG, 'private')])
+        end
+
+        it 'registers an offence for misaligned private in singleton class' do
+          inspect_source(a,
+                         ['class << self',
+                           '',
+                           'private',
+                           '',
+                           '  def test; end',
+                           'end'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([format(AccessControl::INDENT_MSG, 'private')])
+        end
+
+        it 'registers an offence for misaligned protected' do
+          inspect_source(a,
+                         ['class Test',
+                          '',
+                          'protected',
+                          '',
+                          '  def test; end',
+                          'end'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([format(AccessControl::INDENT_MSG, 'protected')])
+        end
+
+        it 'accepts properly indented private' do
+          inspect_source(a,
+                         ['class Test',
+                          '',
+                          '  private',
+                          '',
+                          '  def test; end',
+                          'end'])
+          expect(a.offences).to be_empty
+        end
+
+        it 'accepts properly indented protected' do
+          inspect_source(a,
+                         ['class Test',
+                          '',
+                          '  protected',
+                          '',
+                          '  def test; end',
+                          'end'])
+          expect(a.offences).to be_empty
+        end
+
+        it 'handles properly nested classes' do
+          inspect_source(a,
+                         ['class Test',
+                          '',
+                          '  class Nested',
+                          '',
+                          '  private',
+                          '',
+                          '    def a; end',
+                          '  end',
+                          '',
+                          '  protected',
+                          '',
+                          '  def test; end',
+                          'end'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([format(AccessControl::INDENT_MSG, 'private')])
+        end
+
+        it 'requires blank line before private/protected' do
+          inspect_source(a,
+                         ['class Test',
+                          '  protected',
+                          '',
+                          '  def test; end',
+                          'end'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([format(AccessControl::BLANK_MSG, 'protected')])
+        end
+
+        it 'requires blank line after private/protected' do
+          inspect_source(a,
+                         ['class Test',
+                          '',
+                          '  protected',
+                          '  def test; end',
+                          'end'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([format(AccessControl::BLANK_MSG, 'protected')])
+        end
+
+        it 'recognizes blank lines with DOS style line endings' do
+          inspect_source(a,
+                         ["class Test\r",
+                          "\r",
+                          "  protected\r",
+                          "\r",
+                          "  def test; end\r",
+                          "end\r"])
+          expect(a.offences.size).to eq(0)
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/alias_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe Alias do
+        let(:a) { Alias.new }
+
+        it 'registers an offence for alias with symbol args' do
+          inspect_source(a,
+                         ['alias :ala :bala'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([Alias::MSG])
+        end
+
+        it 'registers an offence for alias with bareword args' do
+          inspect_source(a,
+                         ['alias ala bala'])
+          expect(a.offences.size).to eq(1)
+          expect(a.offences.map(&:message))
+            .to eq([Alias::MSG])
+        end
+
+        it 'does not register an offence for alias_method' do
+          inspect_source(a,
+                         ['alias_method :ala, :bala'])
+          expect(a.offences).to be_empty
+        end
+
+        it 'does not register an offence for :alias' do
+          inspect_source(a,
+                         ['[:alias, :ala, :bala]'])
+          expect(a.offences).to be_empty
+        end
+
+        it 'does not register an offence for alias with gvars' do
+          inspect_source(a,
+                         ['alias $ala $bala'])
+          expect(a.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/align_parameters_spec.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe AlignParameters do
+        let(:align) { AlignParameters.new }
+
+        it 'registers an offence for parameters with single indent' do
+          inspect_source(align, ['function(a,',
+                                 '  if b then c else d end)'])
+          expect(align.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for parameters with double indent' do
+          inspect_source(align, ['function(a,',
+                                 '    if b then c else d end)'])
+          expect(align.offences.size).to eq(1)
+        end
+
+        it 'accepts multiline []= method call' do
+          inspect_source(align, ['Test.config["something"] =',
+                                            ' true'])
+          expect(align.offences).to be_empty
+        end
+
+        it 'accepts correctly aligned parameters' do
+          inspect_source(align, ['function(a,',
+                                 '         0, 1,',
+                                 '         (x + y),',
+                                 '         if b then c else d end)'])
+          expect(align.offences).to be_empty
+        end
+
+        it 'accepts calls that only span one line' do
+          inspect_source(align, ['find(path, s, @special[sexp[0]])'])
+          expect(align.offences).to be_empty
+        end
+
+        it "doesn't get confused by a symbol argument" do
+          inspect_source(align,
+                         ['add_offence(:convention, index,',
+                          '            MSG % kind)'])
+          expect(align.offences).to be_empty
+        end
+
+        it "doesn't get confused by splat operator" do
+          inspect_source(align,
+                         ['func1(*a,',
+                          '      *b,',
+                          '      c)',
+                          'func2(a,',
+                          '     *b,',
+                          '      c)',
+                          'func3(*a)',
+                         ])
+          expect(align.offences.map(&:to_s)).to eq(
+            ['C:  5:  6: Align the parameters of a method call if they span ' +
+             'more than one line.'])
+        end
+
+        it "doesn't get confused by extra comma at the end" do
+          inspect_source(align,
+                         ['func1(a,',
+                          '     b,)'])
+          expect(align.offences.map(&:to_s)).to eq(
+            ['C:  2:  6: Align the parameters of a method call if they span ' +
+             'more than one line.'])
+        end
+
+        it 'can handle a correctly aligned string literal as first argument' do
+          inspect_source(align,
+                         ['add_offence(:convention, x,',
+                          '            a)'])
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle a string literal as other argument' do
+          inspect_source(align,
+                         ['add_offence(:convention,',
+                          '            "", a)'])
+          expect(align.offences).to be_empty
+        end
+
+        it "doesn't get confused by a line break inside a parameter" do
+          inspect_source(align,
+                         ['read(path, { headers:    true,',
+                          '             converters: :numeric })'])
+          expect(align.offences).to be_empty
+        end
+
+        it "doesn't get confused by symbols with embedded expressions" do
+          inspect_source(align,
+                         ['send(:"#{name}_comments_path")'])
+          expect(align.offences).to be_empty
+        end
+
+        it "doesn't get confused by regexen with embedded expressions" do
+          inspect_source(align,
+                         ['a(/#{name}/)'])
+          expect(align.offences).to be_empty
+        end
+
+        it 'accepts braceless hashes' do
+          inspect_source(align,
+                         ['run(collection, :entry_name => label,',
+                          '                :paginator  => paginator)'])
+          expect(align.offences).to be_empty
+        end
+
+        it 'accepts the first parameter being on a new row' do
+          inspect_source(align,
+                         ['  match(',
+                          '    a,',
+                          '    b',
+                          '  )'])
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle heredoc strings' do
+          src = ['class_eval(<<-EOS, __FILE__, __LINE__ + 1)',
+                 '            def run_#{name}_callbacks(*args)',
+                 '              a = 1',
+                 '              return value',
+                 '            end',
+                 '            EOS']
+          inspect_source(align, src)
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle a method call within a method call' do
+          inspect_source(align,
+                         ['a(a1,',
+                          '  b(b1,',
+                          '    b2),',
+                          '  a2)'])
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle a call embedded in a string' do
+          inspect_source(align,
+                         ['model("#{index(name)}", child)'])
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle do-end' do
+          inspect_source(align,
+                         ['      run(lambda do |e|',
+                          "        w = e['warden']",
+                          '      end)'])
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle a call with a block inside another call' do
+          src = ['new(table_name,',
+                 '    exec_query("info(\'#{row[\'name\']}\')").map { |col|',
+                 "      col['name']",
+                 '    })']
+          inspect_source(align, src)
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle a ternary condition with a block reference' do
+          src = ['cond ? a : func(&b)']
+          inspect_source(align, src)
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle parentheses used with no parameters' do
+          src = ['func()']
+          inspect_source(align, src)
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle a multiline hash as second parameter' do
+          src = ['tag(:input, {',
+                 '  :value => value',
+                 '})']
+          inspect_source(align, src)
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle method calls without parentheses' do
+          src = ['a(b c, d)']
+          inspect_source(align, src)
+          expect(align.offences).to be_empty
+        end
+
+        it 'can handle other method calls without parentheses' do
+          src = ['chars(Unicode.apply_mapping @wrapped_string, :uppercase)']
+          inspect_source(align, src)
+          expect(align.offences).to be_empty
+        end
+      end
+    end
+  end
+end