rubocop 0.4.0 → 0.8.0

data/lib/rubocop/cop/grammar.rb

@@ -1,135 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class Grammar
-      def initialize(tokens)
-        @tokens_without_pos = tokens.map { |t| [t.type, t.text] }
-        process_embedded_expressions
-        @token_indexes = {}
-        @tokens_without_pos.each_with_index do |t, i|
-          @token_indexes[t] ||= []
-          @token_indexes[t] << i
-        end
-        @ix = 0
-        @table = {}
-        token_positions = tokens.map { |t| [t.pos.lineno, t.pos.column] }
-        @index_by_pos = Hash[*token_positions.each_with_index.to_a.flatten(1)]
-        @special = {
-          assign:      [:on_op,     '='],
-          brace_block: [:on_lbrace, '{']
-        }
-      end
-
-      # The string "#{x}" will give the tokens
-      # [:on_tstring_beg, '"'], [:on_embexpr_beg, '#{'], [:on_ident, 'x'],
-      # [:on_rbrace, '}'], [:on_tstring_end, '"']
-      # which is not so good for us. We want to distinguish between a
-      # right brace that ends an embedded expression inside a string
-      # and an ordinary right brace. So we replace :on_rbrace with the
-      # made up :on_embexpr_end.
-      def process_embedded_expressions
-        state = :outside
-        brace_depth = 0
-        @tokens_without_pos.each_with_index do |(type, _), ix|
-          case state
-          when :outside
-            state = :inside_string if type == :on_tstring_beg
-          when :inside_string
-            case type
-            when :on_tstring_end
-              state = :outside
-            when :on_embexpr_beg
-              brace_depth = 1
-              state = :inside_expr
-            end
-          when :inside_expr
-            case type
-            when :on_lbrace
-              brace_depth += 1
-            when :on_rbrace
-              if brace_depth == 1
-                @tokens_without_pos[ix][0] = :on_embexpr_end
-                state = :inside_string
-              end
-              brace_depth -= 1
-            end
-          end
-        end
-      end
-
-      # Returns a hash mapping indexes in the token array to grammar
-      # paths, e.g.:
-      # {  0 => [:program, :assign, :var_field, :@ident],
-      #    1 => [:program, :assign],
-      #    2 => [:program, :assign, :@int],
-      #    4 => [:program, :assign, :var_field, :@ident],
-      #    5 => [:program, :assign],
-      #    7 => [:program, :assign, :@int],
-      #    9 => [:program, :assign, :var_field, :@ident],
-      #   11 => [:program, :assign],
-      #   12 => [:program, :assign, :@int] }
-      def correlate(sexp, path = [])
-        case sexp
-        when Array
-          case sexp[0]
-          when /^@/
-            # Leaves in the grammar have a corresponding token with a
-            # position, which we search for and advance @ix.
-            @ix = @index_by_pos[[sexp[-1].lineno, sexp[-1].column]]
-            fail "#{sexp}\n#{@index_by_pos}" unless @ix
-            @table[@ix] = path + [sexp[0]]
-            @ix += 1
-          when *@special.keys
-            # Here we don't advance @ix because there may be other
-            # tokens inbetween the current one and the one we get from
-            # @special.
-            find(path, sexp, @special[sexp[0]])
-          when :block_var # "{ |...|" or "do |...|"
-            @ix = find(path, sexp, [:on_op, '|']) + 1
-            find(path, sexp, [:on_op, '|'])
-          end
-          path += [sexp[0]] if Symbol === sexp[0]
-          # Compensate for reverse order of if/unless/while/until modifier.
-          modifiers = [:if_mod, :unless_mod, :while_mod, :until_mod]
-          children = modifiers.include?(sexp[0]) ? sexp.reverse : sexp
-
-          children.each do |elem|
-            case elem
-            when Array
-              correlate(elem, path) # Dive deeper
-            when Symbol
-              unless elem.to_s =~ /^@?[a-z_]+$/
-                # There's a trailing @ in some symbols in sexp,
-                # e.g. :-@, that don't appear in tokens. That's why we
-                # chomp it off.
-                find(path, [elem], [:on_op, elem.to_s.chomp('@')])
-              end
-            end
-          end
-        end
-        @table
-      end
-
-      private
-
-      def find(path, sexp, token_to_find)
-        indices = @token_indexes[token_to_find] or return
-        ix = indices.find { |i| i >= @ix } or return
-        @table[ix] = path + [sexp[0]]
-        add_matching_rbrace(ix) if token_to_find == [:on_lbrace, '{']
-        ix
-      end
-
-      def add_matching_rbrace(ix)
-        brace_depth = 0
-        rbrace_offset = @tokens_without_pos[ix..-1].index do |t|
-          brace_depth += 1 if t == [:on_lbrace, '{']
-          brace_depth -= 1 if t == [:on_rbrace, '}']
-          brace_depth == 0 && t == [:on_rbrace, '}']
-        end
-        @table[ix + rbrace_offset] = @table[ix] if rbrace_offset
-      end
-    end
-  end
-end

data/lib/rubocop/cop/indentation.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class Indentation < Cop
-      ERROR_MESSAGE = 'Indent when as deep as case.'
-
-      def inspect(file, source, tokens, sexp)
-        case_tokens = find_keywords(tokens, 'case')
-        when_tokens = find_keywords(tokens, 'when')
-        each_when(sexp) do |case_ix|
-          when_pos = when_tokens.shift.pos
-          if when_pos.column != case_tokens[case_ix].pos.column
-            add_offence(:convention, when_pos.lineno, ERROR_MESSAGE)
-          end
-        end
-      end
-
-      def find_keywords(tokens, keyword)
-        indexes = tokens.each_index.select do |ix|
-          keyword?(tokens, ix, keyword)
-        end
-        tokens.values_at(*indexes)
-      end
-
-      def keyword?(tokens, ix, keyword)
-        [tokens[ix].type, tokens[ix].text] == [:on_kw, keyword] &&
-          tokens[ix - 1].type != :on_symbeg
-      end
-
-      # Does a depth first search for :when, yielding the index of the
-      # corresponding :case for each one.
-      def each_when(sexp, case_ix = -1, &block)
-        if sexp[0] == :case
-          @total_case_ix = (@total_case_ix || -1) + 1
-          each_when(sexp[2], @total_case_ix, &block)
-        else
-          yield case_ix if sexp[0] == :when
-          sexp.grep(Array).each { |s| each_when(s, case_ix, &block) }
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/cops/ampersands_pipes_vs_and_or_spec.rb

@@ -1,57 +0,0 @@
-# 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.
-        expect(amp.offences.map(&:message)).to eq(
-          ['Use &&/|| for boolean expressions, and/or for control flow.'])
-        expect(amp.offences[0].line_number).to eq(1)
-      end
-    end
-  end
-end

data/spec/rubocop/cops/grammar_spec.rb

@@ -1,71 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Grammar do
-      EXAMPLE = '3.times { |i| x = "#{y}#{z}}" }'
-      tokens = Ripper.lex(EXAMPLE).map { |t| Token.new(*t) }
-      let(:grammar) { Grammar.new(tokens) }
-
-      it 'correlates token indices to grammar paths', ruby: 2.0 do
-        method_block = [:program, :method_add_block]
-        brace_block = method_block + [:brace_block]
-        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'], # 10
-           [[1, 15], :on_sp, ' '],
-           [[1, 16], :on_op, '='],
-           [[1, 17], :on_sp, ' '],
-           [[1, 18], :on_tstring_beg, '"'],
-           [[1, 19], :on_embexpr_beg, '#{'], # 15
-           [[1, 21], :on_ident, 'y'],
-           [[1, 22], :on_embexpr_end, '}'], # [[1, 22], :on_rbrace, '}'],
-           [[1, 23], :on_embexpr_beg, '#{'],
-           [[1, 25], :on_ident, 'z'],
-           [[1, 26], :on_embexpr_end, '}'], # [[1, 26], :on_rbrace, '}'], # 20
-           [[1, 27], :on_tstring_content, '}'],
-           [[1, 28], :on_tstring_end, '"'],
-           [[1, 29], :on_sp, ' '],
-           [[1, 30], :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 => brace_block + [:assign, :string_literal, :string_content,
-                               :string_embexpr, varref, :@ident], # y
-          19 => brace_block + [:assign, :string_literal, :string_content,
-                               :string_embexpr, varref, :@ident], # z
-          21 => brace_block + [:assign, :string_literal, :string_content,
-                               :@tstring_content],                # }
-        }
-        if RUBY_VERSION >= '2.0'
-          expect(grammar.correlate(sexp)).to eq(test)
-        else
-          test = (test[24] = brace_block)
-          expect(grammar.correlate(sexp)).to eq(test)
-        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/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