rubocop 0.82.0 → 0.83.0

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

@@ -160,7 +160,10 @@ module RuboCop
         end
 
         def highlight_start(line)
-          max - indentation_difference(line)
+          # TODO: The max with 0 is a quick fix to avoid crashes when a line
+          # begins with many tabs, but getting a correct highlighting range
+          # when tabs are used for indentation doesn't work currently.
+          [max - indentation_difference(line), 0].max
         end
 
         def check_line(line, line_index)

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

@@ -6,30 +6,39 @@ module RuboCop
       # This cop checks the indentation of the right hand side operand in
       # binary operations that span more than one line.
       #
+      # The `aligned` style checks that operators are aligned if they are part
+      # of an `if` or `while` condition, a `return` statement, etc. In other
+      # contexts, the second operand should be indented regardless of enforced
+      # style.
+      #
       # @example EnforcedStyle: aligned (default)
       #   # bad
       #   if a +
       #       b
-      #     something
+      #     something &&
+      #     something_else
       #   end
       #
       #   # good
       #   if a +
       #      b
-      #     something
+      #     something &&
+      #       something_else
       #   end
       #
       # @example EnforcedStyle: indented
       #   # bad
       #   if a +
       #      b
-      #     something
+      #     something &&
+      #     something_else
       #   end
       #
       #   # good
       #   if a +
       #       b
-      #     something
+      #     something &&
+      #       something_else
       #   end
       #
       class MultilineOperationIndentation < Cop

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

@@ -139,7 +139,7 @@ module RuboCop
             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
@@ -170,6 +170,19 @@ 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 should_not_have_surrounding_space?(operator)
             return if with_space.is?(operator.source)
@@ -216,6 +229,10 @@ module RuboCop
           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

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

@@ -9,14 +9,12 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
-      #   puts (x + y)
-      #
-      # @example
+      #   do_something (foo)
       #
       #   # good
-      #
-      #   puts(x + y)
+      #   do_something(foo)
+      #   do_something (2 + 3) * 4
+      #   do_something (foo * bar).baz
       class ParenthesesAsGroupedExpression < Cop
         include RangeHelp
 
@@ -25,20 +23,34 @@ module RuboCop
         def on_send(node)
           return unless node.arguments.one?
           return if node.operator_method? || node.setter_method?
-
-          return unless node.first_argument.source.start_with?('(')
+          return if grouped_parentheses?(node)
 
           space_length = spaces_before_left_parenthesis(node)
           return unless space_length.positive?
 
           range = space_range(node.first_argument.source_range, space_length)
 
-          add_offense(nil, location: range)
+          add_offense(node, location: range)
         end
         alias on_csend on_send
 
+        def autocorrect(node)
+          space_length = spaces_before_left_parenthesis(node)
+          range = space_range(node.first_argument.source_range, space_length)
+
+          lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+
         private
 
+        def grouped_parentheses?(node)
+          first_argument = node.first_argument
+
+          first_argument.send_type? && first_argument.receiver&.begin_type?
+        end
+
         def spaces_before_left_parenthesis(node)
           receiver = node.receiver
           receiver_length = if receiver

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

@@ -26,7 +26,6 @@ module RuboCop
       #   # good
       #   x += 1
       class RedundantCopDisableDirective < Cop
-        include NameSimilarity
         include RangeHelp
 
         COP_NAME = 'Lint/RedundantCopDisableDirective'
@@ -235,7 +234,7 @@ module RuboCop
           elsif all_cop_names.include?(cop)
             "`#{cop}`"
           else
-            similar = find_similar_name(cop, [])
+            similar = NameSimilarity.find_similar_name(cop, all_cop_names)
             if similar
               "`#{cop}` (did you mean `#{similar}`?)"
             else
@@ -244,10 +243,6 @@ module RuboCop
           end
         end
 
-        def collect_variable_like_names(scope)
-          all_cop_names.each { |name| scope << name }
-        end
-
         def all_cop_names
           @all_cop_names ||= Cop.registry.names
         end