rubocop 0.26.1 → 0.27.0

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

@@ -11,7 +11,7 @@ module RuboCop
         def on_def(node)
           if @prev_def_end && (def_start(node) - @prev_def_end) == 1
             unless @prev_was_single_line && singe_line_def?(node) &&
-                cop_config['AllowAdjacentOneLineDefs']
+                   cop_config['AllowAdjacentOneLineDefs']
               add_offense(node, :keyword)
             end
           end

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

@@ -24,7 +24,7 @@ module RuboCop
               ((prev_line + 1)...cur_line).each do |line|
                 # we check if the prev and current lines are empty
                 next unless processed_source[line - 2].empty? &&
-                  processed_source[line - 1].empty?
+                            processed_source[line - 1].empty?
 
                 range = source_range(processed_source.buffer, line, 0)
                 add_offense(range, range)

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks if empty lines around the bodies of classes match the
+      # configuration.
+      #
+      # @example
+      #
+      #   class Test
+      #
+      #      def something
+      #        ...
+      #      end
+      #
+      #   end
+      #
+      class EmptyLinesAroundClassBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = 'class'
+
+        def on_class(node)
+          check(node)
+        end
+
+        def on_sclass(node)
+          check(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks if empty lines around the bodies of methods match
+      # the configuration.
+      #
+      # @example
+      #
+      #   def something(arg)
+      #
+      #     ...
+      #   end
+      #
+      class EmptyLinesAroundMethodBody < Cop
+        include EmptyLinesAroundBody
+        include OnMethodDef
+
+        KIND = 'method'
+
+        private
+
+        def on_method_def(node, _method_name, _args, _body)
+          check(node)
+        end
+
+        # Override ConfigurableEnforcedStyle#style and hard-code
+        # configuration. It's difficult to imagine that anybody would want
+        # empty lines around a method body, so we don't make it configurable.
+        def style
+          :no_empty_lines
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks if empty lines around the bodies of modules match
+      # the configuration.
+      #
+      # @example
+      #
+      #   module Test
+      #
+      #      def something
+      #        ...
+      #      end
+      #
+      #   end
+      #
+      class EmptyLinesAroundModuleBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = 'module'
+
+        def on_module(node)
+          check(node)
+        end
+      end
+    end
+  end
+end

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

@@ -46,7 +46,7 @@ module RuboCop
 
         def encoding_line_number(processed_source)
           line_number = 0
-          line_number += 1 if processed_source[line_number] =~ /^#!/
+          line_number += 1 if processed_source[line_number].start_with?('#!')
           line_number
         end
       end

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

@@ -33,11 +33,11 @@ module RuboCop
         def format_method?(name, node)
           receiver, method_name, args = *node
 
-          # we do an argument count check to reduce false positives
-          return false if args && args.children.size < 2
-
           # commands have no explicit receiver
-          !receiver && method_name == name
+          return false unless !receiver && method_name == name
+
+          # we do an argument count check to reduce false positives
+          args && args.children.size >= 2
         end
 
         def format?(node)

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

@@ -28,13 +28,13 @@ module RuboCop
           return if expr.line == left_bracket.line
 
           base_column = left_bracket.source_line =~ /\S/
-          expected_column = base_column + IndentationWidth::CORRECT_INDENTATION
+          expected_column = base_column + configured_indentation_width
           @column_delta = expected_column - expr.column
           return if @column_delta == 0
 
           msg = format('Use %d spaces for indentation in an array, relative ' \
                        'to the start of the line where the left bracket is.',
-                       IndentationWidth::CORRECT_INDENTATION)
+                       configured_indentation_width)
           add_offense(first_pair, :expression, msg)
         end
 

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

@@ -95,20 +95,26 @@ module RuboCop
         def check_first_pair(first_pair, left_brace, left_parenthesis, offset)
           column = first_pair.loc.expression.column
           expected_column = base_column(left_brace, left_parenthesis) +
-            IndentationWidth::CORRECT_INDENTATION + offset
+                            configured_indentation_width + offset
           @column_delta = expected_column - column
 
           if @column_delta == 0
             correct_style_detected
           else
-            add_offense(first_pair, :expression,
-                        message(base_description(left_parenthesis))) do
-              if column == unexpected_column(left_brace, left_parenthesis,
-                                             offset)
-                opposite_style_detected
-              else
-                unrecognized_style_detected
-              end
+            incorrect_style_detected(column, offset, first_pair,
+                                     left_parenthesis, left_brace)
+          end
+        end
+
+        def incorrect_style_detected(column, offset, first_pair,
+                                     left_parenthesis, left_brace)
+          add_offense(first_pair, :expression,
+                      message(base_description(left_parenthesis))) do
+            if column == unexpected_column(left_brace, left_parenthesis,
+                                           offset)
+              opposite_style_detected
+            else
+              unrecognized_style_detected
             end
           end
         end
@@ -146,13 +152,12 @@ module RuboCop
                                      end
           end
 
-          unexpected_base_column + IndentationWidth::CORRECT_INDENTATION +
-            offset
+          unexpected_base_column + configured_indentation_width + offset
         end
 
         def message(base_description)
           format('Use %d spaces for indentation in a hash, relative to %s.',
-                 IndentationWidth::CORRECT_INDENTATION, base_description)
+                 configured_indentation_width, base_description)
         end
       end
     end

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

@@ -14,13 +14,11 @@ module RuboCop
       # end
       class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
         include AutocorrectAlignment
-        include OnMethod
+        include OnMethodDef
         include CheckAssignment
         include IfNode
         include AccessModifierNode
 
-        CORRECT_INDENTATION = 2
-
         def on_rescue(node)
           _begin_node, *rescue_nodes, else_node = *node
           rescue_nodes.each do |rescue_node|
@@ -72,7 +70,7 @@ module RuboCop
           ignore_node(args.first)
         end
 
-        def on_method(node, _method_name, _args, body)
+        def on_method_def(node, _method_name, _args, body)
           check_indentation(node.loc.keyword, body) unless ignored_node?(node)
         end
 
@@ -84,7 +82,7 @@ module RuboCop
         def on_while(node, base = node)
           _condition, body = *node
           return unless node.loc.keyword.begin_pos ==
-            node.loc.expression.begin_pos
+                        node.loc.expression.begin_pos
 
           check_indentation(base.loc, body)
         end
@@ -175,20 +173,10 @@ module RuboCop
         end
 
         def check_indentation(base_loc, body_node)
-          return unless body_node
-
-          # Don't check if expression is on same line as "then" keyword, etc.
-          return if body_node.loc.line == base_loc.line
-
-          return if starts_with_access_modifier?(body_node)
-
-          # Don't check indentation if the line doesn't start with the body.
-          # For example, lines like "else do_something".
-          first_char_pos_on_line = body_node.loc.expression.source_line =~ /\S/
-          return unless body_node.loc.column == first_char_pos_on_line
+          return unless indentation_to_check?(base_loc, body_node)
 
           indentation = body_node.loc.column - base_loc.column
-          @column_delta = CORRECT_INDENTATION - indentation
+          @column_delta = configured_indentation_width - indentation
           return if @column_delta == 0
 
           # This cop only auto-corrects the first statement in a def body, for
@@ -204,13 +192,33 @@ module RuboCop
 
           r = Parser::Source::Range.new(expr.source_buffer, pos.begin, pos.end)
           add_offense(body_node, r,
-                      format("Use #{CORRECT_INDENTATION} (not %d) spaces " \
-                             'for indentation.', indentation))
+                      format("Use #{configured_indentation_width} (not %d) " \
+                             'spaces for indentation.', indentation))
+        end
+
+        def indentation_to_check?(base_loc, body_node)
+          return false unless body_node
+
+          # Don't check if expression is on same line as "then" keyword, etc.
+          return false if body_node.loc.line == base_loc.line
+
+          return false if starts_with_access_modifier?(body_node)
+
+          # Don't check indentation if the line doesn't start with the body.
+          # For example, lines like "else do_something".
+          first_char_pos_on_line = body_node.loc.expression.source_line =~ /\S/
+          return false unless body_node.loc.column == first_char_pos_on_line
+
+          true
         end
 
         def starts_with_access_modifier?(body_node)
           body_node.type == :begin && modifier_node?(body_node.children.first)
         end
+
+        def configured_indentation_width
+          cop_config['Width']
+        end
       end
     end
   end

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

@@ -19,9 +19,9 @@ module RuboCop
         def autocorrect(node)
           # Bail out if the call is going to be auto-corrected by EmptyLiteral.
           if config.for_cop('Style/EmptyLiteral')['Enabled'] &&
-              [EmptyLiteral::HASH_NODE,
-               EmptyLiteral::ARRAY_NODE,
-               EmptyLiteral::STR_NODE].include?(node)
+             [EmptyLiteral::HASH_NODE,
+              EmptyLiteral::ARRAY_NODE,
+              EmptyLiteral::STR_NODE].include?(node)
             return
           end
           @corrections << lambda do |corrector|

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

@@ -29,7 +29,7 @@ module RuboCop
           return if ignored_node?(node)
           receiver, _method_name, *_args = *node
           return unless receiver && receiver.type == :block &&
-            receiver.loc.end.is?('end')
+                        receiver.loc.end.is?('end')
 
           range = Parser::Source::Range.new(receiver.loc.end.source_buffer,
                                             receiver.loc.end.begin_pos,

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

@@ -6,25 +6,18 @@ module RuboCop
       # This cops checks for parentheses around the arguments in method
       # definitions. Both instance and class/singleton methods are checked.
       class MethodDefParentheses < Cop
-        include OnMethod
+        include OnMethodDef
         include ConfigurableEnforcedStyle
 
-        def on_method(node, _method_name, args, _body)
+        def on_method_def(node, _method_name, args, _body)
           if style == :require_parentheses
             if arguments?(args) && !parentheses?(args)
-              add_offense(node,
-                          args.loc.expression,
-                          'Use def with parentheses when there are ' \
-                          'parameters.') do
-                opposite_style_detected
-              end
+              missing_parentheses(node, args)
             else
               correct_style_detected
             end
           elsif parentheses?(args)
-            add_offense(args, :expression, 'Use def without parentheses.') do
-              opposite_style_detected
-            end
+            unwanted_parentheses(args)
           else
             correct_style_detected
           end
@@ -49,6 +42,19 @@ module RuboCop
 
         private
 
+        def missing_parentheses(node, args)
+          add_offense(node, args.loc.expression,
+                      'Use def with parentheses when there are parameters.') do
+            opposite_style_detected
+          end
+        end
+
+        def unwanted_parentheses(args)
+          add_offense(args, :expression, 'Use def without parentheses.') do
+            opposite_style_detected
+          end
+        end
+
         def args_node(def_node)
           if def_node.type == :def
             _method_name, args, _body = *def_node

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

@@ -20,7 +20,7 @@ module RuboCop
         end
 
         def message(style)
-          format('Use %s for methods.', style)
+          format('Use %s for method names.', style)
         end
       end
     end

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

@@ -0,0 +1,174 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks the indentation of the right hand side operand in
+      # binary operations that span more than one line.
+      #
+      # @example
+      #   # bad
+      #   if a +
+      #   b
+      #     something
+      #   end
+      class MultilineOperationIndentation < Cop
+        include ConfigurableEnforcedStyle
+        include AutocorrectAlignment
+
+        def on_and(node)
+          check_and_or(node)
+        end
+
+        def on_or(node)
+          check_and_or(node)
+        end
+
+        def on_send(node)
+          receiver, _method_name, *_args = *node
+          return unless receiver
+
+          lhs, rhs = left_hand_side(receiver), right_hand_side(node)
+          range = offending_range(node, lhs, rhs, style)
+          check(range, node, lhs, rhs)
+        end
+
+        private
+
+        def check_and_or(node)
+          lhs, rhs = *node
+          range = offending_range(node, lhs, rhs.loc.expression, style)
+          check(range, node, lhs, rhs.loc.expression)
+        end
+
+        def check(range, node, lhs, rhs)
+          if range
+            incorrect_style_detected(range, node, lhs, rhs)
+          else
+            correct_style_detected
+          end
+        end
+
+        def incorrect_style_detected(range, node, lhs, rhs)
+          add_offense(range, range, message(node, lhs, rhs)) do
+            unless offending_range(node, lhs, rhs, alternative_style)
+              opposite_style_detected
+            end
+          end
+        end
+
+        def offending_range(node, lhs, rhs, given_style)
+          return false unless begins_its_line?(rhs)
+          return false if lhs.loc.line == rhs.line # Needed for unary op.
+          return false if not_for_this_cop?(node)
+
+          correct_column = if should_align?(node, given_style)
+                             lhs.loc.column
+                           else
+                             indentation(lhs) + correct_indentation(node)
+                           end
+          @column_delta = correct_column - rhs.column
+          rhs if @column_delta != 0
+        end
+
+        def message(node, lhs, rhs)
+          what = operation_description(node)
+          if should_align?(node, style)
+            "Align the operands of #{what} spanning multiple lines."
+          else
+            used_indentation = rhs.column - indentation(lhs)
+            "Use #{correct_indentation(node)} (not #{used_indentation}) " \
+              "spaces for indenting #{what} spanning multiple lines."
+          end
+        end
+
+        def indentation(node)
+          node.loc.expression.source_line =~ /\S/
+        end
+
+        def operation_description(node)
+          ancestor = kw_node_with_special_indentation(node)
+          if ancestor
+            kw = ancestor.loc.keyword.source
+            kind = kw == 'for' ? 'collection' : 'condition'
+            article = kw =~ /^[iu]/ ? 'an' : 'a'
+            "a #{kind} in #{article} `#{kw}` statement"
+          else
+            'an expression' + (assignment?(node) ? ' in an assignment' : '')
+          end
+        end
+
+        # In a chain of method calls, we regard the top send node as the base
+        # for indentation of all lines following the first. For example:
+        # a.
+        #   b c { block }.            <-- b is indented relative to a
+        #   d                         <-- d is indented relative to a
+        def left_hand_side(receiver)
+          lhs = receiver
+          lhs = lhs.parent while lhs.parent && lhs.parent.type == :send
+          lhs
+        end
+
+        def right_hand_side(send_node)
+          _, method_name, *args = *send_node
+          if operator?(method_name) && args.any?
+            args.first.loc.expression
+          elsif send_node.loc.dot &&
+                send_node.loc.dot.line == send_node.loc.selector.line
+            send_node.loc.dot.join(send_node.loc.selector)
+          else
+            send_node.loc.selector
+          end
+        end
+
+        def correct_indentation(node)
+          multiplier = kw_node_with_special_indentation(node) ? 2 : 1
+          configured_indentation_width * multiplier
+        end
+
+        def should_align?(node, given_style)
+          given_style == :aligned && (kw_node_with_special_indentation(node) ||
+                                      assignment?(node))
+        end
+
+        def kw_node_with_special_indentation(node)
+          node.each_ancestor.find do |a|
+            next unless a.loc.respond_to?(:keyword)
+
+            case a.type
+            when :if, :while, :until then condition, = *a
+            when :for                then _, collection, _ = *a
+            end
+
+            if condition || collection
+              within_node?(node, condition || collection)
+            end
+          end
+        end
+
+        def assignment?(node)
+          node.each_ancestor.find { |a| ASGN_NODES.include?(a.type) }
+        end
+
+        def not_for_this_cop?(node)
+          node.each_ancestor.find do |ancestor|
+            grouped_expression?(ancestor) ||
+              inside_arg_list_parentheses?(node, ancestor)
+          end
+        end
+
+        def grouped_expression?(node)
+          node.type == :begin && node.loc.respond_to?(:begin) && node.loc.begin
+        end
+
+        def inside_arg_list_parentheses?(node, ancestor)
+          a = ancestor.loc
+          return false unless ancestor.type == :send && a.begin &&
+                              a.begin.is?('(')
+          n = node.loc.expression
+          n.begin_pos > a.begin.begin_pos && n.end_pos < a.end.end_pos
+        end
+      end
+    end
+  end
+end