rubocop 0.75.0 → 0.79.0

data/lib/rubocop/cop/layout/{align_parameters.rb → parameter_alignment.rb}

@@ -68,7 +68,7 @@ module RuboCop
       #        baz)
       #     123
       #   end
-      class AlignParameters < Cop
+      class ParameterAlignment < Cop
         include Alignment
 
         ALIGN_PARAMS_MSG = 'Align the parameters of a method definition if ' \

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

@@ -96,6 +96,7 @@ module RuboCop
           )
         end
 
+        # rubocop:disable Metrics/AbcSize
         def alignment_source(node, starting_loc)
           ending_loc =
             case node.type
@@ -114,6 +115,7 @@ 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_keyword.rb

@@ -30,10 +30,12 @@ module RuboCop
 
         DO = 'do'
         SAFE_NAVIGATION = '&.'
+        NAMESPACE_OPERATOR = '::'
         ACCEPT_LEFT_PAREN =
           %w[break defined? next not rescue return super yield].freeze
         ACCEPT_LEFT_SQUARE_BRACKET =
           %w[super yield].freeze
+        ACCEPT_NAMESPACE_OPERATOR = 'super'
 
         def on_and(node)
           check(node, [:operator].freeze) if node.keyword?
@@ -193,6 +195,8 @@ module RuboCop
 
           return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
+          return false if accept_namespace_operator?(range) &&
+                          namespace_operator?(range, pos)
 
           char !~ /[\s;,#\\\)\}\]\.]/
         end
@@ -212,10 +216,18 @@ module RuboCop
           ACCEPT_LEFT_SQUARE_BRACKET.include?(range.source)
         end
 
+        def accept_namespace_operator?(range)
+          ACCEPT_NAMESPACE_OPERATOR == range.source
+        end
+
         def safe_navigation_call?(range, pos)
           range.source_buffer.source[pos, 2].start_with?(SAFE_NAVIGATION)
         end
 
+        def namespace_operator?(range, pos)
+          range.source_buffer.source[pos, 2].start_with?(NAMESPACE_OPERATOR)
+        end
+
         def preceded_by_operator?(node, _range)
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them

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

@@ -3,24 +3,37 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks that operators have space around them, except for **
-      # which should not have surrounding space.
+      # Checks that operators have space around them, except for ** which
+      # should or shouldn't have surrounding space depending on configuration.
       #
       # @example
       #   # bad
       #   total = 3*4
       #   "apple"+"juice"
       #   my_number = 38/4
-      #   a ** b
       #
       #   # good
       #   total = 3 * 4
       #   "apple" + "juice"
       #   my_number = 38 / 4
+      #
+      # @example EnforcedStyleForExponentOperator: no_space (default)
+      #   # bad
+      #   a ** b
+      #
+      #   # good
+      #   a**b
+      #
+      # @example EnforcedStyleForExponentOperator: space
+      #   # bad
       #   a**b
+      #
+      #   # good
+      #   a ** b
       class SpaceAroundOperators < Cop
         include PrecedingFollowingAlignment
         include RangeHelp
+        include RationalLiteral
 
         IRREGULAR_METHODS = %i[[] ! []=].freeze
         EXCESSIVE_SPACE = '  '
@@ -53,6 +66,8 @@ module RuboCop
         end
 
         def on_send(node)
+          return if rational_literal?(node)
+
           if node.setter_method?
             on_special_asgn(node)
           elsif regular_operator?(node)
@@ -101,7 +116,7 @@ module RuboCop
 
         def autocorrect(range)
           lambda do |corrector|
-            if range.source =~ /\*\*/
+            if range.source =~ /\*\*/ && !space_around_exponent_operator?
               corrector.replace(range, '**')
             elsif range.source.end_with?("\n")
               corrector.replace(range, " #{range.source.strip}\n")
@@ -138,8 +153,10 @@ module RuboCop
         end
 
         def offense_message(type, operator, with_space, right_operand)
-          if operator.is?('**')
-            'Space around operator `**` detected.' unless with_space.is?('**')
+          if should_not_have_surrounding_space?(operator)
+            return if with_space.is?(operator.source)
+
+            "Space around operator `#{operator.source}` detected."
           elsif with_space.source !~ /^\s.*\s$/
             "Surrounding space missing for operator `#{operator.source}`."
           elsif excess_leading_space?(type, operator, with_space) ||
@@ -169,13 +186,21 @@ module RuboCop
         end
 
         def align_hash_cop_config
-          config.for_cop('Layout/AlignHash')
+          config.for_cop('Layout/HashAlignment')
         end
 
         def hash_table_style?
           align_hash_cop_config &&
             align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
         end
+
+        def space_around_exponent_operator?
+          cop_config['EnforcedStyleForExponentOperator'] == 'space'
+        end
+
+        def should_not_have_surrounding_space?(operator)
+          operator.is?('**') ? !space_around_exponent_operator? : false
+        end
       end
     end
   end

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

@@ -41,6 +41,14 @@ module RuboCop
         def on_block(node)
           return if node.keywords?
 
+          # Do not register an offense for multi-line braces when specifying
+          # `EnforcedStyle: no_space`. It will conflict with auto-correction
+          # by `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` cop.
+          # That means preventing auto-correction to incorrect auto-corrected
+          # code.
+          # See: https://github.com/rubocop-hq/rubocop/issues/7534
+          return if conflict_with_block_delimiters?(node)
+
           left_brace = node.loc.begin
           space_plus_brace = range_with_surrounding_space(range: left_brace)
           used_style =
@@ -110,6 +118,15 @@ module RuboCop
           end
         end
 
+        def conflict_with_block_delimiters?(node)
+          block_delimiters_style == 'line_count_based' &&
+            style == :no_space && node.multiline?
+        end
+
+        def block_delimiters_style
+          config.for_cop('Style/BlockDelimiters')['EnforcedStyle']
+        end
+
         def empty_braces?(loc)
           loc.begin.end_pos == loc.end.begin_pos
         end

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

@@ -48,9 +48,7 @@ module RuboCop
             if style == :require_space
               corrector.insert_before(children[1].source_range, ' ')
             else
-              space_range = range_between(children[0].source_range.end_pos,
-                                          children[1].source_range.begin_pos)
-              corrector.remove(space_range)
+              corrector.remove(space_after_arrow(lambda_node))
             end
           end
         end
@@ -62,10 +60,14 @@ module RuboCop
         end
 
         def space_after_arrow?(lambda_node)
-          arrow = lambda_node.parent.children[0]
-          parentheses = lambda_node.parent.children[1]
-          (parentheses.source_range.begin_pos - arrow.source_range.end_pos)
-            .positive?
+          !space_after_arrow(lambda_node).empty?
+        end
+
+        def space_after_arrow(lambda_node)
+          arrow = lambda_node.parent.children[0].source_range
+          parentheses = lambda_node.parent.children[1].source_range
+
+          arrow.end.join(parentheses.begin)
         end
 
         def range_of_offense(node)

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

@@ -210,18 +210,21 @@ module RuboCop
 
         def compact_corrections(corrector, node, left, right)
           if qualifies_for_compact?(node, left, side: :left)
-            range = side_space_range(range: left.pos, side: :right)
-            corrector.remove(range)
+            compact(corrector, left, :right)
           elsif !left.space_after?
             corrector.insert_after(left.pos, ' ')
           end
           if qualifies_for_compact?(node, right)
-            range = side_space_range(range: right.pos, side: :left)
-            corrector.remove(range)
+            compact(corrector, right, :left)
           elsif !right.space_before?
             corrector.insert_before(right.pos, ' ')
           end
         end
+
+        def compact(corrector, bracket, side)
+          range = side_space_range(range: bracket.pos, side: side)
+          corrector.remove(range)
+        end
       end
     end
   end

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

@@ -72,7 +72,7 @@ module RuboCop
             # If the second token is a comment, that means that a line break
             # follows, and that the rules for space inside don't apply.
             next if token2.comment?
-            next unless token2.line == token1.line && token1.space_after?
+            next unless same_line?(token1, token2) && token1.space_after?
 
             yield range_between(token1.end_pos, token2.begin_pos)
           end
@@ -82,17 +82,18 @@ module RuboCop
           tokens.each_cons(2) do |token1, token2|
             next if can_be_ignored?(token1, token2)
 
-            next unless token2.line == token1.line && !token1.space_after?
-
             if token1.left_parens?
               yield range_between(token2.begin_pos, token2.begin_pos + 1)
-
             elsif token2.right_parens?
               yield range_between(token2.begin_pos, token2.end_pos)
             end
           end
         end
 
+        def same_line?(token1, token2)
+          token1.line == token2.line
+        end
+
         def parens?(token1, token2)
           token1.left_parens? || token2.right_parens?
         end
@@ -104,8 +105,7 @@ module RuboCop
           # follows, and that the rules for space inside don't apply.
           return true if token2.comment?
 
-          # Ignore empty parens. # TODO: Could be configurable.
-          return true if token1.left_parens? && token2.right_parens?
+          return true unless same_line?(token1, token2) && !token1.space_after?
         end
       end
     end

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

@@ -37,7 +37,7 @@ module RuboCop
       #   class Foo; end
       #   # EOF
       #
-      class TrailingBlankLines < Cop
+      class TrailingEmptyLines < Cop
         include ConfigurableEnforcedStyle
         include RangeHelp
 

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

@@ -14,6 +14,20 @@ module RuboCop
       #   # good
       #   x = 0
       #
+      # @example AllowInHeredoc: false (default)
+      #   # The line in this example contains spaces after the 0.
+      #   # bad
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
+      # @example AllowInHeredoc: true
+      #   # The line in this example contains spaces after the 0.
+      #   # good
+      #   code = <<~RUBY
+      #     x = 0
+      #   RUBY
+      #
       class TrailingWhitespace < Cop
         include RangeHelp
 
@@ -22,11 +36,13 @@ module RuboCop
         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, index + 1)
+            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)

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

@@ -43,9 +43,9 @@ module RuboCop
         PATTERN
 
         def_node_matcher :debugger_call?, <<~PATTERN
-          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
+          {(send {nil? #kernel?} {:debugger :byebug :remote_byebug :console} ...)
            (send (send {#kernel? nil?} :binding)
-             {:pry :remote_pry :pry_remote} ...)
+             {:pry :remote_pry :pry_remote :console} ...)
            (send (const {nil? (cbase)} :Pry) :rescue ...)
            (send nil? {:save_and_open_page
                       :save_and_open_screenshot

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

@@ -33,7 +33,7 @@ module RuboCop
 
         # @param [DefNode] node a constructor definition
         def check(node)
-          return unless node.method_name == :initialize
+          return unless node.method?(:initialize)
 
           check_body(node.body)
         end

data/lib/rubocop/cop/lint/{duplicated_key.rb → duplicate_hash_key.rb}

@@ -18,7 +18,7 @@ module RuboCop
       #   # good
       #
       #   hash = { food: 'apple', other_food: 'orange' }
-      class DuplicatedKey < Cop
+      class DuplicateHashKey < Cop
         include Duplication
 
         MSG = 'Duplicated key in hash literal.'

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

@@ -22,7 +22,7 @@ module RuboCop
       #   num = 0
       #   sum = numbers.each_with_object(num) { |e, a| a += e }
       class EachWithObjectArgument < Cop
-        MSG = 'The argument to each_with_object can not be immutable.'
+        MSG = 'The argument to each_with_object cannot be immutable.'
 
         def_node_matcher :each_with_object?, <<~PATTERN
           ({send csend} _ :each_with_object $_)

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

@@ -86,13 +86,13 @@ module RuboCop
           erb_new_with_non_keyword_arguments(node) do |arguments|
             return if correct_arguments?(arguments)
 
-            1.upto(3) do |i|
-              next if !arguments[i] || arguments[i].hash_type?
+            arguments[1..3].each_with_index do |argument, i|
+              next if !argument || argument.hash_type?
 
-              message = format(MESSAGES[i - 1], arg_value: arguments[i].source)
+              message = format(MESSAGES[i], arg_value: argument.source)
 
               add_offense(
-                node, location: arguments[i].source_range, message: message
+                node, location: argument.source_range, message: message
               )
             end
           end
@@ -138,14 +138,15 @@ module RuboCop
         end
 
         def override_by_legacy_args(kwargs, node)
+          arguments = node.arguments
           overridden_kwargs = kwargs.dup
 
-          if node.arguments[2]
-            overridden_kwargs[0] = "trim_mode: #{node.arguments[2].source}"
+          if arguments[2]
+            overridden_kwargs[0] = "trim_mode: #{arguments[2].source}"
           end
 
-          if node.arguments[3] && !node.arguments[3].hash_type?
-            overridden_kwargs[1] = "eoutvar: #{node.arguments[3].source}"
+          if arguments[3] && !arguments[3].hash_type?
+            overridden_kwargs[1] = "eoutvar: #{arguments[3].source}"
           end
 
           overridden_kwargs

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

@@ -117,7 +117,7 @@ module RuboCop
         end
 
         def correct_visibility?(node, modifier, ignored_methods)
-          return true if modifier.nil? || modifier.method_name == :public
+          return true if modifier.nil? || modifier.method?(:public)
 
           ignored_methods.include?(node.method_name)
         end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# rubocop:disable Lint/UnneededCopDisableDirective
+# rubocop:disable Lint/RedundantCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -81,4 +81,4 @@ module RuboCop
     end
   end
 end
-# rubocop:enable Lint/UnneededCopDisableDirective, Layout/SpaceAroundOperators
+# rubocop:enable Lint/RedundantCopDisableDirective, Layout/SpaceAroundOperators

data/lib/rubocop/cop/lint/{multiple_compare.rb → multiple_comparison.rb}

@@ -21,7 +21,7 @@ module RuboCop
       #
       #   x < y && y < z
       #   10 <= x && x <= 20
-      class MultipleCompare < Cop
+      class MultipleComparison < Cop
         MSG = 'Use the `&&` operator to compare multiple values.'
 
         def_node_matcher :multiple_compare?, <<~PATTERN