rubocop 0.78.0 → 1.13.0

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

@@ -26,17 +26,21 @@ module RuboCop
       #
       #   # good - set name to 'Bozhidar', only if it's nil or false
       #   name ||= 'Bozhidar'
-      class OrAssignment < Cop
+      class OrAssignment < Base
+        extend AutoCorrector
+
         MSG = 'Use the double pipe equals operator `||=` instead.'
 
+        # @!method ternary_assignment?(node)
         def_node_matcher :ternary_assignment?, <<~PATTERN
           ({lvasgn ivasgn cvasgn gvasgn} _var
             (if
               ({lvar ivar cvar gvar} _var)
               ({lvar ivar cvar gvar} _var)
-              _))
+              $_))
         PATTERN
 
+        # @!method unless_assignment?(node)
         def_node_matcher :unless_assignment?, <<~PATTERN
           (if
             ({lvar ivar cvar gvar} _var) nil?
@@ -47,34 +51,32 @@ module RuboCop
         def on_if(node)
           return unless unless_assignment?(node)
 
-          add_offense(node)
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         def on_lvasgn(node)
-          return unless ternary_assignment?(node)
+          return unless (else_branch = ternary_assignment?(node))
+          return if else_branch.if_type?
 
-          add_offense(node)
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         alias on_ivasgn on_lvasgn
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           if ternary_assignment?(node)
             variable, default = take_variable_and_default_from_ternary(node)
           else
             variable, default = take_variable_and_default_from_unless(node)
           end
 
-          lambda do |corrector|
-            corrector.replace(node.source_range,
-                              "#{variable} ||= #{default.source}")
-          end
+          corrector.replace(node, "#{variable} ||= #{default.source}")
         end
 
-        private
-
         def take_variable_and_default_from_ternary(node)
           variable, if_statement = *node
           [variable, if_statement.else_branch]

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

@@ -22,36 +22,34 @@ module RuboCop
       #   a = 1
       #   b = 2
       #   c = 3
-      class ParallelAssignment < Cop
+      class ParallelAssignment < Base
         include RescueNode
+        extend AutoCorrector
 
         MSG = 'Do not use parallel assignment.'
 
         def on_masgn(node)
           lhs, rhs = *node
           lhs_elements = *lhs
-          rhs_elements = [*rhs].compact # edge case for one constant
+          rhs_elements = Array(rhs).compact # edge case for one constant
 
           return if allowed_lhs?(lhs) || allowed_rhs?(rhs) ||
                     allowed_masign?(lhs_elements, rhs_elements)
 
-          add_offense(node)
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            left, right = *node
-            left_elements = *left
-            right_elements = [*right].compact
-            order = find_valid_order(left_elements, right_elements)
-            correction = assignment_corrector(node, order)
+        private
 
-            corrector.replace(correction.correction_range,
-                              correction.correction)
-          end
-        end
+        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)
 
-        private
+          corrector.replace(correction.correction_range, correction.correction)
+        end
 
         def allowed_masign?(lhs_elements, rhs_elements)
           lhs_elements.size != rhs_elements.size ||
@@ -69,12 +67,10 @@ module RuboCop
 
         def allowed_rhs?(node)
           # Edge case for one constant
-          elements = [*node].compact
+          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? || return_of_method_call?(node) || elements.any?(&:splat_type?)
         end
 
         def return_of_method_call?(node)
@@ -115,6 +111,7 @@ 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
@@ -123,16 +120,21 @@ module RuboCop
           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
-            @assignments.each { |a| yield a }
+          def tsort_each_node(&block)
+            @assignments.each(&block)
           end
 
           def tsort_each_child(assignment)
@@ -158,9 +160,10 @@ module RuboCop
           # 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?

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

@@ -53,9 +53,10 @@ module RuboCop
       #      y > 10)
       #   end
       #
-      class ParenthesesAroundCondition < Cop
+      class ParenthesesAroundCondition < Base
         include SafeAssignment
         include Parentheses
+        extend AutoCorrector
 
         def on_if(node)
           return if node.ternary?
@@ -68,12 +69,9 @@ module RuboCop
         end
         alias on_until on_while
 
-        def autocorrect(node)
-          ParenthesesCorrector.correct(node)
-        end
-
         private
 
+        # @!method control_op_condition(node)
         def_node_matcher :control_op_condition, <<~PATTERN
           (begin $_ ...)
         PATTERN
@@ -85,7 +83,10 @@ module RuboCop
             return if modifier_op?(first_child)
             return if parens_allowed?(cond)
 
-            add_offense(cond)
+            message = message(cond)
+            add_offense(cond, message: message) do |corrector|
+              ParenthesesCorrector.correct(corrector, cond)
+            end
           end
         end
 

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

@@ -23,8 +23,9 @@ module RuboCop
       #
       #   # bad
       #   %I(alpha beta)
-      class PercentLiteralDelimiters < Cop
+      class PercentLiteralDelimiters < Base
         include PercentLiteral
+        extend AutoCorrector
 
         def on_array(node)
           process(node, '%w', '%W', '%i', '%I')
@@ -47,40 +48,31 @@ module RuboCop
           process(node, '%x')
         end
 
-        def message(node)
-          type = type(node)
-          delimiters = preferred_delimiters_for(type)
-
-          "`#{type}`-literals should be delimited by " \
-          "`#{delimiters[0]}` and `#{delimiters[1]}`."
-        end
+        private
 
-        def autocorrect(node)
+        def on_percent_literal(node)
           type = type(node)
+          return if uses_preferred_delimiter?(node, type) ||
+                    contains_preferred_delimiter?(node, type) ||
+                    include_same_character_as_used_for_delimiter?(node, type)
 
-          opening_delimiter, closing_delimiter = preferred_delimiters_for(type)
+          add_offense(node, message: message(type)) do |corrector|
+            opening_delimiter, closing_delimiter = preferred_delimiters_for(type)
 
-          lambda do |corrector|
             corrector.replace(node.loc.begin, "#{type}#{opening_delimiter}")
             corrector.replace(node.loc.end, closing_delimiter)
           end
         end
 
-        private
-
-        def on_percent_literal(node)
-          type = type(node)
-          return if uses_preferred_delimiter?(node, type) ||
-                    contains_preferred_delimiter?(node, type) ||
-                    include_same_character_as_used_for_delimiter?(node, type)
+        def message(type)
+          delimiters = preferred_delimiters_for(type)
 
-          add_offense(node)
+          "`#{type}`-literals should be delimited by " \
+          "`#{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)
@@ -88,27 +80,27 @@ module RuboCop
         end
 
         def contains_preferred_delimiter?(node, type)
-          preferred_delimiters = preferred_delimiters_for(type)
-          node
-            .children.map { |n| string_source(n) }.compact
-            .any? { |s| preferred_delimiters.any? { |d| s.include?(d) } }
+          contains_delimiter?(node, preferred_delimiters_for(type))
         end
 
         def include_same_character_as_used_for_delimiter?(node, type)
           return false unless %w[%w %i].include?(type)
 
           used_delimiters = matchpairs(begin_source(node)[-1])
-          escaped_delimiters = used_delimiters.map { |d| "\\#{d}" }.join('|')
+          contains_delimiter?(node, used_delimiters)
+        end
 
+        def contains_delimiter?(node, delimiters)
+          delimiters_regexp = Regexp.union(delimiters)
           node
             .children.map { |n| string_source(n) }.compact
-            .any? { |s| Regexp.new(escaped_delimiters) =~ s }
+            .any? { |s| delimiters_regexp.match?(s) }
         end
 
         def string_source(node)
           if node.is_a?(String)
-            node
-          elsif node.respond_to?(:type) && node.str_type?
+            node.scrub
+          elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
             node.source
           end
         end

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

@@ -25,24 +25,18 @@ module RuboCop
       #   # good
       #   %Q/Mix the foo into the baz./
       #   %Q{They all said: 'Hooray!'}
-      class PercentQLiterals < Cop
+      class PercentQLiterals < Base
         include PercentLiteral
         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)
           process(node, '%Q', '%q')
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, corrected(node.source))
-          end
-        end
-
         private
 
         def on_percent_literal(node)
@@ -50,9 +44,12 @@ module RuboCop
 
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
-          return if node.children != parse(corrected(node.source)).ast.children
+          ast = ProcessedSource.new(corrected(node.source), target_ruby_version).ast
+          return if node.children != ast.children
 
-          add_offense(node, location: :begin)
+          add_offense(node.loc.begin) do |corrector|
+            corrector.replace(node, corrected(node.source))
+          end
         end
 
         def correct_literal_style?(node)
@@ -60,7 +57,7 @@ module RuboCop
             style == :upper_case_q && type(node) == '%Q'
         end
 
-        def message(_node)
+        def message(_range)
           style == :lower_case_q ? LOWER_CASE_Q_MSG : UPPER_CASE_Q_MSG
         end
 

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for uses of Perl-style regexp match
-      # backreferences like $1, $2, etc.
+      # backreferences and their English versions like
+      # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
       #
       # @example
       #   # bad
@@ -12,24 +13,91 @@ module RuboCop
       #
       #   # good
       #   puts Regexp.last_match(1)
-      class PerlBackrefs < Cop
-        MSG = 'Avoid the use of Perl-style backrefs.'
+      class PerlBackrefs < Base
+        extend AutoCorrector
+
+        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)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            backref, = *node
-            parent_type = node.parent ? node.parent.type : nil
-            if %i[dstr xstr regexp].include?(parent_type)
-              corrector.replace(node.source_range,
-                                "{Regexp.last_match(#{backref})}")
-            else
-              corrector.replace(node.source_range,
-                                "Regexp.last_match(#{backref})")
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
+
+        private
+
+        # @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
+
+        # @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
+        def on_back_ref_or_gvar_or_nth_ref(node)
+          preferred_expression = preferred_expression_to(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