rubocop 0.80.0 → 1.42.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for potential usage of the `||=` operator.
+      # Checks for potential usage of the `||=` operator.
       #
       # @example
       #   # bad
@@ -26,9 +26,12 @@ 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
@@ -37,6 +40,7 @@ module RuboCop
               $_))
         PATTERN
 
+        # @!method unless_assignment?(node)
         def_node_matcher :unless_assignment?, <<~PATTERN
           (if
             ({lvar ivar cvar gvar} _var) nil?
@@ -47,35 +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 (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)
@@ -151,16 +153,17 @@ module RuboCop
 
           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?

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.
@@ -53,9 +53,11 @@ module RuboCop
       #      y > 10)
       #   end
       #
-      class ParenthesesAroundCondition < Cop
+      class ParenthesesAroundCondition < Base
         include SafeAssignment
         include Parentheses
+        include RangeHelp
+        extend AutoCorrector
 
         def on_if(node)
           return if node.ternary?
@@ -68,27 +70,36 @@ 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 $_ ...)
+          (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 semicolon_separated_expressions?(first_child, rest_children)
             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
 
+        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
@@ -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)
@@ -102,12 +94,12 @@ module RuboCop
           delimiters_regexp = Regexp.union(delimiters)
           node
             .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp =~ s }
+            .any? { |s| delimiters_regexp.match?(s) }
         end
 
         def string_source(node)
           if node.is_a?(String)
-            node
+            node.scrub
           elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
             node.source
           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
@@ -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,17 +44,20 @@ 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)
-          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(_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

@@ -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
@@ -12,24 +13,112 @@ 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
+        # @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
@@ -25,37 +30,31 @@ module RuboCop
       #  # good
       #  Hash#has_key?
       #  Hash#has_value?
-      class PreferredHashMethods < Cop
+      class PreferredHashMethods < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         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
 
         def on_send(node)
-          return unless node.arguments.one? &&
-                        offending_selector?(node.method_name)
+          return unless node.arguments.one? && offending_selector?(node.method_name)
 
-          add_offense(node, location: :selector)
-        end
-        alias on_csend on_send
+          message = message(node.method_name)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              proper_method_name(node.loc.selector.source))
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, proper_method_name(node.loc.selector.source))
           end
         end
+        alias on_csend on_send
 
         private
 
-        def message(node)
-          format(MSG,
-                 prefer: proper_method_name(node.method_name),
-                 current: node.method_name)
+        def message(method_name)
+          format(MSG, prefer: proper_method_name(method_name), current: method_name)
         end
 
         def proper_method_name(method_name)

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
@@ -13,21 +13,24 @@ module RuboCop
       #   # good
       #   p = proc { |n| puts n }
       #
-      class Proc < Cop
+      class Proc < Base
+        extend AutoCorrector
+
         MSG = 'Use `proc` instead of `Proc.new`.'
 
+        # @!method proc_new?(node)
         def_node_matcher :proc_new?,
-                         '(block $(send (const nil? :Proc) :new) ...)'
+                         '({block numblock} $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|
-            add_offense(block_method)
+            add_offense(block_method) do |corrector|
+              corrector.replace(block_method, 'proc')
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.source_range, 'proc') }
-        end
+        alias on_numblock on_block
       end
     end
   end