sabat-rubocop 0.9.0

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

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe LeadingCommentSpace do
+        let(:lcs) { LeadingCommentSpace.new }
+
+        it 'registers an offence for comment without leading space' do
+          inspect_source(lcs,
+                         ['#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,
+                         ['#'])
+          expect(lcs.offences).to be_empty
+        end
+
+        it 'does not register an offence for more than one space' do
+          inspect_source(lcs,
+                         ['#   heavily indented'])
+          expect(lcs.offences).to be_empty
+        end
+
+        it 'does not register an offence for more than one #' do
+          inspect_source(lcs,
+                         ['###### heavily indented'])
+          expect(lcs.offences).to be_empty
+        end
+
+        it 'does not register an offence for only #s' do
+          inspect_source(lcs,
+                         ['######'])
+          expect(lcs.offences).to be_empty
+        end
+
+        it 'does not register an offence for #! on first line' do
+          inspect_source(lcs,
+                         ['#!/usr/bin/ruby',
+                          'test'])
+          expect(lcs.offences).to be_empty
+        end
+
+        it 'registers an offence for #! after the first line' do
+          inspect_source(lcs,
+                         ['test', '#!/usr/bin/ruby'])
+          expect(lcs.offences.size).to eq(1)
+        end
+
+        it 'accepts rdoc syntax' do
+          inspect_source(lcs,
+                         ['#++',
+                          '#--',
+                          '#:nodoc:'])
+
+          expect(lcs.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe LineContinuation do
+        let(:lc) { LineContinuation.new }
+
+        it 'registers an offence for line continuation char' do
+          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,
+                         ['result = "test string\\\n"',
+                          'more'])
+          expect(lc.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+          inspect_source(ll, ['#' * 80])
+          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
+          inspect_source(ll, ['#' * 79])
+          expect(ll.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe MethodAndVariableSnakeCase do
+        let(:snake_case) { MethodAndVariableSnakeCase.new }
+
+        it 'registers an offence for camel case in instance method name' do
+          inspect_source(snake_case,
+                         ['def myMethod',
+                          '  # ...',
+                          'end',
+                         ])
+          expect(snake_case.offences.map(&:message)).to eq(
+            ['Use snake_case for methods and variables.'])
+        end
+
+        it 'registers an offence for camel case in singleton method name' do
+          inspect_source(snake_case,
+                         ['def self.myMethod',
+                          '  # ...',
+                          'end',
+                         ])
+          expect(snake_case.offences.map(&:message)).to eq(
+            ['Use snake_case for methods and variables.'])
+        end
+
+        it 'registers an offence for camel case in local variable name' do
+          inspect_source(snake_case, ['myLocal = 1'])
+          expect(snake_case.offences.map(&:message)).to eq(
+            ['Use snake_case for methods and variables.'])
+        end
+
+        it 'registers an offence for camel case in instance variable name' do
+          inspect_source(snake_case, ['@myAttribute = 3'])
+          expect(snake_case.offences.map(&:message)).to eq(
+            ['Use snake_case for methods and variables.'])
+        end
+
+        it 'registers an offence for camel case in setter name' do
+          inspect_source(snake_case, ['self.mySetter = 2'])
+          expect(snake_case.offences.map(&:message)).to eq(
+            ['Use snake_case for methods and variables.'])
+        end
+
+        it 'registers an offence for capitalized camel case' do
+          inspect_source(snake_case,
+                         ['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,
+                         ['def my_method',
+                          '  my_local_html = 1',
+                          '  self.my_setter = 2',
+                          '  @my_attribute = 3',
+                          'end',
+                         ])
+          expect(snake_case.offences.map(&:message)).to be_empty
+        end
+
+        it 'registers an offence for mixed snake case and camel case' do
+          inspect_source(snake_case,
+                         ['def visit_Arel_Nodes_SelectStatement',
+                          'end'])
+          expect(snake_case.offences.map(&:message)).to eq(
+            ['Use snake_case for methods and variables.'])
+        end
+
+        it 'accepts screaming snake case globals' do
+          inspect_source(snake_case, ['$MY_GLOBAL = 0'])
+          expect(snake_case.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts screaming snake case constants' do
+          inspect_source(snake_case, ['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,
+                         ['Paren = Struct.new :left, :right, :kind'])
+          expect(snake_case.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe MethodCallParentheses do
+        let(:cop) { MethodCallParentheses.new }
+
+        it 'registers an offence for parens in method call without args' do
+          inspect_source(cop, ['top.test()'])
+        end
+
+        it 'it accepts no parens in method call without args' do
+          inspect_source(cop, ['top.test'])
+        end
+
+        it 'it accepts parens in method call with args' do
+          inspect_source(cop, ['top.test(a)'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,151 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe MethodLength do
+        let(:method_length) { MethodLength.new }
+        before do
+          MethodLength.config = { 'Max' => 5, 'CountComments' => false }
+        end
+
+        it 'rejects a method with more than 5 lines' do
+          inspect_source(method_length, ['def m()',
+                                         '  a = 1',
+                                         '  a = 2',
+                                         '  a = 3',
+                                         '  a = 4',
+                                         '  a = 5',
+                                         '  a = 6',
+                                         'end'])
+          expect(method_length.offences.size).to eq(1)
+          expect(method_length.offences.map(&:line).sort).to eq([1])
+        end
+
+        it 'accepts a method with less than 5 lines' do
+          inspect_source(method_length, ['def m()',
+                                         '  a = 1',
+                                         '  a = 2',
+                                         '  a = 3',
+                                         '  a = 4',
+                                         'end'])
+          expect(method_length.offences).to be_empty
+        end
+
+        it 'does not count blank lines' do
+          inspect_source(method_length, ['def m()',
+                                         '  a = 1',
+                                         '  a = 2',
+                                         '  a = 3',
+                                         '  a = 4',
+                                         '',
+                                         '',
+                                         '  a = 7',
+                                         'end'])
+          expect(method_length.offences).to be_empty
+        end
+
+        it 'accepts empty methods' do
+          inspect_source(method_length, ['def m()',
+                                         'end'])
+          expect(method_length.offences).to be_empty
+        end
+
+        it 'is not fooled by one-liner methods, syntax #1' do
+          inspect_source(method_length, ['def one_line; 10 end',
+                                         'def self.m()',
+                                         '  a = 1',
+                                         '  a = 2',
+                                         '  a = 4',
+                                         '  a = 5',
+                                         '  a = 6',
+                                         'end'])
+          expect(method_length.offences).to be_empty
+        end
+
+        it 'is not fooled by one-liner methods, syntax #2' do
+          inspect_source(method_length, ['def one_line(test) 10 end',
+                                         'def self.m()',
+                                         '  a = 1',
+                                         '  a = 2',
+                                         '  a = 4',
+                                         '  a = 5',
+                                         '  a = 6',
+                                         'end'])
+          expect(method_length.offences).to be_empty
+        end
+
+        it 'checks class methods, syntax #1' do
+          inspect_source(method_length, ['def self.m()',
+                                         '  a = 1',
+                                         '  a = 2',
+                                         '  a = 3',
+                                         '  a = 4',
+                                         '  a = 5',
+                                         '  a = 6',
+                                         'end'])
+          expect(method_length.offences.size).to eq(1)
+          expect(method_length.offences.map(&:line).sort).to eq([1])
+        end
+
+        it 'checks class methods, syntax #2' do
+          inspect_source(method_length, ['class K',
+                                         '  class << self',
+                                         '    def m()',
+                                         '      a = 1',
+                                         '      a = 2',
+                                         '      a = 3',
+                                         '      a = 4',
+                                         '      a = 5',
+                                         '      a = 6',
+                                         '    end',
+                                         '  end',
+                                         'end'])
+          expect(method_length.offences.size).to eq(1)
+          expect(method_length.offences.map(&:line).sort).to eq([3])
+        end
+
+        it 'properly counts lines when method ends with block' do
+          inspect_source(method_length, ['def m()',
+                                         '  something do',
+                                         '    a = 2',
+                                         '    a = 3',
+                                         '    a = 4',
+                                         '    a = 5',
+                                         '  end',
+                                         'end'])
+          expect(method_length.offences.size).to eq(1)
+          expect(method_length.offences.map(&:line).sort).to eq([1])
+        end
+
+        it 'does not count commented lines by default' do
+          inspect_source(method_length, ['def m()',
+                                         '  a = 1',
+                                         '  #a = 2',
+                                         '  a = 3',
+                                         '  #a = 4',
+                                         '  a = 5',
+                                         '  a = 6',
+                                         'end'])
+          expect(method_length.offences).to be_empty
+        end
+
+        it 'has the option of counting commented lines' do
+          MethodLength.config['CountComments'] = true
+          inspect_source(method_length, ['def m()',
+                                         '  a = 1',
+                                         '  #a = 2',
+                                         '  a = 3',
+                                         '  #a = 4',
+                                         '  a = 5',
+                                         '  a = 6',
+                                         'end'])
+          expect(method_length.offences.size).to eq(1)
+          expect(method_length.offences.map(&:line).sort).to eq([1])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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',
+                               'end',
+                               'if cond then # bad',
+                               'end'])
+          expect(mit.offences.map(&:line)).to eq([1, 3, 5, 7, 10])
+        end
+
+        it 'accepts multiline if without then' do
+          inspect_source(mit, ['if cond',
+                               'end'])
+          expect(mit.offences).to be_empty
+        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'])
+          expect(mit.offences).to be_empty
+        end
+
+        it 'does not get confused by a then in a when' do
+          inspect_source(mit,
+                         ['if a',
+                          '  case b',
+                          '  when c then',
+                          '  end',
+                          'end'])
+          expect(mit.offences).to be_empty
+        end
+
+        it 'does not get confused by a commented-out then' do
+          inspect_source(mit,
+                         ['if a # then',
+                          '  b',
+                          'end',
+                          'if c # then',
+                          'end'])
+          expect(mit.offences).to be_empty
+        end
+
+        # unless
+
+        it 'registers an offence for then in multiline unless' do
+          inspect_source(mit, ['unless cond then',
+                               'end'])
+          expect(mit.offences.map(&:message)).to eq(
+            ['Never use then for multi-line if/unless.'])
+        end
+
+        it 'accepts multiline unless without then' do
+          inspect_source(mit, ['unless cond',
+                               'end'])
+          expect(mit.offences).to be_empty
+        end
+
+        it 'does not get confused by a postfix unless' do
+          inspect_source(mit,
+                         ['two unless one',
+                         ])
+          expect(mit.offences).to be_empty
+        end
+
+        it 'does not get confused by a nested postfix unless' do
+          inspect_source(mit,
+                         ['if two',
+                          '  puts 1',
+                          'end unless two'
+                         ])
+          expect(mit.offences).to be_empty
+        end
+      end
+    end
+  end
+end