rubocop 1.12.0 → 1.13.0

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

@@ -99,12 +99,9 @@ module RuboCop
 
         def register_offense(node, scope_exiting_keyword, conditional_keyword)
           condition, = node.node_parts
-          example = [scope_exiting_keyword,
-                     conditional_keyword,
-                     condition.source].join(' ')
+          example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
           if too_long_for_single_line?(node, example)
-            example = "#{conditional_keyword} #{condition.source}; " \
-                      "#{scope_exiting_keyword}; end"
+            example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
           end
 
           add_offense(node.loc.keyword, message: format(MSG, example: example))
@@ -126,8 +123,7 @@ module RuboCop
         end
 
         def accepted_form?(node, ending: false)
-          accepted_if?(node, ending) || node.condition.multiline? ||
-            node.parent&.assignment?
+          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
         end
 
         def accepted_if?(node, ending)

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

@@ -61,11 +61,11 @@ module RuboCop
         def single_argument(node)
           first_argument = node.first_argument
           if first_argument.hash_type?
-            add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
-              corrector.replace(node, "{#{first_argument.source}}")
-            end
+            register_offense_for_hash(node, first_argument)
           elsif first_argument.splat_type?
             add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
+          elsif use_zip_method_without_argument?(first_argument)
+            register_offense_for_zip_method(node, first_argument)
           else
             add_offense(node, message: MSG_TO_H) do |corrector|
               replacement = first_argument.source
@@ -75,6 +75,31 @@ module RuboCop
           end
         end
 
+        def use_zip_method_without_argument?(first_argument)
+          return false unless first_argument&.send_type?
+
+          first_argument.method?(:zip) && first_argument.arguments.empty?
+        end
+
+        def register_offense_for_hash(node, hash_argument)
+          add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
+            corrector.replace(node, "{#{hash_argument.source}}")
+
+            parent = node.parent
+            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+          end
+        end
+
+        def register_offense_for_zip_method(node, zip_method)
+          add_offense(node, message: MSG_TO_H) do |corrector|
+            if zip_method.parenthesized?
+              corrector.insert_before(zip_method.loc.end, '[]')
+            else
+              corrector.insert_after(zip_method, '([])')
+            end
+          end
+        end
+
         def requires_parens?(node)
           node.call_type? && node.arguments.any? && !node.parenthesized?
         end
@@ -85,6 +110,9 @@ module RuboCop
           else
             add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
               corrector.replace(node, args_to_hash(node.arguments))
+
+              parent = node.parent
+              add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
             end
           end
         end

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

@@ -38,8 +38,7 @@ module RuboCop
           kv_each(node) do |target, method|
             return unless target.receiver.receiver
 
-            msg = format(message, prefer: "each_#{method[0..-2]}",
-                                  current: "#{method}.each")
+            msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
 
             add_offense(kv_range(target), message: msg) do |corrector|
               correct_key_value_each(target, corrector)

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

@@ -52,8 +52,7 @@ module RuboCop
           return if node.when_branches.size < min_branches_count
 
           hash_like_case?(node) do |condition_nodes, body_nodes|
-            if nodes_of_same_type?(condition_nodes) &&
-               nodes_of_same_type?(body_nodes)
+            if nodes_of_same_type?(condition_nodes) && nodes_of_same_type?(body_nodes)
               add_offense(node)
             end
           end

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

@@ -137,7 +137,7 @@ module RuboCop
         end
 
         def acceptable_19_syntax_symbol?(sym_name)
-          sym_name.sub!(/\A:/, '')
+          sym_name.delete_prefix!(':')
 
           if cop_config['PreferHashRocketsForNonAlnumEndingSymbols'] &&
              # Prefer { :production? => false } over { production?: false } and
@@ -174,10 +174,7 @@ module RuboCop
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''
 
-          corrector.replace(
-            range,
-            range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: ")
-          )
+          corrector.replace(range, range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: "))
 
           hash_node = pair_node.parent
           return unless hash_node.parent&.return_type? && !hash_node.braces?
@@ -194,8 +191,7 @@ module RuboCop
         end
 
         def argument_without_space?(node)
-          node.argument? &&
-            node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+          node.argument? && node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
@@ -215,8 +211,7 @@ module RuboCop
         end
 
         def force_hash_rockets?(pairs)
-          cop_config['UseHashRocketsWithSymbolValues'] &&
-            pairs.map(&:value).any?(&:sym_type?)
+          cop_config['UseHashRocketsWithSymbolValues'] && pairs.map(&:value).any?(&:sym_type?)
         end
       end
     end

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

@@ -100,9 +100,7 @@ module RuboCop
         def check_expressions(expressions)
           return unless expressions.size > 1 && expressions.uniq.one?
 
-          expressions.each do |expression|
-            add_offense(expression)
-          end
+          expressions.each { |expression| add_offense(expression) }
         end
 
         def message(node)

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

@@ -38,13 +38,13 @@ module RuboCop
         include StatementModifier
         include LineLengthHelp
         include IgnoredPattern
+        include RangeHelp
         extend AutoCorrector
 
         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.'
+        MSG_USE_NORMAL = 'Modifier form of `%<keyword>s` makes the line too long.'
 
         def self.autocorrect_incompatible_with
           [Style::SoleNestedConditional]
@@ -67,7 +67,16 @@ module RuboCop
 
         def autocorrect(corrector, node)
           replacement = if node.modifier_form?
-                          to_normal_form(node)
+                          indentation = ' ' * node.source_range.column
+                          last_argument = node.if_branch.last_argument
+
+                          if last_argument.respond_to?(:heredoc?) && last_argument.heredoc?
+                            heredoc = extract_heredoc_from(last_argument)
+                            remove_heredoc(corrector, heredoc)
+                            to_normal_form_with_heredoc(node, indentation, heredoc)
+                          else
+                            to_normal_form(node, indentation)
+                          end
                         else
                           to_modifier_form(node)
                         end
@@ -123,8 +132,7 @@ module RuboCop
         end
 
         def line_length_enabled_at_line?(line)
-          processed_source.comment_config
-                          .cop_enabled_at_line?('Layout/LineLength', line)
+          processed_source.comment_config.cop_enabled_at_line?('Layout/LineLength', line)
         end
 
         def named_capture_in_condition?(node)
@@ -132,10 +140,7 @@ module RuboCop
         end
 
         def non_eligible_node?(node)
-          non_simple_if_unless?(node) ||
-            node.chained? ||
-            node.nested_conditional? ||
-            super
+          non_simple_if_unless?(node) || node.chained? || node.nested_conditional? || super
         end
 
         def non_simple_if_unless?(node)
@@ -153,18 +158,41 @@ module RuboCop
             node  = node.parent
           end
 
-          node && (sibling = node.children[index + 1]) &&
-            sibling.source_range.first_line == line_no
+          node && (sibling = node.children[index + 1]) && sibling.source_range.first_line == line_no
         end
 
-        def to_normal_form(node)
-          indentation = ' ' * node.source_range.column
+        def to_normal_form(node, indentation)
           <<~RUBY.chomp
             #{node.keyword} #{node.condition.source}
             #{indentation}  #{node.body.source}
             #{indentation}end
           RUBY
         end
+
+        def to_normal_form_with_heredoc(node, indentation, heredoc)
+          heredoc_body, heredoc_end = heredoc
+
+          <<~RUBY.chomp
+            #{node.keyword} #{node.condition.source}
+            #{indentation}  #{node.body.source}
+            #{indentation}  #{heredoc_body.source.chomp}
+            #{indentation}  #{heredoc_end.source.chomp}
+            #{indentation}end
+          RUBY
+        end
+
+        def extract_heredoc_from(last_argument)
+          heredoc_body = last_argument.loc.heredoc_body
+          heredoc_end = last_argument.loc.heredoc_end
+
+          [heredoc_body, heredoc_end]
+        end
+
+        def remove_heredoc(corrector, heredoc)
+          heredoc.each do |range|
+            corrector.remove(range_by_whole_lines(range, include_final_newline: true))
+          end
+        end
       end
     end
   end

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

@@ -62,9 +62,7 @@ module RuboCop
             referenced_after_loop?(var, range)
           end
 
-          add_offense(node.loc.keyword) do |corrector|
-            autocorrect(corrector, node)
-          end
+          add_offense(node.loc.keyword) { |corrector| autocorrect(corrector, node) }
         end
 
         def autocorrect(corrector, node)
@@ -107,8 +105,7 @@ module RuboCop
           else
             indentation = body.source_range.source_line[LEADING_SPACE]
 
-            ['loop do', body.source.gsub(/^/, configured_indent),
-             'end'].join("\n#{indentation}")
+            ['loop do', body.source.gsub(/^/, configured_indent), 'end'].join("\n#{indentation}")
           end
         end
 

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

@@ -136,8 +136,7 @@ module RuboCop
         end
 
         def inverse_blocks
-          @inverse_blocks ||= cop_config['InverseBlocks']
-                              .merge(cop_config['InverseBlocks'].invert)
+          @inverse_blocks ||= cop_config['InverseBlocks'].merge(cop_config['InverseBlocks'].invert)
         end
 
         def negated?(node)
@@ -160,9 +159,7 @@ module RuboCop
         # `Integer > Numeric`.
         def possible_class_hierarchy_check?(lhs, rhs, method)
           CLASS_COMPARISON_METHODS.include?(method) &&
-            (camel_case_constant?(lhs) ||
-             (rhs.size == 1 &&
-              camel_case_constant?(rhs.first)))
+            (camel_case_constant?(lhs) || (rhs.size == 1 && camel_case_constant?(rhs.first)))
         end
 
         def camel_case_constant?(node)
@@ -174,8 +171,7 @@ module RuboCop
         end
 
         def remove_end_parenthesis(corrector, node, method, method_call)
-          return unless EQUALITY_METHODS.include?(method) ||
-                        method_call.parent.begin_type?
+          return unless EQUALITY_METHODS.include?(method) || method_call.parent.begin_type?
 
           corrector.remove(end_parentheses(node, method_call))
         end

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

@@ -67,8 +67,7 @@ module RuboCop
 
         def starts_with_hex_or_colon?(str)
           first_char = str[0].ord
-          (48..58).cover?(first_char) || (65..70).cover?(first_char) ||
-            (97..102).cover?(first_char)
+          (48..58).cover?(first_char) || (65..70).cover?(first_char) || (97..102).cover?(first_char)
         end
       end
     end

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

@@ -50,10 +50,8 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for ' \
-                          '%<modifier>s lambdas.'
-        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s ' \
-                         'lambdas.'
+        LITERAL_MESSAGE = 'Use the `-> { ... }` lambda literal syntax for %<modifier>s lambdas.'
+        METHOD_MESSAGE = 'Use the `lambda` method for %<modifier>s lambdas.'
 
         OFFENDING_SELECTORS = {
           style: {

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

@@ -52,8 +52,7 @@ module RuboCop
         private
 
         def offense?(node)
-          explicit_style? && node.implicit_call? ||
-            implicit_style? && !node.implicit_call?
+          explicit_style? && node.implicit_call? || implicit_style? && !node.implicit_call?
         end
 
         def message(_node)

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

@@ -23,14 +23,12 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
-              'those strings.'
+        MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
         CONCAT_TOKEN_TYPES = %i[tPLUS tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
         COMPLEX_STRING_BEGIN_TOKEN = :tSTRING_BEG
         COMPLEX_STRING_END_TOKEN = :tSTRING_END
-        HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT
-                                            tLBRACK2].freeze
+        HIGH_PRECEDENCE_OP_TOKEN_TYPES = %i[tSTAR2 tPERCENT tDOT tLBRACK2].freeze
         QUOTE_DELIMITERS = %w[' "].freeze
 
         def self.autocorrect_incompatible_with
@@ -38,9 +36,7 @@ module RuboCop
         end
 
         def on_new_investigation
-          processed_source.tokens.each_index do |index|
-            check_token_set(index)
-          end
+          processed_source.tokens.each_index { |index| check_token_set(index) }
         end
 
         private
@@ -56,9 +52,7 @@ module RuboCop
 
           return unless eligible_next_successor?(next_successor)
 
-          add_offense(operator.pos) do |corrector|
-            autocorrect(corrector, operator.pos)
-          end
+          add_offense(operator.pos) { |corrector| autocorrect(corrector, operator.pos) }
         end
 
         def autocorrect(corrector, operator_range)
@@ -89,8 +83,7 @@ module RuboCop
         end
 
         def eligible_next_successor?(next_successor)
-          !(next_successor &&
-            HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type))
+          !(next_successor && HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type))
         end
 
         def eligible_predecessor?(predecessor)

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

@@ -40,8 +40,12 @@ module RuboCop
       #     to `true` allows the presence of parentheses in such a method call
       #     even with arguments.
       #
-      # NOTE: Parens are required around a method with arguments when inside an
-      # endless method definition (>= Ruby 3.0).
+      # NOTE: Parentheses are still allowed in cases where omitting them
+      # results in ambiguous or syntactically incorrect code. For example,
+      # parentheses are required around a method with arguments when inside an
+      # endless method definition introduced in Ruby 3.0.  Parentheses are also
+      # allowed when forwarding arguments with the triple-dot syntax introduced
+      # in Ruby 2.7 as omitting them starts an endless range.
       #
       # @example EnforcedStyle: require_parentheses (default)
       #
@@ -198,7 +202,7 @@ module RuboCop
         extend AutoCorrector
 
         def self.autocorrect_incompatible_with
-          [Style::NestedParenthesizedCalls]
+          [Style::NestedParenthesizedCalls, Style::RescueModifier]
         end
 
         def on_send(node)

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       class MethodCallWithArgsParentheses
         # Style omit_parentheses
-        # rubocop:disable Metrics/ModuleLength
+        # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
@@ -13,7 +13,6 @@ module RuboCop
 
           private
 
-          # rubocop:disable Metrics/CyclomaticComplexity
           def omit_parentheses(node)
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
@@ -27,7 +26,6 @@ module RuboCop
               auto_correct(corrector, node)
             end
           end
-          # rubocop:enable Metrics/CyclomaticComplexity
 
           def auto_correct(corrector, node)
             if parentheses_at_the_end_of_multiline_call?(node)
@@ -44,7 +42,7 @@ module RuboCop
 
           def inside_endless_method_def?(node)
             # parens are required around arguments inside an endless method
-            node.each_ancestor(:def).any?(&:endless?) && node.arguments.any?
+            node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
           end
 
           def syntax_like_method_call?(node)
@@ -57,8 +55,7 @@ module RuboCop
 
           def allowed_camel_case_method_call?(node)
             node.camel_case_method? &&
-              (node.arguments.none? ||
-              cop_config['AllowParenthesesInCamelCaseMethod'])
+              (node.arguments.none? || cop_config['AllowParenthesesInCamelCaseMethod'])
           end
 
           def allowed_string_interpolation_method_call?(node)
@@ -101,8 +98,7 @@ module RuboCop
           end
 
           def call_in_optional_arguments?(node)
-            node.parent &&
-              (node.parent.optarg_type? || node.parent.kwoptarg_type?)
+            node.parent && (node.parent.optarg_type? || node.parent.kwoptarg_type?)
           end
 
           def call_in_single_line_inheritance?(node)
@@ -114,14 +110,13 @@ module RuboCop
               call_as_argument_or_chain?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
-                ambigious_literal?(n) || logical_operator?(n) ||
+                n.forwarded_args_type? || ambigious_literal?(n) || logical_operator?(n) ||
                   call_with_braced_block?(n)
               end
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) &&
-              node.block_node && node.block_node.braces?
+            (node.send_type? || node.super_type?) && node.block_node && node.block_node.braces?
           end
 
           def call_as_argument_or_chain?(node)
@@ -147,13 +142,11 @@ module RuboCop
             previous = node.descendants.first
             return false unless previous&.send_type?
 
-            previous.parenthesized? ||
-              allowed_chained_call_with_parentheses?(previous)
+            previous.parenthesized? || allowed_chained_call_with_parentheses?(previous)
           end
 
           def ambigious_literal?(node)
-            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) ||
-              unary_literal?(node)
+            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) || unary_literal?(node)
           end
 
           def splat?(node)
@@ -182,15 +175,14 @@ module RuboCop
           end
 
           def assigned_before?(node, target)
-            node.assignment? &&
-              node.loc.operator.begin < target.loc.begin
+            node.assignment? && node.loc.operator.begin < target.loc.begin
           end
 
           def inside_string_interpolation?(node)
             node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
           end
         end
-        # rubocop:enable Metrics/ModuleLength
+        # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end
     end
   end