rubocop 0.7.2 → 0.8.0

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/lib/rubocop/cop/ampersands_pipes_vs_and_or.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class AmpersandsPipesVsAndOr < Cop
-      ERROR_MESSAGE =
-        'Use &&/|| for boolean expressions, and/or for control flow.'
-
-      def inspect(file, source, tokens, sexp)
-        [:if, :unless, :while, :until].each { |keyword| check(keyword, sexp) }
-      end
-
-      def check(keyword, sexp)
-        each(keyword, sexp) do |sub_sexp|
-          condition = sub_sexp[1]
-          if condition[0] == :binary && [:and, :or].include?(condition[2])
-            add_offence(:convention,
-                        sub_sexp.flatten.grep(Position).first.lineno,
-                        ERROR_MESSAGE)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/array_literal.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class ArrayLiteral < Cop
-      ERROR_MESSAGE = 'Use array literal [] instead of Array.new.'
-
-      def inspect(file, source, tokens, sexp)
-        offences = preliminary_scan(sexp)
-
-        # find Array.new()
-        each(:method_add_arg, sexp) do |s|
-          next if s[1][0] != :call
-
-          receiver = s[1][1][1]
-          method_name = s[1][3][1]
-
-          if receiver && receiver[1] == 'Array' &&
-              method_name == 'new' && s[2] == [:arg_paren, nil]
-            offences.delete(Offence.new(:convention,
-                                        receiver[2].lineno,
-                                        ERROR_MESSAGE))
-            add_offence(:convention,
-                        receiver[2].lineno,
-                        ERROR_MESSAGE)
-          end
-
-          # check for false positives
-          if receiver && receiver[1] == 'Array' &&
-              method_name == 'new' && s[2] != [:arg_paren, nil]
-            offences.delete(Offence.new(:convention,
-                                        receiver[2].lineno,
-                                        ERROR_MESSAGE))
-          end
-        end
-
-        offences.each { |o| add_offence(*o.explode) }
-      end
-
-      def preliminary_scan(sexp)
-        offences = []
-
-        # find Array.new
-        # there will be some false positives here, which
-        # we'll eliminate later on
-        each(:call, sexp) do |s|
-          receiver = s[1][1]
-
-          if receiver && receiver[1] == 'Array' &&
-              s[3][1] == 'new'
-            offences << Offence.new(:convention,
-                                    receiver[2].lineno,
-                                    ERROR_MESSAGE)
-          end
-        end
-
-        offences
-      end
-    end
-  end
-end

data/lib/rubocop/cop/brace_after_percent.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class BraceAfterPercent < Cop
-      ERROR_MESSAGE = 'Prefer () as delimiters for all % literals.'
-      LITERALS = {
-        on_tstring_beg: ['%q', '%Q'],
-        on_words_beg: '%W',
-        on_qwords_beg: '%w',
-        on_qsymbols_beg: '%i',
-        on_symbols_beg: '%I',
-        on_regexp_beg: '%r',
-        on_symbeg: '%s',
-        on_backtick: '%x'
-      }
-
-      def inspect(file, source, tokens, sexp)
-        tokens.each_index do |ix|
-          t = tokens[ix]
-          literals = Array(LITERALS[t.type])
-          literals.each do |literal|
-            if literal && t.text.start_with?(literal) && t.text[2] != '('
-              add_offence(:convention, t.pos.lineno,
-                          ERROR_MESSAGE)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/grammar.rb

@@ -1,138 +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 if RUBY_VERSION < '2.0'
-        @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, '{']],
-          hash:        [[:on_lbrace, '{']],
-          ifop:        [[:on_op, '?'], [:on_op, ':']]
-        }
-      end
-
-      # In ruby 1.9.3 and below, 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, :on_embexpr_end
-              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.
-            @special[sexp[0]].each do |token_to_find|
-              find(path, sexp, token_to_find)
-            end
-          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 then 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/hash_literal.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class HashLiteral < Cop
-      ERROR_MESSAGE = 'Use hash literal {} instead of Hash.new.'
-
-      def inspect(file, source, tokens, sexp)
-        offences = preliminary_scan(sexp)
-
-        # find Hash.new()
-        each(:method_add_arg, sexp) do |s|
-          next if s[1][0] != :call
-
-          receiver = s[1][1][1]
-          method_name = s[1][3][1]
-
-          if receiver && receiver[1] == 'Hash' &&
-              method_name == 'new' && s[2] == [:arg_paren, nil]
-            offences.delete(Offence.new(:convention,
-                                        receiver[2].lineno,
-                                        ERROR_MESSAGE))
-            add_offence(:convention,
-                        receiver[2].lineno,
-                        ERROR_MESSAGE)
-          end
-
-          # check for false positives
-          if receiver && receiver[1] == 'Hash' &&
-              method_name == 'new' && s[2] != [:arg_paren, nil]
-            offences.delete(Offence.new(:convention,
-                                        receiver[2].lineno,
-                                        ERROR_MESSAGE))
-          end
-        end
-
-        offences.each { |o| add_offence(*o.explode) }
-      end
-
-      def preliminary_scan(sexp)
-        offences = []
-
-        # find Hash.new
-        # there will be some false positives here, which
-        # we'll eliminate later on
-        each(:call, sexp) do |s|
-          receiver = s[1][1]
-
-          if receiver && receiver[1] == 'Hash' &&
-              s[3][1] == 'new'
-            offences << Offence.new(:convention,
-                                    receiver[2].lineno,
-                                    ERROR_MESSAGE)
-          end
-        end
-
-        offences
-      end
-    end
-  end
-end

data/lib/rubocop/cop/percent_literals.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class PercentLiterals < Cop
-      ERROR_MESSAGE = 'The use of %s is discouraged.'
-      BAD_LITERALS = {
-        on_tstring_beg: '%q',
-        on_symbeg: '%s',
-        on_backtick: '%x'
-      }
-
-      def inspect(file, source, tokens, sexp)
-        tokens.each_index do |ix|
-          t = tokens[ix]
-          bad_token = BAD_LITERALS[t.type]
-          if bad_token && t.text.downcase.start_with?(bad_token)
-            add_offence(:convention, t.pos.lineno,
-                        sprintf(ERROR_MESSAGE, t.text[0, 2]))
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/symbol_snake_case.rb

@@ -1,47 +0,0 @@
-# encoding: utf-8
-
-module Rubocop
-  module Cop
-    class SymbolSnakeCase < Cop
-      ERROR_MESSAGE = 'Use snake_case for symbols.'
-      SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
-      def inspect(file, source, tokens, sexp)
-        check_for_symbols(sexp)
-        check_for_hash_labels(sexp)
-      end
-
-      private
-
-      def check_for_symbols(sexp)
-        each(:symbol_literal, sexp) do |s|
-          symbol_type = s[1][0] == :symbol ? s[1][1][0] : s[1][0]
-
-          # don't check operators
-          next if symbol_type == :@op
-
-          symbol_ident = s[1][1][1]
-
-          unless symbol_ident =~ SNAKE_CASE
-            line_no = s[1][1][2].lineno
-            add_offence(:convention,
-                        line_no,
-                        ERROR_MESSAGE)
-          end
-        end
-      end
-
-      def check_for_hash_labels(sexp)
-        each(:@label, sexp) do |s|
-          label_ident = s[1].chop
-
-          unless label_ident =~ SNAKE_CASE
-            line_no = s[2].lineno
-            add_offence(:convention,
-                        line_no,
-                        ERROR_MESSAGE)
-          end
-        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