rubocop 1.18.4 → 1.19.0

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

@@ -20,6 +20,13 @@ module RuboCop
 
       private
 
+      def indent_level(str)
+        indentations = str.lines
+                          .map { |line| line[/^\s*/] }
+                          .reject { |line| line.end_with?("\n") }
+        indentations.empty? ? 0 : indentations.min_by(&:size).size
+      end
+
       def delimiter_string(node)
         node.source.match(OPENING_DELIMITER).captures[1]
       end

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

@@ -18,15 +18,16 @@ module RuboCop
           !parent.parenthesized? && parent&.block_literal?
       end
 
+      # Override to determine values that are invalid in a percent array
+      def invalid_percent_array_contents?(_node)
+        false
+      end
+
       def allowed_bracket_array?(node)
         comments_in_array?(node) || below_array_length?(node) ||
           invalid_percent_array_context?(node)
       end
 
-      def message(_node)
-        style == :percent ? self.class::PERCENT_MSG : self.class::ARRAY_MSG
-      end
-
       def comments_in_array?(node)
         line_span = node.source_range.first_line...node.source_range.last_line
         processed_source.each_comment_in_lines(line_span).any?
@@ -35,9 +36,11 @@ module RuboCop
       def check_percent_array(node)
         array_style_detected(:percent, node.values.size)
 
-        return unless style == :brackets
+        return unless style == :brackets || invalid_percent_array_contents?(node)
 
-        add_offense(node) { |corrector| correct_bracketed(corrector, node) }
+        add_offense(node, message: self.class::ARRAY_MSG) do |corrector|
+          correct_bracketed(corrector, node)
+        end
       end
 
       def check_bracketed_array(node, literal_prefix)
@@ -47,7 +50,7 @@ module RuboCop
 
         return unless style == :percent
 
-        add_offense(node) do |corrector|
+        add_offense(node, message: self.class::PERCENT_MSG) do |corrector|
           percent_literal_corrector = PercentLiteralCorrector.new(@config, @preferred_delimiters)
           percent_literal_corrector.correct(corrector, node, literal_prefix)
         end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Ensure a require statement is present for a standard library determined
+    # by variable library_name
+    module RequireLibrary
+      extend NodePattern::Macros
+
+      def ensure_required(corrector, node, library_name)
+        node = node.parent while node.parent&.parent?
+
+        if node.parent&.begin_type?
+          return if @required_libs.include?(library_name)
+
+          remove_subsequent_requires(corrector, node, library_name)
+        end
+
+        RequireLibraryCorrector.correct(corrector, node, library_name)
+      end
+
+      def remove_subsequent_requires(corrector, node, library_name)
+        node.right_siblings.each do |sibling|
+          next unless require_library_name?(sibling, library_name)
+
+          range = range_by_whole_lines(sibling.source_range, include_final_newline: true)
+          corrector.remove(range)
+        end
+      end
+
+      def on_send(node)
+        return if node.parent&.parent?
+
+        name = require_any_library?(node)
+        return if name.nil?
+
+        @required_libs.add(name)
+      end
+
+      private
+
+      def on_new_investigation
+        # Holds the required files at top-level
+        @required_libs = Set.new
+        super
+      end
+
+      # @!method require_any_library?(node)
+      def_node_matcher :require_any_library?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str $_))
+      PATTERN
+
+      # @!method require_library_name?(node, library_name)
+      def_node_matcher :require_library_name?, <<~PATTERN
+        (send {(const {nil? cbase} :Kernel) nil?} :require (str %1))
+      PATTERN
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module RuboCop
       MSG = 'Space found before %<token>s.'
 
       def on_new_investigation
-        each_missing_space(processed_source.tokens) do |token, pos_before|
+        each_missing_space(processed_source.sorted_tokens) do |token, pos_before|
           add_offense(pos_before, message: format(MSG, token: kind(token))) do |corrector|
             PunctuationCorrector.remove_space(corrector, pos_before)
           end

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

@@ -19,6 +19,8 @@ module RuboCop
       # Regex can be specified to identify offenses. Suggestions for replacing a flagged term can
       # be configured and will be displayed as part of the offense message.
       # An AllowedRegex can be specified for a flagged term to exempt allowed uses of the term.
+      # `WholeWord: true` can be set on a flagged term to indicate the cop should only match when
+      # a term matches the whole word (partial matches will not be offenses).
       #
       # @example FlaggedTerms: { whitelist: { Suggestions: ['allowlist'] } }
       #   # Suggest replacing identifier whitelist with allowlist
@@ -56,6 +58,14 @@ module RuboCop
       #   # good
       #   # They had a master's degree
       #
+      # @example FlaggedTerms: { slave: { WholeWord: true } }
+      #   # Specify that only terms that are full matches will be flagged.
+      #
+      #   # bad
+      #   Slave
+      #
+      #   # good (won't be flagged despite containing `slave`)
+      #   TeslaVehicle
       class InclusiveLanguage < Base
         include RangeHelp
 
@@ -123,7 +133,7 @@ module RuboCop
             next if term_definition.nil?
 
             allowed_strings.concat(process_allowed_regex(term_definition['AllowedRegex']))
-            regex_string = ensure_regex_string(term_definition['Regex'] || term)
+            regex_string = ensure_regex_string(extract_regexp(term, term_definition))
             flagged_term_strings << regex_string
 
             add_to_flagged_term_hash(regex_string, term, term_definition)
@@ -132,6 +142,13 @@ module RuboCop
           set_regexes(flagged_term_strings, allowed_strings)
         end
 
+        def extract_regexp(term, term_definition)
+          return term_definition['Regex'] if term_definition['Regex']
+          return /(?:\b|(?<=[\W_]))#{term}(?:\b|(?=[\W_]))/ if term_definition['WholeWord']
+
+          term
+        end
+
         def add_to_flagged_term_hash(regex_string, term, term_definition)
           @flagged_term_hash[Regexp.new(regex_string, Regexp::IGNORECASE)] =
             term_definition.merge('Term' => term,

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

@@ -6,6 +6,11 @@ module RuboCop
       # Check for uses of braces or do/end around single line or
       # multi-line blocks.
       #
+      # Methods that can be either procedural or functional and cannot be
+      # categorised from their usage alone is ignored.
+      # `lambda`, `proc`, and `it` are their defaults.
+      # Additional methods can be added to the `IgnoredMethods`.
+      #
       # @example EnforcedStyle: line_count_based (default)
       #   # bad - single line block
       #   items.each do |item| item / 5 end
@@ -132,6 +137,17 @@ module RuboCop
       #     puts foo
       #   end
       #
+      # @example IgnoredMethods: ['lambda', 'proc', 'it' ] (default)
+      #
+      #   # good
+      #   foo = lambda do |x|
+      #     puts "Hello, #{x}"
+      #   end
+      #
+      #   foo = lambda do |x|
+      #     x * 100
+      #   end
+      #
       class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
         include IgnoredMethods

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

@@ -12,6 +12,7 @@ module RuboCop
       #
       # Auto-correction removes comments from `end` keyword and keeps comments
       # for `class`, `module`, `def` and `begin` above the keyword.
+      # It is marked as unsafe auto-correction as it may remove meaningful comments.
       #
       # @example
       #   # bad
@@ -50,7 +51,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless (match = line(comment).match(/(?<keyword>\S+).*#/)) && offensive?(comment)
+            next unless offensive?(comment) && (match = line(comment).match(/(?<keyword>\S+).*#/))
 
             register_offense(comment, match[:keyword])
           end

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

@@ -26,7 +26,7 @@ module RuboCop
         # `when` nodes contain the entire branch including the condition.
         # We only need the contents of the branch, not the condition.
         def expand_when_branches(when_branches)
-          when_branches.map { |branch| branch.children[1] }
+          when_branches.map(&:body)
         end
 
         def tail(branch)
@@ -272,6 +272,16 @@ module RuboCop
           check_node(node, branches)
         end
 
+        def on_case_match(node)
+          return unless style == :assign_to_condition
+          return unless node.else_branch
+
+          in_pattern_branches = expand_when_branches(node.in_pattern_branches)
+          branches = [*in_pattern_branches, node.else_branch]
+
+          check_node(node, branches)
+        end
+
         private
 
         def check_assignment_to_condition(node)
@@ -297,7 +307,7 @@ module RuboCop
         end
 
         # @!method candidate_condition?(node)
-        def_node_matcher :candidate_condition?, '[{if case} !#allowed_ternary?]'
+        def_node_matcher :candidate_condition?, '[{if case case_match} !#allowed_ternary?]'
 
         def allowed_ternary?(assignment)
           assignment.if_type? && assignment.ternary? && !include_ternary?
@@ -319,7 +329,7 @@ module RuboCop
         end
 
         def move_assignment_outside_condition(corrector, node)
-          if node.case_type?
+          if node.case_type? || node.case_match_type?
             CaseCorrector.correct(corrector, self, node)
           elsif node.ternary?
             TernaryCorrector.correct(corrector, node)
@@ -333,7 +343,7 @@ module RuboCop
 
           if ternary_condition?(condition)
             TernaryCorrector.move_assignment_inside_condition(corrector, node)
-          elsif condition.case_type?
+          elsif condition.case_type? || condition.case_match_type?
             CaseCorrector.move_assignment_inside_condition(corrector, node)
           elsif condition.if_type?
             IfCorrector.move_assignment_inside_condition(corrector, node)
@@ -631,7 +641,11 @@ module RuboCop
           end
 
           def extract_branches(case_node)
-            when_branches = expand_when_branches(case_node.when_branches)
+            when_branches = if case_node.case_type?
+                              expand_when_branches(case_node.when_branches)
+                            else
+                              expand_when_branches(case_node.in_pattern_branches)
+                            end
 
             [when_branches, case_node.else_branch]
           end

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

@@ -93,18 +93,43 @@ module RuboCop
 
         def add_block_argument(node, corrector)
           if node.arguments?
-            last_arg = node.arguments.last
-            arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
-            replacement = ' &block'
-            replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
-            corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
-          elsif node.call_type? || node.zsuper_type?
-            corrector.insert_after(node, '(&block)')
+            insert_argument(node, corrector)
+          elsif empty_arguments?(node)
+            corrector.replace(node.arguments, '(&block)')
+          elsif call_like?(node)
+            correct_call_node(node, corrector)
           else
             corrector.insert_after(node.loc.name, '(&block)')
           end
         end
 
+        def empty_arguments?(node)
+          # Is there an arguments node with only parentheses?
+          node.arguments.is_a?(RuboCop::AST::Node) && node.arguments.loc.begin
+        end
+
+        def call_like?(node)
+          node.call_type? || node.zsuper_type? || node.super_type?
+        end
+
+        def insert_argument(node, corrector)
+          last_arg = node.arguments.last
+          arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
+          replacement = ' &block'
+          replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
+          corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
+        end
+
+        def correct_call_node(node, corrector)
+          corrector.insert_after(node, '(&block)')
+          return unless node.parenthesized?
+
+          args_begin = Util.args_begin(node)
+          args_end = Util.args_end(node)
+          range = range_between(args_begin.begin_pos, args_end.end_pos)
+          corrector.remove(range)
+        end
+
         def block_body_range(block_node, send_node)
           range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
         end

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

@@ -27,11 +27,8 @@ module RuboCop
       #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
       class HashTransformKeys < Base
         include HashTransformMethod
-        extend TargetRubyVersion
         extend AutoCorrector
 
-        minimum_target_ruby_version 2.5
-
         # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block

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

@@ -7,6 +7,22 @@ module RuboCop
       # each branch of a conditional expression. Such expressions should normally
       # be placed outside the conditional expression - before or after it.
       #
+      # This cop is marked unsafe auto-correction as the order of method invocations
+      # must be guaranteed in the following case:
+      #
+      # [source,ruby]
+      # ----
+      # if method_that_modifies_global_state # 1
+      #   method_that_relies_on_global_state # 2
+      #   foo                                # 3
+      # else
+      #   method_that_relies_on_global_state # 2
+      #   bar                                # 3
+      # end
+      # ----
+      #
+      # In such a case, auto-correction may change the invocation order.
+      #
       # NOTE: The cop is poorly named and some people might think that it actually
       # checks for duplicated conditional branches. The name will probably be changed
       # in a future major RuboCop release.
@@ -124,21 +140,30 @@ module RuboCop
           return if branches.any?(&:nil?)
 
           tails = branches.map { |branch| tail(branch) }
-          check_expressions(node, tails, :after_condition) if duplicated_expressions?(tails)
+          check_expressions(node, tails, :after_condition) if duplicated_expressions?(node, tails)
 
           heads = branches.map { |branch| head(branch) }
-          check_expressions(node, heads, :before_condition) if duplicated_expressions?(heads)
+          check_expressions(node, heads, :before_condition) if duplicated_expressions?(node, heads)
         end
 
-        def duplicated_expressions?(expressions)
-          expressions.size > 1 && expressions.uniq.one?
+        def duplicated_expressions?(node, expressions)
+          unique_expressions = expressions.uniq
+          return false unless expressions.size >= 1 && unique_expressions.one?
+
+          unique_expression = unique_expressions.first
+          return true unless unique_expression.assignment?
+
+          lhs = unique_expression.child_nodes.first
+          node.condition.child_nodes.none? { |n| n.source == lhs.source if n.variable? }
         end
 
-        def check_expressions(node, expressions, insert_position)
+        def check_expressions(node, expressions, insert_position) # rubocop:disable Metrics/MethodLength
           inserted_expression = false
 
           expressions.each do |expression|
             add_offense(expression) do |corrector|
+              next if node.if_type? && node.ternary?
+
               range = range_by_whole_lines(expression.source_range, include_final_newline: true)
               corrector.remove(range)
               next if inserted_expression

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

@@ -96,7 +96,7 @@ module RuboCop
         MSG_MISSING = 'Use def with parentheses when there are parameters.'
 
         def on_def(node)
-          return if node.endless?
+          return if forced_parentheses?(node)
 
           args = node.arguments
 
@@ -129,6 +129,15 @@ module RuboCop
           corrector.insert_after(arguments_range, ')')
         end
 
+        def forced_parentheses?(node)
+          # Regardless of style, parentheses are necessary for:
+          # 1. Endless methods
+          # 2. Argument lists containing a `forward-arg` (`...`)
+          # Removing the parens would be a syntax error here.
+
+          node.endless? || node.arguments.any?(&:forward_arg_type?)
+        end
+
         def require_parentheses?(args)
           style == :require_parentheses ||
             (style == :require_no_parentheses_except_multiline && args.multiline?)

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # Checks for `if` expressions that do not have an `else` branch.
       #
+      # NOTE: Pattern matching is allowed to have no `else` branch because unlike `if` and `case`,
+      # it raises `NoMatchingPatternError` if the pattern doesn't match and without having `else`.
+      #
       # Supported styles are: if, case, both.
       #
       # @example EnforcedStyle: if
@@ -114,6 +117,10 @@ module RuboCop
           check(node)
         end
 
+        def on_case_match(node)
+          # do nothing.
+        end
+
         private
 
         def check(node)