rubocop 0.2.1 → 0.3.0

data/spec/rubocop/cli_spec.rb

@@ -14,7 +14,9 @@ module Rubocop
         lambda { cli.run ['--help'] }.should exit_with_code(0)
         message = ['Usage: rubocop [options] [file1, file2, ...]',
                    '    -v, --[no-]verbose               Run verbosely',
-                   '    -e, --emacs                      Emacs style output']
+                   '    -e, --emacs                      Emacs style output',
+                   '    -c, --config FILE                Configuration file',
+                   '    -s, --silent                     Silence summary']
         $stdout.string.should == (message * 2).join("\n") + "\n"
       end
 
@@ -67,6 +69,74 @@ module Rubocop
         end
       end
 
+      it 'ommits summary when --silent passed' do
+        File.open('example1.rb', 'w') { |f| f.puts 'x = 0 ' }
+        File.open('example2.rb', 'w') { |f| f.puts "\tx = 0" }
+        begin
+          cli.run(['--emacs',
+                   '--silent',
+                   'example1.rb',
+                   'example2.rb']).should == 1
+          $stdout.string.should ==
+            ['example1.rb:1: C: Missing encoding comment.',
+             'example1.rb:1: C: Trailing whitespace detected.',
+             'example2.rb:1: C: Missing encoding comment.',
+             'example2.rb:1: C: Tab detected.',
+             ''].join("\n")
+        ensure
+          File.delete 'example1.rb'
+          File.delete 'example2.rb'
+        end
+      end
+
+      it 'can be configured with option to disable a certain error' do
+        File.open('example1.rb', 'w') { |f| f.puts 'x = 0 ' }
+        File.open('rubocop.yml', 'w') do |f|
+          f.puts('Encoding:',
+                 '  Enabled: false',
+                 '',
+                 'Indentation:',
+                 '  Enabled: false')
+        end
+        begin
+          return_code = cli.run(['-c', 'rubocop.yml', 'example1.rb'])
+          $stdout.string.should ==
+            ['== example1.rb ==',
+             'C:  1: Trailing whitespace detected.',
+             '',
+             '1 files inspected, 1 offences detected',
+             ''].join("\n")
+          return_code.should == 1
+        ensure
+          File.delete 'example1.rb'
+          File.delete 'rubocop.yml'
+        end
+      end
+
+      it 'can be configured with project config to disable a certain error' do
+        FileUtils.mkdir 'example_src'
+        File.open('example_src/example1.rb', 'w') { |f| f.puts 'x = 0 ' }
+        File.open('example_src/.rubocop.yml', 'w') do |f|
+          f.puts('Encoding:',
+                 '  Enabled: false',
+                 '',
+                 'Indentation:',
+                 '  Enabled: false')
+        end
+        begin
+          return_code = cli.run(['example_src/example1.rb'])
+          $stdout.string.should ==
+            ['== example_src/example1.rb ==',
+             'C:  1: Trailing whitespace detected.',
+             '',
+             '1 files inspected, 1 offences detected',
+             ''].join("\n")
+          return_code.should == 1
+        ensure
+          FileUtils.rm_rf 'example_src'
+        end
+      end
+
       it 'finds no violations when checking the rubocop source code' do
         cli.run
         $stdout.string.should =~ /files inspected, 0 offences detected\n/

data/spec/rubocop/cops/align_parameters_spec.rb

@@ -54,20 +54,20 @@ module Rubocop
                         'func3(*a)',
                        ])
         align.offences.map(&:to_s).should ==
-          ['C:  5: Align the parameters of a method call if they span more ' +
-           'than one line.']
+          ['C:  5: Align the parameters of a method call if they span ' +
+           'more than one line.']
       end
 
       it 'can handle a correctly aligned string literal as first argument' do
         inspect_source(align, '',
-                       ['add_offence("", x,',
+                       ['add_offence(:convention, x,',
                         '            a)'])
         align.offences.map(&:message).should == []
       end
 
       it 'can handle a string literal as other argument' do
         inspect_source(align, '',
-                       ['add_offence(x,',
+                       ['add_offence(:convention,',
                         '            "", a)'])
         align.offences.map(&:message).should == []
       end

data/spec/rubocop/cops/ampersands_pipes_vs_and_or_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AmpersandsPipesVsAndOr do
+      let (:amp) { AmpersandsPipesVsAndOr.new }
+
+      it 'registers an offence for AND used in condition of if statement' do
+        check('if', 'and', '&&')
+      end
+
+      it 'registers an offence for OR used in condition of if statement' do
+        check('if', 'or', '||')
+      end
+
+      it 'registers an offence for AND used in condition of unless' do
+        check('unless', 'and', '&&')
+      end
+
+      it 'registers an offence for OR used in condition of unless' do
+        check('unless', 'or', '||')
+      end
+
+      it 'registers an offence for AND used in condition of while' do
+        check('while', 'and', '&&')
+      end
+
+      it 'registers an offence for OR used in condition of while' do
+        check('while', 'or', '||')
+      end
+
+      it 'registers an offence for AND used in condition of until' do
+        check('until', 'and', '&&')
+      end
+
+      it 'registers an offence for OR used in condition of until' do
+        check('until', 'or', '||')
+      end
+
+      def check(keyword, bad_operator, good_operator)
+        inspect_source(amp, 'file.rb', ["#{keyword} a #{bad_operator} b",
+                                        '  c',
+                                        'end',
+                                        "#{keyword} a #{good_operator} b",
+                                        '  c',
+                                        'end'])
+        # Just one offence should be registered. The good_operator
+        # should be accepted.
+        amp.offences.map(&:message).should ==
+          ['Use &&/|| for boolean expressions, and/or for control flow.']
+        amp.offences[0].line_number.should == 1
+      end
+    end
+  end
+end

data/spec/rubocop/cops/cop_spec.rb

@@ -16,13 +16,13 @@ module Rubocop
       end
 
       it 'keeps track of offences' do
-        cop.add_offence('file', 1, 'message')
+        cop.add_offence(:convention, 1, 'message')
 
         cop.offences.size.should == 1
       end
 
       it 'will report registered offences' do
-        cop.add_offence('file', 1, 'message')
+        cop.add_offence(:convention, 1, 'message')
 
         cop.has_report?.should be_true
       end

data/spec/rubocop/cops/{def_parentheses_spec.rb → def_with_parentheses_spec.rb}

@@ -4,16 +4,8 @@ require 'spec_helper'
 
 module Rubocop
   module Cop
-    describe DefParentheses do
-      let (:def_par) { DefParentheses.new }
-
-      it 'reports an offence for def with parameters but no parens' do
-        src = ['def func a, b',
-               'end']
-        inspect_source(def_par, '', src)
-        def_par.offences.map(&:message).should ==
-          ['Use def with parentheses when there are arguments.']
-      end
+    describe DefWithParentheses do
+      let (:def_par) { DefWithParentheses.new }
 
       it 'reports an offence for def with empty parens' do
         src = ['def func()',
@@ -31,18 +23,11 @@ module Rubocop
         def_par.offences.map(&:message).should == []
       end
 
-      it 'accepts def with no args and no parens' do
-        src = ['def func',
-               'end']
-        inspect_source(def_par, '', src)
-        def_par.offences.map(&:message).should == []
-      end
-
       it 'accepts empty parentheses in one liners' do
         src = ["def to_s() join '/' end"]
         inspect_source(def_par, '', src)
         def_par.offences.map(&:message).should == []
-    end
+      end
     end
   end
 end

data/spec/rubocop/cops/def_without_parentheses_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe DefWithoutParentheses do
+      let (:def_par) { DefWithoutParentheses.new }
+
+      it 'reports an offence for def with parameters but no parens' do
+        src = ['def func a, b',
+               'end']
+        inspect_source(def_par, '', src)
+        def_par.offences.map(&:message).should ==
+          ['Use def with parentheses when there are arguments.']
+      end
+
+      it 'accepts def with no args and no parens' do
+        src = ['def func',
+               'end']
+        inspect_source(def_par, '', src)
+        def_par.offences.map(&:message).should == []
+      end
+    end
+  end
+end

data/spec/rubocop/cops/encoding_spec.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe Encoding do
+      let (:encoding) { Encoding.new }
+
+      it 'registers an offence when no encoding present' do
+        inspect_source(encoding, 'file.rb', ['def foo() end'])
+
+        encoding.offences.map(&:message).should ==
+          ['Missing encoding comment.']
+      end
+
+      it 'accepts encoding on first line' do
+        inspect_source(encoding, 'file.rb', ['# encoding: utf-8',
+                                             'def foo() end'])
+
+        encoding.offences.should == []
+      end
+
+      it 'accepts encoding on second line when shebang present' do
+        inspect_source(encoding, 'file.rb', ['#!/usr/bin/env ruby',
+                                             '# encoding: utf-8',
+                                             'def foo() end'])
+
+        encoding.offences.map(&:message).should == []
+      end
+
+      it 'registers an offence when encoding is in the wrong place' do
+        inspect_source(encoding, 'file.rb', ['def foo() end',
+                                             '# encoding: utf-8'])
+
+        encoding.offences.map(&:message).should ==
+          ['Missing encoding comment.']
+      end
+    end
+  end
+end

data/spec/rubocop/cops/end_of_line_spec.rb

@@ -12,6 +12,12 @@ module Rubocop
         eol.offences.map(&:message).should ==
           ['Carriage return character detected.']
       end
+
+      it 'registers an offence for CR at end of file' do
+        inspect_source(eol, 'file.rb', ["x=0\r"])
+        eol.offences.map(&:message).should ==
+          ['Carriage return character detected.']
+      end
     end
   end
 end

data/spec/rubocop/cops/if_with_semicolon_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe IfWithSemicolon do
+      let (:iws) { IfWithSemicolon.new }
+
+      it 'registers an offence for one line if/;/end' do
+        inspect_source(iws, '', ['if cond; run else dont end'])
+        iws.offences.map(&:message).should ==
+          ['Never use if x; Use the ternary operator instead.']
+      end
+    end
+  end
+end

data/spec/rubocop/cops/indentation_spec.rb

@@ -15,7 +15,8 @@ module Rubocop
                   '        end',
                   'end']
         inspect_source(ind, 'file.rb', source)
-        ind.offences.size.should == 2
+        ind.offences.map(&:message).should ==
+          ['Indent when as deep as case.'] * 2
       end
 
       it "accepts a when clause that's equally indented with case" do

data/spec/rubocop/cops/{blocks_spec.rb → multiline_blocks_spec.rb}

@@ -4,8 +4,8 @@ require 'spec_helper'
 
 module Rubocop
   module Cop
-    describe Blocks do
-      let (:blocks) { Blocks.new }
+    describe MultilineBlocks do
+      let (:blocks) { MultilineBlocks.new }
 
       it 'registers an offence for a multiline block with braces' do
         inspect_source(blocks, '', ['each { |x|',
@@ -14,17 +14,6 @@ module Rubocop
           ['Avoid using {...} for multi-line blocks.']
       end
 
-      it 'registers an offence for a single line block with do-end' do
-        inspect_source(blocks, '', ['each do |x| end'])
-        blocks.offences.map(&:message).should ==
-          ['Prefer {...} over do...end for single-line blocks.']
-      end
-
-      it 'accepts a single line block with braces' do
-        inspect_source(blocks, '', ['each { |x| }'])
-        blocks.offences.map(&:message).should == []
-      end
-
       it 'accepts a multiline block with do-end' do
         inspect_source(blocks, '', ['each do |x|',
                                     'end'])

data/spec/rubocop/cops/multiline_if_then_spec.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe MultilineIfThen do
+      let (:mit) { MultilineIfThen.new }
+
+      # if
+
+      it 'registers an offence for then in multiline if' do
+        inspect_source(mit, '', ['if cond then',
+                                 'end',
+                                 "if cond then\t",
+                                 'end',
+                                 'if cond then  ',
+                                 'end',
+                                 'if cond then # bad',
+                                 'end'])
+        mit.offences.map(&:line_number).should == [1, 3, 5, 7]
+      end
+
+      it 'accepts multiline if without then' do
+        inspect_source(mit, '', ['if cond',
+                                          'end'])
+        mit.offences.map(&:message).should == []
+      end
+
+      it 'accepts table style if/then/elsif/ends' do
+        inspect_source(mit, '',
+                       ['if    @io == $stdout then str << "$stdout"',
+                        'elsif @io == $stdin  then str << "$stdin"',
+                        'elsif @io == $stderr then str << "$stderr"',
+                        'else                      str << @io.class.to_s',
+                        'end'])
+        mit.offences.map(&:message).should == []
+      end
+
+      # unless
+
+      it 'registers an offence for then in multiline unless' do
+        inspect_source(mit, '', ['unless cond then',
+                                 'end'])
+        mit.offences.map(&:message).should ==
+          ['Never use then for multi-line if/unless.']
+      end
+
+      it 'accepts multiline unless without then' do
+        inspect_source(mit, '', ['unless cond',
+                                 'end'])
+        mit.offences.map(&:message).should == []
+      end
+    end
+  end
+end

data/spec/rubocop/cops/one_line_conditional_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe OneLineConditional do
+      let (:olc) { OneLineConditional.new }
+
+      it 'registers an offence for one line if/then/end' do
+        inspect_source(olc, '', ['if cond then run else dont end'])
+        olc.offences.map(&:message).should ==
+          ['Favor the ternary operator (?:) over if/then/else/end constructs.']
+      end
+    end
+  end
+end