rubocop 0.9.1 → 0.10.0

data/spec/rubocop/cops/lint/ensure_return_spec.rb

@@ -6,41 +6,38 @@ module Rubocop
   module Cop
     module Lint
       describe EnsureReturn do
-        let(:er) { EnsureReturn.new }
+        let(:cop) { EnsureReturn.new }
 
         it 'registers an offence for return in ensure' do
-          inspect_source(er,
+          inspect_source(cop,
                          ['begin',
                           '  something',
                           'ensure',
                           '  file.close',
                           '  return',
                           'end'])
-          expect(er.offences.size).to eq(1)
-          expect(er.offences.map(&:message))
-            .to eq([EnsureReturn::MSG])
+          expect(cop.offences).to have(1).item
         end
 
         it 'does not register an offence for return outside ensure' do
-          inspect_source(er,
+          inspect_source(cop,
                          ['begin',
                           '  something',
                           '  return',
                           'ensure',
                           '  file.close',
                           'end'])
-          expect(er.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'does not check when ensure block has no body' do
           expect do
-            inspect_source(er,
+            inspect_source(cop,
                            ['begin',
                             '  something',
                             'ensure',
                             'end'])
           end.to_not raise_exception
-
         end
       end
     end

data/spec/rubocop/cops/offence_spec.rb

@@ -43,6 +43,34 @@ module Rubocop
         expect(offence).to be_frozen
       end
 
+      describe '.from_diagnostic' do
+        subject(:offence) { Offence.from_diagnostic(diagnostic) }
+        let(:diagnostic) { Parser::Diagnostic.new(level, message, location) }
+        let(:level) { :warning }
+        let(:message) { 'This is a message' }
+        let(:location) { double('location').as_null_object }
+
+        it 'returns an offence' do
+          expect(offence).to be_a(Offence)
+        end
+
+        it "sets diagnostic's level to offence's severity" do
+          expect(offence.severity).to eq(level)
+        end
+
+        it "sets diagnostic's message to offence's message" do
+          expect(offence.message).to eq(message)
+        end
+
+        it "sets diagnostic's location to offence's location" do
+          expect(offence.location).to eq(location)
+        end
+
+        it 'sets Sytanx as cop name' do
+          expect(offence.cop_name).to eq('Syntax')
+        end
+      end
+
       [:severity, :location, :line, :column, :message, :cop_name].each do |a|
         describe "##{a}" do
           it 'is frozen' do

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

@@ -6,32 +6,42 @@ module Rubocop
   module Cop
     module Style
       describe AndOr do
-        let(:amp) { AndOr.new }
+        let(:cop) { AndOr.new }
 
         it 'registers an offence for OR' do
-          inspect_source(amp,
+          inspect_source(cop,
                          ['test if a or b'])
-          expect(amp.offences.size).to eq(1)
-          expect(amp.messages).to eq(['Use || instead of or.'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq(['Use || instead of or.'])
         end
 
         it 'registers an offence for AND' do
-          inspect_source(amp,
+          inspect_source(cop,
                          ['test if a and b'])
-          expect(amp.offences.size).to eq(1)
-          expect(amp.messages).to eq(['Use && instead of and.'])
+          expect(cop.offences.size).to eq(1)
+          expect(cop.messages).to eq(['Use && instead of and.'])
         end
 
         it 'accepts ||' do
-          inspect_source(amp,
+          inspect_source(cop,
                          ['test if a || b'])
-          expect(amp.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'accepts &&' do
-          inspect_source(amp,
+          inspect_source(cop,
                          ['test if a && b'])
-          expect(amp.offences).to be_empty
+          expect(cop.offences).to be_empty
+        end
+
+        it 'auto-corrects "and" with &&' do
+          new_source = autocorrect_source(cop, 'true and false')
+          expect(new_source).to eq('true && false')
+        end
+
+        it 'auto-corrects "or" with ||' do
+          new_source = autocorrect_source(cop, 'true or false')
+          expect(new_source).to eq('true || false')
         end
       end
     end

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

@@ -22,6 +22,20 @@ module Rubocop
                          ['x.empty?'])
           expect(ascii.offences).to be_empty
         end
+
+        it 'does not get confused by a byte order mark' do
+          bom = "\xef\xbb\xbf"
+          inspect_source(ascii,
+                         [bom + '# encoding: utf-8',
+                          "puts 'foo'"])
+          expect(ascii.offences).to be_empty
+        end
+
+        it 'does not get confused by an empty file' do
+          inspect_source(ascii,
+                         [''])
+          expect(ascii.offences).to be_empty
+        end
       end
     end
   end

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

@@ -6,27 +6,23 @@ module Rubocop
   module Cop
     module Style
       describe AvoidGlobalVars do
-        let(:ap) { AvoidGlobalVars.new }
+        let(:cop) { AvoidGlobalVars.new }
 
         it 'registers an offence for $custom' do
-          inspect_source(ap, ['puts $custom'])
-          expect(ap.offences.size).to eq(1)
+          inspect_source(cop, ['puts $custom'])
+          expect(cop.offences).to have(1).item
         end
 
-        it 'does not register an offence for $"' do
-          inspect_source(ap, ['puts $"'])
-
-          expect(ap.offences).to be_empty
-        end
-
-        it 'does not register an offence for $ORS' do
-          inspect_source(ap, ['puts $0'])
-          expect(ap.offences).to be_empty
+        AvoidGlobalVars::BUILT_IN_VARS.each do |var|
+          it "does not register an offence for built-in variable #{var}" do
+            inspect_source(cop, ["puts #{var}"])
+            expect(cop.offences).to be_empty
+          end
         end
 
         it 'does not register an offence for backrefs like $1' do
-          inspect_source(ap, ['puts $1'])
-          expect(ap.offences).to be_empty
+          inspect_source(cop, ['puts $1'])
+          expect(cop.offences).to be_empty
         end
       end
     end

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

@@ -10,18 +10,33 @@ module Rubocop
 
         it 'registers an offence for character literals' do
           inspect_source(cop, ['x = ?x'])
-          expect(cop.offences.size).to eq(1)
+          expect(cop.offences).to have(1).item
         end
 
         it 'registers an offence for literals like \n' do
           inspect_source(cop, ['x = ?\n'])
-          expect(cop.offences.size).to eq(1)
+          expect(cop.offences).to have(1).item
         end
 
         it 'accepts literals like ?\C-\M-d' do
           inspect_source(cop, ['x = ?\C-\M-d'])
           expect(cop.offences).to be_empty
         end
+
+        it 'accepts ? in a %w literal' do
+          inspect_source(cop, ['%w{? A}'])
+          expect(cop.offences).to be_empty
+        end
+
+        it "auto-corrects ?x to 'x'" do
+          new_source = autocorrect_source(cop, 'x = ?x')
+          expect(new_source).to eq("x = 'x'")
+        end
+
+        it 'auto-corrects ?\n to "\\n"' do
+          new_source = autocorrect_source(cop, 'x = ?\n')
+          expect(new_source).to eq('x = "\\n"')
+        end
       end
     end
   end

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

@@ -6,48 +6,53 @@ module Rubocop
   module Cop
     module Style
       describe ColonMethodCall do
-        let(:smc) { ColonMethodCall.new }
+        let(:cop) { ColonMethodCall.new }
 
         it 'registers an offence for instance method call' do
-          inspect_source(smc,
+          inspect_source(cop,
                          ['test::method_name'])
-          expect(smc.offences.size).to eq(1)
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'registers an offence for instance method call with arg' do
-          inspect_source(smc,
+          inspect_source(cop,
                          ['test::method_name(arg)'])
-          expect(smc.offences.size).to eq(1)
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'registers an offence for class method call' do
-          inspect_source(smc,
+          inspect_source(cop,
                          ['Class::method_name'])
-          expect(smc.offences.size).to eq(1)
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'registers an offence for class method call with arg' do
-          inspect_source(smc,
+          inspect_source(cop,
                          ['Class::method_name(arg, arg2)'])
-          expect(smc.offences.size).to eq(1)
+          expect(cop.offences.size).to eq(1)
         end
 
         it 'does not register an offence for constant access' do
-          inspect_source(smc,
+          inspect_source(cop,
                          ['Tip::Top::SOME_CONST'])
-          expect(smc.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'does not register an offence for nested class' do
-          inspect_source(smc,
+          inspect_source(cop,
                          ['Tip::Top.some_method'])
-          expect(smc.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'does not register an offence for op methods' do
-          inspect_source(smc,
+          inspect_source(cop,
                          ['Tip::Top.some_method[3]'])
-          expect(smc.offences).to be_empty
+          expect(cop.offences).to be_empty
+        end
+
+        it 'auto-corrects "::" with "."' do
+          new_source = autocorrect_source(cop, 'test::method')
+          expect(new_source).to eq('test.method')
         end
       end
     end

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe CommentAnnotation do
+        let(:cop) { CommentAnnotation.new }
+
+        it 'registers an offence for a missing colon' do
+          inspect_source(cop, ['# TODO make better'])
+          expect(cop.offences).to have(1).item
+        end
+
+        context 'when used with the clang formatter' do
+          let(:formatter) { Formatter::ClangStyleFormatter.new(output) }
+          let(:output) { StringIO.new }
+
+          it 'marks the annotation keyword' do
+            inspect_source(cop, ['# TODO:make better'])
+            formatter.report_file('t', cop.offences)
+            expect(output.string).to eq(["t:1:3: C: #{CommentAnnotation::MSG}",
+                                         '# TODO:make better',
+                                         '  ^^^^^',
+                                         ''].join("\n"))
+          end
+        end
+
+        it 'registers an offence for lower case' do
+          inspect_source(cop, ['# fixme: does not work'])
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'registers an offence for capitalized annotation keyword' do
+          inspect_source(cop, ['# Optimize: does not work'])
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'registers an offence for upper case with colon but no note' do
+          inspect_source(cop, ['# HACK:'])
+          expect(cop.offences).to have(1).item
+        end
+
+        it 'accepts upper case keyword with colon, space and note' do
+          inspect_source(cop, ['# REVIEW: not sure about this'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts upper case keyword alone' do
+          inspect_source(cop, ['# OPTIMIZE'])
+          expect(cop.offences).to be_empty
+        end
+
+        it 'accepts a comment that is obviously a code example' do
+          inspect_source(cop, ['# Todo.destroy(1)'])
+          expect(cop.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -43,6 +43,13 @@ module Rubocop
 
           expect(encoding.offences).to be_empty
         end
+
+        it 'accepts encoding inserted by magic_encoding gem', ruby: 1.9 do
+          inspect_source(encoding, ['# -*- encoding : utf-8 -*-',
+                                    'def foo() end'])
+
+          expect(encoding.offences.map(&:message)).to be_empty
+        end
       end
     end
   end

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

@@ -6,10 +6,13 @@ module Rubocop
   module Cop
     module Style
       describe ParenthesesAroundCondition do
-        let(:pac) { ParenthesesAroundCondition.new }
+        let(:cop) { ParenthesesAroundCondition.new }
+        before do
+          ParenthesesAroundCondition.config = { 'AllowSafeAssignment' => true }
+        end
 
         it 'registers an offence for parentheses around condition' do
-          inspect_source(pac, ['if (x > 10)',
+          inspect_source(cop, ['if (x > 10)',
                                'elsif (x < 3)',
                                'end',
                                'unless (x > 10)',
@@ -23,11 +26,11 @@ module Rubocop
                                'x += 1 while (x < 10)',
                                'x += 1 until (x < 10)',
                               ])
-          expect(pac.offences.size).to eq(9)
+          expect(cop.offences.size).to eq(9)
         end
 
         it 'accepts condition without parentheses' do
-          inspect_source(pac, ['if x > 10',
+          inspect_source(cop, ['if x > 10',
                                'end',
                                'unless x > 10',
                                'end',
@@ -40,18 +43,43 @@ module Rubocop
                                'x += 1 while x < 10',
                                'x += 1 until x < 10',
                               ])
-          expect(pac.offences).to be_empty
+          expect(cop.offences).to be_empty
         end
 
         it 'is not confused by leading brace in subexpression' do
-          inspect_source(pac, ['(a > b) && other ? one : two'])
-          expect(pac.offences).to be_empty
+          inspect_source(cop, ['(a > b) && other ? one : two'])
+          expect(cop.offences).to be_empty
         end
 
         it 'is not confused by unbalanced parentheses' do
-          inspect_source(pac, ['if (a + b).c()',
+          inspect_source(cop, ['if (a + b).c()',
                                'end'])
-          expect(pac.offences).to be_empty
+          expect(cop.offences).to be_empty
+        end
+
+        context 'safe assignment is allowed' do
+          it 'accepts = in condition surrounded with braces' do
+            inspect_source(cop,
+                           ['if (test = 10)',
+                            'end'
+                           ])
+            expect(cop.offences).to be_empty
+          end
+
+        end
+
+        context 'safe assignment is not allowed' do
+          before do
+            ParenthesesAroundCondition.config['AllowSafeAssignment'] = false
+          end
+
+          it 'does not accepts = in condition surrounded with braces' do
+            inspect_source(cop,
+                           ['if (test = 10)',
+                            'end'
+                           ])
+            expect(cop.offences.size).to eq(1)
+          end
         end
       end
     end