rubocop 0.6.1 → 0.7.0

data/spec/rubocop/cops/eval_spec.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Eval do
+      let(:a) { Eval.new }
+
+      it 'registers an offence for eval as function' do
+        inspect_source(a,
+                       'file.rb',
+                       ['eval(something)'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([Eval::ERROR_MESSAGE])
+      end
+
+      it 'registers an offence for eval as command' do
+        inspect_source(a,
+                       'file.rb',
+                       ['eval something'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([Eval::ERROR_MESSAGE])
+      end
+
+      it 'does not register an offence for eval as variable' do
+        inspect_source(a,
+                       'file.rb',
+                       ['eval = something'])
+        expect(a.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/favor_join_spec.rb

@@ -0,0 +1,39 @@
+# 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,
+                       'file.rb',
+                       ['%w(one two three) * ", "'])
+        expect(fj.offences.size).to eq(1)
+        expect(fj.offences.map(&:message))
+          .to eq([FavorJoin::ERROR_MESSAGE])
+      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
+    end
+  end
+end

data/spec/rubocop/cops/hash_literal_spec.rb

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

data/spec/rubocop/cops/leading_comment_space_spec.rb

@@ -0,0 +1,60 @@
+# 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,
+                       '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'])
+        expect(lcs.offences).to be_empty
+      end
+
+      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
+    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, 'file.rb',
+                       ['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',
+                       ['result = "test string\\\n"',
+                        'more'])
+        expect(lc.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/line_length_spec.rb

@@ -6,6 +6,7 @@ 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)

data/spec/rubocop/cops/method_and_variable_snake_case_spec.rb

@@ -19,6 +19,15 @@ module Rubocop
           ['Use snake_case for methods and variables.'] * 4)
       end
 
+      it 'registers an offence for capitalized camel case' do
+        inspect_source(snake_case, 'file.rb',
+                       ['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',
                        ['def my_method',
@@ -42,6 +51,17 @@ module Rubocop
         inspect_source(snake_case, 'file.rb', ['$MY_GLOBAL = 0'])
         expect(snake_case.offences.map(&:message)).to be_empty
       end
+
+      it 'accepts screaming snake case constants' do
+        inspect_source(snake_case, 'file.rb', ['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, 'file.rb',
+                       ['Paren = Struct.new :left, :right, :kind'])
+        expect(snake_case.offences.map(&:message)).to be_empty
+      end
     end
   end
 end

data/spec/rubocop/cops/method_length_spec.rb

@@ -6,10 +6,7 @@ module Rubocop
   module Cop
     describe MethodLength do
       let(:method_length) { MethodLength.new }
-      before do
-        MethodLength.stub(:max).and_return(5)
-        MethodLength.stub(:count_comments?).and_return(false)
-      end
+      before { MethodLength.config = { 'Max' => 5, 'CountComments' => false } }
 
       it 'rejects a method with more than 5 lines' do
         inspect_source(method_length, '', ['def m()',
@@ -133,7 +130,7 @@ module Rubocop
       end
 
       it 'has the option of counting commented lines' do
-        MethodLength.stub(:count_comments?).and_return(true)
+        MethodLength.config['CountComments'] = true
         inspect_source(method_length, '', ['def m()',
                                            '  a = 1',
                                            '  #a = 2',

data/spec/rubocop/cops/new_lambda_literal_spec.rb

@@ -9,14 +9,13 @@ module Rubocop
 
       it 'registers an offence for an old lambda call' do
         inspect_source(lambda_literal, 'file.rb', ['f = lambda { |x| x }'])
-        expect(lambda_literal.offences.map(&:message)).to eq(
-          ['The new lambda literal syntax is preferred in Ruby 1.9.'])
+        expect(lambda_literal.offences.size).to eq(1)
       end
 
       it 'accepts the new lambda literal' do
         inspect_source(lambda_literal, 'file.rb', ['lambda = ->(x) { x }',
                                               'lambda.(1)'])
-        expect(lambda_literal.offences.map(&:message)).to be_empty
+        expect(lambda_literal.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/not_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Not do
+      let(:a) { Not.new }
+
+      it 'registers an offence for not' do
+        inspect_source(a,
+                       'file.rb',
+                       ['not test'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([Not::ERROR_MESSAGE])
+      end
+
+      it 'does not register an offence for !' do
+        inspect_source(a,
+                       'file.rb',
+                       ['!test'])
+        expect(a.offences).to be_empty
+      end
+
+      it 'does not register an offence for :not' do
+        inspect_source(a,
+                       'file.rb',
+                       ['[:not, :if, :else]'])
+        expect(a.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/offence_spec.rb

@@ -24,6 +24,13 @@ module Rubocop
 
         expect(offence.to_s).to eq('C:  1: message % test')
       end
+
+      it 'redefines == to compare offences based on their contents' do
+        o1 = Offence.new(:test, 1, 'message')
+        o2 = Offence.new(:test, 1, 'message')
+
+        expect(o1 == o2).to be_true
+      end
     end
   end
 end

data/spec/rubocop/cops/semicolon_spec.rb

@@ -6,14 +6,19 @@ module Rubocop
   module Cop
     describe Semicolon do
       let(:s) { Semicolon.new }
+      before do
+        Semicolon.config = {
+          'AllowAfterParameterListInOneLineMethods' => false,
+          'AllowBeforeEndInOneLineMethods' => true
+        }
+      end
 
       it 'registers an offence for a single expression' do
         inspect_source(s,
                        'file.rb',
                        ['puts "this is a test";'])
         expect(s.offences.size).to eq(1)
-        expect(s.offences.map(&:message))
-          .to eq([Semicolon::ERROR_MESSAGE])
+        expect(s.offences.map(&:message)).to eq([Semicolon::ERROR_MESSAGE])
       end
 
       it 'registers an offence for several expressions' do
@@ -21,8 +26,78 @@ module Rubocop
                        'file.rb',
                        ['puts "this is a test"; puts "So is this"'])
         expect(s.offences.size).to eq(1)
-        expect(s.offences.map(&:message))
-          .to eq([Semicolon::ERROR_MESSAGE])
+        expect(s.offences.map(&:message)).to eq([Semicolon::ERROR_MESSAGE])
+      end
+
+      it 'registers an offence for one line method with two statements' do
+        inspect_source(s,
+                       'file.rb',
+                       ['def foo(a) x(1); y(2); z(3); end'])
+        expect(s.offences.size).to eq(2)
+      end
+
+      it 'registers an offence for semicolon before end if so configured' do
+        Semicolon.config['AllowBeforeEndInOneLineMethods'] = false
+        inspect_source(s,
+                       'file.rb',
+                       ['def foo(a) z(3); end'])
+        expect(s.offences.size).to eq(1)
+      end
+
+      it 'accepts semicolon before end if so configured' do
+        inspect_source(s,
+                       'file.rb',
+                       ['def foo(a) z(3); end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'registers an offence for semicolon after params if so configured' do
+        inspect_source(s,
+                       'file.rb',
+                       ['def foo(a); y(2); z(3) end',
+                        'def bar(a) y(2); z(3) end'])
+        expect(s.offences.size).to eq(3)
+      end
+
+      it 'accepts semicolon after params if so configured' do
+        Semicolon.config['AllowAfterParameterListInOneLineMethods'] = true
+        inspect_source(s,
+                       'file.rb',
+                       ['def foo(a); z(3) end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'accepts one line method definitions' do
+        Semicolon.config['AllowAfterParameterListInOneLineMethods'] = true
+        inspect_source(s,
+                       'file.rb',
+                       ['def foo1; x(3) end',
+                        'def initialize(*_); end',
+                        'def foo2() x(3); end',
+                        'def foo3; x(3); end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'accepts one line empty class definitions' do
+        inspect_source(s,
+                       'file.rb',
+                       ['  class Foo < Exception; end',
+                        '  class Bar; end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'accepts one line empty module definitions' do
+        inspect_source(s,
+                       'file.rb',
+                       ['module Foo; end'])
+        expect(s.offences).to be_empty
+      end
+
+      it 'registers an offence for semicolon at the end no matter what' do
+        inspect_source(s,
+                       'file.rb',
+                       ['module Foo; end;'])
+        expect(s.offences.size).to eq(1)
       end
     end
   end

data/spec/rubocop/cops/single_line_methods_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe SingleLineMethods do
+      let(:slm) { SingleLineMethods.new }
+      before { SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => true } }
+
+      it 'registers an offence for a single-line method' do
+        inspect_source(slm, '',
+                       ['def some_method; body end',
+                        'def link_to(name, url); {:name => name}; end',
+                        'def @table.columns; super; end'])
+        expect(slm.offences.map(&:message)).to eq(
+          [SingleLineMethods::ERROR_MESSAGE] * 3)
+      end
+
+      it 'registers an offence for an empty method if so configured' do
+        SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => false }
+        inspect_source(slm, '', ['def no_op; end',
+                                 'def self.resource_class=(klass); end',
+                                 'def @table.columns; end'])
+        expect(slm.offences.size).to eq(3)
+      end
+
+      it 'accepts a single-line empty method if so configured' do
+        SingleLineMethods.config = { 'AllowIfMethodIsEmpty' => true }
+        inspect_source(slm, '', ['def no_op; end',
+                                 'def self.resource_class=(klass); end',
+                                 'def @table.columns; end'])
+        expect(slm.offences).to be_empty
+      end
+
+      it 'accepts a multi-line method' do
+        inspect_source(slm, '', ['def some_method',
+                                 '  body',
+                                 'end'])
+        expect(slm.offences).to be_empty
+      end
+
+      it 'does not crash on an method with a capitalized name' do
+        inspect_source(slm, '', ['def NoSnakeCase',
+                                 'end'])
+        expect(slm.offences).to be_empty
+      end
+    end
+  end
+end