rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks that reference brackets have or don't have
+      # surrounding space depending on configuration.
+      #
+      # @example EnforcedStyle: no_space (default)
+      #   # The `no_space` style enforces that reference brackets have
+      #   # no surrounding space.
+      #
+      #   # bad
+      #   hash[ :key ]
+      #   array[ index ]
+      #
+      #   # good
+      #   hash[:key]
+      #   array[index]
+      #
+      # @example EnforcedStyle: space
+      #   # The `space` style enforces that reference brackets have
+      #   # surrounding space.
+      #
+      #   # bad
+      #   hash[:key]
+      #   array[index]
+      #
+      #   # good
+      #   hash[ :key ]
+      #   array[ index ]
+      #
+      #
+      # @example EnforcedStyleForEmptyBrackets: no_space (default)
+      #   # The `no_space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty reference brackets do not contain spaces.
+      #
+      #   # bad
+      #   foo[ ]
+      #   foo[     ]
+      #
+      #   # good
+      #   foo[]
+      #
+      # @example EnforcedStyleForEmptyBrackets: space
+      #   # The `space` EnforcedStyleForEmptyBrackets style enforces that
+      #   # empty reference brackets contain exactly one space.
+      #
+      #   # bad
+      #   foo[]
+      #   foo[    ]
+      #
+      #   # good
+      #   foo[ ]
+      #
+      class SpaceInsideReferenceBrackets < Cop
+        include SurroundingSpace
+        include ConfigurableEnforcedStyle
+
+        MSG = '%<command>s space inside reference brackets.'
+        EMPTY_MSG = '%<command>s space inside empty reference brackets.'
+
+        BRACKET_METHODS = %i[[] []=].freeze
+
+        def on_send(node)
+          return if node.multiline?
+          return unless bracket_method?(node)
+
+          tokens = tokens(node)
+          left_token = left_ref_bracket(node, tokens)
+          return unless left_token
+
+          right_token = closing_bracket(tokens, left_token)
+
+          if empty_brackets?(left_token, right_token)
+            return empty_offenses(node, left_token, right_token, EMPTY_MSG)
+          end
+
+          if style == :no_space
+            no_space_offenses(node, left_token, right_token, MSG)
+          else
+            space_offenses(node, left_token, right_token, MSG)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            left, right = reference_brackets(node)
+
+            if empty_brackets?(left, right)
+              SpaceCorrector.empty_corrections(processed_source, corrector,
+                                               empty_config, left, right)
+            elsif style == :no_space
+              SpaceCorrector.remove_space(processed_source, corrector,
+                                          left, right)
+            else
+              SpaceCorrector.add_space(processed_source, corrector, left, right)
+            end
+          end
+        end
+
+        private
+
+        def reference_brackets(node)
+          tokens = tokens(node)
+          left = left_ref_bracket(node, tokens)
+          [left, closing_bracket(tokens, left)]
+        end
+
+        def bracket_method?(node)
+          BRACKET_METHODS.include?(node.method_name)
+        end
+
+        def left_ref_bracket(node, tokens)
+          current_token = tokens.reverse.find(&:left_ref_bracket?)
+          previous_token = previous_token(current_token)
+
+          if node.method?(:[]=) ||
+             previous_token && !previous_token.right_bracket?
+            tokens.find(&:left_ref_bracket?)
+          else
+            current_token
+          end
+        end
+
+        def closing_bracket(tokens, opening_bracket)
+          i = tokens.index(opening_bracket)
+          inner_left_brackets_needing_closure = 0
+
+          tokens[i..-1].each do |token|
+            inner_left_brackets_needing_closure += 1 if token.left_bracket?
+            inner_left_brackets_needing_closure -= 1 if token.right_bracket?
+            return token if inner_left_brackets_needing_closure.zero? && token.right_bracket?
+          end
+        end
+
+        def previous_token(current_token)
+          index = processed_source.tokens.index(current_token)
+          index.nil? || index.zero? ? nil : processed_source.tokens[index - 1]
+        end
+
+        def empty_config
+          cop_config['EnforcedStyleForEmptyBrackets']
+        end
+      end
+    end
+  end
+end

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

@@ -5,63 +5,59 @@ module RuboCop
     module Layout
       # This cop checks for whitespace within string interpolations.
       #
-      # @example
-      #   # Good if EnforcedStyle is no_space, bad if space.
+      # @example EnforcedStyle: no_space (default)
+      #   # bad
+      #      var = "This is the #{ space } example"
+      #
+      #   # good
       #      var = "This is the #{no_space} example"
       #
-      #   # Good if EnforceStyle is space, bad if no_space.
+      # @example EnforcedStyle: space
+      #   # bad
+      #      var = "This is the #{no_space} example"
+      #
+      #   # good
       #      var = "This is the #{ space } example"
       class SpaceInsideStringInterpolation < Cop
+        include Interpolation
+        include SurroundingSpace
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        NO_SPACE_MSG = 'Space inside string interpolation detected.'.freeze
-        SPACE_MSG = 'Missing space around string interpolation detected.'.freeze
-
-        def on_dstr(node)
-          each_style_violation(node) do |final_node|
-            add_offense(final_node)
-          end
-        end
+        NO_SPACE_MSG = 'Space inside string interpolation detected.'
+        SPACE_MSG = 'Missing space inside string interpolation detected.'
 
-        private
+        def on_interpolation(begin_node)
+          return if begin_node.multiline?
 
-        def each_style_violation(node)
-          node.each_child_node(:begin) do |begin_node|
-            final_node = begin_node.children.last
-            next unless final_node
+          delims = delimiters(begin_node)
+          return if empty_brackets?(*delims)
 
-            if style == :no_space && space_on_any_side?(final_node)
-              yield final_node
-            elsif style == :space && !space_on_each_side?(final_node)
-              yield final_node
-            end
+          if style == :no_space
+            no_space_offenses(begin_node, *delims, NO_SPACE_MSG)
+          else
+            space_offenses(begin_node, *delims, SPACE_MSG)
           end
         end
 
-        def message(_node)
-          style == :no_space ? NO_SPACE_MSG : SPACE_MSG
-        end
-
-        def space_on_any_side?(node)
-          interp = node.source_range
-          interp_with_surrounding_space = range_with_surrounding_space(interp)
+        def autocorrect(begin_node)
+          lambda do |corrector|
+            delims = delimiters(begin_node)
 
-          interp_with_surrounding_space != interp
+            if style == :no_space
+              SpaceCorrector.remove_space(processed_source, corrector, *delims)
+            else
+              SpaceCorrector.add_space(processed_source, corrector, *delims)
+            end
+          end
         end
 
-        def space_on_each_side?(node)
-          interp = node.source_range
-          interp_with_surrounding_space = range_with_surrounding_space(interp)
-
-          interp_with_surrounding_space.source == " #{interp.source} "
-        end
+        private
 
-        def autocorrect(node)
-          new_source = style == :no_space ? node.source : " #{node.source} "
-          lambda do |corrector|
-            corrector.replace(range_with_surrounding_space(node.source_range),
-                              new_source)
-          end
+        def delimiters(begin_node)
+          left = processed_source.tokens[index_of_first_token(begin_node)]
+          right = processed_source.tokens[index_of_last_token(begin_node)]
+          [left, right]
         end
       end
     end

data/lib/rubocop/cop/layout/{trailing_blank_lines.rb → trailing_empty_lines.rb}

@@ -5,12 +5,45 @@ module RuboCop
     module Layout
       # This cop looks for trailing blank lines and a final newline in the
       # source code.
-      class TrailingBlankLines < Cop
+      #
+      # @example EnforcedStyle: final_blank_line
+      #   # `final_blank_line` looks for one blank line followed by a new line
+      #   # at the end of files.
+      #
+      #   # bad
+      #   class Foo; end
+      #   # EOF
+      #
+      #   # bad
+      #   class Foo; end # EOF
+      #
+      #   # good
+      #   class Foo; end
+      #
+      #   # EOF
+      #
+      # @example EnforcedStyle: final_newline (default)
+      #   # `final_newline` looks for one newline at the end of files.
+      #
+      #   # bad
+      #   class Foo; end
+      #
+      #   # EOF
+      #
+      #   # bad
+      #   class Foo; end # EOF
+      #
+      #   # good
+      #   class Foo; end
+      #   # EOF
+      #
+      class TrailingEmptyLines < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         def investigate(processed_source)
-          sb = processed_source.buffer
-          return if sb.source.empty?
+          buffer = processed_source.buffer
+          return if buffer.source.empty?
 
           # The extra text that comes after the last token could be __END__
           # followed by some data to read. If so, we don't check it because
@@ -18,24 +51,30 @@ module RuboCop
           # number of newlines.
           return if ends_in_end?(processed_source)
 
-          whitespace_at_end = sb.source[/\s*\Z/]
+          whitespace_at_end = buffer.source[/\s*\Z/]
           blank_lines = whitespace_at_end.count("\n") - 1
           wanted_blank_lines = style == :final_newline ? 0 : 1
 
           return unless blank_lines != wanted_blank_lines
 
-          offense_detected(sb, wanted_blank_lines, blank_lines,
+          offense_detected(buffer, wanted_blank_lines, blank_lines,
                            whitespace_at_end)
         end
 
+        def autocorrect(range)
+          lambda do |corrector|
+            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
+          end
+        end
+
         private
 
-        def offense_detected(sb, wanted_blank_lines, blank_lines,
+        def offense_detected(buffer, wanted_blank_lines, blank_lines,
                              whitespace_at_end)
-          begin_pos = sb.source.length - whitespace_at_end.length
-          autocorrect_range = range_between(begin_pos, sb.source.length)
+          begin_pos = buffer.source.length - whitespace_at_end.length
+          autocorrect_range = range_between(begin_pos, buffer.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
-          report_range = range_between(begin_pos, sb.source.length)
+          report_range = range_between(begin_pos, buffer.source.length)
 
           add_offense(autocorrect_range,
                       location: report_range,
@@ -43,13 +82,13 @@ module RuboCop
         end
 
         def ends_in_end?(processed_source)
-          sb = processed_source.buffer
+          buffer = processed_source.buffer
 
-          return true if sb.source.strip.start_with?('__END__')
+          return true if buffer.source.strip.start_with?('__END__')
           return false if processed_source.tokens.empty?
 
-          extra = sb.source[processed_source.tokens.last.pos.end_pos..-1]
-          extra && extra.strip.start_with?('__END__')
+          extra = buffer.source[processed_source.tokens.last.end_pos..-1]
+          extra&.strip&.start_with?('__END__')
         end
 
         def message(wanted_blank_lines, blank_lines)
@@ -64,14 +103,8 @@ module RuboCop
                          else
                            "instead of #{wanted_blank_lines} "
                          end
-            format('%d trailing blank lines %sdetected.', blank_lines,
-                   instead_of)
-          end
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
+            format('%<current>d trailing blank lines %<prefer>sdetected.',
+                   current: blank_lines, prefer: instead_of)
           end
         end
       end

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

@@ -4,15 +4,45 @@ module RuboCop
   module Cop
     module Layout
       # This cop looks for trailing whitespace in the source code.
+      #
+      # @example
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   x = 0
+      #
+      #   # The line in this example ends directly after the 0.
+      #   # good
+      #   x = 0
+      #
+      # @example AllowInHeredoc: false
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
+      # @example AllowInHeredoc: true (default)
+      #   # The line in this example contains spaces after the 0.
+      #   # good
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
       class TrailingWhitespace < Cop
-        MSG = 'Trailing whitespace detected.'.freeze
+        include RangeHelp
+
+        MSG = 'Trailing whitespace detected.'
 
         def investigate(processed_source)
+          heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
+            lineno = index + 1
+
             next unless line.end_with?(' ', "\t")
+            next if skip_heredoc? && inside_heredoc?(heredoc_ranges, lineno)
 
             range = source_range(processed_source.buffer,
-                                 index + 1,
+                                 lineno,
                                  (line.rstrip.length)...(line.length))
 
             add_offense(range, location: range)
@@ -22,6 +52,25 @@ module RuboCop
         def autocorrect(range)
           ->(corrector) { corrector.remove(range) }
         end
+
+        private
+
+        def skip_heredoc?
+          cop_config.fetch('AllowInHeredoc', false)
+        end
+
+        def inside_heredoc?(heredoc_ranges, line_number)
+          heredoc_ranges.any? { |r| r.include?(line_number) }
+        end
+
+        def extract_heredoc_ranges(ast)
+          return [] unless ast
+
+          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
+            body = node.location.heredoc_body
+            (body.first_line...body.last_line)
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/legacy/corrections_proxy.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legacy
+      # Legacy support for Corrector#corrections
+      # See https://docs.rubocop.org/rubocop/cop_api_v1_changelog.html
+      class CorrectionsProxy
+        def initialize(corrector)
+          @corrector = corrector
+        end
+
+        def <<(callable)
+          suppress_clobbering do
+            @corrector.transaction do
+              callable.call(@corrector)
+            end
+          end
+        end
+
+        def empty?
+          @corrector.empty?
+        end
+
+        def concat(corrections)
+          if corrections.is_a?(CorrectionsProxy)
+            suppress_clobbering do
+              corrector.merge!(corrections.corrector)
+            end
+          else
+            corrections.each { |correction| self << correction }
+          end
+        end
+
+        protected
+
+        attr_reader :corrector
+
+        private
+
+        def suppress_clobbering
+          yield
+        rescue ::Parser::ClobberingError
+          # ignore Clobbering errors
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/legacy/corrector.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Legacy
+      # Legacy Corrector for v0 API support.
+      # See https://docs.rubocop.org/rubocop/cop_api_v1_changelog.html
+      class Corrector < RuboCop::Cop::Corrector
+        # Support legacy second argument
+        def initialize(source, corr = [])
+          super(source)
+          if corr.is_a?(CorrectionsProxy)
+            merge!(corr.send(:corrector))
+          else
+            # warn "Corrector.new with corrections is deprecated." unless corr.empty? TODO
+            corr.each do |c|
+              corrections << c
+            end
+          end
+        end
+
+        def corrections
+          # warn "#corrections is deprecated. Open an issue if you have a valid usecase." TODO
+          CorrectionsProxy.new(self)
+        end
+      end
+    end
+  end
+end

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

@@ -25,43 +25,37 @@ module RuboCop
       #   # Lambda arguments require no disambiguation
       #   foo = ->(bar) { bar.baz }
       class AmbiguousBlockAssociation < Cop
-        MSG = 'Parenthesize the param `%s` to make sure that the block will be'\
-              ' associated with the `%s` method call.'.freeze
+        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.parenthesized? || allowed_method?(node)
-          return if lambda_argument?(node.last_argument)
+          return if !node.arguments? || node.parenthesized? ||
+                    node.last_argument.lambda? || allowed_method?(node)
 
-          return unless method_with_block?(node.last_argument)
-          last_param = node.last_argument.children.first
-          return unless method_as_param?(last_param)
+          return unless ambiguous_block_association?(node)
 
           add_offense(node)
         end
+        alias on_csend on_send
 
         private
 
-        def allowed_method?(node)
-          node.assignment? || node.operator_method? || node.method?(:[])
-        end
-
-        def method_with_block?(param)
-          param && param.block_type?
+        def ambiguous_block_association?(send_node)
+          send_node.last_argument.block_type? &&
+            !send_node.last_argument.send_node.arguments?
         end
 
-        def method_as_param?(param)
-          param && param.send_type? && !param.arguments?
+        def allowed_method?(node)
+          node.assignment? || node.operator_method? || node.method?(:[])
         end
 
-        def message(node)
-          param = node.last_argument
+        def message(send_node)
+          block_param = send_node.last_argument
 
-          format(MSG, param.source, param.children.first.source)
+          format(MSG, param: block_param.source,
+                      method: block_param.send_node.source)
         end
-
-        def_node_matcher :lambda_argument?, <<-PATTERN
-          (block (send _ :lambda) ...)
-        PATTERN
       end
     end
   end

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

@@ -36,7 +36,13 @@ module RuboCop
         MSG_FORMAT = 'Ambiguous %<actual>s operator. Parenthesize the method ' \
                      "arguments if it's surely a %<actual>s operator, or add " \
                      'a whitespace to the right of the `%<operator>s` if it ' \
-                     'should be a %<possible>s.'.freeze
+                     'should be a %<possible>s.'
+
+        def autocorrect(node)
+          lambda do |corrector|
+            add_parentheses(node, corrector)
+          end
+        end
 
         private
 
@@ -44,11 +50,46 @@ module RuboCop
           diagnostic.reason == :ambiguous_prefix
         end
 
+        def find_offense_node_by(diagnostic)
+          ast = processed_source.ast
+          ast.each_node(:splat, :block_pass, :kwsplat) do |node|
+            next unless offense_position?(node, diagnostic)
+
+            offense_node = offense_node(node)
+            return offense_node if offense_node
+          end
+
+          ast.each_node(:send).find do |send_node|
+            first_argument = send_node.first_argument
+
+            first_argument &&
+              offense_position?(first_argument, diagnostic) &&
+              unary_operator?(first_argument, diagnostic)
+          end
+        end
+
         def alternative_message(diagnostic)
           operator = diagnostic.location.source
           hash = AMBIGUITIES[operator]
           format(MSG_FORMAT, hash)
         end
+
+        def offense_position?(node, diagnostic)
+          node.source_range.begin_pos == diagnostic.location.begin_pos
+        end
+
+        def offense_node(node)
+          case node.type
+          when :splat, :block_pass
+            node.parent
+          when :kwsplat
+            node.parent.parent
+          end
+        end
+
+        def unary_operator?(node, diagnostic)
+          node.source.start_with?(diagnostic.arguments[:prefix])
+        end
       end
     end
   end

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

@@ -26,7 +26,13 @@ module RuboCop
 
         MSG = 'Ambiguous regexp literal. Parenthesize the method arguments ' \
               "if it's surely a regexp literal, or add a whitespace to the " \
-              'right of the `/` if it should be a division.'.freeze
+              'right of the `/` if it should be a division.'
+
+        def autocorrect(node)
+          lambda do |corrector|
+            add_parentheses(node, corrector)
+          end
+        end
 
         private
 
@@ -34,6 +40,14 @@ module RuboCop
           diagnostic.reason == :ambiguous_literal
         end
 
+        def find_offense_node_by(diagnostic)
+          node = processed_source.ast.each_node(:regexp).find do |regexp_node|
+            regexp_node.source_range.begin_pos == diagnostic.location.begin_pos
+          end
+
+          node.parent
+        end
+
         def alternative_message(_diagnostic)
           MSG
         end