rubocop 0.7.2 → 0.8.0

data/spec/rubocop/cops/favor_join_spec.rb

@@ -9,28 +9,24 @@ module Rubocop
 
       it 'registers an offence for an array followed by string' do
         inspect_source(fj,
-                       'file.rb',
                        ['%w(one two three) * ", "'])
         expect(fj.offences.size).to eq(1)
         expect(fj.offences.map(&:message))
-          .to eq([FavorJoin::ERROR_MESSAGE])
+          .to eq([FavorJoin::MSG])
       end
 
       it 'does not register an offence for numbers' do
         inspect_source(fj,
-                       'file.rb',
                        ['%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,
-                       'file.rb',
                        ['test * ", "'])
         expect(fj.offences).to be_empty
 
         inspect_source(fj,
-                       'file.rb',
                        ['%w(one two three) * test'])
         expect(fj.offences).to be_empty
       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.rb → favor_percent_r_spec.rb}

@@ -8,20 +8,20 @@ module Rubocop
       let(:fpr) { FavorPercentR.new }
 
       it 'registers an offence for // with two slashes in regexp' do
-        inspect_source(fpr, 'file.rb', ['x =~ /home\/\//',
-                                        'y =~ /etc\/top\//'])
+        inspect_source(fpr, ['x =~ /home\/\//',
+                             'y =~ /etc\/top\//'])
         expect(fpr.offences.map(&:message))
-          .to eq([FavorPercentR::ERROR_MESSAGE] * 2)
+          .to eq([FavorPercentR::MSG] * 2)
       end
 
       it 'accepts // with only one slash in regexp' do
-        inspect_source(fpr, 'file.rb', ['x =~ /\/home/',
-                                        'y =~ /\//)'])
+        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, 'file.rb', ['x =~ %r(/home/)'])
+        inspect_source(fpr, ['x =~ %r(/home/)'])
         expect(fpr.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/favor_sprintf_spec.rb

@@ -9,48 +9,42 @@ module Rubocop
 
       it 'registers an offence for a string followed by something' do
         inspect_source(fs,
-                       'file.rb',
                        ['puts "%d" % 10'])
         expect(fs.offences.size).to eq(1)
         expect(fs.offences.map(&:message))
-          .to eq([FavorSprintf::ERROR_MESSAGE])
+          .to eq([FavorSprintf::MSG])
       end
 
       it 'registers an offence for something followed by an array' do
         inspect_source(fs,
-                       'file.rb',
                        ['puts x % [10, 11]'])
         expect(fs.offences.size).to eq(1)
         expect(fs.offences.map(&:message))
-          .to eq([FavorSprintf::ERROR_MESSAGE])
+          .to eq([FavorSprintf::MSG])
       end
 
       it 'does not register an offence for numbers' do
         inspect_source(fs,
-                       'file.rb',
                        ['puts 10 % 4'])
         expect(fs.offences).to be_empty
       end
 
       it 'does not register an offence for ambiguous cases' do
         inspect_source(fs,
-                       'file.rb',
                        ['puts x % 4'])
         expect(fs.offences).to be_empty
 
         inspect_source(fs,
-                       'file.rb',
                        ['puts x % Y'])
         expect(fs.offences).to be_empty
       end
 
       it 'works if the first operand contains embedded expressions' do
         inspect_source(fs,
-                       'file.rb',
                        ['puts "#{x * 5} %d #{@test}" % 10'])
         expect(fs.offences.size).to eq(1)
         expect(fs.offences.map(&:message))
-          .to eq([FavorSprintf::ERROR_MESSAGE])
+          .to eq([FavorSprintf::MSG])
       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

@@ -9,7 +9,6 @@ module Rubocop
 
       it 'registers an offence for empty rescue block' do
         inspect_source(he,
-                       'file.rb',
                        ['begin',
                         '  something',
                         'rescue',
@@ -17,12 +16,11 @@ module Rubocop
                         'end'])
         expect(he.offences.size).to eq(1)
         expect(he.offences.map(&:message))
-          .to eq([HandleExceptions::ERROR_MESSAGE])
+          .to eq([HandleExceptions::MSG])
       end
 
       it 'does not register an offence for rescue with body' do
         inspect_source(he,
-                       'file.rb',
                        ['begin',
                         '  something',
                         '  return',

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

@@ -9,42 +9,36 @@ module Rubocop
 
       it 'registers an offence for comment without leading space' do
         inspect_source(lcs,
-                       'file.rb',
                        ['#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,
-                       'file.rb',
                        ['#'])
         expect(lcs.offences).to be_empty
       end
 
       it 'does not register an offence for more than one space' do
         inspect_source(lcs,
-                       'file.rb',
                        ['#   heavily indented'])
         expect(lcs.offences).to be_empty
       end
 
       it 'does not register an offence for more than one #' do
         inspect_source(lcs,
-                       'file.rb',
                        ['###### heavily indented'])
         expect(lcs.offences).to be_empty
       end
 
       it 'does not register an offence for only #s' do
         inspect_source(lcs,
-                       'file.rb',
                        ['######'])
         expect(lcs.offences).to be_empty
       end
 
       it 'does not register an offence for #! on first line' do
         inspect_source(lcs,
-                       'file.rb',
                        ['#!/usr/bin/ruby',
                         'test'])
         expect(lcs.offences).to be_empty
@@ -52,7 +46,6 @@ module Rubocop
 
       it 'registers an offence for #! after the first line' do
         inspect_source(lcs,
-                       'file.rb',
                        ['test', '#!/usr/bin/ruby'])
         expect(lcs.offences.size).to eq(1)
       end

data/spec/rubocop/cops/line_continuation_spec.rb

@@ -8,13 +8,13 @@ module Rubocop
       let(:lc) { LineContinuation.new }
 
       it 'registers an offence for line continuation char' do
-        inspect_source(lc, 'file.rb',
+        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, 'file.rb',
+        inspect_source(lc,
                        ['result = "test string\\\n"',
                         'more'])
         expect(lc.offences).to be_empty

data/spec/rubocop/cops/line_length_spec.rb

@@ -9,13 +9,13 @@ module Rubocop
       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