rubocop 1.44.1 → 1.45.0

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

@@ -108,7 +108,7 @@ module RuboCop
           return unless def_ancestor
 
           within_scoping_def =
-            node.each_ancestor(:block, :sclass).any? do |ancestor|
+            node.each_ancestor(:block, :numblock, :sclass).any? do |ancestor|
               scoping_method_call?(ancestor)
             end
 
@@ -120,7 +120,7 @@ module RuboCop
 
         def scoping_method_call?(child)
           child.sclass_type? || eval_call?(child) || exec_call?(child) ||
-            class_or_module_or_struct_new_call?(child) || allowed_method_name?(child)
+            class_constructor?(child) || allowed_method_name?(child)
         end
 
         def allowed_method_name?(node)
@@ -139,9 +139,12 @@ module RuboCop
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
 
-        # @!method class_or_module_or_struct_new_call?(node)
-        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          (block (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
+        # @!method class_constructor?(node)
+        def_node_matcher :class_constructor?, <<~PATTERN
+          ({block numblock} {
+            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+            (send (const {nil? cbase} :Data) :define ...)
+          } ...)
         PATTERN
       end
     end

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

@@ -167,9 +167,12 @@ module RuboCop
           ({block numblock} (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
-        # @!method class_or_module_or_struct_new_call?(node)
-        def_node_matcher :class_or_module_or_struct_new_call?, <<~PATTERN
-          ({block numblock} (send (const {nil? cbase} {:Class :Module :Struct}) :new ...) ...)
+        # @!method class_constructor?(node)
+        def_node_matcher :class_constructor?, <<~PATTERN
+          ({block numblock} {
+            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
+            (send (const {nil? cbase} :Data) :define ...)
+          } ...)
         PATTERN
 
         def check_node(node)
@@ -270,7 +273,7 @@ module RuboCop
 
         def eval_call?(child)
           class_or_instance_eval?(child) ||
-            class_or_module_or_struct_new_call?(child) ||
+            class_constructor?(child) ||
             any_context_creating_methods?(child)
         end
 

data/lib/rubocop/cop/metrics/block_length.rb

@@ -51,7 +51,7 @@ module RuboCop
         def on_block(node)
           return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return if method_receiver_excluded?(node)
-          return if node.class_constructor? || node.struct_constructor?
+          return if node.class_constructor?
 
           check_code_length(node)
         end

data/lib/rubocop/cop/mixin/allowed_methods.rb

@@ -3,7 +3,9 @@
 module RuboCop
   module Cop
     # This module encapsulates the ability to allow certain methods when
-    # parsing.
+    # parsing. Even if the code is in offense, if it contains methods
+    # that are allowed. This module is equivalent to the IgnoredMethods module,
+    # which will be deprecated in RuboCop 2.0.
     module AllowedMethods
       private
 

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -62,10 +62,12 @@ module RuboCop
       # Returns the end line of a node, which might be a comment and not part of the AST
       # End line is considered either the line at which another node starts, or
       # the line at which the parent node ends.
-      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def find_end_line(node)
-        if node.if_type? && node.loc.else
+        if node.if_type? && node.else?
           node.loc.else.line
+        elsif node.if_type? && node.ternary?
+          node.else_branch.loc.line
         elsif (next_sibling = node.right_sibling)
           next_sibling.loc.line
         elsif (parent = node.parent)
@@ -74,7 +76,7 @@ module RuboCop
           node.loc.end.line
         end
       end
-      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
     end
   end
 end

data/lib/rubocop/cop/mixin/hash_shorthand_syntax.rb

@@ -95,16 +95,19 @@ module RuboCop
           use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
       end
 
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def def_node_that_require_parentheses(node)
         last_pair = node.parent.pairs.last
         return unless last_pair.key.source == last_pair.value.source
-        return unless (method_dispatch_node = find_ancestor_method_dispatch_node(node))
-        return unless without_parentheses_call_expr_follows?(method_dispatch_node)
+        return unless (dispatch_node = find_ancestor_method_dispatch_node(node))
+        return if node.respond_to?(:parenthesized?) && !node.parenthesized?
+        return unless last_expression?(dispatch_node) || method_dispatch_as_argument?(dispatch_node)
 
         def_node = node.each_ancestor(:send, :csend, :super, :yield).first
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
       def find_ancestor_method_dispatch_node(node)
         return unless (ancestor = node.parent.parent)
@@ -129,15 +132,16 @@ module RuboCop
         ancestor.ancestors.any? { |node| node.respond_to?(:modifier_form?) && node.modifier_form? }
       end
 
-      def without_parentheses_call_expr_follows?(ancestor)
-        return false unless ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized?
+      def last_expression?(ancestor)
+        ancestor.right_sibling ||
+          ancestor.each_ancestor.find { |node| node.assignment? || node.send_type? }&.right_sibling
+      end
 
-        right_sibling = ancestor.right_sibling
-        right_sibling ||= ancestor.each_ancestor.find do |node|
-          node.assignment? || node.send_type?
-        end&.right_sibling
+      def method_dispatch_as_argument?(method_dispatch_node)
+        parent = method_dispatch_node.parent
+        return false unless parent
 
-        !!right_sibling
+        parent.call_type? || parent.super_type? || parent.yield_type?
       end
 
       def breakdown_value_types_of_hash(hash_node)

data/lib/rubocop/cop/mixin/surrounding_space.rb

@@ -107,9 +107,9 @@ module RuboCop
         end
       end
 
-      def empty_brackets?(left_bracket_token, right_bracket_token)
-        left_index = processed_source.tokens.index(left_bracket_token)
-        right_index = processed_source.tokens.index(right_bracket_token)
+      def empty_brackets?(left_bracket_token, right_bracket_token, tokens: processed_source.tokens)
+        left_index = tokens.index(left_bracket_token)
+        right_index = tokens.index(right_bracket_token)
         right_index && left_index == right_index - 1
       end
 

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -132,7 +132,7 @@ module RuboCop
 
       def avoid_comma(kind, comma_begin_pos, extra_info)
         range = range_between(comma_begin_pos, comma_begin_pos + 1)
-        article = /array/.match?(kind) ? 'an' : 'a'
+        article = kind.include?('array') ? 'an' : 'a'
         msg = format(
           MSG,
           command: 'Avoid',

data/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -34,7 +34,7 @@ module RuboCop
 
           allowed = /#{cop_config['AllowedNames'].join('|')}/
           name = node.loc.name.source.gsub(allowed, '')
-          return unless /_/.match?(name)
+          return unless name.include?('_')
 
           add_offense(node.loc.name)
         end

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

@@ -129,7 +129,8 @@ module RuboCop
         end
 
         def offense?(node)
-          (group_style? && access_modifier_is_inlined?(node)) ||
+          (group_style? && access_modifier_is_inlined?(node) &&
+            !right_siblings_same_inline_method?(node)) ||
             (inline_style? && access_modifier_is_not_inlined?(node))
         end
 
@@ -149,6 +150,12 @@ module RuboCop
           !access_modifier_is_inlined?(node)
         end
 
+        def right_siblings_same_inline_method?(node)
+          node.right_siblings.any? do |sibling|
+            sibling.method?(node.method_name) && !sibling.arguments.empty?
+          end
+        end
+
         def message(range)
           access_modifier = range.source
 

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

@@ -84,6 +84,7 @@ module RuboCop
         def on_def(node)
           return unless node.body
           return unless (rest_args_name, args = use_rest_arguments?(node.arguments))
+          return if args.any?(&:default?)
 
           node.each_descendant(:send) do |send_node|
             kwargs_name, block_name = extract_argument_names_from(args)

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

@@ -178,7 +178,7 @@ module RuboCop
         end
 
         def compact_node_name?(node)
-          /::/.match?(node.identifier.source)
+          node.identifier.source.include?('::')
         end
       end
     end

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

@@ -148,7 +148,7 @@ module RuboCop
         end
 
         def contains_backtick?(node)
-          /`/.match?(node_body(node))
+          node_body(node).include?('`')
         end
 
         def node_body(node)

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

@@ -145,7 +145,7 @@ module RuboCop
         end
 
         def compact_namespace?(node)
-          /::/.match?(node.loc.name.source)
+          node.loc.name.source.include?('::')
         end
 
         # First checks if the :nodoc: comment is associated with the

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

@@ -7,6 +7,10 @@ module RuboCop
       # It can optionally be configured to also require documentation for
       # non-public methods.
       #
+      # NOTE: This cop allows `initialize` method because `initialize` is
+      # a special method called from `new`. In some programming languages
+      # they are called constructor to distinguish it from method.
+      #
       # @example
       #
       #   # bad
@@ -103,6 +107,8 @@ module RuboCop
         PATTERN
 
         def on_def(node)
+          return if node.method?(:initialize)
+
           parent = node.parent
           module_function_node?(parent) ? check(parent) : check(node)
         end

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

@@ -34,6 +34,7 @@ module RuboCop
       #   return cond ? b : c
       #
       class MultilineTernaryOperator < Base
+        include CommentsHelp
         extend AutoCorrector
 
         MSG_IF = 'Avoid multi-line ternary operators, use `if` or `unless` instead.'
@@ -46,9 +47,7 @@ module RuboCop
           message = enforce_single_line_ternary_operator?(node) ? MSG_SINGLE_LINE : MSG_IF
 
           add_offense(node, message: message) do |corrector|
-            next unless offense?(node)
-
-            corrector.replace(node, replacement(node))
+            autocorrect(corrector, node)
           end
         end
 
@@ -58,6 +57,16 @@ module RuboCop
           node.ternary? && node.multiline?
         end
 
+        def autocorrect(corrector, node)
+          return unless offense?(node)
+
+          corrector.replace(node, replacement(node))
+          return unless (parent = node.parent)
+          return unless (comments_in_condition = comments_in_condition(node))
+
+          corrector.insert_before(parent, comments_in_condition)
+        end
+
         def replacement(node)
           if enforce_single_line_ternary_operator?(node)
             "#{node.condition.source} ? #{node.if_branch.source} : #{node.else_branch.source}"
@@ -72,6 +81,12 @@ module RuboCop
           end
         end
 
+        def comments_in_condition(node)
+          comments_in_range(node).map do |comment|
+            "#{comment.loc.expression.source}\n"
+          end.join
+        end
+
         def enforce_single_line_ternary_operator?(node)
           SINGLE_LINE_TYPES.include?(node.parent&.type) && !use_assignment_method?(node.parent)
         end

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

@@ -12,10 +12,11 @@ module RuboCop
       #
       # @example Max: 1 (default)
       #   # bad
-      #   foo { _1.call(_2, _3, _4) }
+      #   use_multiple_numbered_parameters { _1.call(_2, _3, _4) }
       #
       #   # good
-      #   foo { do_something(_1) }
+      #   array.each { use_array_element_as_numbered_parameter(_1) }
+      #   hash.each { use_only_hash_value_as_numbered_parameter(_2) }
       class NumberedParametersLimit < Base
         extend TargetRubyVersion
         extend ExcludeLimit
@@ -26,9 +27,10 @@ module RuboCop
         exclude_limit 'Max'
 
         MSG = 'Avoid using more than %<max>i numbered %<parameter>s; %<count>i detected.'
+        NUMBERED_PARAMETER_PATTERN = /\A_[1-9]\z/.freeze
 
         def on_numblock(node)
-          _send_node, param_count, * = *node
+          param_count = numbered_parameter_nodes(node).uniq.count
           return if param_count <= max_count
 
           parameter = max_count > 1 ? 'parameters' : 'parameter'
@@ -38,6 +40,12 @@ module RuboCop
 
         private
 
+        def numbered_parameter_nodes(node)
+          node.each_descendant(:lvar).select do |lvar_node|
+            lvar_node.source.match?(NUMBERED_PARAMETER_PATTERN)
+          end
+        end
+
         def max_count
           max = cop_config.fetch('Max', DEFAULT_MAX_VALUE)
 

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

@@ -25,7 +25,7 @@ module RuboCop
 
         def on_send(node)
           return unless (dot = node.loc.dot)
-          return if node.receiver.const_type?
+          return if node.receiver.const_type? || !node.arguments.one?
 
           _lhs, _op, rhs = *node
           return if !rhs || method_call_with_parenthesized_arg?(rhs) || anonymous_forwarding?(rhs)

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

@@ -36,6 +36,9 @@ module RuboCop
 
         MSG = 'Use double pipes `||` instead.'
         REDUNDANT_CONDITION = 'This condition is not needed.'
+        ARGUMENT_WITH_OPERATOR_TYPES = %i[
+          splat block_pass forwarded_restarg forwarded_kwrestarg forwarded_args
+        ].freeze
 
         def on_if(node)
           return if node.elsif_conditional?
@@ -150,13 +153,25 @@ module RuboCop
         end
 
         def single_argument_method?(node)
-          node.send_type? && !node.method?(:[]) && node.arguments.one?
+          return false if !node.send_type? || node.method?(:[]) || !node.arguments.one?
+
+          !argument_with_operator?(node.first_argument)
         end
 
         def same_method?(if_branch, else_branch)
           if_branch.method?(else_branch.method_name) && if_branch.receiver == else_branch.receiver
         end
 
+        # If the argument is using an operator, it is an invalid syntax.
+        # e.g. `foo || *bar`, `foo || **bar`, and `foo || &bar`.
+        def argument_with_operator?(argument)
+          return true if ARGUMENT_WITH_OPERATOR_TYPES.include?(argument.type)
+          return false unless argument.hash_type?
+
+          node = argument.children.first
+          node.kwsplat_type? || node.forwarded_kwrestarg_type?
+        end
+
         def if_source(if_branch, arithmetic_operation)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for redundant heredoc delimiter quotes.
+      #
+      # @example
+      #
+      #   # bad
+      #   do_something(<<~'EOS')
+      #     no string interpolation style text
+      #   EOS
+      #
+      #   # good
+      #   do_something(<<~EOS)
+      #     no string interpolation style text
+      #   EOS
+      #
+      #   do_something(<<~'EOS')
+      #     #{string_interpolation_style_text_not_evaluated}
+      #   EOS
+      #
+      #   do_something(<<~'EOS')
+      #     Preserve \
+      #     newlines
+      #   EOS
+      #
+      class RedundantHeredocDelimiterQuotes < Base
+        include Heredoc
+        extend AutoCorrector
+
+        MSG = 'Remove the redundant heredoc delimiter quotes, use `%<replacement>s` instead.'
+        STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN = /#(\{|@|\$)|\\/.freeze
+
+        def on_heredoc(node)
+          return if need_heredoc_delimiter_quotes?(node)
+
+          replacement = "#{heredoc_type(node)}#{delimiter_string(node)}"
+
+          add_offense(node, message: format(MSG, replacement: replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def need_heredoc_delimiter_quotes?(node)
+          heredoc_delimiter = node.source.delete(heredoc_type(node))
+          return true unless heredoc_delimiter.start_with?("'", '"')
+
+          node.loc.heredoc_end.source.strip.match?(/\W/) ||
+            node.loc.heredoc_body.source.match?(STRING_INTERPOLATION_OR_ESCAPED_CHARACTER_PATTERN)
+        end
+      end
+    end
+  end
+end

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

@@ -60,7 +60,7 @@ module RuboCop
         def symbols_contain_spaces?(node)
           node.children.any? do |sym|
             content, = *sym
-            / /.match?(content)
+            content.to_s.include?(' ')
           end
         end
 

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

@@ -110,7 +110,7 @@ module RuboCop
             string = s.str_content.dup.force_encoding(::Encoding::UTF_8)
             !string.valid_encoding? ||
               (complex_regex && !complex_regex.match?(string)) ||
-              / /.match?(string)
+              string.include?(' ')
           end
         end
 

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

@@ -33,12 +33,14 @@ module RuboCop
       #   "bar" != foo
       #   42 >= foo
       #   10 < bar
+      #   99 == CONST
       #
       #   # good
       #   foo == 99
       #   foo == "bar"
       #   foo <= 42
       #   bar > 10
+      #   CONST == 99
       #   "#{interpolation}" == foo
       #   /#{interpolation}/ == foo
       #
@@ -92,9 +94,10 @@ module RuboCop
         def on_send(node)
           return unless yoda_compatible_condition?(node)
           return if (equality_only? && non_equality_operator?(node)) ||
-                    file_constant_equal_program_name?(node)
+                    file_constant_equal_program_name?(node) ||
+                    valid_yoda?(node)
 
-          valid_yoda?(node) || add_offense(node) do |corrector|
+          add_offense(node) do |corrector|
             corrector.replace(actual_code_range(node), corrected_code(node))
           end
         end
@@ -119,11 +122,11 @@ module RuboCop
           lhs = node.receiver
           rhs = node.first_argument
 
-          return true if (lhs.literal? && rhs.literal?) ||
-                         (!lhs.literal? && !rhs.literal?) ||
+          return true if (constant_portion?(lhs) && constant_portion?(rhs)) ||
+                         (!constant_portion?(lhs) && !constant_portion?(rhs)) ||
                          interpolation?(lhs)
 
-          enforce_yoda? ? lhs.literal? : rhs.literal?
+          enforce_yoda? ? constant_portion?(lhs) : constant_portion?(rhs)
         end
 
         def message(node)
@@ -137,6 +140,10 @@ module RuboCop
           "#{rhs.source} #{reverse_comparison(node.method_name)} #{lhs.source}"
         end
 
+        def constant_portion?(node)
+          node.literal? || node.const_type?
+        end
+
         def actual_code_range(node)
           range_between(node.loc.expression.begin_pos, node.loc.expression.end_pos)
         end

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

@@ -24,12 +24,14 @@ module RuboCop
       #   1 + x
       #   10 * y
       #   1 & z
+      #   1 + CONST
       #
       #   # good
       #   60 * 24
       #   x + 1
       #   y * 10
       #   z & 1
+      #   CONST + 1
       #
       #   # good
       #   1 | x
@@ -50,8 +52,7 @@ module RuboCop
 
           lhs = node.receiver
           rhs = node.first_argument
-          return if !lhs.numeric_type? || rhs.numeric_type?
-
+          return unless yoda_expression_constant?(lhs, rhs)
           return if offended_ancestor?(node)
 
           message = format(MSG, source: rhs.source)
@@ -64,6 +65,14 @@ module RuboCop
 
         private
 
+        def yoda_expression_constant?(lhs, rhs)
+          constant_portion?(lhs) && !constant_portion?(rhs)
+        end
+
+        def constant_portion?(node)
+          node.numeric_type? || node.const_type?
+        end
+
         def supported_operators
           Array(cop_config['SupportedOperators'])
         end

data/lib/rubocop/cop/team.rb

@@ -77,7 +77,7 @@ module RuboCop
       end
 
       # @return [Commissioner::InvestigationReport]
-      def investigate(processed_source)
+      def investigate(processed_source, offset: 0, original: processed_source)
         be_ready
 
         # The autocorrection process may have to be repeated multiple times
@@ -87,14 +87,15 @@ module RuboCop
         on_duty = roundup_relevant_cops(processed_source.file_path)
 
         autocorrect_cops, other_cops = on_duty.partition(&:autocorrect?)
+        report = investigate_partial(autocorrect_cops, processed_source,
+                                     offset: offset, original: original)
 
-        report = investigate_partial(autocorrect_cops, processed_source)
-
-        unless autocorrect(processed_source, report)
+        unless autocorrect(processed_source, report, offset: offset, original: original)
           # If we corrected some errors, another round of inspection will be
           # done, and any other offenses will be caught then, so only need
           # to check other_cops if no correction was done
-          report = report.merge(investigate_partial(other_cops, processed_source))
+          report = report.merge(investigate_partial(other_cops, processed_source,
+                                                    offset: offset, original: original))
         end
 
         process_errors(processed_source.path, report.errors)
@@ -116,12 +117,12 @@ module RuboCop
 
       private
 
-      def autocorrect(processed_source, report)
+      def autocorrect(processed_source, report, original:, offset:)
         @updated_source_file = false
         return unless autocorrect?
         return if report.processed_source.parser_error
 
-        new_source = autocorrect_report(report)
+        new_source = autocorrect_report(report, original: original, offset: offset)
 
         return unless new_source
 
@@ -149,9 +150,9 @@ module RuboCop
       end
 
       # @return [Commissioner::InvestigationReport]
-      def investigate_partial(cops, processed_source)
+      def investigate_partial(cops, processed_source, offset:, original:)
         commissioner = Commissioner.new(cops, self.class.forces_for(cops), @options)
-        commissioner.investigate(processed_source)
+        commissioner.investigate(processed_source, offset: offset, original: original)
       end
 
       # @return [Array<cop>]
@@ -175,18 +176,22 @@ module RuboCop
         cop.class.support_target_rails_version?(cop.target_rails_version)
       end
 
-      def autocorrect_report(report)
-        corrector = collate_corrections(report)
+      def autocorrect_report(report, offset:, original:)
+        corrector = collate_corrections(report, offset: offset, original: original)
 
         corrector.rewrite unless corrector.empty?
       end
 
-      def collate_corrections(report)
-        corrector = Corrector.new(report.processed_source)
+      def collate_corrections(report, offset:, original:)
+        corrector = Corrector.new(original)
 
         each_corrector(report) do |to_merge|
           suppress_clobbering do
-            corrector.merge!(to_merge)
+            if offset.positive?
+              corrector.import!(to_merge, offset: offset)
+            else
+              corrector.merge!(to_merge)
+            end
           end
         end