rubocop 0.74.0 → 0.75.0

data/lib/rubocop/cop/style/frozen_string_literal_comment.rb

@@ -3,11 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # This cop is designed to help upgrade to after Ruby 3.0. It will add the
-      # comment `# frozen_string_literal: true` to the top of files to
-      # enable frozen string literals. Frozen string literals may be default
-      # after Ruby 3.0. The comment will be added below a shebang and encoding
-      # comment. The frozen string literal comment is only valid in Ruby 2.3+.
+      # This cop is designed to help you transition from mutable string literals
+      # to frozen string literals.
+      # It will add the comment `# frozen_string_literal: true` to the top of
+      # files to enable frozen string literals. Frozen string literals may be
+      # default in future Ruby. The comment will be added below a shebang and
+      # encoding comment. The frozen string literal comment is only valid in
+      # Ruby 2.3+.
       #
       # @example EnforcedStyle: always (default)
       #   # The `always` style will always add the frozen string literal comment
@@ -121,42 +123,25 @@ module RuboCop
         end
 
         def insert_comment(corrector)
-          last_special_comment = last_special_comment(processed_source)
-          if last_special_comment.nil?
-            corrector.insert_before(correction_range, preceding_comment)
-          else
-            corrector.insert_after(correction_range, proceeding_comment)
-          end
-        end
+          comment = last_special_comment(processed_source)
 
-        def preceding_comment
-          if processed_source.tokens[0].space_before?
-            "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+          if comment
+            corrector.insert_after(line_range(comment.line), following_comment)
           else
-            "#{FROZEN_STRING_LITERAL_ENABLED}\n\n"
+            corrector.insert_before(line_range(1), preceding_comment)
           end
         end
 
-        def proceeding_comment
-          last_special_comment = last_special_comment(processed_source)
-          following_line = processed_source.following_line(last_special_comment)
-
-          if following_line&.empty?
-            "\n#{FROZEN_STRING_LITERAL_ENABLED}"
-          else
-            "\n#{FROZEN_STRING_LITERAL_ENABLED}\n"
-          end
+        def line_range(line)
+          processed_source.buffer.line_range(line)
         end
 
-        def correction_range
-          last_special_comment = last_special_comment(processed_source)
+        def preceding_comment
+          "#{FROZEN_STRING_LITERAL_ENABLED}\n"
+        end
 
-          if last_special_comment.nil?
-            range_with_surrounding_space(range: processed_source.tokens[0],
-                                         side: :left)
-          else
-            last_special_comment.pos
-          end
+        def following_comment
+          "\n#{FROZEN_STRING_LITERAL_ENABLED}"
         end
       end
     end

data/lib/rubocop/cop/style/if_unless_modifier.rb

@@ -3,10 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for if and unless statements that would fit on one line
-      # if written as a modifier if/unless. The maximum line length is
-      # configured in the `Metrics/LineLength` cop. The tab size is configured
-      # in the `IndentationWidth` of the `Layout/Tab` cop.
+      # Checks for `if` and `unless` statements that would fit on one line if
+      # written as modifier `if`/`unless`. The cop also checks for modifier
+      # `if`/`unless` lines that exceed the maximum line length.
+      #
+      # The maximum line length is configured in the `Metrics/LineLength`
+      # cop. The tab size is configured in the `IndentationWidth` of the
+      # `Layout/Tab` cop.
       #
       # @example
       #   # bad
@@ -18,35 +21,59 @@ module RuboCop
       #     Foo.do_something
       #   end
       #
+      #   do_something_in_a_method_with_a_long_name(arg) if long_condition
+      #
       #   # good
       #   do_stuff(bar) if condition
       #   Foo.do_something unless qux.empty?
+      #
+      #   if long_condition
+      #     do_something_in_a_method_with_a_long_name(arg)
+      #   end
       class IfUnlessModifier < Cop
         include StatementModifier
 
-        MSG = 'Favor modifier `%<keyword>s` usage when having a single-line ' \
-              'body. Another good alternative is the usage of control flow ' \
-              '`&&`/`||`.'
+        MSG_USE_MODIFIER = 'Favor modifier `%<keyword>s` usage when having a ' \
+                           'single-line body. Another good alternative is ' \
+                           'the usage of control flow `&&`/`||`.'
+        MSG_USE_NORMAL =
+          'Modifier form of `%<keyword>s` makes the line too long.'
 
         ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
                               gvasgn ivasgn masgn].freeze
 
         def on_if(node)
-          return unless eligible_node?(node)
-          return if named_capture_in_condition?(node)
-
-          add_offense(node, location: :keyword,
-                            message: format(MSG, keyword: node.keyword))
+          msg = if eligible_node?(node)
+                  MSG_USE_MODIFIER unless named_capture_in_condition?(node)
+                elsif node.modifier_form? && too_long_single_line?(node)
+                  MSG_USE_NORMAL
+                end
+          return unless msg
+
+          add_offense(node,
+                      location: :keyword,
+                      message: format(msg, keyword: node.keyword))
         end
 
         def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, to_modifier_form(node))
-          end
+          replacement = if node.modifier_form?
+                          to_normal_form(node)
+                        else
+                          to_modifier_form(node)
+                        end
+          ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
         private
 
+        def too_long_single_line?(node)
+          return false unless max_line_length
+
+          range = node.source_range
+          range.first_line == range.last_line &&
+            range.last_column > max_line_length
+        end
+
         def named_capture_in_condition?(node)
           node.condition.match_with_lvasgn_type?
         end
@@ -79,6 +106,15 @@ module RuboCop
           parenthesize?(node) ? "(#{expression})" : expression
         end
 
+        def to_normal_form(node)
+          indentation = ' ' * node.source_range.column
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}end
+          RUBY
+        end
+
         def first_line_comment(node)
           comment =
             processed_source.find_comment { |c| c.loc.line == node.loc.line }

data/lib/rubocop/cop/style/infinite_loop.rb

@@ -119,7 +119,7 @@ module RuboCop
         end
 
         def configured_indent
-          ' ' * config.for_cop('IndentationWidth')['Width']
+          ' ' * config.for_cop('Layout/IndentationWidth')['Width']
         end
       end
     end

data/lib/rubocop/cop/style/method_call_with_args_parentheses.rb

@@ -9,7 +9,7 @@ module RuboCop
       #
       # In the default style (require_parentheses), macro methods are ignored.
       # Additional methods can be added to the `IgnoredMethods`
-      # or `IgnoredMethodPatterns` list. These options are
+      # or `IgnoredPatterns` list. These options are
       # valid only in the default style. Macros can be included by
       # either setting `IgnoreMacros` to false or adding specific macros to
       # the `IncludedMacros` list.
@@ -17,7 +17,7 @@ module RuboCop
       # Precedence of options is all follows:
       #
       # 1. `IgnoredMethods`
-      # 2. `IgnoredMethodPatterns`
+      # 2. `IgnoredPatterns`
       # 3. `IncludedMacros`
       #
       # eg. If a method is listed in both
@@ -61,7 +61,7 @@ module RuboCop
       #   # okay with `puts` listed in `IgnoredMethods`
       #   puts 'test'
       #
-      #   # okay with `^assert` listed in `IgnoredMethodPatterns`
+      #   # okay with `^assert` listed in `IgnoredPatterns`
       #   assert_equal 'test', x
       #
       #   # IgnoreMacros: true (default)
@@ -148,7 +148,7 @@ module RuboCop
       class MethodCallWithArgsParentheses < Cop
         include ConfigurableEnforcedStyle
         include IgnoredMethods
-        include IgnoredMethodPatterns
+        include IgnoredPattern
 
         TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
 
@@ -186,7 +186,7 @@ module RuboCop
 
         def add_offense_for_require_parentheses(node)
           return if ignored_method?(node.method_name)
-          return if ignored_method_pattern?(node.method_name)
+          return if matches_ignored_pattern?(node.method_name)
           return if eligible_for_parentheses_omission?(node)
           return unless node.arguments? && !node.parenthesized?
 

data/lib/rubocop/cop/style/mixin_usage.rb

@@ -49,6 +49,10 @@ module RuboCop
             const)
         PATTERN
 
+        def_node_matcher :wrapped_macro_scope?, <<~PATTERN
+          {({sclass class module block} ... ({begin if} ...))}
+        PATTERN
+
         def on_send(node)
           include_statement(node) do |statement|
             return if node.argument? ||
@@ -62,7 +66,13 @@ module RuboCop
         private
 
         def accepted_include?(node)
-          node.parent && node.macro?
+          node.parent && (node.macro? || ascend_macro_scope?(node.parent))
+        end
+
+        def ascend_macro_scope?(ancestor)
+          return true if wrapped_macro_scope?(ancestor)
+
+          ancestor.parent && ascend_macro_scope?(ancestor.parent)
         end
 
         def belongs_to_class_or_module?(node)

data/lib/rubocop/cop/style/multiline_memoization.rb

@@ -73,7 +73,7 @@ module RuboCop
         end
 
         def keyword_begin_str(node, node_buf)
-          indent = config.for_cop('IndentationWidth')['Width'] || 2
+          indent = config.for_cop('Layout/IndentationWidth')['Width'] || 2
           if node_buf.source[node.loc.begin.end_pos] == "\n"
             'begin'
           else

data/lib/rubocop/cop/style/nested_modifier.rb

@@ -73,12 +73,28 @@ module RuboCop
         end
 
         def right_hand_operand(node, left_hand_keyword)
-          expr = node.condition.source
-          expr = "(#{expr})" if requires_parens?(node.condition)
+          condition = node.condition
+
+          expr = if condition.send_type? && !condition.arguments.empty? &&
+                    !condition.operator_method?
+                   add_parentheses_to_method_arguments(condition)
+                 else
+                   condition.source
+                 end
+          expr = "(#{expr})" if requires_parens?(condition)
           expr = "!#{expr}" unless left_hand_keyword == node.keyword
           expr
         end
 
+        def add_parentheses_to_method_arguments(send_node)
+          expr = +''
+          expr << "#{send_node.receiver.source}." if send_node.receiver
+          expr << send_node.method_name.to_s
+          expr << "(#{send_node.arguments.map(&:source).join(', ')})"
+
+          expr
+        end
+
         def requires_parens?(node)
           node.or_type? ||
             !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?

data/lib/rubocop/cop/style/or_assignment.rb

@@ -81,7 +81,12 @@ module RuboCop
         end
 
         def take_variable_and_default_from_unless(node)
-          variable, default = *node.if_branch
+          if node.if_branch
+            variable, default = *node.if_branch
+          else
+            variable, default = *node.else_branch
+          end
+
           [variable, default]
         end
       end

data/lib/rubocop/cop/style/parentheses_around_condition.rb

@@ -6,6 +6,11 @@ module RuboCop
       # This cop checks for the presence of superfluous parentheses around the
       # condition of if/unless/while/until.
       #
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
+      #
       # @example
       #   # bad
       #   x += 1 while (x < 10)
@@ -23,6 +28,14 @@ module RuboCop
       #   elsif x < 3
       #   end
       #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo unless (bar = baz)
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo unless (bar = baz)
+      #
       # @example AllowInMultilineConditions: false (default)
       #   # bad
       #   if (x > 10 &&
@@ -39,6 +52,7 @@ module RuboCop
       #   if (x > 10 &&
       #      y > 10)
       #   end
+      #
       class ParenthesesAroundCondition < Cop
         include SafeAssignment
         include Parentheses

data/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -40,7 +40,7 @@ module RuboCop
 
         def parens_allowed?(node)
           empty_parentheses?(node) ||
-            hash_literal_as_first_arg?(node) ||
+            first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
             allowed_expression?(node)
         end
@@ -76,12 +76,21 @@ module RuboCop
           node.children.empty?
         end
 
-        def hash_literal_as_first_arg?(node)
-          # Don't flag `method ({key: value})`
-          node.children.first.hash_type? && first_argument?(node) &&
+        def first_arg_begins_with_hash_literal?(node)
+          # Don't flag `method ({key: value})` or `method ({key: value}.method)`
+          method_chain_begins_with_hash_literal?(node.children.first) &&
+            first_argument?(node) &&
             !parentheses?(node.parent)
         end
 
+        def method_chain_begins_with_hash_literal?(node)
+          return false if node.nil?
+          return true if node.hash_type?
+          return false unless node.send_type?
+
+          method_chain_begins_with_hash_literal?(node.children.first)
+        end
+
         def check(begin_node)
           node = begin_node.children.first
           if keyword_with_redundant_parentheses?(node)

data/lib/rubocop/cop/style/redundant_self.rb

@@ -83,9 +83,16 @@ module RuboCop
           on_argument(node)
         end
 
+        def on_masgn(node)
+          lhs, rhs = *node
+          lhs.children.each do |child|
+            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
+          end
+        end
+
         def on_lvasgn(node)
           lhs, rhs = *node
-          @local_variables_scopes[rhs] << lhs
+          add_lhs_to_local_variables_scopes(rhs, lhs)
         end
 
         def on_send(node)
@@ -148,6 +155,16 @@ module RuboCop
 
           @allowed_send_nodes << node
         end
+
+        def add_lhs_to_local_variables_scopes(rhs, lhs)
+          if rhs&.send_type? && !rhs.arguments.empty?
+            rhs.arguments.each do |argument|
+              @local_variables_scopes[argument] << lhs
+            end
+          else
+            @local_variables_scopes[rhs] << lhs
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/style/rescue_modifier.rb

@@ -5,16 +5,40 @@ module RuboCop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       #
+      # The cop to check `rescue` in its modifier form is added for following
+      # reasons:
+      #
+      # * The syntax of modifier form `rescue` can be misleading because it
+      #   might led us to believe that `rescue` handles the given exception
+      #   but it actually rescue all exceptions to return the given rescue
+      #   block. In this case, value returned by handle_error or
+      #   SomeException.
+      #
+      # * Modifier form `rescue` would rescue all the exceptions. It would
+      #   silently skip all exception or errors and handle the error.
+      #   Example: If `NoMethodError` is raised, modifier form rescue would
+      #   handle the exception.
+      #
       # @example
       #   # bad
       #   some_method rescue handle_error
       #
+      #   # bad
+      #   some_method rescue SomeException
+      #
       #   # good
       #   begin
       #     some_method
       #   rescue
       #     handle_error
       #   end
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue SomeException
+      #     handle_error
+      #   end
       class RescueModifier < Cop
         include Alignment
         include RescueNode