rubocop 0.7.2 → 0.8.0

data/spec/rubocop/cops/array_literal_spec.rb

@@ -1,46 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe ArrayLiteral do
-      let(:a) { ArrayLiteral.new }
-
-      it 'registers an offence for Array.new()' do
-        inspect_source(a,
-                       'file.rb',
-                       ['test = Array.new()'])
-        expect(a.offences.size).to eq(1)
-        expect(a.offences.map(&:message))
-          .to eq([ArrayLiteral::ERROR_MESSAGE])
-      end
-
-      it 'registers an offence for Array.new' do
-        inspect_source(a,
-                       'file.rb',
-                       ['test = Array.new'])
-        expect(a.offences.size).to eq(1)
-        expect(a.offences.map(&:message))
-          .to eq([ArrayLiteral::ERROR_MESSAGE])
-      end
-
-      it 'does not register an offence for Array.new(3)' do
-        inspect_source(a,
-                       'file.rb',
-                       ['test = Array.new(3)'])
-        expect(a.offences).to be_empty
-      end
-
-      it 'does not crash when a method is called on super' do
-        inspect_source(a,
-                       'file.rb',
-                       ['class Derived < Base',
-                        '  def func',
-                        '    super.slice(1..2)',
-                        '  end',
-                        'end'])
-      end
-    end
-  end
-end

data/spec/rubocop/cops/brace_after_percent_spec.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe BraceAfterPercent do
-      let(:bap) { BraceAfterPercent.new }
-      literals = %w(q Q r i I w W x s)
-
-      literals.each do |literal|
-        # %i and %I are new in ruby 2.0
-        tag = literal.downcase == 'i' ? { ruby: 2.0 } : {}
-
-        it "registers an offence for %#{literal}[", tag  do
-          inspect_source(bap,
-                         'file.rb',
-                         ["puts %#{literal}[test top]"])
-          expect(bap.offences.size).to eq(1)
-          expect(bap.offences.map(&:message))
-            .to eq([BraceAfterPercent::ERROR_MESSAGE])
-        end
-
-        it "does not registers an offence for %#{literal}(", tag do
-          inspect_source(bap,
-                         'file.rb',
-                         ["puts %#{literal}(test top)"])
-          expect(bap.offences).to be_empty
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/cops/grammar_spec.rb

@@ -1,81 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Grammar do
-      EXAMPLE = '3.times { |i| x = "#{c ? y : a}#{z}}" }'
-      tokens = Ripper.lex(EXAMPLE).map { |t| Token.new(*t) }
-      let(:grammar) { Grammar.new(tokens) }
-
-      it 'correlates token indices to grammar paths' do
-        method_block = [:program, :method_add_block]
-        brace_block = method_block + [:brace_block]
-        string_embexpr = brace_block + [:assign, :string_literal,
-                                        :string_content,
-                                        :string_embexpr]
-
-        test_2_0 = [[[1, 0], :on_int, '3'],
-          [[1, 1], :on_period, '.'],
-          [[1, 2], :on_ident, 'times'],
-          [[1, 7], :on_sp, ' '],
-          [[1, 8], :on_lbrace, '{'],
-          [[1, 9], :on_sp, ' '], # 5
-          [[1, 10], :on_op, '|'],
-          [[1, 11], :on_ident, 'i'],
-          [[1, 12], :on_op, '|'],
-          [[1, 13], :on_sp, ' '],
-          [[1, 14], :on_ident, 'x'],
-          [[1, 15], :on_sp, ' '],
-          [[1, 16], :on_op, '='],
-          [[1, 17], :on_sp, ' '],
-          [[1, 18], :on_tstring_beg, '"'],
-          [[1, 19], :on_embexpr_beg, '#{'],
-          [[1, 21], :on_ident, 'c'],
-          [[1, 22], :on_sp, ' '],
-          [[1, 23], :on_op, '?'],
-          [[1, 24], :on_sp, ' '],
-          [[1, 25], :on_ident, 'y'],
-          [[1, 26], :on_sp, ' '],
-          [[1, 27], :on_op, ':'],
-          [[1, 28], :on_sp, ' '],
-          [[1, 29], :on_ident, 'a'],
-          [[1, 30], :on_embexpr_end, '}'],
-          [[1, 31], :on_embexpr_beg, '#{'],
-          [[1, 33], :on_ident, 'z'],
-          [[1, 34], :on_embexpr_end, '}'],
-          [[1, 35], :on_tstring_content, '}'],
-          [[1, 36], :on_tstring_end, '"'],
-          [[1, 37], :on_sp, ' '],
-          [[1, 38], :on_rbrace, '}']]
-        expect(Ripper.lex(EXAMPLE)).to eq(test_2_0) if RUBY_VERSION >= '2.0'
-        sexp = Ripper.sexp(EXAMPLE)
-        Position.make_position_objects(sexp)
-
-        varref = (RUBY_VERSION == '1.9.2') ? :var_ref : :vcall
-
-        test = {
-          0  => method_block + [:call, :@int],                      # 3
-          2  => method_block + [:call, :@ident],                    # times
-          4  => brace_block,                                        # {
-          6  => brace_block + [:block_var],                         # |
-          7  => brace_block + [:block_var, :params, :@ident],       # i
-          8  => brace_block + [:block_var],                         # |
-          10 => brace_block + [:assign, :var_field, :@ident],       # x
-          12 => brace_block + [:assign],                            # =
-          16 => string_embexpr + [:ifop, varref, :@ident],          # c
-          18 => string_embexpr + [:ifop],                           # ?
-          20 => string_embexpr + [:ifop, varref, :@ident],          # y
-          22 => string_embexpr + [:ifop],                           # :
-          24 => string_embexpr + [:ifop, varref, :@ident],          # a
-          27 => string_embexpr + [:vcall, :@ident],                 # z
-          29 => brace_block + [:assign, :string_literal,
-                               :string_content, :@tstring_content], # }
-          32 => brace_block,
-        }
-        expect(grammar.correlate(sexp)).to eq(test)
-      end
-    end
-  end
-end

data/spec/rubocop/cops/hash_literal_spec.rb

@@ -1,46 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe HashLiteral do
-      let(:a) { HashLiteral.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 '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,
-                       'file.rb',
-                       ['test = Hash.new(3)'])
-        expect(a.offences).to be_empty
-      end
-
-      it 'does not crash when a method is called on super' do
-        inspect_source(a,
-                       'file.rb',
-                       ['class Derived < Base',
-                        '  def func',
-                        '    super.slice(1..2)',
-                        '  end',
-                        'end'])
-      end
-    end
-  end
-end

data/spec/rubocop/cops/multiline_blocks_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe MultilineBlocks do
-      let(:blocks) { MultilineBlocks.new }
-
-      it 'registers an offence for a multiline block with braces' do
-        inspect_source(blocks, '', ['each { |x|',
-                                    '}'])
-        expect(blocks.offences.map(&:message)).to eq(
-          ['Avoid using {...} for multi-line blocks.'])
-      end
-
-      it 'accepts a multiline block with do-end' do
-        inspect_source(blocks, '', ['each do |x|',
-                                    'end'])
-        expect(blocks.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/percent_literals_spec.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe PercentLiterals do
-      let(:pl) { PercentLiterals.new }
-
-      it 'registers an offence for %q' do
-        inspect_source(pl,
-                       'file.rb',
-                       ['puts %q(test)'])
-        expect(pl.offences.size).to eq(1)
-        expect(pl.offences.map(&:message))
-          .to eq(['The use of %q is discouraged.'])
-      end
-
-      it 'registers an offence for %Q' do
-        inspect_source(pl,
-                       'file.rb',
-                       ['puts %Q(test)'])
-        expect(pl.offences.size).to eq(1)
-        expect(pl.offences.map(&:message))
-          .to eq(['The use of %Q is discouraged.'])
-      end
-
-      it 'registers an offence for %x' do
-        inspect_source(pl,
-                       'file.rb',
-                       ['puts %x(test)'])
-        expect(pl.offences.size).to eq(1)
-        expect(pl.offences.map(&:message))
-          .to eq(['The use of %x is discouraged.'])
-      end
-
-      it 'registers an offence for %s' do
-        inspect_source(pl,
-                       'file.rb',
-                       ['puts %s(test)'])
-        expect(pl.offences.size).to eq(1)
-        expect(pl.offences.map(&:message))
-          .to eq(['The use of %s is discouraged.'])
-      end
-    end
-  end
-end

data/spec/rubocop/cops/single_line_blocks_spec.rb

@@ -1,22 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe SingleLineBlocks do
-      let(:blocks) { SingleLineBlocks.new }
-
-      it 'registers an offence for a single line block with do-end' do
-        inspect_source(blocks, '', ['each do |x| end'])
-        expect(blocks.offences.map(&:message)).to eq(
-          ['Prefer {...} over do...end for single-line blocks.'])
-      end
-
-      it 'accepts a single line block with braces' do
-        inspect_source(blocks, '', ['each { |x| }'])
-        expect(blocks.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/symbol_snake_case_spec.rb

@@ -1,93 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe SymbolSnakeCase do
-      let(:snake_case) { SymbolSnakeCase.new }
-
-      it 'registers an offence for camel case in names' do
-        inspect_source(snake_case, 'file.rb',
-                       ['test = :BadIdea'])
-        expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for symbols.'])
-      end
-
-      it 'registers an offence for symbol used as hash label' do
-        inspect_source(snake_case, 'file.rb',
-                       ['{ ONE: 1, TWO: 2 }'])
-        expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for symbols.'] * 2)
-      end
-
-      it 'accepts snake case in names' do
-        inspect_source(snake_case, 'file.rb',
-                       ['test = :good_idea'])
-        expect(snake_case.offences).to be_empty
-      end
-
-      it 'accepts snake case in hash label names' do
-        inspect_source(snake_case, 'file.rb',
-                       ['{ one: 1, one_more_3: 2 }'])
-        expect(snake_case.offences).to be_empty
-      end
-
-      it 'accepts snake case with a prefix @ in names' do
-        inspect_source(snake_case, 'file.rb',
-                       ['test = :@good_idea'])
-        expect(snake_case.offences).to be_empty
-      end
-
-      it 'accepts snake case with ? suffix' do
-        inspect_source(snake_case, 'file.rb',
-                       ['test = :good_idea?'])
-        expect(snake_case.offences).to be_empty
-      end
-
-      it 'accepts snake case with ! suffix' do
-        inspect_source(snake_case, 'file.rb',
-                       ['test = :good_idea!'])
-        expect(snake_case.offences).to be_empty
-      end
-
-      it 'accepts snake case with = suffix' do
-        inspect_source(snake_case, 'file.rb',
-                       ['test = :good_idea='])
-        expect(snake_case.offences).to be_empty
-      end
-
-      it 'accepts special cases - !, [] and **' do
-        inspect_source(snake_case, 'file.rb',
-                       ['test = :**',
-                        'test = :!',
-                        'test = :[]',
-                        'test = :[]='])
-        expect(snake_case.offences).to be_empty
-      end
-
-      it 'accepts special cases - ==, <=>, >, <, >=, <=' do
-        inspect_source(snake_case, 'file.rb',
-                       ['test = :==',
-                        'test = :<=>',
-                        'test = :>',
-                        'test = :<',
-                        'test = :>=',
-                        'test = :<='])
-        expect(snake_case.offences).to be_empty
-      end
-
-      it 'can handle an alias of and operator without crashing' do
-        inspect_source(snake_case, 'file.rb',
-                       ['alias + add'])
-        expect(snake_case.offences).to be_empty
-      end
-
-      it 'registers an offence for SCREAMING_SNAKE_CASE' do
-        inspect_source(snake_case, 'file.rb',
-                       ['test = :BAD_IDEA'])
-        expect(snake_case.offences.size).to eq(1)
-      end
-    end
-  end
-end