rubocop 0.5.0 → 0.6.0

data/lib/rubocop/cop/brace_after_percent.rb

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

data/lib/rubocop/cop/cop.rb

@@ -32,7 +32,7 @@ module Rubocop
 
     class Cop
       attr_accessor :offences
-      attr_writer :correlations
+      attr_writer :correlations, :disabled_lines
 
       @all = []
       @config = {}
@@ -55,7 +55,9 @@ module Rubocop
       end
 
       def add_offence(severity, line_number, message)
-        @offences << Offence.new(severity, line_number, message)
+        unless @disabled_lines && @disabled_lines.include?(line_number)
+          @offences << Offence.new(severity, line_number, message)
+        end
       end
 
       private
@@ -83,13 +85,23 @@ module Rubocop
         end
       end
 
+      def find_all(sym, sexp)
+        result = []
+        each(sym, sexp) { |s| result << s }
+        result
+      end
+
+      def find_first(sym, sexp)
+        find_all(sym, sexp).first
+      end
+
       def whitespace?(token)
         [:on_sp, :on_ignored_nl, :on_nl].include?(token.type)
       end
 
       def all_positions(sexp)
         return [sexp[2]] if sexp[0] =~ /^@/
-        sexp.grep(Array).reduce([]) { |memo, s| memo + all_positions(s) }
+        sexp.grep(Array).reduce([]) { |a, e| a + all_positions(e) }
       end
     end
   end

data/lib/rubocop/cop/encoding.rb

@@ -3,7 +3,7 @@
 module Rubocop
   module Cop
     class Encoding < Cop
-      ERROR_MESSAGE = 'Missing encoding comment.'
+      ERROR_MESSAGE = 'Missing utf-8 encoding comment.'
 
       def inspect(file, source, tokens, sexp)
         unless RUBY_VERSION >= '2.0.0'

data/lib/rubocop/cop/ensure_return.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class EnsureReturn < Cop
+      ERROR_MESSAGE = 'Never return from an ensure block.'
+
+      def inspect(file, source, tokens, sexp)
+        in_ensure = false
+        ensure_col = nil
+
+        tokens.each_index do |ix|
+          t = tokens[ix]
+          if ensure_start?(t)
+            in_ensure = true
+            ensure_col = t.pos.column
+          elsif ensure_end?(t, ensure_col)
+            in_ensure = false
+          elsif in_ensure && t.type == :on_kw && t.text == 'return'
+            add_offence(:warning, t.pos.lineno, ERROR_MESSAGE)
+          end
+        end
+      end
+
+      private
+
+      def ensure_start?(t)
+        t.type == :on_kw && t.text == 'ensure'
+      end
+
+      def ensure_end?(t, column)
+        t.type == :on_kw && t.text == 'end' && t.pos.column == column
+      end
+    end
+  end
+end

data/lib/rubocop/cop/favor_percent_r.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class FavorPercentR < Cop
+      ERROR_MESSAGE = 'Use %r for regular expressions matching more ' +
+        "than one '/' character."
+
+      def inspect(file, source, tokens, sexp)
+        tokens.each_cons(2) do |t1, t2|
+          if t1.type == :on_regexp_beg && t1.text == '/' &&
+              t2.text.scan(/\//).size > 1
+            add_offence(:convention, t1.pos.lineno, ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/favor_sprintf.rb

@@ -14,16 +14,8 @@ module Rubocop
           # we care only about the % operator
           next unless matching?(operator, op1, op2)
 
-          # FIXME implement reliable lineno extraction
-          # we either have some string literal
-          if op1[0] == :string_literal
-            lineno_struct = s[1][1][1][2]
-            lineno = lineno_struct.lineno if lineno_struct.respond_to?(:lineno)
-          else
-            # or some identifier
-            lineno_struct = s[1][1][2]
-            lineno = lineno_struct.lineno if lineno_struct.respond_to?(:lineno)
-          end
+          pos = all_positions(s[1]).first
+          lineno = pos.lineno if pos
 
           add_offence(
             :convention,

data/lib/rubocop/cop/grammar.rb

@@ -16,8 +16,9 @@ module Rubocop
         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, '{']
+          assign:      [[:on_op,     '=']],
+          brace_block: [[:on_lbrace, '{']],
+          ifop:        [[:on_op, '?'], [:on_op, ':']]
         }
       end
 
@@ -84,7 +85,9 @@ module Rubocop
             # 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]])
+            @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, '|'])

data/lib/rubocop/cop/handle_exceptions.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class HandleExceptions < Cop
+      ERROR_MESSAGE = 'Do not suppress exceptions.'
+
+      def inspect(file, source, tokens, sexp)
+        each(:begin, sexp) do |s|
+          each(:rescue, s) do |rs|
+            if rs[3] == [[:void_stmt]]
+              add_offence(:warning,
+                          all_positions(s)[-1].lineno + 1,
+                          ERROR_MESSAGE)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/hash_literal.rb

@@ -0,0 +1,22 @@
+# 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)
+        each(:method_add_arg, sexp) do |s|
+          potential_class = s[1][1][1]
+
+          if potential_class[1] == 'Hash' && s[1][3][1] == 'new' &&
+              s[2] == [:arg_paren, nil]
+            add_offence(:convention,
+                        potential_class[2].lineno,
+                        ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/method_length.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class MethodLength < Cop
+      ERROR_MESSAGE = 'Method has too many lines. [%d/%d]'
+
+      def inspect(file, source, tokens, sexp)
+        def_token_indices(tokens, source).each do |t_ix|
+          def_lineno, end_lineno = def_and_end_lines(tokens, t_ix)
+          length = calculate_length(def_lineno, end_lineno, source)
+
+          if length > MethodLength.max
+            message = sprintf(ERROR_MESSAGE, length, MethodLength.max)
+            add_offence(:convention, def_lineno, message)
+          end
+        end
+      end
+
+      def self.max
+        MethodLength.config ? MethodLength.config['Max'] || 10 : 10
+      end
+
+      def self.count_comments?
+        if MethodLength.config
+          MethodLength.config['CountComments'] || false
+        else
+          false
+        end
+      end
+
+      private
+
+      def calculate_length(def_lineno, end_lineno, source)
+        lines = source[def_lineno..(end_lineno - 2)].reject(&:empty?)
+        unless MethodLength.count_comments?
+          lines = lines.reject { |line| line =~ /^\s*#/ }
+        end
+        lines.size
+      end
+
+      def def_token_indices(tokens, source)
+        tokens.each_index.select do |ix|
+          t = tokens[ix]
+
+          # Need to check:
+          # 1. if the previous character is a ':' to prevent matching ':def'
+          # 2. if the method is a one line, which we will ignore
+          [t.type, t.text] == [:on_kw, 'def'] &&
+            source[t.pos.lineno - 1][t.pos.column - 1] != ':' &&
+            source[t.pos.lineno - 1] !~ /^\s*def.*(?:\(.*\)|;).*end\s*$/
+        end
+      end
+
+      # Find the matching 'end' based on the indentation of 'def'
+      # Fall back to last token if indentation cannot be matched
+      def def_and_end_lines(tokens, t_ix)
+        t1 = tokens[t_ix]
+        t2 = tokens[(t_ix + 1)..-1].find(-> { tokens[-1] }) do |t|
+          [t1.pos.column, t.type, t.text] == [t.pos.column, :on_kw, 'end']
+        end
+        [t1.pos.lineno, t2.pos.lineno]
+      end
+    end
+  end
+end

data/lib/rubocop/cop/op_method.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class OpMethod < Cop
+      ERROR_MESSAGE = 'When defining the %s operator, name its argument other.'
+
+      def inspect(file, source, tokens, sexp)
+        each(:def, sexp) do |s|
+          if s[1][0] == :@op && !%w([] []= <<).include?(s[1][1])
+            param = s[2][1][1][0]
+
+            unless param[1] == 'other'
+              add_offence(:convention,
+                          param[2].lineno,
+                          sprintf(ERROR_MESSAGE, s[1][1]))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/percent_literals.rb

@@ -0,0 +1,25 @@
+# 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/percent_r.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class PercentR < Cop
+      ERROR_MESSAGE = 'Use %r only for regular expressions matching more ' +
+        "than one '/' character."
+
+      def inspect(file, source, tokens, sexp)
+        tokens.each_cons(2) do |t1, t2|
+          if t1.type == :on_regexp_beg && t1.text =~ /^%r/ &&
+              t2.text !~ %r(/.*/)
+            add_offence(:convention, t1.pos.lineno, ERROR_MESSAGE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/reduce_arguments.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class ReduceArguments < Cop
+      ERROR_MESSAGE = 'Name reduce arguments |a, e| (accumulator, element)'
+
+      def inspect(file, source, tokens, sexp)
+        find_reduce_blocks(tokens).each do |reduce_block|
+          l_ix, r_ix = reduce_block
+          unless arguments_named_properly?(l_ix, r_ix, tokens)
+            add_offence(:convention, tokens[l_ix].pos.lineno, ERROR_MESSAGE)
+          end
+        end
+      end
+
+      private
+
+      def arguments_named_properly?(l_ix, r_ix, tokens)
+        a, e = false, false
+        tokens[l_ix..r_ix].each do |t|
+          if a == true && [t.type, t.text] == [:on_ident, 'e']
+            e = true
+          elsif [t.type, t.text] == [:on_ident, 'a']
+            a = true
+          end
+        end
+        a && e
+      end
+
+      def find_reduce_blocks(tokens)
+        blocks = []
+        tokens.each_with_index do |t, ix|
+          if [t.type, t.text] == [:on_ident, 'reduce']
+            # Make sure we didn't select a :reduce symbol
+            next if tokens[ix - 1].text == ':'
+
+            block = find_brace_block(tokens, ix)
+            blocks << block if block
+          end
+        end
+        blocks
+      end
+
+      def find_brace_block(tokens, reduce_ix)
+        stack = []
+        block = false
+
+        # When we find the braces we need to add reduce_ix in order to
+        # find the real tokens index, since we're looping through a subset
+        tokens[reduce_ix..-1].each_with_index do |t, ix|
+          break if t.pos.lineno != tokens[reduce_ix].pos.lineno
+          if [:on_lbrace, :on_tlambeg].include? t.type
+            stack.push ix + reduce_ix
+          elsif t.type == :on_rbrace
+            left_ix = stack.pop
+            ix += reduce_ix
+            block = [left_ix, ix] if (stack.empty? &&
+                                      tokens[left_ix].type != :on_tlambeg)
+          end
+        end
+
+        block
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rescue_exception.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class RescueException < Cop
+      ERROR_MESSAGE = 'Avoid rescuing the Exception class.'
+
+      def inspect(file, source, tokens, sexp)
+        each(:rescue, sexp) do |s|
+          # TODO Improve handling of rescue One, Two => e
+          if valid_case?(s)
+            target_class = s[1][0][1][1]
+
+            lineno = s[1][0][1][2].lineno
+
+            add_offence(:warning,
+                        lineno,
+                        ERROR_MESSAGE) if target_class == 'Exception'
+          end
+        end
+      end
+
+      def valid_case?(s)
+        if s[1].nil?
+          # rescue with no args
+          false
+        elsif s[1][0] == :mrhs_new_from_args
+          # rescue One, Two => e
+          false
+        elsif s[1][0][0] == :const_path_ref
+          # rescue Module::Class
+          false
+        else
+          true
+        end
+      end
+    end
+  end
+end