rubocop 0.16.0 → 0.17.0

data/lib/rubocop/cop/mixin/space_inside.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for checking for spaces inside various
+    # kinds of parentheses.
+    module SpaceInside
+      include SurroundingSpace
+      MSG = 'Space inside %s detected.'
+
+      def investigate(processed_source)
+        @processed_source = processed_source
+        left, right, kind = specifics
+        processed_source.tokens.each_cons(2) do |t1, t2|
+          if t1.type == left || t2.type == right
+            if t2.pos.line == t1.pos.line && space_between?(t1, t2)
+              range = Parser::Source::Range.new(processed_source.buffer,
+                                                t1.pos.end_pos,
+                                                t2.pos.begin_pos)
+              add_offence(range, range, format(MSG, kind))
+            end
+          end
+        end
+      end
+
+      def autocorrect(range)
+        @corrections << ->(corrector) { corrector.remove(range) }
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for modifier cops.
+    module StatementModifier
+      include IfNode
+
+      # TODO: Extremely ugly solution that needs lots of polish.
+      def check(sexp, comments)
+        case sexp.loc.keyword.source
+        when 'if'     then cond, body, _else = *sexp
+        when 'unless' then cond, _else, body = *sexp
+        else               cond, body = *sexp
+        end
+
+        return false if length(sexp) > 3
+
+        body_length = body_length(body)
+
+        return false if body_length == 0
+
+        on_node(:lvasgn, cond) do
+          return false
+        end
+
+        indentation = sexp.loc.keyword.column
+        kw_length = sexp.loc.keyword.size
+        cond_length = cond.loc.expression.size
+        space = 1
+        total = indentation + body_length + space + kw_length + space +
+          cond_length
+        total <= max_line_length && !body_has_comment?(body, comments)
+      end
+
+      def max_line_length
+        config.for_cop('LineLength')['Max']
+      end
+
+      def length(sexp)
+        sexp.loc.expression.source.lines.to_a.size
+      end
+
+      def body_length(body)
+        if body && body.loc.expression
+          body.loc.expression.size
+        else
+          0
+        end
+      end
+
+      def body_has_comment?(body, comments)
+        comment_lines = comments.map(&:location).map(&:line)
+        body_line = body.loc.expression.line
+        comment_lines.include?(body_line)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/string_help.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Classes that include this module just implement functions to determine
+    # what is an offence and how to do auto-correction. They get help with
+    # adding offences for the faulty string nodes, and with filtering out
+    # nodes.
+    module StringHelp
+      def on_str(node)
+        # Constants like __FILE__ are handled as strings,
+        # but don't respond to begin.
+        return unless node.loc.respond_to?(:begin) && node.loc.begin
+        return if part_of_ignored_node?(node)
+
+        if offence?(node)
+          add_offence(node, :expression) { opposite_style_detected }
+        else
+          correct_style_detected
+        end
+      end
+
+      def on_dstr(node)
+        ignore_node(node)
+      end
+
+      def on_regexp(node)
+        ignore_node(node)
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/surrounding_space.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # Common functionality for checking surrounding space.
+    module SurroundingSpace
+      def space_between?(t1, t2)
+        char_preceding_2nd_token =
+          @processed_source[t2.pos.line - 1][t2.pos.column - 1]
+        if char_preceding_2nd_token == '+' && t1.type != :tPLUS
+          # Special case. A unary plus is not present in the tokens.
+          char_preceding_2nd_token =
+            @processed_source[t2.pos.line - 1][t2.pos.column - 2]
+        end
+        t2.pos.line > t1.pos.line || char_preceding_2nd_token =~ /[ \t]/
+      end
+
+      def index_of_first_token(node)
+        b = node.loc.expression.begin
+        token_table[[b.line, b.column]]
+      end
+
+      def index_of_last_token(node)
+        e = node.loc.expression.end
+        (0...e.column).to_a.reverse.find do |c|
+          ix = token_table[[e.line, c]]
+          return ix if ix
+        end
+      end
+
+      def token_table
+        @token_table ||= begin
+          table = {}
+          @processed_source.tokens.each_with_index do |t, ix|
+            table[[t.pos.line, t.pos.column]] = ix
+          end
+          table
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/default_scope.rb

@@ -25,7 +25,9 @@ module Rubocop
 
           first_arg = args[0]
 
-          add_offence(first_arg, :expression) if lambda_or_proc?(first_arg)
+          if first_arg.type != :block || lambda_or_proc?(first_arg)
+            add_offence(first_arg, :expression)
+          end
         end
       end
     end

data/lib/rubocop/cop/style/accessor_method_name.rb

@@ -18,23 +18,15 @@ module Rubocop
       #   # good
       #   def attribute ...
       class AccessorMethodName < Cop
-        def on_def(node)
-          method_name, args, _body = *node
-          check(node, method_name.to_s, args)
-        end
-
-        def on_defs(node)
-          _scope, method_name, args, _body = *node
-          check(node, method_name.to_s, args)
-        end
+        include CheckMethods
 
         private
 
-        def check(node, method_name, args)
-          if bad_reader_name?(method_name, args)
+        def check(node, method_name, args, _body)
+          if bad_reader_name?(method_name.to_s, args)
             add_offence(node, :name,
                         'Do not prefix reader method names with get_.')
-          elsif bad_writer_name?(method_name, args)
+          elsif bad_writer_name?(method_name.to_s, args)
             add_offence(node, :name,
                         'Do not prefix writer method names with set_.')
           end

data/lib/rubocop/cop/style/braces_around_hash_parameters.rb

@@ -13,7 +13,7 @@ module Rubocop
           # Discard attr writer methods.
           return if method_name.to_s.end_with?('=')
           # Discard operator methods.
-          return if OPERATOR_METHODS.include?(method_name)
+          return if operator?(method_name)
 
           # We care only for the last argument.
           arg = args.last
@@ -48,6 +48,7 @@ module Rubocop
             if style == :no_braces
               corrector.remove(node.loc.begin)
               corrector.remove(node.loc.end)
+              remove_trailing_comma(node, corrector)
             elsif style == :braces
               corrector.insert_before(node.loc.expression, '{')
               corrector.insert_after(node.loc.expression, '}')
@@ -55,6 +56,20 @@ module Rubocop
           end
         end
 
+        def remove_trailing_comma(node, corrector)
+          sb = node.loc.end.source_buffer
+          pos_after_last_pair = node.children.last.loc.expression.end_pos
+          range_after_last_pair =
+            Parser::Source::Range.new(sb, pos_after_last_pair,
+                                      node.loc.end.begin_pos)
+          trailing_comma_offset = range_after_last_pair.source =~ /,/
+          if trailing_comma_offset
+            comma_begin = pos_after_last_pair + trailing_comma_offset
+            corrector.remove(Parser::Source::Range.new(sb, comma_begin,
+                                                       comma_begin + 1))
+          end
+        end
+
         def non_empty_hash?(arg)
           arg && arg.type == :hash && arg.children.any?
         end

data/lib/rubocop/cop/style/case_indentation.rb

@@ -8,35 +8,52 @@ module Rubocop
       #
       # It will register a separate offence for each misaligned *when*.
       class CaseIndentation < Cop
+        include ConfigurableEnforcedStyle
+
         def on_case(case_node)
           _condition, *whens, _else = *case_node
 
-          base, indent = cop_config.values_at('IndentWhenRelativeTo',
-                                              'IndentOneStep')
+          base = style
+          indent = cop_config['IndentOneStep']
           base_column = base_column(case_node, base)
 
           whens.each do |when_node|
-            pos = when_node.loc.keyword
-            expected_column = base_column +
-              (indent ? IndentationWidth::CORRECT_INDENTATION : 0)
-            if pos.column != expected_column
-              msg = 'Indent when ' + if indent
-                                       "one step more than #{base}."
-                                     else
-                                       "as deep as #{base}."
-                                     end
-              add_offence(when_node, pos, msg)
-            end
+            check_when(when_node, case_node, base, indent, base_column)
           end
         end
 
         private
 
+        def check_when(when_node, case_node, base, indent, base_column)
+          pos = when_node.loc.keyword
+          expected_column = base_column +
+            (indent ? IndentationWidth::CORRECT_INDENTATION : 0)
+          if pos.column == expected_column
+            correct_style_detected
+          else
+            msg = 'Indent when ' + if indent
+                                     "one step more than #{base}."
+                                   else
+                                     "as deep as #{base}."
+                                   end
+            add_offence(when_node, pos, msg) do
+              if pos.column == base_column(case_node, alternative_style)
+                opposite_style_detected
+              else
+                unrecognized_style_detected
+              end
+            end
+          end
+        end
+
+        def parameter_name
+          'IndentWhenRelativeTo'
+        end
+
         def base_column(case_node, base)
           case base
-          when 'case' then case_node.location.keyword.column
-          when 'end'  then case_node.location.end.column
-          else fail "Unknown IndentWhenRelativeTo: #{base}"
+          when :case then case_node.location.keyword.column
+          when :end  then case_node.location.end.column
           end
         end
       end

data/lib/rubocop/cop/style/character_literal.rb

@@ -26,6 +26,16 @@ module Rubocop
             end
           end
         end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def opposite_style_detected
+        end
+
+        # Dummy implementation of method in ConfigurableEnforcedStyle that is
+        # called from StringHelp.
+        def correct_style_detected
+        end
       end
     end
   end

data/lib/rubocop/cop/style/dot_position.rb

@@ -5,16 +5,34 @@ module Rubocop
     module Style
       # This cop checks the . position in multi-line method calls.
       class DotPosition < Cop
-        MSG = 'Place the . on the next line, together with the method name.'
+        include ConfigurableEnforcedStyle
 
         def on_send(node)
           return unless node.loc.dot
 
-          add_offence(node, :dot) unless proper_dot_position?(node)
+          if proper_dot_position?(node)
+            correct_style_detected
+          else
+            add_offence(node, :dot) { opposite_style_detected }
+          end
         end
 
         private
 
+        def message(node)
+          'Place the . on the ' +
+            case style
+            when :leading
+              'next line, together with the method name.'
+            when :trailing
+              'previous line, together with the method call receiver.'
+            end
+        end
+
+        def parameter_name
+          'Style'
+        end
+
         def proper_dot_position?(node)
           dot_line = node.loc.dot.line
 
@@ -25,10 +43,9 @@ module Rubocop
             selector_line = node.loc.begin.line
           end
 
-          case cop_config['Style'].downcase
-          when 'leading' then dot_line == selector_line
-          when 'trailing' then dot_line != selector_line || same_line?(node)
-          else fail 'Unknown dot position style selected.'
+          case style
+          when :leading then dot_line == selector_line
+          when :trailing then dot_line != selector_line || same_line?(node)
           end
         end
 

data/lib/rubocop/cop/style/empty_lines_around_body.rb

@@ -3,7 +3,7 @@
 module Rubocop
   module Cop
     module Style
-      # This cops checks redundant blanks lines around the bodies of classes,
+      # This cops checks redundant empty lines around the bodies of classes,
       # modules & methods.
       #
       # @example
@@ -24,8 +24,8 @@ module Rubocop
       class EmptyLinesAroundBody < Cop
         include CheckMethods
 
-        MSG_BEG = 'Extra blank line detected at body beginning.'
-        MSG_END = 'Extra blank line detected at body end.'
+        MSG_BEG = 'Extra empty line detected at body beginning.'
+        MSG_END = 'Extra empty line detected at body end.'
 
         def on_class(node)
           check(node)
@@ -55,7 +55,7 @@ module Rubocop
         end
 
         def check_source(start_line, end_line)
-          if processed_source.lines[start_line].blank?
+          if processed_source.lines[start_line].empty?
             range = source_range(processed_source.buffer,
                                  processed_source[0...start_line],
                                  0,
@@ -63,7 +63,7 @@ module Rubocop
             add_offence(range, range, MSG_BEG)
           end
 
-          if processed_source.lines[end_line - 2].blank?
+          if processed_source.lines[end_line - 2].empty?
             range = source_range(processed_source.buffer,
                                  processed_source[0...(end_line - 2)],
                                  0,

data/lib/rubocop/cop/style/favor_unless_over_negated_if.rb

@@ -3,28 +3,10 @@
 module Rubocop
   module Cop
     module Style
-      # Some common code shared between the two cops.
-      module FavorOtherKeywordOverNegation
-        def check(node)
-          condition, _body, _rest = *node
-
-          # Look at last expression of contents if there's a parenthesis
-          # around condition.
-          condition = condition.children.last while condition.type == :begin
-
-          if condition.type == :send
-            _object, method = *condition
-            if method == :! && !(node.loc.respond_to?(:else) && node.loc.else)
-              add_offence(node, :expression, error_message)
-            end
-          end
-        end
-      end
-
       # Checks for uses of if with a negated condition. Only ifs
       # without else are considered.
       class FavorUnlessOverNegatedIf < Cop
-        include FavorOtherKeywordOverNegation
+        include NegativeConditional
 
         def on_if(node)
           return unless node.loc.respond_to?(:keyword)
@@ -37,19 +19,6 @@ module Rubocop
           'Favor unless (or control flow or) over if for negative conditions.'
         end
       end
-
-      # Checks for uses of while with a negated condition.
-      class FavorUntilOverNegatedWhile < Cop
-        include FavorOtherKeywordOverNegation
-
-        def on_while(node)
-          check(node)
-        end
-
-        def error_message
-          'Favor until over while for negative conditions.'
-        end
-      end
     end
   end
 end