rubocop 0.8.3 → 0.9.0

data/spec/rubocop/cops/rescue_exception_spec.rb

@@ -1,125 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe RescueException do
-      let(:re) { RescueException.new }
-
-      it 'registers an offence for rescue from Exception' do
-        inspect_source(re,
-                       ['begin',
-                        '  something',
-                        'rescue Exception',
-                        '  #do nothing',
-                        'end'])
-        expect(re.offences.size).to eq(1)
-        expect(re.offences.map(&:message))
-          .to eq([RescueException::MSG])
-      end
-
-      it 'registers an offence for rescue with ::Exception' do
-        inspect_source(re,
-                       ['begin',
-                        '  something',
-                        'rescue ::Exception',
-                        '  #do nothing',
-                        'end'])
-        expect(re.offences.size).to eq(1)
-        expect(re.offences.map(&:message))
-          .to eq([RescueException::MSG])
-      end
-
-      it 'registers an offence for rescue with StandardError, Exception' do
-        inspect_source(re,
-                       ['begin',
-                        '  something',
-                        'rescue StandardError, Exception',
-                        '  #do nothing',
-                        'end'])
-        expect(re.offences.size).to eq(1)
-        expect(re.offences.map(&:message))
-          .to eq([RescueException::MSG])
-      end
-
-      it 'registers an offence for rescue with Exception => e' do
-        inspect_source(re,
-                       ['begin',
-                        '  something',
-                        'rescue Exception => e',
-                        '  #do nothing',
-                        'end'])
-        expect(re.offences.size).to eq(1)
-        expect(re.offences.map(&:message))
-          .to eq([RescueException::MSG])
-      end
-
-      it 'does not register an offence for rescue with no class' do
-        inspect_source(re,
-                       ['begin',
-                        '  something',
-                        '  return',
-                        'rescue',
-                        '  file.close',
-                        'end'])
-        expect(re.offences).to be_empty
-      end
-
-      it 'does not register an offence for rescue with no class and => e' do
-        inspect_source(re,
-                       ['begin',
-                        '  something',
-                        '  return',
-                        'rescue => e',
-                        '  file.close',
-                        'end'])
-        expect(re.offences).to be_empty
-      end
-
-      it 'does not register an offence for rescue with other class' do
-        inspect_source(re,
-                       ['begin',
-                        '  something',
-                        '  return',
-                        'rescue ArgumentError => e',
-                        '  file.close',
-                        'end'])
-        expect(re.offences).to be_empty
-      end
-
-      it 'does not register an offence for rescue with other classes' do
-        inspect_source(re,
-                       ['begin',
-                        '  something',
-                        '  return',
-                        'rescue EOFError, ArgumentError => e',
-                        '  file.close',
-                        'end'])
-        expect(re.offences).to be_empty
-      end
-
-      it 'does not register an offence for rescue with a module prefix' do
-        inspect_source(re,
-                       ['begin',
-                        '  something',
-                        '  return',
-                        'rescue Test::Exception => e',
-                        '  file.close',
-                        'end'])
-        expect(re.offences).to be_empty
-      end
-
-      it 'does not crash when the splat operator is used in a rescue' do
-        inspect_source(re,
-                       ['ERRORS = [Exception]',
-                        'begin',
-                        '  a = 3 / 0',
-                        'rescue *ERRORS',
-                        '  puts e',
-                        'end'])
-        expect(re.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/rescue_modifier_spec.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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 'does not register an offence for normal rescue' do
-        inspect_source(rm,
-                       ['begin',
-                        '  test',
-                        'rescue',
-                        '  handle',
-                        'end'])
-        expect(rm.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/semicolon_spec.rb

@@ -1,88 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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)
-        expect(s.offences.map(&:message)).to eq([Semicolon::MSG])
-      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)
-        expect(s.offences.map(&:message)).to eq([Semicolon::MSG])
-      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
-    end
-  end
-end

data/spec/rubocop/cops/single_line_methods_spec.rb

@@ -1,50 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe SingleLineMethods do
-      let(:slm) { SingleLineMethods.new }
-      before { SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => true } }
-
-      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

data/spec/rubocop/cops/space_after_colon_spec.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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

data/spec/rubocop/cops/space_after_comma_spec.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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

data/spec/rubocop/cops/space_after_control_keyword_spec.rb

@@ -1,67 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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_number)).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_number)).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_number)).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_number)).to eq([1, 2])
-      end
-    end
-  end
-end

data/spec/rubocop/cops/space_after_semicolon_spec.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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