rubocop 0.87.1 → 0.89.1

data/lib/rubocop/cop/layout/end_alignment.rb

@@ -150,9 +150,10 @@ module RuboCop
         end
 
         def alignment_node(node)
-          if style == :keyword
+          case style
+          when :keyword
             node
-          elsif style == :variable
+          when :variable
             alignment_node_for_variable_style(node)
           else
             start_line_range(node)

data/lib/rubocop/cop/layout/extra_spacing.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout
@@ -30,7 +28,8 @@ module RuboCop
       #   object.method(arg)         # this is a comment
       #   another_object.method(arg) # this is another comment
       #   some_object.method(arg)    # this is some comment
-      class ExtraSpacing < Cop
+      class ExtraSpacing < Base
+        extend AutoCorrector
         include PrecedingFollowingAlignment
         include RangeHelp
 
@@ -38,9 +37,10 @@ module RuboCop
         MSG_UNALIGNED_ASGN = '`=` is not aligned with the %<location>s ' \
                              'assignment.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.blank?
 
+          @aligned_comments = aligned_locations(processed_source.comments.map(&:loc))
           @corrected = Set.new if force_equal_sign_alignment?
 
           processed_source.tokens.each_cons(2) do |token1, token2|
@@ -48,18 +48,20 @@ module RuboCop
           end
         end
 
-        def autocorrect(range)
-          lambda do |corrector|
-            if range.source.end_with?('=')
-              align_equal_signs(range, corrector)
-            else
-              corrector.remove(range)
-            end
+        private
+
+        def aligned_locations(locs)
+          return [] if locs.empty?
+
+          aligned = Set[locs.first.line, locs.last.line]
+          locs.each_cons(3) do |before, loc, after|
+            col = loc.column
+            aligned << loc.line if col == before.column || # rubocop:disable Style/MultipleComparison
+                                   col == after.column
           end
+          aligned
         end
 
-        private
-
         def check_tokens(ast, token1, token2)
           return if token2.type == :tNL
 
@@ -74,7 +76,9 @@ module RuboCop
           return unless aligned_with_preceding_assignment(token) == :no
 
           message = format(MSG_UNALIGNED_ASGN, location: 'preceding')
-          add_offense(token.pos, location: token.pos, message: message)
+          add_offense(token.pos, message: message) do |corrector|
+            align_equal_signs(token.pos, corrector)
+          end
         end
 
         def check_other(token1, token2, ast)
@@ -84,7 +88,9 @@ module RuboCop
           extra_space_range(token1, token2) do |range|
             next if ignored_range?(ast, range.begin_pos)
 
-            add_offense(range, location: range, message: MSG_UNNECESSARY)
+            add_offense(range, message: MSG_UNNECESSARY) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
 
@@ -102,7 +108,7 @@ module RuboCop
 
         def aligned_tok?(token)
           if token.comment?
-            aligned_comments?(token)
+            @aligned_comments.include?(token.line)
           else
             aligned_with_something?(token.pos)
           end
@@ -126,26 +132,6 @@ module RuboCop
           end.compact
         end
 
-        def aligned_comments?(comment_token)
-          ix = processed_source.comments.index do |comment|
-            comment.loc.expression.begin_pos == comment_token.begin_pos
-          end
-          aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
-        end
-
-        def aligned_with_previous_comment?(index)
-          index.positive? && comment_column(index - 1) == comment_column(index)
-        end
-
-        def aligned_with_next_comment?(index)
-          index < processed_source.comments.length - 1 &&
-            comment_column(index + 1) == comment_column(index)
-        end
-
-        def comment_column(index)
-          processed_source.comments[index].loc.column
-        end
-
         def force_equal_sign_alignment?
           cop_config['ForceEqualSignAlignment']
         end

data/lib/rubocop/cop/layout/first_method_argument_line_break.rb

@@ -27,7 +27,7 @@ module RuboCop
               'multi-line method argument list.'
 
         def on_send(node)
-          args = node.arguments
+          args = node.arguments.dup
 
           # If there is a trailing hash arg without explicit braces, like this:
           #

data/lib/rubocop/cop/layout/heredoc_indentation.rb

@@ -161,11 +161,11 @@ module RuboCop
         end
 
         def heredoc_body(node)
-          node.loc.heredoc_body.source.scrub
+          node.loc.heredoc_body.source
         end
 
         def heredoc_end(node)
-          node.loc.heredoc_end.source.scrub
+          node.loc.heredoc_end.source
         end
       end
     end

data/lib/rubocop/cop/layout/indentation_style.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-
 module RuboCop
   module Cop
     module Layout

data/lib/rubocop/cop/layout/leading_comment_space.rb

@@ -55,7 +55,7 @@ module RuboCop
         MSG = 'Missing space after `#`.'
 
         def investigate(processed_source)
-          processed_source.each_comment do |comment|
+          processed_source.comments.each do |comment|
             next unless /\A#+[^#\s=:+-]/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)

data/lib/rubocop/cop/layout/multiline_block_layout.rb

@@ -95,11 +95,22 @@ module RuboCop
         end
 
         def line_break_necessary_in_args?(node)
-          needed_length = node.source_range.column +
-                          node.source.lines.first.length +
-                          block_arg_string(node, node.arguments).length +
-                          PIPE_SIZE
-          needed_length > max_line_length
+          needed_length_for_args(node) > max_line_length
+        end
+
+        def needed_length_for_args(node)
+          node.source_range.column +
+            characters_needed_for_space_and_pipes(node) +
+            node.source.lines.first.chomp.length +
+            block_arg_string(node, node.arguments).length
+        end
+
+        def characters_needed_for_space_and_pipes(node)
+          if node.source.lines.first.end_with?("|\n")
+            PIPE_SIZE
+          else
+            1 + PIPE_SIZE * 2
+          end
         end
 
         def add_offense_for_expression(node, expr, msg)

data/lib/rubocop/cop/layout/multiline_method_argument_line_breaks.rb

@@ -37,7 +37,7 @@ module RuboCop
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
           if (last_arg = args.last)
-            args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
+            args = args[0...-1] + last_arg.children if last_arg.hash_type? && !last_arg.braces?
           end
 
           check_line_breaks(node, args)

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -96,7 +96,6 @@ module RuboCop
           )
         end
 
-        # rubocop:disable Metrics/AbcSize
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -115,7 +114,6 @@ module RuboCop
 
           range_between(starting_loc.begin_pos, ending_loc.end_pos).source
         end
-        # rubocop:enable Metrics/AbcSize
 
         # We will use ancestor or wrapper with access modifier.
 

data/lib/rubocop/cop/layout/space_around_block_parameters.rb

@@ -56,11 +56,12 @@ module RuboCop
         def check_inside_pipes(arguments)
           opening_pipe, closing_pipe = pipes(arguments)
 
-          if style == :no_space
+          case style
+          when :no_space
             check_no_space_style_inside_pipes(arguments.children,
                                               opening_pipe,
                                               closing_pipe)
-          elsif style == :space
+          when :space
             check_space_style_inside_pipes(arguments.children,
                                            opening_pipe,
                                            closing_pipe)

data/lib/rubocop/cop/layout/space_around_method_call_operator.rb

@@ -34,96 +34,63 @@ module RuboCop
       #   RuboCop::Cop::Cop
       #   ::RuboCop::Cop
       #
-      class SpaceAroundMethodCallOperator < Cop
-        include SurroundingSpace
+      class SpaceAroundMethodCallOperator < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        SPACES_REGEXP = /\A[ \t]+\z/.freeze
 
         MSG = 'Avoid using spaces around a method call operator.'
 
         def on_send(node)
-          return unless dot_or_safe_navigation_operator?(node)
+          return unless node.dot? || node.safe_navigation?
 
-          check_and_add_offense(node)
+          check_space_before_dot(node)
+          check_space_after_dot(node)
         end
+        alias on_csend on_send
 
         def on_const(node)
           return unless node.loc.double_colon
 
-          check_and_add_offense(node, false)
-        end
-
-        def autocorrect(node)
-          operator = operator_token(node)
-          left = left_token_for_auto_correction(node, operator)
-          right = right_token_for_auto_correction(operator)
-
-          lambda do |corrector|
-            SpaceCorrector.remove_space(
-              processed_source, corrector, left, right
-            )
-          end
+          check_space_after_double_colon(node)
         end
 
-        alias on_csend on_send
-
         private
 
-        def check_and_add_offense(node, add_left_offense = true)
-          operator = operator_token(node)
-          left = previous_token(operator)
-          right = next_token(operator)
-
-          if !right.comment? && valid_right_token?(right, operator)
-            no_space_offenses(node, operator, right, MSG)
-          end
-          return unless valid_left_token?(left, operator)
-
-          no_space_offenses(node, left, operator, MSG) if add_left_offense
+        def check_space_before_dot(node)
+          receiver_pos = node.receiver.source_range.end_pos
+          dot_pos = node.loc.dot.begin_pos
+          check_space(receiver_pos, dot_pos)
         end
 
-        def operator_token(node)
-          operator_location =
-            node.const_type? ? node.loc.double_colon : node.loc.dot
+        def check_space_after_dot(node)
+          dot_pos = node.loc.dot.end_pos
 
-          processed_source.find_token do |token|
-            token.pos == operator_location
-          end
-        end
-
-        def previous_token(current_token)
-          index = processed_source.tokens.index(current_token)
-          index.zero? ? nil : processed_source.tokens[index - 1]
-        end
-
-        def next_token(current_token)
-          index = processed_source.tokens.index(current_token)
-          processed_source.tokens[index + 1]
-        end
+          selector_pos =
+            # `Proc#call` shorthand syntax
+            if node.method?(:call) && !node.loc.selector
+              node.loc.begin.begin_pos
+            else
+              node.loc.selector.begin_pos
+            end
 
-        def dot_or_safe_navigation_operator?(node)
-          node.dot? || node.safe_navigation?
+          check_space(dot_pos, selector_pos)
         end
 
-        def valid_left_token?(left, operator)
-          left && left.line == operator.line
+        def check_space_after_double_colon(node)
+          double_colon_pos = node.loc.double_colon.end_pos
+          name_pos = node.loc.name.begin_pos
+          check_space(double_colon_pos, name_pos)
         end
 
-        def valid_right_token?(right, operator)
-          right && right.line == operator.line
-        end
-
-        def left_token_for_auto_correction(node, operator)
-          left_token = previous_token(operator)
-          return operator if node.const_type?
-          return left_token if valid_left_token?(left_token, operator)
-
-          operator
-        end
+        def check_space(begin_pos, end_pos)
+          return if end_pos <= begin_pos
 
-        def right_token_for_auto_correction(operator)
-          right_token = next_token(operator)
-          return right_token if !right_token.comment? && valid_right_token?(right_token, operator)
+          range = range_between(begin_pos, end_pos)
+          return unless range.source.match?(SPACES_REGEXP)
 
-          operator
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
       end
     end

data/lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb

@@ -142,11 +142,12 @@ module RuboCop
         end
 
         def issue_offenses(node, left, right, start_ok, end_ok)
-          if style == :no_space
+          case style
+          when :no_space
             start_ok = next_to_comment?(node, left)
             no_space_offenses(node, left, right, MSG, start_ok: start_ok,
                                                       end_ok: end_ok)
-          elsif style == :space
+          when :space
             space_offenses(node, left, right, MSG, start_ok: start_ok,
                                                    end_ok: end_ok)
           else

data/lib/rubocop/cop/lint/ambiguous_block_association.rb

@@ -24,18 +24,21 @@ module RuboCop
       #   # good
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
-      class AmbiguousBlockAssociation < Cop
+      class AmbiguousBlockAssociation < Base
         MSG = 'Parenthesize the param `%<param>s` to make sure that the ' \
               'block will be associated with the `%<method>s` method ' \
               'call.'
 
         def on_send(node)
-          return if !node.arguments? || node.parenthesized? ||
-                    node.last_argument.lambda? || allowed_method?(node)
+          return unless node.arguments?
 
           return unless ambiguous_block_association?(node)
+          return if node.parenthesized? ||
+                    node.last_argument.lambda? || allowed_method?(node)
+
+          message = message(node)
 
-          add_offense(node)
+          add_offense(node, message: message)
         end
         alias on_csend on_send
 

data/lib/rubocop/cop/lint/ambiguous_operator.rb

@@ -20,8 +20,8 @@ module RuboCop
       #
       #   # With parentheses, there's no ambiguity.
       #   do_something(*some_array)
-      class AmbiguousOperator < Cop
-        include ParserDiagnostic
+      class AmbiguousOperator < Base
+        extend AutoCorrector
 
         AMBIGUITIES = {
           '+'  => { actual: 'positive number', possible: 'addition' },
@@ -38,18 +38,23 @@ module RuboCop
                      'a whitespace to the right of the `%<operator>s` if it ' \
                      'should be a %<possible>s.'
 
-        def autocorrect(node)
-          lambda do |corrector|
-            add_parentheses(node, corrector)
+        def on_new_investigation
+          processed_source.diagnostics.each do |diagnostic|
+            next unless diagnostic.reason == :ambiguous_prefix
+
+            offense_node = find_offense_node_by(diagnostic)
+            message = message(diagnostic)
+
+            add_offense(
+              diagnostic.location, message: message, severity: diagnostic.level
+            ) do |corrector|
+              add_parentheses(offense_node, corrector)
+            end
           end
         end
 
         private
 
-        def relevant_diagnostic?(diagnostic)
-          diagnostic.reason == :ambiguous_prefix
-        end
-
         def find_offense_node_by(diagnostic)
           ast = processed_source.ast
           ast.each_node(:splat, :block_pass, :kwsplat) do |node|
@@ -68,7 +73,7 @@ module RuboCop
           end
         end
 
-        def alternative_message(diagnostic)
+        def message(diagnostic)
           operator = diagnostic.location.source
           hash = AMBIGUITIES[operator]
           format(MSG_FORMAT, hash)