sabat-rubocop 0.9.0

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

@@ -0,0 +1,122 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe RescueModifier do
+        let(:rm) { RescueModifier.new }
+
+        it 'registers an offence for modifier rescue' do
+          inspect_source(rm,
+                         ['method rescue handle'])
+          expect(rm.offences.size).to eq(1)
+          expect(rm.offences.map(&:message))
+            .to eq([RescueModifier::MSG])
+        end
+
+        it 'handles more complex expression with modifier rescue' do
+          inspect_source(rm,
+                         ['method1 or method2 rescue handle'])
+          expect(rm.offences.size).to eq(1)
+          expect(rm.offences.map(&:message))
+            .to eq([RescueModifier::MSG])
+        end
+
+        it 'handles modifier rescue in normal rescue' do
+          inspect_source(rm,
+                         ['begin',
+                          '  test rescue modifier_handle',
+                          'rescue',
+                          '  normal_handle',
+                          'end'])
+          expect(rm.offences.size).to eq(1)
+          expect(rm.offences.first.line).to eq(2)
+        end
+
+        it 'does not register an offence for normal rescue' do
+          inspect_source(rm,
+                         ['begin',
+                          '  test',
+                          'rescue',
+                          '  handle',
+                          'end'])
+          expect(rm.offences).to be_empty
+        end
+
+        it 'does not register an offence for normal rescue with ensure' do
+          inspect_source(rm,
+                         ['begin',
+                          '  test',
+                          'rescue',
+                          '  handle',
+                          'ensure',
+                          '  cleanup',
+                          'end'])
+          expect(rm.offences).to be_empty
+        end
+
+        it 'does not register an offence for nested normal rescue' do
+          inspect_source(rm,
+                         ['begin',
+                          '  begin',
+                          '    test',
+                          '  rescue',
+                          '    handle_inner',
+                          '  end',
+                          'rescue',
+                          '  handle_outer',
+                          'end'])
+          expect(rm.offences).to be_empty
+        end
+
+        context 'when an instance method has implicit begin' do
+          it 'accepts normal rescue' do
+            inspect_source(rm,
+                           ['def some_method',
+                            '  test',
+                            'rescue',
+                            '  handle',
+                            'end'])
+            expect(rm.offences).to be_empty
+          end
+
+          it 'handles modifier rescue in body of implicit begin' do
+            inspect_source(rm,
+                           ['def some_method',
+                            '  test rescue modifier_handle',
+                            'rescue',
+                            '  normal_handle',
+                            'end'])
+            expect(rm.offences.size).to eq(1)
+            expect(rm.offences.first.line).to eq(2)
+          end
+        end
+
+        context 'when a singleton method has implicit begin' do
+          it 'accepts normal rescue' do
+            inspect_source(rm,
+                           ['def self.some_method',
+                            '  test',
+                            'rescue',
+                            '  handle',
+                            'end'])
+            expect(rm.offences).to be_empty
+          end
+
+          it 'handles modifier rescue in body of implicit begin' do
+            inspect_source(rm,
+                           ['def self.some_method',
+                            '  test rescue modifier_handle',
+                            'rescue',
+                            '  normal_handle',
+                            'end'])
+            expect(rm.offences.size).to eq(1)
+            expect(rm.offences.first.line).to eq(2)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe Semicolon do
+        let(:s) { Semicolon.new }
+        before do
+          Semicolon.config = {
+            'AllowAfterParameterListInOneLineMethods' => false,
+            'AllowBeforeEndInOneLineMethods' => true
+          }
+        end
+
+        it 'registers an offence for a single expression' do
+          inspect_source(s,
+                         ['puts "this is a test";'])
+          expect(s.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for several expressions' do
+          inspect_source(s,
+                         ['puts "this is a test"; puts "So is this"'])
+          expect(s.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for one line method with two statements' do
+          inspect_source(s,
+                         ['def foo(a) x(1); y(2); z(3); end'])
+          expect(s.offences.size).to eq(1)
+        end
+
+        it 'accepts semicolon before end if so configured' do
+          inspect_source(s,
+                         ['def foo(a) z(3); end'])
+          expect(s.offences).to be_empty
+        end
+
+        it 'accepts semicolon after params if so configured' do
+          inspect_source(s,
+                         ['def foo(a); z(3) end'])
+          expect(s.offences).to be_empty
+        end
+
+        it 'accepts one line method definitions' do
+          inspect_source(s,
+                         ['def foo1; x(3) end',
+                          'def initialize(*_); end',
+                          'def foo2() x(3); end',
+                          'def foo3; x(3); end'])
+          expect(s.offences).to be_empty
+        end
+
+        it 'accepts one line empty class definitions' do
+          inspect_source(s,
+                         ['# Prefer a single-line format for class ...',
+                          'class Foo < Exception; end',
+                          '',
+                          'class Bar; end'])
+          expect(s.offences).to be_empty
+        end
+
+        it 'accepts one line empty method definitions' do
+          inspect_source(s,
+                         ['# One exception to the rule are empty-body methods',
+                          'def no_op; end',
+                          '',
+                          'def foo; end'])
+          expect(s.offences).to be_empty
+        end
+
+        it 'accepts one line empty module definitions' do
+          inspect_source(s,
+                         ['module Foo; end'])
+          expect(s.offences).to be_empty
+        end
+
+        it 'registers an offence for semicolon at the end no matter what' do
+          inspect_source(s,
+                         ['module Foo; end;'])
+          expect(s.offences.size).to eq(1)
+        end
+
+        it 'accept semicolons inside strings' do
+          inspect_source(s,
+                         ['string = ";',
+                          'multi-line string"'])
+          expect(s.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SingleLineMethods do
+        let(:slm) { SingleLineMethods.new }
+        before do
+          SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => true }
+        end
+
+        it 'registers an offence for a single-line method' do
+          inspect_source(slm,
+                         ['def some_method; body end',
+                          'def link_to(name, url); {:name => name}; end',
+                          'def @table.columns; super; end'])
+          expect(slm.offences.map(&:message)).to eq(
+            [SingleLineMethods::MSG] * 3)
+        end
+
+        it 'registers an offence for an empty method if so configured' do
+          SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => false }
+          inspect_source(slm, ['def no_op; end',
+                               'def self.resource_class=(klass); end',
+                               'def @table.columns; end'])
+          expect(slm.offences.size).to eq(3)
+        end
+
+        it 'accepts a single-line empty method if so configured' do
+          SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => true }
+          inspect_source(slm, ['def no_op; end',
+                               'def self.resource_class=(klass); end',
+                               'def @table.columns; end'])
+          expect(slm.offences).to be_empty
+        end
+
+        it 'accepts a multi-line method' do
+          inspect_source(slm, ['def some_method',
+                               '  body',
+                               'end'])
+          expect(slm.offences).to be_empty
+        end
+
+        it 'does not crash on an method with a capitalized name' do
+          inspect_source(slm, ['def NoSnakeCase',
+                               'end'])
+          expect(slm.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceAfterColon do
+        let(:space) { SpaceAfterColon.new }
+
+        it 'registers an offence for colon without space after it' do
+          inspect_source(space, ['x = w ? {a:3}:4'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Space missing after colon.'] * 2)
+        end
+
+        it 'allows the colons in symbols' do
+          inspect_source(space, ['x = :a'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'allows colons in strings' do
+          inspect_source(space, ["str << ':'"])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceAfterComma do
+        let(:space) { SpaceAfterComma.new }
+
+        it 'registers an offence for block argument commas without space' do
+          inspect_source(space, ['each { |s,t| }'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Space missing after comma.'])
+        end
+
+        it 'registers an offence for array index commas without space' do
+          inspect_source(space, ['formats[0,1]'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Space missing after comma.'])
+        end
+
+        it 'registers an offence for method call arg commas without space' do
+          inspect_source(space, ['a(1,2)'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Space missing after comma.'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceAfterControlKeyword do
+        let(:ap) { SpaceAfterControlKeyword.new }
+
+        it 'registers an offence for normal if' do
+          inspect_source(ap,
+                         ['if(test) then result end'])
+          expect(ap.offences.size).to eq(1)
+        end
+
+        it 'registers an offence for modifier unless' do
+          inspect_source(ap, ['action unless(test)'])
+
+          expect(ap.offences.size).to eq(1)
+        end
+
+        it 'does not get confused by keywords' do
+          inspect_source(ap, ['[:if, :unless].action'])
+          expect(ap.offences).to be_empty
+        end
+
+        it 'does not get confused by the ternary operator' do
+          inspect_source(ap, ['a ? b : c'])
+          expect(ap.offences).to be_empty
+        end
+
+        it 'registers an offence for if, elsif, and unless' do
+          inspect_source(ap,
+                         ['if(a)',
+                          'elsif(b)',
+                          '  unless(c)',
+                          '  end',
+                          'end'])
+          expect(ap.offences.map(&:line)).to eq([1, 2, 3])
+        end
+
+        it 'registers an offence for case and when' do
+          inspect_source(ap,
+                         ['case(a)',
+                          'when(0) then 1',
+                          'end'])
+          expect(ap.offences.map(&:line)).to eq([1, 2])
+        end
+
+        it 'registers an offence for case and when' do
+          inspect_source(ap,
+                         ['case(a)',
+                          'when(0) then 1',
+                          'end'])
+          expect(ap.offences.map(&:line)).to eq([1, 2])
+        end
+
+        it 'registers an offence for while and until' do
+          inspect_source(ap,
+                         ['while(a)',
+                          '  b until(c)',
+                          'end'])
+          expect(ap.offences.map(&:line)).to eq([1, 2])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceAfterSemicolon do
+        let(:space) { SpaceAfterSemicolon.new }
+
+        it 'registers an offence for semicolon without space after it' do
+          inspect_source(space, ['x = 1;y = 2'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Space missing after semicolon.'])
+        end
+
+        it 'does not crash if semicolon is the last character of the file' do
+          inspect_source(space, ['x = 1;'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceAroundBraces do
+        let(:space) { SpaceAroundBraces.new }
+
+        it 'registers an offence for left brace without spaces' do
+          inspect_source(space, ['each{ puts }'])
+          expect(space.offences.map(&:message)).to eq(
+            ["Surrounding space missing for '{'."])
+        end
+
+        it 'registers an offence for right brace without inner space' do
+          inspect_source(space, ['each { puts}'])
+          expect(space.offences.map(&:message)).to eq(
+            ["Space missing to the left of '}'."])
+        end
+
+        it 'accepts an empty hash literal with no space inside' do
+          inspect_source(space,
+                         ['view_hash.each do |view_key|',
+                          'end',
+                          '@views = {}',
+                          ''])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts string interpolation braces with no space inside' do
+          inspect_source(space,
+                         ['"A=#{a}"',
+                          ':"#{b}"',
+                          '/#{c}/',
+                          '`#{d}`',
+                          'sprintf("#{message.gsub(/%/, \'%%\')}", line)'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts braces around a hash literal argument' do
+          inspect_source(space, ["new({'user' => user_params})"])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end