rubocop 0.93.1 → 1.79.2

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'tsort'
-
 module RuboCop
   module Cop
     module Style
@@ -28,27 +26,29 @@ module RuboCop
 
         MSG = 'Do not use parallel assignment.'
 
-        def on_masgn(node)
-          lhs, rhs = *node
-          lhs_elements = *lhs
+        def on_masgn(node) # rubocop:disable Metrics/AbcSize
+          return if part_of_ignored_node?(node)
+
+          rhs = node.rhs
+          rhs = rhs.body if rhs.rescue_type?
           rhs_elements = Array(rhs).compact # edge case for one constant
 
-          return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
-                    allowed_masign?(lhs_elements, rhs_elements)
+          return if allowed_lhs?(node.assignments) || allowed_rhs?(rhs) ||
+                    allowed_masign?(node.assignments, rhs_elements)
+
+          range = node.source_range.begin.join(rhs.source_range.end)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
+          add_offense(range) do |corrector|
+            autocorrect(corrector, node, rhs)
           end
+          ignore_node(node)
         end
 
         private
 
-        def autocorrect(corrector, node)
-          left, right = *node
-          left_elements = *left
-          right_elements = Array(right).compact
-          order = find_valid_order(left_elements, right_elements)
-          correction = assignment_corrector(node, order)
+        def autocorrect(corrector, node, rhs)
+          order = find_valid_order(node.assignments, Array(rhs).compact)
+          correction = assignment_corrector(node, rhs, order)
 
           corrector.replace(correction.correction_range, correction.correction)
         end
@@ -59,9 +59,7 @@ module RuboCop
                               add_self_to_getters(rhs_elements))
         end
 
-        def allowed_lhs?(node)
-          elements = *node
-
+        def allowed_lhs?(elements)
           # Account for edge cases using one variable with a comma
           # E.g.: `foo, = *bar`
           elements.one? || elements.any?(&:splat_type?)
@@ -72,38 +70,31 @@ module RuboCop
           elements = Array(node).compact
 
           # Account for edge case of `Constant::CONSTANT`
-          !node.array_type? ||
-            return_of_method_call?(node) ||
-            elements.any?(&:splat_type?)
+          !node.array_type? || elements.any?(&:splat_type?)
         end
 
-        def return_of_method_call?(node)
-          node.block_type? || node.send_type?
-        end
+        def assignment_corrector(node, rhs, order)
+          if node.parent&.rescue_type?
+            _assignment, modifier = *node.parent
+          else
+            _assignment, modifier = *rhs.parent
+          end
 
-        def assignment_corrector(node, order)
-          _assignment, modifier = *node.parent
           if modifier_statement?(node.parent)
-            ModifierCorrector.new(node, config, order)
+            ModifierCorrector.new(node, rhs, modifier, config, order)
           elsif rescue_modifier?(modifier)
-            RescueCorrector.new(node, config, order)
+            RescueCorrector.new(node, rhs, modifier, config, order)
           else
-            GenericCorrector.new(node, config, order)
+            GenericCorrector.new(node, rhs, modifier, config, order)
           end
         end
 
         def find_valid_order(left_elements, right_elements)
           # arrange left_elements in an order such that no corresponding right
           # element refers to a left element earlier in the sequence
-          # this can be done using an algorithm called a "topological sort"
-          # fortunately for us, Ruby's stdlib contains an implementation
           assignments = left_elements.zip(right_elements)
 
-          begin
-            AssignmentSorter.new(assignments).tsort
-          rescue TSort::Cyclic
-            nil
-          end
+          AssignmentSorter.new(assignments).tsort
         end
 
         # Converts (send nil :something) nodes to (send (:self) :something).
@@ -115,52 +106,76 @@ module RuboCop
           end
         end
 
+        # @!method implicit_self_getter?(node)
         def_node_matcher :implicit_self_getter?, '(send nil? $_)'
 
-        # Helper class necessitated by silly design of TSort prior to Ruby 2.1
-        # Newer versions have a better API, but that doesn't help us
+        # Topologically sorts the assignments with Kahn's algorithm.
+        # https://en.wikipedia.org/wiki/Topological_sorting#Kahn's_algorithm
         class AssignmentSorter
-          include TSort
           extend RuboCop::NodePattern::Macros
 
+          # @!method var_name(node)
           def_node_matcher :var_name, '{(casgn _ $_) (_ $_)}'
+
+          # @!method uses_var?(node)
           def_node_search :uses_var?, '{({lvar ivar cvar gvar} %) (const _ %)}'
+
+          # @!method matching_calls(node, receiver, method_name)
           def_node_search :matching_calls, '(send %1 %2 $...)'
 
           def initialize(assignments)
             @assignments = assignments
           end
 
-          def tsort_each_node(&block)
-            @assignments.each(&block)
+          def tsort
+            dependencies = @assignments.to_h do |assignment|
+              [assignment, dependencies_for_assignment(assignment)]
+            end
+            result = []
+
+            while (matched_node, = dependencies.find { |_node, edges| edges.empty? })
+              dependencies.delete(matched_node)
+              result.push(matched_node)
+
+              dependencies.each do |node, edges|
+                dependencies[node].delete(matched_node) if edges.include?(matched_node)
+              end
+            end
+            # Cyclic dependency
+            return nil if dependencies.any?
+
+            result
           end
 
-          def tsort_each_child(assignment)
-            # yield all the assignments which must come after `assignment`
-            # (due to dependencies on the previous value of the assigned var)
+          # Returns all the assignments which must come after `assignment`
+          # (due to dependencies on the previous value of the assigned var)
+          def dependencies_for_assignment(assignment)
             my_lhs, _my_rhs = *assignment
 
-            @assignments.each do |other|
-              _other_lhs, other_rhs = *other
+            @assignments.filter_map do |other|
+              # Exclude self, there are no dependencies in cases such as `a, b = a, b`.
+              next if other == assignment
 
+              _other_lhs, other_rhs = *other
               next unless dependency?(my_lhs, other_rhs)
 
-              yield other
+              other
             end
           end
 
           def dependency?(lhs, rhs)
             uses_var?(rhs, var_name(lhs)) ||
-              lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs)
+              (lhs.send_type? && lhs.assignment_method? && accesses?(rhs, lhs))
           end
 
           # `lhs` is an assignment method call like `obj.attr=` or `ary[idx]=`.
           # Does `rhs` access the same value which is assigned by `lhs`?
           def accesses?(rhs, lhs)
             if lhs.method?(:[]=)
-              matching_calls(rhs, lhs.receiver, :[]).any? do |args|
-                args == lhs.arguments
-              end
+              # FIXME: Workaround `rubocop:disable` comment for JRuby.
+              # rubocop:disable Performance/RedundantEqualityComparisonBlock
+              matching_calls(rhs, lhs.receiver, :[]).any? { |args| args == lhs.arguments }
+              # rubocop:enable Performance/RedundantEqualityComparisonBlock
             else
               access_method = lhs.method_name.to_s.chop.to_sym
               matching_calls(rhs, lhs.receiver, access_method).any?
@@ -169,17 +184,21 @@ module RuboCop
         end
 
         def modifier_statement?(node)
-          node && %i[if while until].include?(node.type) && node.modifier_form?
+          return false unless node
+
+          node.basic_conditional? && node.modifier_form?
         end
 
         # An internal class for correcting parallel assignment
         class GenericCorrector
           include Alignment
 
-          attr_reader :config, :node
+          attr_reader :node, :rhs, :rescue_result, :config
 
-          def initialize(node, config, new_elements)
+          def initialize(node, rhs, modifier, config, new_elements)
             @node = node
+            @rhs = rhs
+            _, _, @rescue_result = *modifier
             @config = config
             @new_elements = new_elements
           end
@@ -195,15 +214,16 @@ module RuboCop
           protected
 
           def assignment
-            @new_elements.map { |lhs, rhs| "#{lhs.source} = #{source(rhs)}" }
+            @new_elements.map { |lhs, rhs| "#{lhs.source} = #{source(rhs, rhs.loc)}" }
           end
 
           private
 
-          def source(node)
-            if node.str_type? && node.loc.begin.nil?
+          def source(node, loc)
+            # __FILE__ is treated as a StrNode but has no begin
+            if node.str_type? && loc.respond_to?(:begin) && loc.begin.nil?
               "'#{node.source}'"
-            elsif node.sym_type? && node.loc.begin.nil?
+            elsif node.sym_type? && loc.begin.nil?
               ":#{node.source}"
             else
               node.source
@@ -223,13 +243,10 @@ module RuboCop
         # protected by rescue
         class RescueCorrector < GenericCorrector
           def correction
-            _node, rescue_clause = *node.parent
-            _, _, rescue_result = *rescue_clause
-
             # If the parallel assignment uses a rescue modifier and it is the
             # only contents of a method, then we want to make use of the
             # implicit begin
-            if node.parent.parent&.def_type?
+            if rhs.parent.parent.parent&.def_type?
               super + def_correction(rescue_result)
             else
               begin_correction(rescue_result)
@@ -237,7 +254,7 @@ module RuboCop
           end
 
           def correction_range
-            node.parent.source_range
+            rhs.parent.parent.source_range
           end
 
           private
@@ -276,9 +293,7 @@ module RuboCop
           private
 
           def modifier_range(node)
-            Parser::Source::Range.new(node.source_range.source_buffer,
-                                      node.loc.keyword.begin_pos,
-                                      node.source_range.end_pos)
+            node.loc.keyword.join(node.source_range.end)
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the presence of superfluous parentheses around the
+      # Checks for the presence of superfluous parentheses around the
       # condition of if/unless/while/until.
       #
       # `AllowSafeAssignment` option for safe assignment.
@@ -56,6 +56,7 @@ module RuboCop
       class ParenthesesAroundCondition < Base
         include SafeAssignment
         include Parentheses
+        include RangeHelp
         extend AutoCorrector
 
         def on_if(node)
@@ -71,14 +72,17 @@ module RuboCop
 
         private
 
+        # @!method control_op_condition(node)
         def_node_matcher :control_op_condition, <<~PATTERN
-          (begin $_ ...)
+          (begin $_ $...)
         PATTERN
 
         def process_control_op(node)
           cond = node.condition
 
-          control_op_condition(cond) do |first_child|
+          control_op_condition(cond) do |first_child, rest_children|
+            return if require_parentheses?(node, first_child)
+            return if semicolon_separated_expressions?(first_child, rest_children)
             return if modifier_op?(first_child)
             return if parens_allowed?(cond)
 
@@ -89,6 +93,21 @@ module RuboCop
           end
         end
 
+        def require_parentheses?(node, condition_body)
+          return false unless node.type?(:while, :until)
+          return false unless condition_body.any_block_type?
+
+          condition_body.send_node.block_literal? && condition_body.keywords?
+        end
+
+        def semicolon_separated_expressions?(first_exp, rest_exps)
+          return false unless (second_exp = rest_exps.first)
+
+          range = range_between(first_exp.source_range.end_pos, second_exp.source_range.begin_pos)
+
+          range.source.include?(';')
+        end
+
         def modifier_op?(node)
           return false if node.if_type? && node.ternary?
           return true if node.rescue_type?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the consistent usage of `%`-literal delimiters.
+      # Enforces the consistent usage of `%`-literal delimiters.
       #
       # Specify the 'default' key to set all preferred delimiters at once. You
       # can continue to specify individual preferred delimiters to override the
@@ -68,13 +68,11 @@ module RuboCop
           delimiters = preferred_delimiters_for(type)
 
           "`#{type}`-literals should be delimited by " \
-          "`#{delimiters[0]}` and `#{delimiters[1]}`."
+            "`#{delimiters[0]}` and `#{delimiters[1]}`."
         end
 
         def preferred_delimiters_for(type)
-          PreferredDelimiters
-            .new(type, @config, nil)
-            .delimiters
+          PreferredDelimiters.new(type, @config, nil).delimiters
         end
 
         def uses_preferred_delimiter?(node, type)
@@ -94,15 +92,14 @@ module RuboCop
 
         def contains_delimiter?(node, delimiters)
           delimiters_regexp = Regexp.union(delimiters)
-          node
-            .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp.match?(s) }
+
+          node.children.filter_map { |n| string_source(n) }.any?(delimiters_regexp)
         end
 
         def string_source(node)
           if node.is_a?(String)
             node.scrub
-          elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
+          elsif node.respond_to?(:type) && node.type?(:str, :sym)
             node.source
           end
         end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for usage of the %Q() syntax when %q() would do.
+      # Checks for usage of the %Q() syntax when %q() would do.
       #
       # @example EnforcedStyle: lower_case_q (default)
       #   # The `lower_case_q` style prefers `%q` unless
@@ -30,8 +30,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        LOWER_CASE_Q_MSG = 'Do not use `%Q` unless interpolation is ' \
-                           'needed. Use `%q`.'
+        LOWER_CASE_Q_MSG = 'Do not use `%Q` unless interpolation is needed. Use `%q`.'
         UPPER_CASE_Q_MSG = 'Use `%Q` instead of `%q`.'
 
         def on_str(node)
@@ -45,8 +44,8 @@ module RuboCop
 
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
-          ast = ProcessedSource.new(corrected(node.source), target_ruby_version).ast
-          return if node.children != ast.children
+          ast = parse(corrected(node.source)).ast
+          return if node.children != ast&.children
 
           add_offense(node.loc.begin) do |corrector|
             corrector.replace(node, corrected(node.source))
@@ -54,8 +53,8 @@ module RuboCop
         end
 
         def correct_literal_style?(node)
-          style == :lower_case_q && type(node) == '%q' ||
-            style == :upper_case_q && type(node) == '%Q'
+          (style == :lower_case_q && type(node) == '%q') ||
+            (style == :upper_case_q && type(node) == '%Q')
         end
 
         def message(_range)

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of Perl-style regexp match
-      # backreferences like $1, $2, etc.
+      # Looks for uses of Perl-style regexp match
+      # backreferences and their English versions like
+      # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
       #
       # @example
       #   # bad
@@ -15,19 +16,109 @@ module RuboCop
       class PerlBackrefs < Base
         extend AutoCorrector
 
-        MSG = 'Avoid the use of Perl-style backrefs.'
+        MESSAGE_FORMAT = 'Prefer `%<preferred_expression>s` over `%<original_expression>s`.'
+
+        def on_back_ref(node)
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
+
+        def on_gvar(node)
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
 
         def on_nth_ref(node)
-          add_offense(node) do |corrector|
-            backref, = *node
-            parent_type = node.parent ? node.parent.type : nil
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
+
+        private
 
-            if %i[dstr xstr regexp].include?(parent_type)
-              corrector.replace(node, "{Regexp.last_match(#{backref})}")
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def derived_from_braceless_interpolation?(node)
+          %i[dstr regexp xstr].include?(node.parent&.type)
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @param [String] preferred_expression
+        # @return [String]
+        def format_message(node:, preferred_expression:)
+          original_expression = original_expression_of(node)
+          format(
+            MESSAGE_FORMAT,
+            original_expression: original_expression,
+            preferred_expression: preferred_expression
+          )
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String]
+        def original_expression_of(node)
+          first = node.to_a.first
+          if first.is_a?(::Integer)
+            "$#{first}"
+          else
+            first.to_s
+          end
+        end
 
-            else
-              corrector.replace(node, "Regexp.last_match(#{backref})")
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String, nil]
+        def preferred_expression_to(node)
+          first = node.to_a.first
+          case first
+          when ::Integer
+            "Regexp.last_match(#{first})"
+          when :$&, :$MATCH
+            'Regexp.last_match(0)'
+          when :$`, :$PREMATCH
+            'Regexp.last_match.pre_match'
+          when :$', :$POSTMATCH
+            'Regexp.last_match.post_match'
+          when :$+, :$LAST_PAREN_MATCH
+            'Regexp.last_match(-1)'
+          end
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String, nil]
+        def preferred_expression_to_node_with_constant_prefix(node)
+          expression = preferred_expression_to(node)
+          return unless expression
+
+          "#{constant_prefix(node)}#{expression}"
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String]
+        def constant_prefix(node)
+          if node.each_ancestor(:class, :module).any?
+            '::'
+          else
+            ''
+          end
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        def on_back_ref_or_gvar_or_nth_ref(node)
+          preferred_expression = preferred_expression_to_node_with_constant_prefix(node)
+          return unless preferred_expression
+
+          add_offense(
+            node,
+            message: format_message(node: node, preferred_expression: preferred_expression)
+          ) do |corrector|
+            if derived_from_braceless_interpolation?(node)
+              preferred_expression = "{#{preferred_expression}}"
             end
+
+            corrector.replace(node, preferred_expression)
           end
         end
       end

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

@@ -3,10 +3,15 @@
 module RuboCop
   module Cop
     module Style
-      # This cop (by default) checks for uses of methods Hash#has_key? and
-      # Hash#has_value? where it enforces Hash#key? and Hash#value?
-      # It is configurable to enforce the inverse, using `verbose` method
-      # names also.
+      # Checks for uses of methods `Hash#has_key?` and
+      # `Hash#has_value?`, and suggests using `Hash#key?` and `Hash#value?` instead.
+      #
+      # It is configurable to enforce the verbose method names, by using the
+      # `EnforcedStyle: verbose` configuration.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is a `Hash` or responds to the replacement methods.
       #
       # @example EnforcedStyle: short (default)
       #  # bad
@@ -31,10 +36,7 @@ module RuboCop
 
         MSG = 'Use `Hash#%<prefer>s` instead of `Hash#%<current>s`.'
 
-        OFFENDING_SELECTORS = {
-          short: %i[has_key? has_value?],
-          verbose: %i[key? value?]
-        }.freeze
+        OFFENDING_SELECTORS = { short: %i[has_key? has_value?], verbose: %i[key? value?] }.freeze
 
         RESTRICT_ON_SEND = OFFENDING_SELECTORS.values.flatten.freeze
 
@@ -59,7 +61,7 @@ module RuboCop
           if style == :verbose
             "has_#{method_name}"
           else
-            method_name.to_s.sub(/has_/, '')
+            method_name.to_s.delete_prefix('has_')
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of Proc.new where Kernel#proc
+      # Checks for uses of Proc.new where Kernel#proc
       # would be more appropriate.
       #
       # @example
@@ -18,8 +18,8 @@ module RuboCop
 
         MSG = 'Use `proc` instead of `Proc.new`.'
 
-        def_node_matcher :proc_new?,
-                         '(block $(send (const {nil? cbase} :Proc) :new) ...)'
+        # @!method proc_new?(node)
+        def_node_matcher :proc_new?, '(any_block $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|
@@ -28,6 +28,9 @@ module RuboCop
             end
           end
         end
+
+        alias on_numblock on_block
+        alias on_itblock on_block
       end
     end
   end