rubocop 0.6.1 → 0.7.0

data/spec/rubocop/cops/alias_spec.rb

@@ -31,6 +31,13 @@ module Rubocop
                        ['alias_method :ala, :bala'])
         expect(a.offences).to be_empty
       end
+
+      it 'does not register an offence for :alias' do
+        inspect_source(a,
+                       'file.rb',
+                       ['[:alias, :ala, :bala]'])
+        expect(a.offences).to be_empty
+      end
     end
   end
 end

data/spec/rubocop/cops/array_literal_spec.rb

@@ -16,7 +16,14 @@ module Rubocop
           .to eq([ArrayLiteral::ERROR_MESSAGE])
       end
 
-      it 'registers an offence for Array.new'
+      it 'registers an offence for Array.new' do
+        inspect_source(a,
+                       'file.rb',
+                       ['test = Array.new'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([ArrayLiteral::ERROR_MESSAGE])
+      end
 
       it 'does not register an offence for Array.new(3)' do
         inspect_source(a,

data/spec/rubocop/cops/avoid_for_spec.rb

@@ -11,12 +11,26 @@ module Rubocop
         inspect_source(af,
                        'file.rb',
                        ['for n in [1, 2, 3] do',
-                        'puts n',
+                        '  puts n',
                         'end'])
         expect(af.offences.size).to eq(1)
         expect(af.offences.map(&:message))
           .to eq([AvoidFor::ERROR_MESSAGE])
       end
+
+      it 'does not register an offence for :for' do
+        inspect_source(af,
+                       'file.rb',
+                       ['[:for, :ala, :bala]'])
+        expect(af.offences).to be_empty
+      end
+
+      it 'does not register an offence for def for' do
+        inspect_source(af,
+                       'file.rb',
+                       ['def for; end'])
+        expect(af.offences).to be_empty
+      end
     end
   end
 end

data/spec/rubocop/cops/avoid_global_vars.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AvoidGlobalVars do
+      let(:ap) { AvoidGlobalVars.new }
+
+      it 'registers an offence for $custom' do
+        inspect_source(ap, 'file.rb', ['puts $custom'])
+        expect(ap.offences.size).to eq(1)
+      end
+
+      it 'does not register an offence for $"' do
+        inspect_source(ap, 'file.rb', ['puts $"'])
+
+        expect(ap.offences).to be_empty
+      end
+
+      it 'does not register an offence for $ORS' do
+        inspect_source(ap, 'file.rb', ['puts $0'])
+        expect(ap.offences).to be_empty
+      end
+
+      it 'does not register an offence for backrefs like $1' do
+        inspect_source(ap, 'file.rb', ['puts $1'])
+        expect(ap.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/block_comments_spec.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe BlockComments do
+      let(:block) { BlockComments.new }
+
+      it 'registers an offence for block comments' do
+        inspect_source(block,
+                       'file.rb',
+                       ['=begin',
+                        'comment',
+                        '=end'])
+        expect(block.offences.size).to eq(1)
+        expect(block.offences.map(&:message))
+          .to eq([BlockComments::ERROR_MESSAGE])
+      end
+
+      it 'accepts regular comments' do
+        inspect_source(block,
+                       'file.rb',
+                       ['# comment'])
+        expect(block.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/brace_after_percent_spec.rb

@@ -6,21 +6,27 @@ module Rubocop
   module Cop
     describe BraceAfterPercent do
       let(:bap) { BraceAfterPercent.new }
+      literals = %w(q Q r i I w W x s)
 
-      it 'registers an offence for %w[' do
-        inspect_source(bap,
-                       'file.rb',
-                       ['puts %w[test top]'])
-        expect(bap.offences.size).to eq(1)
-        expect(bap.offences.map(&:message))
-          .to eq([BraceAfterPercent::ERROR_MESSAGE])
-      end
+      literals.each do |literal|
+        # %i and %I are new in ruby 2.0
+        tag = literal.downcase == 'i' ? { ruby: 2.0 } : {}
+
+        it "registers an offence for %#{literal}[", tag  do
+          inspect_source(bap,
+                         'file.rb',
+                         ["puts %#{literal}[test top]"])
+          expect(bap.offences.size).to eq(1)
+          expect(bap.offences.map(&:message))
+            .to eq([BraceAfterPercent::ERROR_MESSAGE])
+        end
 
-      it 'registers an offence for %w(' do
-        inspect_source(bap,
-                       'file.rb',
-                       ['puts %w(test top)'])
-        expect(bap.offences).to be_empty
+        it "does not registers an offence for %#{literal}(", tag do
+          inspect_source(bap,
+                         'file.rb',
+                         ["puts %#{literal}(test top)"])
+          expect(bap.offences).to be_empty
+        end
       end
     end
   end

data/spec/rubocop/cops/{indentation_spec.rb → case_indentation_spec.rb}

@@ -4,8 +4,8 @@ require 'spec_helper'
 
 module Rubocop
   module Cop
-    describe Indentation do
-      let(:ind) { Indentation.new }
+    describe CaseIndentation do
+      let(:ind) { CaseIndentation.new }
 
       it "registers an offence for a when clause that's deeper than case" do
         source = ['case a',

data/spec/rubocop/cops/class_methods_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe ClassMethods do
+      let(:cm) { ClassMethods.new }
+
+      it 'registers an offence for methods using a class name' do
+        inspect_source(cm, 'file.rb',
+                       ['class Test',
+                        '  def Test.some_method',
+                        '    do_something',
+                        '  end',
+                        'end'])
+        expect(cm.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for methods using a module name' do
+        inspect_source(cm, 'file.rb',
+                       ['module Test',
+                        '  def Test.some_method',
+                        '    do_something',
+                        '  end',
+                        'end'])
+        expect(cm.offences.size).to eq(1)
+      end
+
+      it 'does not register an offence for methods using self' do
+        inspect_source(cm, 'file.rb',
+                       ['module Test',
+                        '  def self.some_method',
+                        '    do_something',
+                        '  end',
+                        'end'])
+        expect(cm.offences).to be_empty
+      end
+
+      it 'does not register an offence outside class/module bodies' do
+        inspect_source(cm, 'file.rb',
+                       ['def self.some_method',
+                        '  do_something',
+                        'end'])
+        expect(cm.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/colon_method_call_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe ColonMethodCall do
+      let(:smc) { ColonMethodCall.new }
+
+      it 'registers an offence for instance method call' do
+        inspect_source(smc,
+                       'file.rb',
+                       ['test::method_name'])
+        expect(smc.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for instance method call with arg' do
+        inspect_source(smc,
+                       'file.rb',
+                       ['test::method_name(arg)'])
+        expect(smc.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for class method call' do
+        inspect_source(smc,
+                       'file.rb',
+                       ['Class::method_name'])
+        expect(smc.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for class method call with arg' do
+        inspect_source(smc,
+                       'file.rb',
+                       ['Class::method_name(arg, arg2)'])
+        expect(smc.offences.size).to eq(1)
+      end
+
+      it 'does not register an offence for constant access' do
+        inspect_source(smc,
+                       'file.rb',
+                       ['Tip::Top::SOME_CONST'])
+        expect(smc.offences).to be_empty
+      end
+
+    end
+  end
+end

data/spec/rubocop/cops/empty_line_between_defs_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe EmptyLineBetweenDefs do
+      let(:empty_lines) { EmptyLineBetweenDefs.new }
+
+      it 'finds offences in inner classes' do
+        inspect_source(empty_lines, '', ['class K',
+                                        '  def m',
+                                        '  end',
+                                        '  class J',
+                                        '    def n',
+                                        '    end',
+                                        '    def o',
+                                        '    end',
+                                        '  end',
+                                        '  # checks something',
+                                        '  def p',
+                                        '  end',
+                                        'end'])
+        expect(empty_lines.offences.size).to eq(2)
+        expect(empty_lines.offences.map(&:line_number).sort).to eq([7, 11])
+      end
+
+      # Only one def, so rule about empty line *between* defs does not
+      # apply.
+      it 'accepts a def that follows a line with code' do
+        inspect_source(empty_lines, '', ['x = 0',
+                                        'def m',
+                                        'end'])
+        expect(empty_lines.offences).to be_empty
+      end
+
+      # Only one def, so rule about empty line *between* defs does not
+      # apply.
+      it 'accepts a def that follows code and a comment' do
+        inspect_source(empty_lines, '', ['  x = 0',
+                                        '  # 123',
+                                        '  def m',
+                                        '  end'])
+        expect(empty_lines.offences).to be_empty
+      end
+
+      it 'accepts the first def without leading empty line in a class' do
+        inspect_source(empty_lines, '', ['class K',
+                                        '  def m',
+                                        '  end',
+                                        'end'])
+        expect(empty_lines.offences).to be_empty
+      end
+
+      it 'accepts a def that follows an empty line and then a comment' do
+        inspect_source(empty_lines, '', ['class A',
+                                        '  # calculates value',
+                                        '  def m',
+                                        '  end',
+                                        '',
+                                        '  private',
+                                        '  # calculates size',
+                                        '  def n',
+                                        '  end',
+                                        'end',
+                                       ])
+        expect(empty_lines.offences).to be_empty
+      end
+
+      it 'accepts a def that is the first of a module' do
+        source = ['module Util',
+                  '  public',
+                  '  #',
+                  '  def html_escape(s)',
+                  '  end',
+                  'end',
+                 ]
+        inspect_source(empty_lines, '', source)
+        expect(empty_lines.offences.map(&:message)).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/empty_lines_spec.rb

@@ -7,77 +7,20 @@ module Rubocop
     describe EmptyLines do
       let(:empty_lines) { EmptyLines.new }
 
-      it 'finds offences in inner classes' do
-        inspect_source(empty_lines, '', ['class K',
-                                        '  def m',
-                                        '  end',
-                                        '  class J',
-                                        '    def n',
-                                        '    end',
-                                        '    def o',
-                                        '    end',
-                                        '  end',
-                                        '  # checks something',
-                                        '  def p',
-                                        '  end',
-                                        'end'])
+      it 'registers an offence for consecutive empty lines' do
+        inspect_source(empty_lines, 'file.rb',
+                       ['test = 5', '', '', '', 'top'])
         expect(empty_lines.offences.size).to eq(2)
-        expect(empty_lines.offences.map(&:line_number).sort).to eq([7, 11])
       end
 
-      # Only one def, so rule about empty line *between* defs does not
-      # apply.
-      it 'accepts a def that follows a line with code' do
-        inspect_source(empty_lines, '', ['x = 0',
-                                        'def m',
-                                        'end'])
-        expect(empty_lines.offences).to be_empty
-      end
+      it 'does not register an offence for empty lines in a string' do
+        inspect_source(empty_lines, 'file.rb', ['result = "test
 
-      # Only one def, so rule about empty line *between* defs does not
-      # apply.
-      it 'accepts a def that follows code and a comment' do
-        inspect_source(empty_lines, '', ['  x = 0',
-                                        '  # 123',
-                                        '  def m',
-                                        '  end'])
-        expect(empty_lines.offences).to be_empty
-      end
 
-      it 'accepts the first def without leading empty line in a class' do
-        inspect_source(empty_lines, '', ['class K',
-                                        '  def m',
-                                        '  end',
-                                        'end'])
-        expect(empty_lines.offences).to be_empty
-      end
 
-      it 'accepts a def that follows an empty line and then a comment' do
-        inspect_source(empty_lines, '', ['class A',
-                                        '  # calculates value',
-                                        '  def m',
-                                        '  end',
-                                        '',
-                                        '  private',
-                                        '  # calculates size',
-                                        '  def n',
-                                        '  end',
-                                        'end',
-                                       ])
+                                                 string"'])
         expect(empty_lines.offences).to be_empty
       end
-
-      it 'accepts a def that is the first of a module' do
-        source = ['module Util',
-                  '  public',
-                  '  #',
-                  '  def html_escape(s)',
-                  '  end',
-                  'end',
-                 ]
-        inspect_source(empty_lines, '', source)
-        expect(empty_lines.offences.map(&:message)).to be_empty
-      end
     end
   end
 end