rubocop 0.4.0 → 0.8.0

data/spec/rubocop/cops/favor_join_spec.rb

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

data/spec/rubocop/cops/favor_modifier_spec.rb

@@ -4,13 +4,14 @@ require 'spec_helper'
 
 module Rubocop
   module Cop
-    describe FavorModifier do
+    describe FavorModifier, broken: true do
       let(:if_until) { 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.
-        inspect_source(if_until, 'file.rb',
+        inspect_source(if_until,
                        ['if a_condition_that_is_just_short_enough',
                         '  some_long_metod_name(followed_by_args)',
                         'end'])
@@ -28,23 +29,24 @@ module Rubocop
       end
 
       it 'registers an offence for multiline unless that fits on one line' do
-        inspect_source(if_until, 'file.rb', ['unless a',
-                                        '  b',
-                                        'end'])
+        inspect_source(if_until, ['unless a',
+                                  '  b',
+                                  'end'])
         expect(if_until.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 and/or.'])
       end
 
       it 'accepts code with EOL comment since user might want to keep it' do
-        inspect_source(if_until, 'file.rb', ['unless a',
-                                             '  b # A comment',
-                                             'end'])
+        pending
+        inspect_source(if_until, ['unless a',
+                                  '  b # A comment',
+                                  'end'])
         expect(if_until.offences.map(&:message)).to be_empty
       end
 
       it 'accepts if-else-end' do
-        inspect_source(if_until, 'file.rb',
+        inspect_source(if_until,
                        ['if args.last.is_a? Hash then args.pop else ' +
                         'Hash.new end'])
         expect(if_until.offences.map(&:message)).to be_empty
@@ -83,16 +85,16 @@ module Rubocop
       end
 
       def check_really_short(cop, keyword)
-        inspect_source(cop, 'file.rb', ["#{keyword} a",
-                                        '  b',
-                                        'end'])
+        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)
-        inspect_source(cop, 'file.rb',
+        inspect_source(cop,
                        ["  #{keyword} a_lengthy_condition_that_goes_on_and_on",
                         '    some_long_metod_name(followed_by_args)',
                         '  end'])
@@ -100,7 +102,7 @@ module Rubocop
       end
 
       def check_short_multiline(cop, keyword)
-        inspect_source(cop, 'file.rb',
+        inspect_source(cop,
                        ["#{keyword} ENV['COVERAGE']",
                         "  require 'simplecov'",
                         '  SimpleCov.start',

data/spec/rubocop/cops/favor_percent_r_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe FavorPercentR do
+      let(:fpr) { FavorPercentR.new }
+
+      it 'registers an offence for // with two slashes in regexp' do
+        inspect_source(fpr, ['x =~ /home\/\//',
+                             'y =~ /etc\/top\//'])
+        expect(fpr.offences.map(&:message))
+          .to eq([FavorPercentR::MSG] * 2)
+      end
+
+      it 'accepts // with only one slash in regexp' do
+        inspect_source(fpr, ['x =~ /\/home/',
+                             'y =~ /\//'])
+        expect(fpr.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts %r delimiters for regexp with two or more slashes' do
+        inspect_source(fpr, ['x =~ %r(/home/)'])
+        expect(fpr.offences.map(&:message)).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/favor_sprintf_spec.rb

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

data/spec/rubocop/cops/favor_unless_over_negated_if_spec.rb

@@ -8,7 +8,7 @@ module Rubocop
       let(:fav_unless) { FavorUnlessOverNegatedIf.new }
 
       it 'registers an offence for if with exclamation point condition' do
-        inspect_source(fav_unless, 'file.rb',
+        inspect_source(fav_unless,
                        ['if !a_condition',
                         '  some_method',
                         'end',
@@ -20,7 +20,7 @@ module Rubocop
       end
 
       it 'registers an offence for if with "not" condition' do
-        inspect_source(fav_unless, 'file.rb',
+        inspect_source(fav_unless,
                        ['if not a_condition',
                         '  some_method',
                         'end',
@@ -32,7 +32,7 @@ module Rubocop
       end
 
       it 'accepts an if/else with negative condition' do
-        inspect_source(fav_unless, 'file.rb',
+        inspect_source(fav_unless,
                        ['if !a_condition',
                         '  some_method',
                         'else',
@@ -47,7 +47,7 @@ module Rubocop
       end
 
       it 'accepts an if where only part of the contition is negated' do
-        inspect_source(fav_unless, 'file.rb',
+        inspect_source(fav_unless,
                        ['if !a_condition && another_condition',
                         '  some_method',
                         'end',

data/spec/rubocop/cops/favor_until_over_negated_while_spec.rb

@@ -8,7 +8,7 @@ module Rubocop
       let(:fav_until) { FavorUntilOverNegatedWhile.new }
 
       it 'registers an offence for while with exclamation point condition' do
-        inspect_source(fav_until, 'file.rb',
+        inspect_source(fav_until,
                        ['while !a_condition',
                         '  some_method',
                         'end',
@@ -19,7 +19,7 @@ module Rubocop
       end
 
       it 'registers an offence for while with "not" condition' do
-        inspect_source(fav_until, 'file.rb',
+        inspect_source(fav_until,
                        ['while (not a_condition)',
                         '  some_method',
                         'end',
@@ -30,7 +30,7 @@ module Rubocop
       end
 
       it 'accepts an while where only part of the contition is negated' do
-        inspect_source(fav_until, 'file.rb',
+        inspect_source(fav_until,
                        ['while !a_condition && another_condition',
                         '  some_method',
                         'end',

data/spec/rubocop/cops/handle_exceptions_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe HandleExceptions do
+      let(:he) { HandleExceptions.new }
+
+      it 'registers an offence for empty rescue block' do
+        inspect_source(he,
+                       ['begin',
+                        '  something',
+                        'rescue',
+                        '  #do nothing',
+                        'end'])
+        expect(he.offences.size).to eq(1)
+        expect(he.offences.map(&:message))
+          .to eq([HandleExceptions::MSG])
+      end
+
+      it 'does not register an offence for rescue with body' do
+        inspect_source(he,
+                       ['begin',
+                        '  something',
+                        '  return',
+                        'rescue',
+                        '  file.close',
+                        'end'])
+        expect(he.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/hash_syntax_spec.rb

@@ -8,35 +8,40 @@ module Rubocop
       let(:hash_syntax) { HashSyntax.new }
 
       it 'registers an offence for hash rocket syntax when new is possible' do
-        inspect_source(hash_syntax, '', ['x = { :a => 0 }'])
+        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 }'])
+        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)'])
+        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 }'])
+        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 }'])
+        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)'])
+        inspect_source(hash_syntax, ['func(3, a: 0)'])
         expect(hash_syntax.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/if_with_semicolon_spec.rb

@@ -8,10 +8,16 @@ module Rubocop
       let(:iws) { IfWithSemicolon.new }
 
       it 'registers an offence for one line if/;/end' do
-        inspect_source(iws, '', ['if cond; run else dont end'])
+        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

data/spec/rubocop/cops/leading_comment_space_spec.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe LeadingCommentSpace do
+      let(:lcs) { LeadingCommentSpace.new }
+
+      it 'registers an offence for comment without leading space' do
+        inspect_source(lcs,
+                       ['#missing space'])
+        expect(lcs.offences.size).to eq(1)
+      end
+
+      it 'does not register an offence for # followed by no text' do
+        inspect_source(lcs,
+                       ['#'])
+        expect(lcs.offences).to be_empty
+      end
+
+      it 'does not register an offence for more than one space' do
+        inspect_source(lcs,
+                       ['#   heavily indented'])
+        expect(lcs.offences).to be_empty
+      end
+
+      it 'does not register an offence for more than one #' do
+        inspect_source(lcs,
+                       ['###### heavily indented'])
+        expect(lcs.offences).to be_empty
+      end
+
+      it 'does not register an offence for only #s' do
+        inspect_source(lcs,
+                       ['######'])
+        expect(lcs.offences).to be_empty
+      end
+
+      it 'does not register an offence for #! on first line' do
+        inspect_source(lcs,
+                       ['#!/usr/bin/ruby',
+                        'test'])
+        expect(lcs.offences).to be_empty
+      end
+
+      it 'registers an offence for #! after the first line' do
+        inspect_source(lcs,
+                       ['test', '#!/usr/bin/ruby'])
+        expect(lcs.offences.size).to eq(1)
+      end
+    end
+  end
+end

data/spec/rubocop/cops/line_continuation_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe LineContinuation do
+      let(:lc) { LineContinuation.new }
+
+      it 'registers an offence for line continuation char' do
+        inspect_source(lc,
+                       ['test = 5 \\', '+ 5'])
+        expect(lc.offences.size).to eq(1)
+      end
+
+      it 'does not register an offence for cont char in a string' do
+        inspect_source(lc,
+                       ['result = "test string\\\n"',
+                        'more'])
+        expect(lc.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/line_length_spec.rb

@@ -6,15 +6,16 @@ module Rubocop
   module Cop
     describe LineLength do
       let(:ll) { LineLength.new }
+      before { LineLength.config = { 'Max' => 79 } }
 
       it "registers an offence for a line that's 80 characters wide" do
-        ll.inspect('file.rb', ['#' * 80], nil, nil)
+        ll.inspect(['#' * 80], nil, nil, nil)
         expect(ll.offences.size).to eq(1)
         expect(ll.offences.first.message).to eq('Line is too long. [80/79]')
       end
 
       it "accepts a line that's 79 characters wide" do
-        ll.inspect('file.rb', ['#' * 79], nil, nil)
+        ll.inspect(['#' * 79], nil, nil, nil)
         expect(ll.offences).to be_empty
       end
     end

data/spec/rubocop/cops/loop_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Loop do
+      let(:loop) { Loop.new }
+
+      it 'registers an offence for begin/end/while' do
+        inspect_source(loop, ['begin something; top; end while test'])
+        expect(loop.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for begin/end/until' do
+        inspect_source(loop, ['begin something; top; end until test'])
+        expect(loop.offences.size).to eq(1)
+      end
+
+      it 'accepts normal while' do
+        inspect_source(loop, ['while test; one; two; end'])
+        expect(loop.offences).to be_empty
+      end
+
+      it 'accepts normal until' do
+        inspect_source(loop, ['until test; one; two; end'])
+        expect(loop.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/method_and_variable_snake_case_spec.rb

@@ -7,20 +7,55 @@ module Rubocop
     describe MethodAndVariableSnakeCase do
       let(:snake_case) { MethodAndVariableSnakeCase.new }
 
-      it 'registers an offence for camel case in names' do
-        inspect_source(snake_case, 'file.rb',
+      it 'registers an offence for camel case in instance method name' do
+        inspect_source(snake_case,
                        ['def myMethod',
-                        '  myLocal = 1',
-                        '  self.mySetter = 2',
-                        '  @myAttribute = 3',
+                        '  # ...',
                         'end',
                        ])
         expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for methods and variables.'] * 4)
+          ['Use snake_case for methods and variables.'])
+      end
+
+      it 'registers an offence for camel case in singleton method name' do
+        inspect_source(snake_case,
+                       ['def self.myMethod',
+                        '  # ...',
+                        'end',
+                       ])
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
+      end
+
+      it 'registers an offence for camel case in local variable name' do
+        inspect_source(snake_case, ['myLocal = 1'])
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
+      end
+
+      it 'registers an offence for camel case in instance variable name' do
+        inspect_source(snake_case, ['@myAttribute = 3'])
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
+      end
+
+      it 'registers an offence for camel case in setter name' do
+        inspect_source(snake_case, ['self.mySetter = 2'])
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
+      end
+
+      it 'registers an offence for capitalized camel case' do
+        inspect_source(snake_case,
+                       ['def MyMethod',
+                        'end',
+                       ])
+        expect(snake_case.offences.map(&:message)).to eq(
+          ['Use snake_case for methods and variables.'])
       end
 
       it 'accepts snake case in names' do
-        inspect_source(snake_case, 'file.rb',
+        inspect_source(snake_case,
                        ['def my_method',
                         '  my_local_html = 1',
                         '  self.my_setter = 2',
@@ -31,7 +66,7 @@ module Rubocop
       end
 
       it 'registers an offence for mixed snake case and camel case' do
-        inspect_source(snake_case, 'file.rb',
+        inspect_source(snake_case,
                        ['def visit_Arel_Nodes_SelectStatement',
                         'end'])
         expect(snake_case.offences.map(&:message)).to eq(
@@ -39,7 +74,18 @@ module Rubocop
       end
 
       it 'accepts screaming snake case globals' do
-        inspect_source(snake_case, 'file.rb', ['$MY_GLOBAL = 0'])
+        inspect_source(snake_case, ['$MY_GLOBAL = 0'])
+        expect(snake_case.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts screaming snake case constants' do
+        inspect_source(snake_case, ['MY_CONSTANT = 0'])
+        expect(snake_case.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts assigning to camel case constant' do
+        inspect_source(snake_case,
+                       ['Paren = Struct.new :left, :right, :kind'])
         expect(snake_case.offences.map(&:message)).to be_empty
       end
     end