rubocop 1.22.0 → 1.45.1

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)
@@ -73,13 +74,14 @@ module RuboCop
 
         # @!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)
 
@@ -90,6 +92,14 @@ module RuboCop
           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

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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of Perl-style regexp match
+      # Looks for uses of Perl-style regexp match
       # backreferences and their English versions like
       # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
       #
@@ -83,10 +83,31 @@ module RuboCop
           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)
+          preferred_expression = preferred_expression_to_node_with_constant_prefix(node)
           return unless preferred_expression
 
           add_offense(

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of methods `Hash#has_key?` and
+      # 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

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
@@ -19,7 +19,8 @@ module RuboCop
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         # @!method proc_new?(node)
-        def_node_matcher :proc_new?, '(block $(send (const {nil? cbase} :Proc) :new) ...)'
+        def_node_matcher :proc_new?,
+                         '({block numblock} $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|
@@ -28,6 +29,8 @@ module RuboCop
             end
           end
         end
+
+        alias on_numblock on_block
       end
     end
   end

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # Checks if the quotes used for quoted symbols match the configured defaults.
-      # By default uses the same configuration as `Style/StringLiterals`.
+      # By default uses the same configuration as `Style/StringLiterals`; if that
+      # cop is not enabled, the default `EnforcedStyle` is `single_quotes`.
       #
       # String interpolation is always kept in double quotes.
       #
@@ -45,7 +46,7 @@ module RuboCop
 
           message = style == :single_quotes ? MSG_SINGLE : MSG_DOUBLE
 
-          if wrong_quotes?(node)
+          if wrong_quotes?(node) || invalid_double_quotes?(node.source)
             add_offense(node, message: message) do |corrector|
               opposite_style_detected
               autocorrect(corrector, node)
@@ -57,6 +58,16 @@ module RuboCop
 
         private
 
+        def invalid_double_quotes?(source)
+          return false unless style == :double_quotes
+
+          # The string needs single quotes if:
+          # 1. It contains a double quote
+          # 2. It contains text that would become an escape sequence with double quotes
+          # 3. It contains text that would become an interpolation with double quotes
+          !/" | (?<!\\)\\[aAbcdefkMnprsStuUxzZ0-7] | \#[@{$]/x.match?(source)
+        end
+
         def autocorrect(corrector, node)
           str = if hash_colon_key?(node)
                   # strip quotes
@@ -75,11 +86,14 @@ module RuboCop
         end
 
         def correct_quotes(str)
-          if style == :single_quotes
-            to_string_literal(str)
-          else
-            str.inspect
-          end
+          correction = if style == :single_quotes
+                         to_string_literal(str)
+                       else
+                         str.gsub("\\'", "'").inspect
+                       end
+
+          # The conversion process doubles escaped slashes, so they have to be reverted
+          correction.gsub('\\\\', '\\').gsub('\"', '"')
         end
 
         def style
@@ -102,7 +116,7 @@ module RuboCop
         def wrong_quotes?(node)
           return super if hash_key?(node)
 
-          super(node.source[1..-1])
+          super(node.source[1..])
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks the args passed to `fail` and `raise`. For exploded
+      # Checks the args passed to `fail` and `raise`. For exploded
       # style (default), it recommends passing the exception class and message
       # to `raise`, rather than construct an instance of the error. It will
       # still allow passing just a message, or the construction of an error
@@ -80,7 +80,7 @@ module RuboCop
           return node.source if message_nodes.size > 1
 
           argument = message_nodes.first.source
-          exception_class = exception_node.const_name || exception_node.receiver.source
+          exception_class = exception_node.receiver&.source || exception_node.source
 
           if node.parent && requires_parens?(node.parent)
             "#{node.method_name}(#{exception_class}.new(#{argument}))"
@@ -91,6 +91,9 @@ module RuboCop
 
         def check_compact(node)
           if node.arguments.size > 1
+            exception = node.first_argument
+            return if exception.send_type? && exception.first_argument&.hash_type?
+
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
               replacement = correction_exploded_to_compact(node)
 
@@ -107,8 +110,7 @@ module RuboCop
 
           first_arg = node.first_argument
 
-          return unless first_arg.send_type? && first_arg.method?(:new)
-          return if acceptable_exploded_args?(first_arg.arguments)
+          return if !use_new_method?(first_arg) || acceptable_exploded_args?(first_arg.arguments)
 
           return if allowed_non_exploded_type?(first_arg)
 
@@ -120,6 +122,10 @@ module RuboCop
           end
         end
 
+        def use_new_method?(first_arg)
+          first_arg.send_type? && first_arg.receiver && first_arg.method?(:new)
+        end
+
         def acceptable_exploded_args?(args)
           # Allow code like `raise Ex.new(arg1, arg2)`.
           return true if args.size > 1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of randomly generated numbers,
+      # Checks for the use of randomly generated numbers,
       # added/subtracted with integer literals, as well as those with
       # Integer#succ and Integer#pred methods. Prefer using ranges instead,
       # as it clearly states the intentions.

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for a redundant argument passed to certain methods.
+      # Checks for a redundant argument passed to certain methods.
       #
       # NOTE: This cop is limited to methods with single parameter.
       #
@@ -13,6 +13,7 @@ module RuboCop
       # ----
       # Methods:
       #   join: ''
+      #   sum: 0
       #   split: ' '
       #   chomp: "\n"
       #   chomp!: "\n"
@@ -33,6 +34,7 @@ module RuboCop
       #   # bad
       #   array.join('')
       #   [1, 2, 3].join("")
+      #   array.sum(0)
       #   string.split(" ")
       #   "first\nsecond".split(" ")
       #   string.chomp("\n")
@@ -42,6 +44,7 @@ module RuboCop
       #   # good
       #   array.join
       #   [1, 2, 3].join
+      #   array.sum
       #   string.split
       #   "first second".split
       #   string.chomp
@@ -58,8 +61,11 @@ module RuboCop
           return if node.arguments.count != 1
           return unless redundant_argument?(node)
 
-          add_offense(node, message: format(MSG, arg: node.arguments.first.source)) do |corrector|
-            corrector.remove(argument_range(node))
+          offense_range = argument_range(node)
+          message = format(MSG, arg: node.arguments.first.source)
+
+          add_offense(offense_range, message: message) do |corrector|
+            corrector.remove(offense_range)
           end
         end
 
@@ -83,7 +89,7 @@ module RuboCop
           if node.parenthesized?
             range_between(node.loc.begin.begin_pos, node.loc.end.end_pos)
           else
-            range_with_surrounding_space(range: node.first_argument.source_range, newlines: false)
+            range_with_surrounding_space(node.first_argument.source_range, newlines: false)
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant assignment before returning.
+      # Checks for redundant assignment before returning.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for redundant `begin` blocks.
+      # Checks for redundant `begin` blocks.
       #
       # Currently it checks for code like this:
       #
@@ -36,6 +36,7 @@ module RuboCop
       #   do_something
       #
       #   # bad
+      #   # When using Ruby 2.5 or later.
       #   do_something do
       #     begin
       #       something
@@ -67,14 +68,21 @@ module RuboCop
 
         MSG = 'Redundant `begin` block detected.'
 
+        # @!method offensive_kwbegins(node)
+        def_node_search :offensive_kwbegins, <<~PATTERN
+          [(kwbegin ...) !#allowable_kwbegin?]
+        PATTERN
+
         def on_def(node)
           return unless node.body&.kwbegin_type?
+          return if node.endless? && !node.body.children.one?
 
           register_offense(node.body)
         end
         alias on_defs on_def
 
         def on_block(node)
+          return if target_ruby_version < 2.5
           return if node.send_node.lambda_literal?
           return if node.braces?
           return unless node.body&.kwbegin_type?
@@ -82,22 +90,28 @@ module RuboCop
           register_offense(node.body)
         end
 
+        alias on_numblock on_block
+
         def on_kwbegin(node)
-          return if empty_begin?(node) ||
-                    begin_block_has_multiline_statements?(node) ||
-                    contain_rescue_or_ensure?(node) ||
-                    valid_context_using_only_begin?(node)
+          return unless (target_node = offensive_kwbegins(node).to_a.last)
 
-          register_offense(node)
+          register_offense(target_node)
         end
 
         private
 
+        def allowable_kwbegin?(node)
+          empty_begin?(node) ||
+            begin_block_has_multiline_statements?(node) ||
+            contain_rescue_or_ensure?(node) ||
+            valid_context_using_only_begin?(node)
+        end
+
         def register_offense(node)
           offense_range = node.loc.begin
 
           add_offense(offense_range) do |corrector|
-            if any_ancestor_assignment_node?(node)
+            if node.parent&.assignment?
               replace_begin_with_statement(corrector, offense_range, node)
             else
               corrector.remove(offense_range)
@@ -170,11 +184,7 @@ module RuboCop
         end
 
         def valid_begin_assignment?(node)
-          any_ancestor_assignment_node?(node) && !node.children.one?
-        end
-
-        def any_ancestor_assignment_node?(node)
-          node.each_ancestor.any?(&:assignment?)
+          node.parent&.assignment? && !node.children.one?
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for usage of the %W() syntax when %w() would do.
+      # Checks for usage of the %W() syntax when %w() would do.
       #
       # @example
       #   # bad
@@ -37,8 +37,7 @@ module RuboCop
 
         def requires_interpolation?(node)
           node.child_nodes.any? do |string|
-            string.dstr_type? ||
-              double_quotes_required?(string.source)
+            string.dstr_type? || double_quotes_required?(string.source)
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for unnecessary conditional expressions.
+      # Checks for unnecessary conditional expressions.
       #
       # @example
       #   # bad
@@ -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?
@@ -44,9 +47,9 @@ module RuboCop
           message = message(node)
 
           add_offense(range_of_offense(node), message: message) do |corrector|
-            if node.ternary?
+            if node.ternary? && !branches_have_method?(node)
               correct_ternary(corrector, node)
-            elsif node.modifier_form? || !node.else_branch
+            elsif redundant_condition?(node)
               corrector.replace(node, node.if_branch.source)
             else
               corrected = make_ternary_form(node)
@@ -59,7 +62,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.modifier_form? || !node.else_branch
+          if redundant_condition?(node)
             REDUNDANT_CONDITION
           else
             MSG
@@ -68,18 +71,22 @@ module RuboCop
 
         def range_of_offense(node)
           return node.loc.expression unless node.ternary?
+          return node.loc.expression if node.ternary? && branches_have_method?(node)
 
           range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
         end
 
         def offense?(node)
-          condition, if_branch, else_branch = *node
+          _condition, _if_branch, else_branch = *node
 
           return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
-          condition == if_branch && !node.elsif? && (
-            node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?
-          )
+          synonymous_condition_and_branch?(node) && !node.elsif? &&
+            (node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?)
+        end
+
+        def redundant_condition?(node)
+          node.modifier_form? || !node.else_branch
         end
 
         def use_if_branch?(else_branch)
@@ -90,19 +97,138 @@ module RuboCop
           else_branch&.send_type? && else_branch&.method?(:[]=)
         end
 
-        def else_source(else_branch)
-          if require_parentheses?(else_branch)
+        def use_hash_key_access?(node)
+          node.send_type? && node.method?(:[])
+        end
+
+        def synonymous_condition_and_branch?(node)
+          condition, if_branch, _else_branch = *node
+          # e.g.
+          #   if var
+          #     var
+          #   else
+          #     'foo'
+          #   end
+          return true if condition == if_branch
+
+          # e.g.
+          #   if foo
+          #     @value = foo
+          #   else
+          #     @value = another_value?
+          #   end
+          return true if branches_have_assignment?(node) && condition == if_branch.expression
+
+          # e.g.
+          #   if foo
+          #     test.value = foo
+          #   else
+          #     test.value = another_value?
+          #   end
+          branches_have_method?(node) && condition == if_branch.first_argument &&
+            !use_hash_key_access?(if_branch)
+        end
+
+        def branches_have_assignment?(node)
+          _condition, if_branch, else_branch = *node
+
+          return false unless if_branch && else_branch
+
+          asgn_type?(if_branch) && (if_branch_variable_name = if_branch.name) &&
+            asgn_type?(else_branch) && (else_branch_variable_name = else_branch.name) &&
+            if_branch_variable_name == else_branch_variable_name
+        end
+
+        def asgn_type?(node)
+          node.lvasgn_type? || node.ivasgn_type? || node.cvasgn_type? || node.gvasgn_type?
+        end
+
+        def branches_have_method?(node)
+          _condition, if_branch, else_branch = *node
+
+          return false unless if_branch && else_branch
+
+          single_argument_method?(if_branch) && single_argument_method?(else_branch) &&
+            same_method?(if_branch, else_branch)
+        end
+
+        def single_argument_method?(node)
+          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?
+          return false unless (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(')')
+          elsif arithmetic_operation
+            argument_source = if_branch.first_argument.source
+
+            "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
+          else
+            if_branch.source
+          end
+        end
+
+        def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
+          if arithmetic_operation
+            "#{else_branch.first_argument.source})"
+          elsif branches_have_method?(else_branch.parent)
+            else_source_if_has_method(else_branch)
+          elsif require_parentheses?(else_branch)
             "(#{else_branch.source})"
           elsif without_argument_parentheses_method?(else_branch)
             "#{else_branch.method_name}(#{else_branch.arguments.map(&:source).join(', ')})"
+          elsif branches_have_assignment?(else_branch.parent)
+            else_source_if_has_assignment(else_branch)
           else
             else_branch.source
           end
         end
 
+        def else_source_if_has_method(else_branch)
+          if require_parentheses?(else_branch.first_argument)
+            "(#{else_branch.first_argument.source})"
+          elsif require_braces?(else_branch.first_argument)
+            "{ #{else_branch.first_argument.source} }"
+          else
+            else_branch.first_argument.source
+          end
+        end
+
+        def else_source_if_has_assignment(else_branch)
+          if require_parentheses?(else_branch.expression)
+            "(#{else_branch.expression.source})"
+          elsif require_braces?(else_branch.expression)
+            "{ #{else_branch.expression.source} }"
+          else
+            else_branch.expression.source
+          end
+        end
+
         def make_ternary_form(node)
           _condition, if_branch, else_branch = *node
-          ternary_form = [if_branch.source, else_source(else_branch)].join(' || ')
+          arithmetic_operation = use_arithmetic_operation?(if_branch)
+
+          ternary_form = [
+            if_source(if_branch, arithmetic_operation),
+            else_source(else_branch, arithmetic_operation)
+          ].join(' || ')
+          ternary_form += ')' if branches_have_method?(node) && if_branch.parenthesized?
 
           if node.parent&.send_type?
             "(#{ternary_form})"
@@ -126,9 +252,17 @@ module RuboCop
             (node.respond_to?(:semantic_operator?) && node.semantic_operator?)
         end
 
+        def require_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
+        def use_arithmetic_operation?(node)
+          node.respond_to?(:arithmetic_operation?) && node.arithmetic_operation?
+        end
+
         def without_argument_parentheses_method?(node)
-          node.send_type? &&
-            !node.arguments.empty? && !node.parenthesized? && !node.operator_method?
+          node.send_type? && !node.arguments.empty? &&
+            !node.parenthesized? && !node.operator_method? && !node.assignment_method?
         end
       end
     end