rubocop 0.8.3 → 0.9.0

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceAroundEqualsInParameterDefault do
+        let(:space) { SpaceAroundEqualsInParameterDefault.new }
+
+        it 'registers an offence for default value assignment without space' do
+          inspect_source(space, ['def f(x, y=0, z=1)', 'end'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Surrounding space missing in default value assignment.'] * 2)
+        end
+
+        it 'registers an offence for assignment empty string without space' do
+          inspect_source(space, ['def f(x, y="", z=1)', 'end'])
+          expect(space.offences.size).to eq(2)
+        end
+
+        it 'registers an offence for assignment of empty list without space' do
+          inspect_source(space, ['def f(x, y=[])', 'end'])
+          expect(space.offences.size).to eq(1)
+        end
+
+        it 'accepts default value assignment with space' do
+          inspect_source(space, ['def f(x, y = 0, z = {})', 'end'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,216 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceAroundOperators do
+        let(:space) { SpaceAroundOperators.new }
+
+        it 'registers an offence for assignment without space on both sides' do
+          inspect_source(space, ['x=0', 'y= 0', 'z =0'])
+          expect(space.offences.map(&:message)).to eq(
+            ["Surrounding space missing for operator '='."] * 3)
+        end
+
+        it 'registers an offence for ternary operator without space' do
+          inspect_source(space, ['x == 0?1:2'])
+          expect(space.offences.map(&:message)).to eq(
+            ["Surrounding space missing for operator '?'.",
+             "Surrounding space missing for operator ':'."])
+        end
+
+        it 'registers an offence in presence of modifier if statement' do
+          check_modifier('if')
+        end
+
+        it 'registers an offence in presence of modifier unless statement' do
+          check_modifier('unless')
+        end
+
+        it 'registers an offence in presence of modifier while statement' do
+          check_modifier('unless')
+        end
+
+        it 'registers an offence in presence of modifier until statement' do
+          check_modifier('unless')
+        end
+
+        def check_modifier(keyword)
+          src = ["a=1 #{keyword} condition",
+                 'c=2']
+          inspect_source(space, src)
+          expect(space.offences.map(&:line)).to eq([1, 2])
+          expect(space.offences.map(&:message)).to eq(
+            ["Surrounding space missing for operator '='."] * 2)
+        end
+
+        it 'registers an offence for binary operators that could be unary' do
+          inspect_source(space, ['a-3', 'x&0xff', 'z+0'])
+          expect(space.offences.map(&:message)).to eq(
+            ["Surrounding space missing for operator '-'.",
+             "Surrounding space missing for operator '&'.",
+             "Surrounding space missing for operator '+'."])
+        end
+
+        it 'registers an offence for arguments to a method' do
+          inspect_source(space, ['puts 1+2'])
+          expect(space.offences.map(&:message)).to eq(
+            ["Surrounding space missing for operator '+'."])
+        end
+
+        it 'accepts operator symbols' do
+          inspect_source(space, ['func(:-)'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts ranges' do
+          inspect_source(space, ['a, b = (1..2), (1...3)'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts scope operator' do
+          source = ['@io.class == Zlib::GzipWriter']
+          inspect_source(space, source)
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts ::Kernel::raise' do
+          source = ['::Kernel::raise IllegalBlockError.new']
+          inspect_source(space, source)
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts exclamation point negation' do
+          inspect_source(space, ['x = !a&&!b'])
+          expect(space.offences.map(&:message)).to eq(
+            ["Surrounding space missing for operator '&&'."])
+        end
+
+        it 'accepts exclamation point definition' do
+          inspect_source(space, ['  def !',
+                                 '    !__getobj__',
+                                 '  end'])
+          expect(space.offences).to be_empty
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts a unary' do
+          inspect_source(space,
+                         ['  def bm(label_width = 0, *labels, &blk)',
+                          '    benchmark(CAPTION, label_width, FORMAT,',
+                          '              *labels, &blk)',
+                          '  end',
+                          '',
+                          '  def each &block',
+                          '  end',
+                          '',
+                          '  def each *args',
+                          '  end',
+                          ''])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts splat operator' do
+          inspect_source(space, ['return *list if options'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts def of operator' do
+          inspect_source(space, ['def +(other); end',
+                                 'def self.===(other); end'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts an operator at the end of a line' do
+          inspect_source(space,
+                         ["['Favor unless over if for negative ' +",
+                          " 'conditions.'] * 2"])
+          expect(space.offences.map(&:message)).to eq([])
+        end
+
+        it 'accepts an assignment with spaces' do
+          inspect_source(space, ['x = 0'])
+          expect(space.offences).to be_empty
+        end
+
+        it 'accepts an operator called with method syntax' do
+          inspect_source(space, ['Date.today.+(1).to_s'])
+          expect(space.offences).to be_empty
+        end
+
+        it 'registers an offence for operators without spaces' do
+          inspect_source(space,
+                         ['x+= a+b-c*d/e%f^g|h&i||j',
+                          'y -=k&&l'])
+          expect(space.offences.map(&:message))
+            .to eq(["Surrounding space missing for operator '+='.",
+                    "Surrounding space missing for operator '+'.",
+                    "Surrounding space missing for operator '-'.",
+                    "Surrounding space missing for operator '*'.",
+                    "Surrounding space missing for operator '/'.",
+                    "Surrounding space missing for operator '%'.",
+                    "Surrounding space missing for operator '^'.",
+                    "Surrounding space missing for operator '|'.",
+                    "Surrounding space missing for operator '&'.",
+                    "Surrounding space missing for operator '||'.",
+                    "Surrounding space missing for operator '-='.",
+                    "Surrounding space missing for operator '&&'."])
+        end
+
+        it 'accepts operators with spaces' do
+          inspect_source(space,
+                         ['x += a + b - c * d / e % f ^ g | h & i || j',
+                          'y -= k && l'])
+          expect(space.offences.map(&:message)).to eq([])
+        end
+
+        it "accepts some operators that are exceptions & don't need spaces" do
+          inspect_source(space, ['(1..3)',
+                                 'ActionController::Base',
+                                 'each { |s, t| }'])
+          expect(space.offences.map(&:message)).to eq([])
+        end
+
+        it 'accepts an assignment followed by newline' do
+          inspect_source(space, ['x =', '0'])
+          expect(space.offences).to be_empty
+        end
+
+        it 'registers an offences for exponent operator with spaces' do
+          inspect_source(space, ['x = a * b ** 2'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Space around operator ** detected.'])
+        end
+
+        it 'accepts exponent operator without spaces' do
+          inspect_source(space, ['x = a * b**2'])
+          expect(space.offences).to be_empty
+        end
+
+        it 'accepts unary operators without space' do
+          inspect_source(space, ['[].map(&:size)',
+                                            '-3',
+                                            'x = +2'])
+          expect(space.offences.map(&:message)).to eq([])
+        end
+
+        it 'accepts argument default values without space' do
+          # These are handled by SpaceAroundEqualsInParameterDefault,
+          # so SpaceAroundOperators leaves them alone.
+          inspect_source(space,
+                         ['def init(name=nil)',
+                          'end'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts the construct class <<self with no space after <<' do
+          inspect_source(space, ['class <<self',
+                                 'end'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceInsideBrackets do
+        let(:space) { SpaceInsideBrackets.new }
+
+        it 'registers an offence for an array literal with spaces inside' do
+          inspect_source(space, ['a = [1, 2 ]',
+                                           'b = [ 1, 2]'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Space inside square brackets detected.',
+             'Space inside square brackets detected.'])
+        end
+
+        it 'accepts space inside strings within square brackets' do
+          inspect_source(space, ["['Encoding:',",
+                                 " '  Enabled: false']"])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts space inside square brackets if on its own row' do
+          inspect_source(space, ['a = [',
+                                 '     1, 2',
+                                 '    ]'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts square brackets as method name' do
+          inspect_source(space, ['def Vector.[](*array)',
+                                           'end'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts square brackets called with method call syntax' do
+          inspect_source(space, ['subject.[](0)'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'only reports a single space once' do
+          inspect_source(space, ['[ ]'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Space inside square brackets detected.'])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceInsideHashLiteralBraces do
+        let(:sihlb) { SpaceInsideHashLiteralBraces.new }
+        before do
+          SpaceInsideHashLiteralBraces.config = {
+            'EnforcedStyleIsWithSpaces' => true
+          }
+        end
+
+        it 'registers an offence for hashes with no spaces by default' do
+          inspect_source(sihlb,
+                         ['h = {a: 1, b: :two}',
+                          'h = {a => 1 }'])
+          expect(sihlb.offences.map(&:message)).to eq(
+            ['Space inside hash literal braces missing.'] * 3)
+        end
+
+        it 'registers an offence for hashes with no spaces if so configured' do
+          inspect_source(sihlb,
+                         ['h = {a: 1, b: 2}',
+                          'h = {a => 1 }'])
+          expect(sihlb.offences.map(&:message)).to eq(
+            ['Space inside hash literal braces missing.'] * 3)
+        end
+
+        it 'registers an offence for hashes with spaces if so configured' do
+          SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+            false
+          inspect_source(sihlb,
+                         ['h = { a: 1, b: 2 }'])
+          expect(sihlb.offences.map(&:message)).to eq(
+            ['Space inside hash literal braces detected.'] * 2)
+        end
+
+        it 'accepts hashes with spaces by default' do
+          inspect_source(sihlb,
+                         ['h = { a: 1, b: 2 }',
+                          'h = { a => 1 }'])
+          expect(sihlb.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts hashes with no spaces if so configured' do
+          SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+            false
+          inspect_source(sihlb,
+                         ['h = {a: 1, b: 2}',
+                          'h = {a => 1}'])
+          expect(sihlb.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts multiline hashes even if configured for no space' do
+          SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+            false
+          inspect_source(sihlb,
+                         ['h = {',
+                          '      a: 1,',
+                          '      b: 2,',
+                          '}'])
+          expect(sihlb.offences).to be_empty
+        end
+
+        it 'accepts empty hashes without spaces by default' do
+          inspect_source(sihlb, ['h = {}'])
+          expect(sihlb.offences).to be_empty
+        end
+
+        it 'accepts empty hashes without spaces if configured false' do
+          SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+            false
+          inspect_source(sihlb, ['h = {}'])
+          expect(sihlb.offences).to be_empty
+        end
+
+        it 'accepts empty hashes without spaces even if configured true' do
+          inspect_source(sihlb, ['h = {}'])
+          expect(sihlb.offences).to be_empty
+        end
+
+        it 'accepts hash literals with no braces' do
+          inspect_source(sihlb, ['x(a: b.c)'])
+          expect(sihlb.offences).to be_empty
+        end
+
+        it 'can handle interpolation in a braceless hash literal' do
+          # A tricky special case where the closing brace of the
+          # interpolation risks getting confused for a hash literal brace.
+          inspect_source(sihlb, ['f(get: "#{x}")'])
+          expect(sihlb.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SpaceInsideParens do
+        let(:space) { SpaceInsideParens.new }
+
+        it 'registers an offence for spaces inside parens' do
+          inspect_source(space, ['f( 3)',
+                                 'g(3 )'])
+          expect(space.offences.map(&:message)).to eq(
+            ['Space inside parentheses detected.',
+             'Space inside parentheses detected.'])
+        end
+
+        it 'accepts parentheses in block parameter list' do
+          inspect_source(space,
+                         ['list.inject(Tms.new) { |sum, (label, item)|',
+                          '}'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+
+        it 'accepts parentheses with no spaces' do
+          inspect_source(space, ['split("\n")'])
+          expect(space.offences.map(&:message)).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe StringLiterals do
+        let(:sl) { StringLiterals.new }
+
+        it 'registers offence for double quotes when single quotes suffice' do
+          inspect_source(sl, ['s = "abc"',
+                              'x = "a\\\\b"',
+                              'y ="\\\\b"',
+                              'z = "a\\\\"'])
+          expect(sl.offences.size).to eq(4)
+        end
+
+        it 'accepts double quotes when they are needed' do
+          src = ['a = "\n"',
+                 'b = "#{encode_severity}:' +
+                 '#{sprintf("%3d", line_number)}: #{m}"',
+                 'c = "\'"',
+                 'd = "#@test"',
+                 'e = "#$test"',
+                  'f = "\e"',
+                 'g = "#@@test"']
+          inspect_source(sl, src)
+          expect(sl.offences).to be_empty
+        end
+
+        it 'accepts double quotes at the start of regexp literals' do
+          inspect_source(sl, ['s = /"((?:[^\\"]|\\.)*)"/'])
+          expect(sl.offences).to be_empty
+        end
+
+        it 'accepts double quotes with some other special symbols' do
+          # "Substitutions in double-quoted strings"
+          # http://www.ruby-doc.org/docs/ProgrammingRuby/html/language.html
+          src = ['g = "\xf9"',
+                 'copyright = "\u00A9"']
+          inspect_source(sl, src)
+          expect(sl.offences).to be_empty
+        end
+
+        it 'can handle double quotes within embedded expression' do
+          src = ['"#{"A"}"']
+          inspect_source(sl, src)
+          expect(sl.offences).to be_empty
+        end
+
+        it 'can handle a built-in constant parsed as string' do
+          # Parser will produce str nodes for constants such as __FILE__.
+          src = ['if __FILE__ == $PROGRAM_NAME',
+                 'end']
+          inspect_source(sl, src)
+          expect(sl.offences).to be_empty
+        end
+      end
+    end
+  end
+end