rubocop 1.9.1 → 1.13.0

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

@@ -32,6 +32,7 @@ module RuboCop
 
         minimum_target_ruby_version 2.5
 
+        # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :each_with_object (hash))
@@ -43,6 +44,7 @@ module RuboCop
             ({send csend} (lvar _memo) :[]= $!`_memo $(lvar _val)))
         PATTERN
 
+        # @!method on_bad_hash_brackets_map(node)
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
             (const _ :Hash)
@@ -55,6 +57,7 @@ module RuboCop
               (array $_ $(lvar _val))))
         PATTERN
 
+        # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
@@ -66,6 +69,7 @@ module RuboCop
             :to_h)
         PATTERN
 
+        # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :to_h)

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

@@ -29,6 +29,7 @@ module RuboCop
         include HashTransformMethod
         extend AutoCorrector
 
+        # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :each_with_object (hash))
@@ -40,6 +41,7 @@ module RuboCop
             ({send csend} (lvar _memo) :[]= $(lvar _key) $!`_memo))
         PATTERN
 
+        # @!method on_bad_hash_brackets_map(node)
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
             (const _ :Hash)
@@ -52,6 +54,7 @@ module RuboCop
               (array $(lvar _key) $_)))
         PATTERN
 
+        # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
@@ -63,6 +66,7 @@ module RuboCop
             :to_h)
         PATTERN
 
+        # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :to_h)

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

@@ -34,9 +34,11 @@ module RuboCop
         MSG = 'Remove redundant %<keyword>s with boolean literal branches.'
         MSG_FOR_ELSIF = 'Use `else` instead of redundant `elsif` with boolean literal branches.'
 
+        # @!method if_with_boolean_literal_branches?(node)
         def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
           (if #return_boolean_value? {(true) (false) | (false) (true)})
         PATTERN
+        # @!method double_negative?(node)
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_if(node)

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

@@ -19,6 +19,7 @@ module RuboCop
               ' rather than just a message.'
         RESTRICT_ON_SEND = %i[raise fail].freeze
 
+        # @!method implicit_runtime_error_raise_or_fail(node)
         def_node_matcher :implicit_runtime_error_raise_or_fail,
                          '(send nil? ${:raise :fail} {str dstr})'
 

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

@@ -48,6 +48,7 @@ module RuboCop
           [Style::Not, Style::SymbolProc]
         end
 
+        # @!method inverse_candidate?(node)
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(send $(...) $_ $...) :!)
@@ -56,6 +57,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
           (block $(send (...) $_) ... { $(send ... :!)
                                         $(send (...) {:!= :!~} ...)
@@ -134,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)
@@ -158,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)
@@ -172,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)
       #
@@ -79,6 +83,30 @@ module RuboCop
       #   # good
       #   foo.enforce strict: true
       #
+      #   # good
+      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   model.validate strict(true)
+      #
+      #   # good
+      #   # Allows parens for calls that won't produce valid Ruby or be ambiguous.
+      #   yield path, File.basename(path)
+      #
+      #   # good
+      #   # Operators methods calls with parens
+      #   array&.[](index)
+      #
+      #   # good
+      #   # Operators methods without parens, if you prefer
+      #   array.[] index
+      #
+      #   # good
+      #   # Operators methods calls with parens
+      #   array&.[](index)
+      #
+      #   # good
+      #   # Operators methods without parens, if you prefer
+      #   array.[] index
+      #
       # @example IgnoreMacros: true (default)
       #
       #   # good
@@ -146,6 +174,22 @@ module RuboCop
       #
       #   # good
       #   Array 1
+      #
+      # @example AllowParenthesesInStringInterpolation: false (default)
+      #
+      #   # bad
+      #   "#{t('this.is.bad')}"
+      #
+      #   # good
+      #   "#{t 'this.is.better'}"
+      #
+      # @example AllowParenthesesInStringInterpolation: true
+      #
+      #   # good
+      #   "#{t('this.is.good')}"
+      #
+      #   # good
+      #   "#{t 'this.is.also.good'}"
       class MethodCallWithArgsParentheses < Base
         require_relative 'method_call_with_args_parentheses/omit_parentheses'
         require_relative 'method_call_with_args_parentheses/require_parentheses'
@@ -158,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,6 +5,7 @@ module RuboCop
     module Style
       class MethodCallWithArgsParentheses
         # Style omit_parentheses
+        # rubocop:disable Metrics/ModuleLength, Metrics/CyclomaticComplexity
         module OmitParentheses
           TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
           OMIT_MSG = 'Omit parentheses for method calls with arguments.'
@@ -15,10 +16,11 @@ module RuboCop
           def omit_parentheses(node)
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
-            return if node.implicit_call?
+            return if syntax_like_method_call?(node)
             return if super_call_without_arguments?(node)
             return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
+            return if allowed_string_interpolation_method_call?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
               auto_correct(corrector, node)
@@ -40,7 +42,11 @@ 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)
+            node.implicit_call? || node.operator_method?
           end
 
           def super_call_without_arguments?(node)
@@ -49,8 +55,12 @@ 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)
+            cop_config['AllowParenthesesInStringInterpolation'] &&
+              inside_string_interpolation?(node)
           end
 
           def parentheses_at_the_end_of_multiline_call?(node)
@@ -88,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)
@@ -101,20 +110,19 @@ 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)
             node.parent &&
               (node.parent.send_type? && !assigned_before?(node.parent, node) ||
-              node.parent.csend_type? || node.parent.super_type?)
+              node.parent.csend_type? || node.parent.super_type? || node.parent.yield_type?)
           end
 
           def hash_literal_in_arguments?(node)
@@ -134,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)
@@ -169,10 +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, Metrics/CyclomaticComplexity
       end
     end
   end