rubocop 0.8.3 → 0.9.0

data/spec/rubocop/cops/space_around_braces_spec.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe SpaceAroundBraces do
-      let(:space) { SpaceAroundBraces.new }
-
-      it 'registers an offence for left brace without spaces' do
-        inspect_source(space, ['each{ puts }'])
-        expect(space.offences.map(&:message)).to eq(
-          ["Surrounding space missing for '{'."])
-      end
-
-      it 'registers an offence for right brace without inner space' do
-        inspect_source(space, ['each { puts}'])
-        expect(space.offences.map(&:message)).to eq(
-          ["Space missing to the left of '}'."])
-      end
-
-      it 'accepts an empty hash literal with no space inside' do
-        inspect_source(space,
-                       ['view_hash.each do |view_key|',
-                        'end',
-                        '@views = {}',
-                        ''])
-        expect(space.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts string interpolation braces with no space inside' do
-        inspect_source(space,
-                       ['"A=#{a}"',
-                        ':"#{b}"',
-                        '/#{c}/',
-                        '`#{d}`',
-                        'sprintf("#{message.gsub(/%/, \'%%\')}", line)'])
-        expect(space.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts braces around a hash literal argument' do
-        inspect_source(space, ["new({'user' => user_params})"])
-        expect(space.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/space_around_equals_in_default_parameter_spec.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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 of 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

data/spec/rubocop/cops/space_around_operators_spec.rb

@@ -1,209 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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_number)).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 '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 and 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

data/spec/rubocop/cops/space_inside_brackets_spec.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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

data/spec/rubocop/cops/space_inside_hash_literal_braces_spec.rb

@@ -1,86 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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 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

data/spec/rubocop/cops/space_inside_parens_spec.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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