rubocop 0.7.2 → 0.8.0

data/lib/rubocop/cop/empty_line_between_defs.rb

@@ -3,23 +3,19 @@
 module Rubocop
   module Cop
     class EmptyLineBetweenDefs < Cop
-      ERROR_MESSAGE = 'Use empty lines between defs.'
+      MSG = 'Use empty lines between defs.'
 
-      def inspect(file, source, tokens, sexp)
-        each_parent_of(:def, sexp) do |parent|
-          defs = parent.select { |child| child[0] == :def }
-          identifier_of_first_def = defs[0][1]
-          current_row_ix = identifier_of_first_def[-1].lineno - 1
-          # The first def doesn't need to have an empty line above it,
-          # so we iterate starting at index 1.
-          defs[1..-1].each do |child|
-            next_row_ix = child[1][-1].lineno - 1
-            if source[current_row_ix..next_row_ix].grep(/^[ \t]*$/).empty?
-              add_offence(:convention, next_row_ix + 1, ERROR_MESSAGE)
-            end
-            current_row_ix = next_row_ix
-          end
+      def on_def(s)
+        def_start = s.loc.keyword.line
+        def_end = s.loc.end.line
+
+        if @prev_def_end && (def_start - @prev_def_end) < 2
+          add_offence(:convention, def_start, MSG)
         end
+
+        @prev_def_end = def_end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/empty_lines.rb

@@ -3,19 +3,30 @@
 module Rubocop
   module Cop
     class EmptyLines < Cop
-      ERROR_MESSAGE = 'Extra blank line detected.'
+      MSG = 'Extra blank line detected.'
+      LINE_OFFSET = 2
 
-      def inspect(file, source, tokens, sexp)
-        previous_token = Token.new(0, :init, '')
+      def inspect(source, tokens, ast, comments)
+        return if tokens.empty?
 
-        tokens.each do |t|
-          if t.type == :on_ignored_nl && previous_token.type == :on_ignored_nl
-            add_offence(:convention,
-                        t.pos.lineno,
-                        ERROR_MESSAGE)
+        prev_line = 1
+
+        tokens.each do |token|
+          cur_line = token.pos.line
+          line_diff = cur_line - prev_line
+
+          if line_diff > LINE_OFFSET
+            # we need to be wary of comments since they
+            # don't show up in the tokens
+            ((prev_line + 1)...cur_line).each do |line|
+              # we check if the prev and current lines are empty
+              if source[line - 2].empty? && source[line - 1].empty?
+                add_offence(:convention, line, MSG)
+              end
+            end
           end
 
-          previous_token = t
+          prev_line = cur_line
         end
       end
     end

data/lib/rubocop/cop/empty_literal.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    class EmptyLiteral < Cop
+      ARR_MSG = 'Use array literal [] instead of Array.new.'
+      HASH_MSG = 'Use hash literal {} instead of Hash.new.'
+      STR_MSG = "Use string literal '' instead of String.new."
+
+      # Empty array node
+      #
+      # (send
+      #   (const nil :Array) :new)
+      ARRAY_NODE = s(:send, s(:const, nil, :Array), :new)
+
+      # Empty hash node
+      #
+      # (send
+      #   (const nil :Hash) :new)
+      HASH_NODE = s(:send, s(:const, nil, :Hash), :new)
+
+      # Empty string node
+      #
+      # (send
+      #   (const nil :String) :new)
+      STR_NODE = s(:send, s(:const, nil, :String), :new)
+
+      def inspect(source, tokens, ast, comments)
+        on_node(:send, ast, :block) do |node|
+          if node == ARRAY_NODE
+            add_offence(:convention,
+                        node.loc.line,
+                        ARR_MSG)
+          elsif node == HASH_NODE
+            add_offence(:convention,
+                        node.loc.line,
+                        HASH_MSG)
+          elsif node == STR_NODE
+            add_offence(:convention,
+                        node.loc.line,
+                        STR_MSG)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/encoding.rb

@@ -3,14 +3,14 @@
 module Rubocop
   module Cop
     class Encoding < Cop
-      ERROR_MESSAGE = 'Missing utf-8 encoding comment.'
+      MSG = 'Missing utf-8 encoding comment.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         unless RUBY_VERSION >= '2.0.0'
           expected_line = 0
           expected_line += 1 if source[expected_line] =~ /^#!/
           unless source[expected_line] =~ /#.*coding: (UTF|utf)-8/
-            add_offence(:convention, 1, ERROR_MESSAGE)
+            add_offence(:convention, 1, MSG)
           end
         end
       end

data/lib/rubocop/cop/end_of_line.rb

@@ -3,11 +3,11 @@
 module Rubocop
   module Cop
     class EndOfLine < Cop
-      ERROR_MESSAGE = 'Carriage return character detected.'
+      MSG = 'Carriage return character detected.'
 
-      def inspect(file, source, tokens, sexp)
+      def inspect(source, tokens, ast, comments)
         source.each_with_index do |line, index|
-          add_offence(:convention, index + 1, ERROR_MESSAGE) if line =~ /\r$/
+          add_offence(:convention, index + 1, MSG) if line =~ /\r$/
         end
       end
     end

data/lib/rubocop/cop/ensure_return.rb

@@ -3,33 +3,16 @@
 module Rubocop
   module Cop
     class EnsureReturn < Cop
-      ERROR_MESSAGE = 'Never return from an ensure block.'
+      MSG = 'Never return from an ensure block.'
 
-      def inspect(file, source, tokens, sexp)
-        in_ensure = false
-        ensure_col = nil
+      def on_ensure(node)
+        _body, ensure_body = *node
 
-        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
+        on_node(:return, ensure_body) do |e|
+          add_offence(:warning, e.loc.line, MSG)
         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
+        super
       end
     end
   end

data/lib/rubocop/cop/eval.rb

@@ -3,19 +3,16 @@
 module Rubocop
   module Cop
     class Eval < Cop
-      ERROR_MESSAGE = 'The use of eval is a serious security risk.'
+      MSG = 'The use of eval is a serious security risk.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:command, sexp) { |s| process_ident(s[1]) }
-        each(:fcall, sexp) { |s| process_ident(s[1]) }
-      end
+      def on_send(node)
+        receiver, method_name, = *node
 
-      def process_ident(sexp)
-        if sexp[0] == :@ident && sexp[1] == 'eval'
-          add_offence(:security,
-                      sexp[2].lineno,
-                      ERROR_MESSAGE)
+        if receiver.nil? && method_name == :eval
+          add_offence(:security, node.loc.line, MSG)
         end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/favor_join.rb

@@ -3,34 +3,19 @@
 module Rubocop
   module Cop
     class FavorJoin < Cop
-      ERROR_MESSAGE = 'Favor Array#join over Array#*.'
+      MSG = 'Favor Array#join over Array#*.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:binary, sexp) do |s|
-          op1 = s[1]
-          operator = s[2]
-          op2 = s[3]
+      def on_send(node)
+        receiver_node, method_name, *arg_nodes = *node
 
-          # we care only about the * operator
-          next unless matching?(operator, op1, op2)
-
-          pos = all_positions(s[1]).first
-          lineno = pos.lineno if pos
-
-          add_offence(
-            :convention,
-            lineno,
-            ERROR_MESSAGE
-          ) if lineno
+        if receiver_node && receiver_node.type == :array &&
+            method_name == :* && arg_nodes[0].type == :str
+          add_offence(:convention,
+                      node.loc.expression.line,
+                      MSG)
         end
-      end
-
-      private
-
-      def matching?(operator, op1, op2)
-        return false unless operator == :*
 
-        op1[0] == :array and op2[0] == :string_literal
+        super
       end
     end
   end

data/lib/rubocop/cop/favor_modifier.rb

@@ -3,53 +3,36 @@
 module Rubocop
   module Cop
     module FavorModifier
-      def check(kind, tokens, sexp)
-        token_positions = tokens.map(&:pos)
-        token_texts = tokens.map(&:text)
-        each(kind, sexp) do |s|
-          # If it contains an else, it can't be written as a modifier.
-          next if s[3] && s[3][0] == :else
+      # TODO extremely ugly solution that needs lots of polish
+      def check(sexp)
+        # discard if/then/else
+        return false if sexp.loc.respond_to?(:else) && sexp.loc.else
 
-          sexp_positions = all_positions(s)
-          ix = token_positions.index(sexp_positions.first)
-          if_ix = token_texts[0..ix].rindex(kind.to_s) # index of if/unless/...
-          ix = token_positions.index(sexp_positions.last)
-          end_ix = ix + token_texts[ix..-1].index('end')
+        if %w(if while).include?(sexp.loc.keyword.source)
+          cond, body = *sexp
+        else
+          cond, _else, body = *sexp
+        end
 
-          # If there's a comment anywhere between
-          # if/unless/while/until and end, we don't report. It's
-          # possible that the comment will be less clear if put above
-          # a one liner rather than inside.
-          next if tokens[if_ix...end_ix].map(&:type).include?(:on_comment)
+        if length(sexp) > 3
+          false
+        else
+          cond_length = sexp.loc.keyword.size + cond.loc.expression.size + 1
+          body_length = body_length(body)
 
-          if token_positions[end_ix].lineno - token_positions[if_ix].lineno > 2
-            next # not a single-line body
-          end
-          # The start ix is the index of the leftmost token on the
-          # line of the if/unless, i.e. the index of if/unless itself,
-          # or of the indentation space.
-          start_ix = if_ix.downto(0).find do |block_ix|
-            block_ix == 0 || tokens[block_ix - 1].text =~ /\n/
-          end
-          # The stop index is the index of the token just before
-          # 'end', not counting whitespace tokens.
-          stop_ix = (end_ix - 1).downto(0).find do |block_ix|
-            tokens[block_ix].text !~ /\s/
-          end
-          if length(tokens, start_ix, stop_ix) <= LineLength.max
-            add_offence(:convention, token_positions[if_ix].lineno,
-                        error_message)
-          end
+          (cond_length + body_length) <= LineLength.max
         end
       end
 
-      def length(tokens, start_ix, stop_ix)
-        (start_ix..stop_ix).reduce(0) do |acc, ix|
-          acc + if ix > start_ix && tokens[ix - 1].text =~ /\n/
-                  0
-                else
-                  tokens[ix].text.length
-                end
+      def length(sexp)
+        sexp.loc.expression.source.split("\n").size
+      end
+
+      def body_length(body)
+        if body
+          body.loc.expression.column + body.loc.expression.size
+        else
+          0
         end
       end
     end
@@ -59,23 +42,30 @@ module Rubocop
 
       def error_message
         'Favor modifier if/unless usage when you have a single-line body. ' +
-          'Another good alternative is the usage of control flow and/or.'
+          'Another good alternative is the usage of control flow &&/||.'
       end
 
-      def inspect(file, source, tokens, sexp)
-        [:if, :unless].each { |kind| check(kind, tokens, sexp) }
+      def on_if(node)
+        # discard ternary ops and modifier if/unless nodes
+        return unless node.loc.respond_to?(:keyword) &&
+          node.loc.respond_to?(:else)
+
+        add_offence(:convention, node.loc.line, error_message) if check(node)
+
+        super
       end
     end
 
     class WhileUntilModifier < Cop
       include FavorModifier
 
-      def error_message
+      MSG =
         'Favor modifier while/until usage when you have a single-line body.'
-      end
 
-      def inspect(file, source, tokens, sexp)
-        [:while, :until].each { |kind| check(kind, tokens, sexp) }
+      def inspect(source, tokens, ast, comments)
+        on_node([:while, :until], ast) do |node|
+          add_offence(:convention, node.loc.line, MSG) if check(node)
+        end
       end
     end
   end

data/lib/rubocop/cop/favor_percent_r.rb

@@ -3,16 +3,16 @@
 module Rubocop
   module Cop
     class FavorPercentR < Cop
-      ERROR_MESSAGE = 'Use %r for regular expressions matching more ' +
+      MSG = '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
+      def on_regexp(node)
+        if node.loc.begin.source == '/' &&
+            node.loc.expression.source[1...-1].scan(/\//).size > 1
+          add_offence(:convention, node.loc.line, MSG)
         end
+
+        super
       end
     end
   end

data/lib/rubocop/cop/favor_sprintf.rb

@@ -3,34 +3,18 @@
 module Rubocop
   module Cop
     class FavorSprintf < Cop
-      ERROR_MESSAGE = 'Favor sprintf over String#%.'
+      MSG = 'Favor sprintf over String#%.'
 
-      def inspect(file, source, tokens, sexp)
-        each(:binary, sexp) do |s|
-          op1 = s[1]
-          operator = s[2]
-          op2 = s[3]
+      def on_send(node)
+        receiver_node, method_name, *arg_nodes = *node
 
-          # we care only about the % operator
-          next unless matching?(operator, op1, op2)
-
-          pos = all_positions(s[1]).first
-          lineno = pos.lineno if pos
-
-          add_offence(
-            :convention,
-            lineno,
-            ERROR_MESSAGE
-          ) if lineno
+        if method_name == :% &&
+            ([:str, :dstr].include?(receiver_node.type) ||
+             arg_nodes[0].type == :array)
+          add_offence(:convention, node.loc.expression.line, MSG)
         end
-      end
-
-      private
-
-      def matching?(operator, op1, op2)
-        return false unless operator == :%
 
-        op1[0] == :string_literal or op2[0] == :array
+        super
       end
     end
   end