sabat-rubocop 0.9.0

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe FavorJoin do
+        let(:fj) { FavorJoin.new }
+
+        it 'registers an offence for an array followed by string' do
+          inspect_source(fj,
+                         ['%w(one two three) * ", "'])
+          expect(fj.offences.size).to eq(1)
+          expect(fj.offences.map(&:message))
+            .to eq([FavorJoin::MSG])
+        end
+
+        it 'does not register an offence for numbers' do
+          inspect_source(fj,
+                         ['%w(one two three) * 4'])
+          expect(fj.offences).to be_empty
+        end
+
+        it 'does not register an offence for ambiguous cases' do
+          inspect_source(fj,
+                         ['test * ", "'])
+          expect(fj.offences).to be_empty
+
+          inspect_source(fj,
+                         ['%w(one two three) * test'])
+          expect(fj.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe FavorModifier do
+        let(:if_unless) { IfUnlessModifier.new }
+        let(:while_until) { WhileUntilModifier.new }
+        before { LineLength.config = { 'Max' => 79 } }
+
+        it 'registers an offence for multiline if that fits on one line' do
+          # This if statement fits exactly on one line if written as a
+          # modifier.
+          condition = 'a' * 38
+          body = 'b' * 35
+          expect("  #{body} if #{condition}".length).to eq(79)
+
+          inspect_source(if_unless,
+                         ["  if #{condition}",
+                          "    #{body}",
+                          '  end'])
+          expect(if_unless.offences.map(&:message)).to eq(
+            ['Favor modifier if/unless usage when you have a single-line' +
+             ' body. Another good alternative is the usage of control flow' +
+             ' &&/||.'])
+        end
+
+        it "accepts multiline if that doesn't fit on one line" do
+          check_too_long(if_unless, 'if')
+        end
+
+        it 'accepts multiline if whose body is more than one line' do
+          check_short_multiline(if_unless, 'if')
+        end
+
+        it 'registers an offence for multiline unless that fits on one line' do
+          inspect_source(if_unless, ['unless a',
+                                    '  b',
+                                    'end'])
+          expect(if_unless.offences.map(&:message)).to eq(
+            ['Favor modifier if/unless usage when you have a single-line' +
+             ' body. Another good alternative is the usage of control flow' +
+             ' &&/||.'])
+        end
+
+        it 'accepts code with EOL comment since user might want to keep it' do
+          inspect_source(if_unless, ['unless a',
+                                     '  b # A comment',
+                                     'end'])
+          expect(if_unless.offences).to be_empty
+        end
+
+        it 'accepts if-else-end' do
+          inspect_source(if_unless,
+                         ['if args.last.is_a? Hash then args.pop else ' +
+                          'Hash.new end'])
+          expect(if_unless.offences.map(&:message)).to be_empty
+        end
+
+        it "accepts multiline unless that doesn't fit on one line" do
+          check_too_long(while_until, 'unless')
+        end
+
+        it 'accepts multiline unless whose body is more than one line' do
+          check_short_multiline(while_until, 'unless')
+        end
+
+        it 'registers an offence for multiline while that fits on one line' do
+          check_really_short(while_until, 'while')
+        end
+
+        it "accepts multiline while that doesn't fit on one line" do
+          check_too_long(while_until, 'while')
+        end
+
+        it 'accepts multiline while whose body is more than one line' do
+          check_short_multiline(while_until, 'while')
+        end
+
+        it 'registers an offence for multiline until that fits on one line' do
+          check_really_short(while_until, 'until')
+        end
+
+        it "accepts multiline until that doesn't fit on one line" do
+          check_too_long(while_until, 'until')
+        end
+
+        it 'accepts multiline until whose body is more than one line' do
+          check_short_multiline(while_until, 'until')
+        end
+
+        it 'accepts an empty condition' do
+          check_empty(if_unless, 'if')
+          check_empty(if_unless, 'unless')
+          check_empty(while_until, 'while')
+          check_empty(while_until, 'until')
+        end
+
+        it 'accepts if/elsif' do
+          inspect_source(if_unless, ['if test',
+                                     '  something',
+                                     'elsif test2',
+                                     '  something_else',
+                                     'end'])
+          expect(if_unless.offences).to be_empty
+        end
+
+        it 'accepts modifier while' do
+          inspect_source(while_until, ['ala while bala'])
+          expect(while_until.offences).to be_empty
+        end
+
+        it 'accepts modifier until' do
+          inspect_source(while_until, ['ala until bala'])
+          expect(while_until.offences).to be_empty
+        end
+
+        def check_empty(cop, keyword)
+          inspect_source(cop, ["#{keyword} cond",
+                               'end'])
+          expect(cop.offences).to be_empty
+        end
+
+        def check_really_short(cop, keyword)
+          inspect_source(cop, ["#{keyword} a",
+                               '  b',
+                               'end'])
+          expect(cop.offences.map(&:message)).to eq(
+            ['Favor modifier while/until usage when you have a single-line ' +
+             'body.'])
+        end
+
+        def check_too_long(cop, keyword)
+          # This statement is one character too long to fit.
+          condition = 'a' * (40 - keyword.length)
+          body = 'b' * 36
+          expect("  #{body} #{keyword} #{condition}".length).to eq(80)
+
+          inspect_source(cop,
+                         ["  #{keyword} #{condition}",
+                          "    #{body}",
+                          '  end'])
+
+          expect(cop.offences).to be_empty
+        end
+
+        def check_short_multiline(cop, keyword)
+          inspect_source(cop,
+                         ["#{keyword} ENV['COVERAGE']",
+                          "  require 'simplecov'",
+                          '  SimpleCov.start',
+                          'end'])
+          expect(cop.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe FavorSprintf do
+        let(:fs) { FavorSprintf.new }
+
+        it 'registers an offence for a string followed by something' do
+          inspect_source(fs,
+                         ['puts "%d" % 10'])
+          expect(fs.offences.size).to eq(1)
+          expect(fs.offences.map(&:message))
+            .to eq([FavorSprintf::MSG])
+        end
+
+        it 'registers an offence for something followed by an array' do
+          inspect_source(fs,
+                         ['puts x % [10, 11]'])
+          expect(fs.offences.size).to eq(1)
+          expect(fs.offences.map(&:message))
+            .to eq([FavorSprintf::MSG])
+        end
+
+        it 'does not register an offence for numbers' do
+          inspect_source(fs,
+                         ['puts 10 % 4'])
+          expect(fs.offences).to be_empty
+        end
+
+        it 'does not register an offence for ambiguous cases' do
+          inspect_source(fs,
+                         ['puts x % 4'])
+          expect(fs.offences).to be_empty
+
+          inspect_source(fs,
+                         ['puts x % Y'])
+          expect(fs.offences).to be_empty
+        end
+
+        it 'works if the first operand contains embedded expressions' do
+          inspect_source(fs,
+                         ['puts "#{x * 5} %d #{@test}" % 10'])
+          expect(fs.offences.size).to eq(1)
+          expect(fs.offences.map(&:message))
+            .to eq([FavorSprintf::MSG])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe FavorUnlessOverNegatedIf do
+        let(:fav_unless) { FavorUnlessOverNegatedIf.new }
+
+        it 'registers an offence for if with exclamation point condition' do
+          inspect_source(fav_unless,
+                         ['if !a_condition',
+                          '  some_method',
+                          'end',
+                          'some_method if !a_condition',
+                         ])
+          expect(fav_unless.offences.map(&:message)).to eq(
+            ['Favor unless (or control flow or) over if for negative ' +
+             'conditions.'] * 2)
+        end
+
+        it 'registers an offence for if with "not" condition' do
+          inspect_source(fav_unless,
+                         ['if not a_condition',
+                          '  some_method',
+                          'end',
+                          'some_method if not a_condition'])
+          expect(fav_unless.offences.map(&:message)).to eq(
+            ['Favor unless (or control flow or) over if for negative ' +
+             'conditions.'] * 2)
+          expect(fav_unless.offences.map(&:line)).to eq([1, 4])
+        end
+
+        it 'accepts an if/else with negative condition' do
+          inspect_source(fav_unless,
+                         ['if !a_condition',
+                          '  some_method',
+                          'else',
+                          '  something_else',
+                          'end',
+                          'if not a_condition',
+                          '  some_method',
+                          'elsif other_condition',
+                          '  something_else',
+                          'end'])
+          expect(fav_unless.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts an if where only part of the contition is negated' do
+          inspect_source(fav_unless,
+                         ['if !condition && another_condition',
+                          '  some_method',
+                          'end',
+                          'if not condition or another_condition',
+                          '  some_method',
+                          'end',
+                          'some_method if not condition or another_condition'])
+          expect(fav_unless.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe FavorUntilOverNegatedWhile do
+        let(:fav_until) { FavorUntilOverNegatedWhile.new }
+
+        it 'registers an offence for while with exclamation point condition' do
+          inspect_source(fav_until,
+                         ['while !a_condition',
+                          '  some_method',
+                          'end',
+                          'some_method while !a_condition',
+                         ])
+          expect(fav_until.offences.map(&:message)).to eq(
+            ['Favor until over while for negative conditions.'] * 2)
+        end
+
+        it 'registers an offence for while with "not" condition' do
+          inspect_source(fav_until,
+                         ['while (not a_condition)',
+                          '  some_method',
+                          'end',
+                          'some_method while not a_condition'])
+          expect(fav_until.offences.map(&:message)).to eq(
+            ['Favor until over while for negative conditions.'] * 2)
+          expect(fav_until.offences.map(&:line)).to eq([1, 4])
+        end
+
+        it 'accepts an while where only part of the contition is negated' do
+          inspect_source(fav_until,
+                         ['while !a_condition && another_condition',
+                          '  some_method',
+                          'end',
+                          'while not a_condition or another_condition',
+                          '  some_method',
+                          'end',
+                          'some_method while not a_condition or other_cond'])
+          expect(fav_until.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe HashSyntax do
+        let(:hash_syntax) { HashSyntax.new }
+
+        it 'registers offence for hash rocket syntax when new is possible' do
+          inspect_source(hash_syntax, ['x = { :a => 0 }'])
+          expect(hash_syntax.offences.map(&:message)).to eq(
+            ['Ruby 1.8 hash syntax detected'])
+        end
+
+        it 'registers an offence for mixed syntax when new is possible' do
+          inspect_source(hash_syntax, ['x = { :a => 0, b: 1 }'])
+          expect(hash_syntax.offences.map(&:message)).to eq(
+            ['Ruby 1.8 hash syntax detected'])
+        end
+
+        it 'registers an offence for hash rockets in method calls' do
+          inspect_source(hash_syntax, ['func(3, :a => 0)'])
+          expect(hash_syntax.offences.map(&:message)).to eq(
+            ['Ruby 1.8 hash syntax detected'])
+        end
+
+        it 'accepts hash rockets when keys have different types' do
+          inspect_source(hash_syntax, ['x = { :a => 0, "b" => 1 }'])
+          expect(hash_syntax.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts hash rockets when keys special symbols in them' do
+          inspect_source(hash_syntax, ['x = { :"t o" => 0, :"\xab" => 1 }'])
+          expect(hash_syntax.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts new syntax in a hash literal' do
+          inspect_source(hash_syntax, ['x = { a: 0, b: 1 }'])
+          expect(hash_syntax.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts new syntax in method calls' do
+          inspect_source(hash_syntax, ['func(3, a: 0)'])
+          expect(hash_syntax.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe IfWithSemicolon do
+        let(:iws) { IfWithSemicolon.new }
+
+        it 'registers an offence for one line if/;/end' do
+          inspect_source(iws, ['if cond; run else dont end'])
+          expect(iws.offences.map(&:message)).to eq(
+            ['Never use if x; Use the ternary operator instead.'])
+        end
+
+        it 'can handle modifier conditionals' do
+          inspect_source(iws, ['class Hash',
+                               'end if RUBY_VERSION < "1.8.7"'])
+          expect(iws.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe Lambda do
+        let(:lambda) { Lambda.new }
+
+        it 'registers an offence for an old single-line lambda call' do
+          inspect_source(lambda, ['f = lambda { |x| x }'])
+          expect(lambda.offences.size).to eq(1)
+          expect(lambda.messages).to eq([Lambda::SINGLE_MSG])
+        end
+
+        it 'accepts the new lambda literal with single-line body' do
+          inspect_source(lambda, ['lambda = ->(x) { x }',
+                                     'lambda.(1)'])
+          expect(lambda.offences).to be_empty
+        end
+
+        it 'registers an offence for a new multi-line lambda call' do
+          inspect_source(lambda, ['f = ->(x) do',
+                                          '  x',
+                                          'end'])
+          expect(lambda.offences.size).to eq(1)
+          expect(lambda.messages).to eq([Lambda::MULTI_MSG])
+        end
+
+        it 'accepts the old lambda syntax with multi-line body' do
+          inspect_source(lambda, ['l = lambda do |x|',
+                                          '  x',
+                                          'end'])
+          expect(lambda.offences).to be_empty
+        end
+
+        it 'accepts the lambda call outside of block' do
+          inspect_source(lambda, ['l = lambda.test'])
+          expect(lambda.offences).to be_empty
+        end
+      end
+    end
+  end
+end