rubocop 0.76.0 → 0.83.0

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

@@ -3,24 +3,55 @@
 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.
+      #
+      # This cop has `AllowForAlignment` option. When `true`, allows most
+      # uses of extra spacing if the intent is to align with an operator on
+      # the previous or next line, not counting empty lines or comment lines.
       #
       # @example
       #   # bad
       #   total = 3*4
       #   "apple"+"juice"
       #   my_number = 38/4
-      #   a ** b
       #
       #   # good
       #   total = 3 * 4
       #   "apple" + "juice"
       #   my_number = 38 / 4
+      #
+      # @example AllowForAlignment: true (default)
+      #   # good
+      #   {
+      #     1 =>  2,
+      #     11 => 3
+      #   }
+      #
+      # @example AllowForAlignment: false
+      #   # bad
+      #   {
+      #     1 =>  2,
+      #     11 => 3
+      #   }
+      #
+      # @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 +84,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,12 +134,12 @@ 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")
             else
-              corrector.replace(range, " #{range.source.strip} ")
+              enclose_operator_with_space(corrector, range)
             end
           end
         end
@@ -137,10 +170,25 @@ module RuboCop
           yield msg if msg
         end
 
+        def enclose_operator_with_space(corrector, range)
+          operator = range.source
+
+          # If `ForceEqualSignAlignment` is true, `Layout/ExtraSpacing` cop
+          # inserts spaces before operator. If `Layout/SpaceAroundOperators` cop
+          # inserts a space, it collides and raises the infinite loop error.
+          if force_equal_sign_alignment?
+            corrector.insert_after(range, ' ') unless operator.end_with?(' ')
+          else
+            corrector.replace(range, " #{operator.strip} ")
+          end
+        end
+
         def offense_message(type, operator, with_space, right_operand)
-          if operator.is?('**')
-            'Space around operator `**` detected.' unless with_space.is?('**')
-          elsif with_space.source !~ /^\s.*\s$/
+          if should_not_have_surrounding_space?(operator)
+            return if with_space.is?(operator.source)
+
+            "Space around operator `#{operator.source}` detected."
+          elsif !/^\s.*\s$/.match?(with_space.source)
             "Surrounding space missing for operator `#{operator.source}`."
           elsif excess_leading_space?(type, operator, with_space) ||
                 excess_trailing_space?(right_operand, with_space)
@@ -169,13 +217,25 @@ 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 force_equal_sign_alignment?
+          config.for_cop('Layout/ExtraSpacing')['ForceEqualSignAlignment']
+        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_before_first_arg.rb

@@ -54,6 +54,7 @@ module RuboCop
 
         def expect_params_after_method_name?(node)
           return false if node.parenthesized?
+          return true if no_space_between_method_name_and_first_argument?(node)
 
           first_arg = node.first_argument
 
@@ -61,6 +62,13 @@ module RuboCop
             !(allow_for_alignment? &&
               aligned_with_something?(first_arg.source_range))
         end
+
+        def no_space_between_method_name_and_first_argument?(node)
+          end_pos_of_method_name = node.loc.selector.end_pos
+          begin_pos_of_argument = node.first_argument.source_range.begin_pos
+
+          end_pos_of_method_name == begin_pos_of_argument
+        end
       end
     end
   end

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

@@ -46,7 +46,7 @@ module RuboCop
           children = lambda_node.parent.children
           lambda do |corrector|
             if style == :require_space
-              corrector.insert_before(children[1].source_range, ' ')
+              corrector.insert_before(children[1], ' ')
             else
               corrector.remove(space_after_arrow(lambda_node))
             end

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

@@ -117,7 +117,7 @@ module RuboCop
             range = range_between(left_brace.end_pos, right_brace.begin_pos)
             inner = range.source
 
-            if inner =~ /\S/
+            if /\S/.match?(inner)
               braces_with_contents_inside(node, inner)
             elsif style_for_empty_braces == :no_space
               offense(range.begin_pos, range.end_pos,
@@ -142,7 +142,7 @@ module RuboCop
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
-          if inner =~ /\A\S/
+          if /\A\S/.match?(inner)
             no_space_inside_left_brace(left_brace, args_delimiter)
           else
             space_inside_left_brace(left_brace, args_delimiter)

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

@@ -83,17 +83,10 @@ module RuboCop
 
         def autocorrect(range)
           lambda do |corrector|
-            # It is possible that BracesAroundHashParameters will remove the
-            # braces while this cop inserts spaces. This can lead to unwanted
-            # changes to the inspected code. If we replace the brace with a
-            # brace plus space (rather than just inserting a space), then any
-            # removal of the same brace will give us a clobbering error. This
-            # in turn will make RuboCop fall back on cop-by-cop
-            # auto-correction. Problem solved.
             case range.source
             when /\s/ then corrector.remove(range)
-            when '{' then corrector.replace(range, '{ ')
-            else corrector.replace(range, ' }')
+            when '{' then corrector.insert_after(range, ' ')
+            else corrector.insert_before(range, ' ')
             end
           end
         end

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

@@ -35,7 +35,7 @@ module RuboCop
 
           lambda do |corrector|
             corrector.replace(
-              node.source_range,
+              node,
               expression
                 .sub(/\s+#{operator_escaped}/, operator)
                 .sub(/#{operator_escaped}\s+/, operator)
@@ -53,7 +53,7 @@ module RuboCop
           # account for multiline range literals
           expression.sub!(/#{escaped_op}\n\s*/, op)
 
-          return unless expression =~ /(\s#{escaped_op})|(#{escaped_op}\s)/
+          return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
 
           add_offense(node)
         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,14 +14,14 @@ module RuboCop
       #   # good
       #   x = 0
       #
-      # @example AllowInHeredoc: false (default)
+      # @example AllowInHeredoc: false
       #   # The line in this example contains spaces after the 0.
       #   # bad
       #   code = <<~RUBY
       #     x = 0
       #   RUBY
       #
-      # @example AllowInHeredoc: true
+      # @example AllowInHeredoc: true (default)
       #   # The line in this example contains spaces after the 0.
       #   # good
       #   code = <<~RUBY

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

@@ -38,17 +38,55 @@ 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)
+          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|
+            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|
+            offense_position?(send_node.first_argument, diagnostic) &&
+              unary_operator?(send_node.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

@@ -28,12 +28,26 @@ module RuboCop
               "if it's surely a regexp literal, or add a whitespace to the " \
               'right of the `/` if it should be a division.'
 
+        def autocorrect(node)
+          lambda do |corrector|
+            add_parentheses(node, corrector)
+          end
+        end
+
         private
 
         def relevant_diagnostic?(diagnostic)
           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

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

@@ -32,6 +32,18 @@ module RuboCop
 
           add_offense(node, message: format(MSG, boolean: node.value))
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            boolean_literal = node.source.delete(':')
+            parent = node.parent
+            if parent&.pair_type? && node.equal?(parent.children[0])
+              corrector.remove(parent.loc.operator)
+              boolean_literal = "#{node.source} =>"
+            end
+            corrector.replace(node, boolean_literal)
+          end
+        end
       end
     end
   end

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

@@ -45,7 +45,7 @@ module RuboCop
         def_node_matcher :debugger_call?, <<~PATTERN
           {(send {nil? #kernel?} {:debugger :byebug :remote_byebug} ...)
            (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
@@ -69,7 +69,7 @@ module RuboCop
         end
 
         def binding_irb?(node)
-          target_ruby_version >= 2.4 && binding_irb_call?(node)
+          binding_irb_call?(node)
         end
       end
     end

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/duplicate_methods.rb

@@ -95,10 +95,6 @@ module RuboCop
           (send nil? :alias_method (sym $_name) _)
         PATTERN
 
-        def_node_matcher :attr?, <<~PATTERN
-          (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
-        PATTERN
-
         def_node_matcher :sym_name, '(sym $_name)'
 
         def on_send(node)
@@ -108,7 +104,7 @@ module RuboCop
             return if possible_dsl?(node)
 
             found_instance_method(node, name)
-          elsif (attr = attr?(node))
+          elsif (attr = node.attribute_accessor?)
             on_attr(node, *attr)
           end
         end

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/empty_when.rb

@@ -8,26 +8,49 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   case foo
-      #   when bar then 1
-      #   when baz then # nothing
+      #   when bar
+      #     do_something
+      #   when baz
       #   end
       #
       # @example
       #
       #   # good
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     nil
+      #   end
       #
-      #   case foo
-      #   when bar then 1
-      #   when baz then 2
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     # noop
       #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   case condition
+      #   when foo
+      #     do_something
+      #   when bar
+      #     # do nothing
+      #   end
+      #
       class EmptyWhen < Cop
         MSG = 'Avoid `when` branches without a body.'
 
         def on_case(node)
           node.each_when do |when_node|
             next if when_node.body
+            next if cop_config['AllowComments'] && comment_lines?(node)
 
             add_offense(when_node, location: when_node.source_range)
           end

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

@@ -29,6 +29,8 @@ module RuboCop
       #     do_something_else
       #   end
       class EnsureReturn < Cop
+        include RangeHelp
+
         MSG = 'Do not return from an `ensure` block.'
 
         def on_ensure(node)
@@ -37,7 +39,22 @@ module RuboCop
           return unless ensure_body
 
           ensure_body.each_node(:return) do |return_node|
-            add_offense(return_node)
+            next if return_node.arguments.size >= 2
+
+            add_offense(return_node, location: :keyword)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.arguments?
+              corrector.replace(node, node.source.gsub(/return\s*/, ''))
+            else
+              range = range_by_whole_lines(
+                node.loc.expression, include_final_newline: true
+              )
+              corrector.remove(range)
+            end
           end
         end
       end

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

@@ -84,7 +84,7 @@ module RuboCop
 
         def on_send(node)
           erb_new_with_non_keyword_arguments(node) do |arguments|
-            return if correct_arguments?(arguments)
+            return if arguments.empty? || correct_arguments?(arguments)
 
             arguments[1..3].each_with_index do |argument, i|
               next if !argument || argument.hash_type?

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

@@ -81,7 +81,7 @@ module RuboCop
         end
 
         def display_str(node)
-          if node.source =~ /\n/
+          if /\n/.match?(node.source)
             str_content(node).inspect
           else
             node.source

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/inherit_exception.rb

@@ -77,7 +77,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.loc.expression, preferred_base_class)
+            corrector.replace(node, preferred_base_class)
           end
         end
 

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

@@ -25,7 +25,7 @@ module RuboCop
 
           parent = node.parent
           return if parent && (parent.dstr_type? || parent.regexp_type?)
-          return unless node.source.scrub =~ /(?<!\\)#\{.*\}/
+          return unless /(?<!\\)#\{.*\}/.match?(node.source.scrub)
 
           add_offense(node)
         end

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

@@ -10,26 +10,25 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   if 20
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # bad
-      #
       #   if some_var && true
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   if some_var && some_condition
       #     do_something
       #   end
+      #
+      #   # good
+      #   # When using a boolean value for an infinite loop.
+      #   while true
+      #     break if condition
+      #   end
       class LiteralAsCondition < Cop
         MSG = 'Literal `%<literal>s` appeared as a condition.'
 
@@ -38,20 +37,18 @@ module RuboCop
         end
 
         def on_while(node)
-          check_for_literal(node)
-        end
+          return if condition(node).true_type?
 
-        def on_while_post(node)
           check_for_literal(node)
         end
+        alias on_while_post on_while
 
         def on_until(node)
-          check_for_literal(node)
-        end
+          return if condition(node).false_type?
 
-        def on_until_post(node)
           check_for_literal(node)
         end
+        alias on_until_post on_until
 
         def on_case(case_node)
           if case_node.condition

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

@@ -37,7 +37,7 @@ module RuboCop
           return if node.dstr_type? # nested, fixed in next iteration
 
           value = autocorrected_value(node)
-          ->(corrector) { corrector.replace(node.parent.source_range, value) }
+          ->(corrector) { corrector.replace(node.parent, value) }
         end
 
         private