rubocop 0.51.0 → 0.87.0

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

@@ -7,40 +7,48 @@ module RuboCop
       # current Ruby version supports keyword arguments.
       #
       # @example
-      #   Instead of:
       #
+      #   # bad
       #   def fry(options = {})
       #     temperature = options.fetch(:temperature, 300)
-      #     ...
+      #     # ...
       #   end
       #
-      #   Prefer:
       #
+      #   # good
       #   def fry(temperature: 300)
-      #     ...
+      #     # ...
       #   end
       class OptionHash < Cop
-        MSG = 'Prefer keyword arguments to options hashes.'.freeze
+        MSG = 'Prefer keyword arguments to options hashes.'
 
-        def on_args(node)
-          *_but_last, last_arg = *node
-
-          return unless last_arg && last_arg.optarg_type?
+        def_node_matcher :option_hash, <<~PATTERN
+          (args ... $(optarg [#suspicious_name? _] (hash)))
+        PATTERN
 
-          arg, default_value = *last_arg
-
-          return unless default_value.hash_type? && default_value.pairs.empty?
-          return unless suspicious_name?(arg)
+        def on_args(node)
+          return if super_used?(node)
+          return if allowlist.include?(node.parent.method_name.to_s)
 
-          add_offense(last_arg)
+          option_hash(node) do |options|
+            add_offense(options)
+          end
         end
 
         private
 
+        def allowlist
+          cop_config['Allowlist'] || []
+        end
+
         def suspicious_name?(arg_name)
           cop_config.key?('SuspiciousParamNames') &&
             cop_config['SuspiciousParamNames'].include?(arg_name.to_s)
         end
+
+        def super_used?(node)
+          node.parent.each_node(:zsuper).any?
+        end
       end
     end
   end

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for optional arguments to methods
-      # that do not come at the end of the argument list
+      # that do not come at the end of the argument list.
       #
       # @example
       #   # bad
@@ -19,13 +19,10 @@ module RuboCop
       #   end
       class OptionalArguments < Cop
         MSG = 'Optional arguments should appear at the end ' \
-              'of the argument list.'.freeze
+              'of the argument list.'
 
         def on_def(node)
-          _method, arguments, = *node
-          arguments = *arguments
-
-          each_misplaced_optional_arg(arguments) do |argument|
+          each_misplaced_optional_arg(node.arguments) do |argument|
             add_offense(argument)
           end
         end

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

@@ -27,17 +27,17 @@ module RuboCop
       #   # good - set name to 'Bozhidar', only if it's nil or false
       #   name ||= 'Bozhidar'
       class OrAssignment < Cop
-        MSG = 'Use the double pipe equals operator `||=` instead.'.freeze
+        MSG = 'Use the double pipe equals operator `||=` instead.'
 
-        def_node_matcher :ternary_assignment?, <<-PATTERN
+        def_node_matcher :ternary_assignment?, <<~PATTERN
           ({lvasgn ivasgn cvasgn gvasgn} _var
             (if
               ({lvar ivar cvar gvar} _var)
               ({lvar ivar cvar gvar} _var)
-              _))
+              $_))
         PATTERN
 
-        def_node_matcher :unless_assignment?, <<-PATTERN
+        def_node_matcher :unless_assignment?, <<~PATTERN
           (if
             ({lvar ivar cvar gvar} _var) nil?
             ({lvasgn ivasgn cvasgn gvasgn} _var
@@ -46,11 +46,14 @@ module RuboCop
 
         def on_if(node)
           return unless unless_assignment?(node)
+
           add_offense(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)
         end
 
@@ -58,8 +61,6 @@ module RuboCop
         alias on_cvasgn on_lvasgn
         alias on_gvasgn on_lvasgn
 
-        private
-
         def autocorrect(node)
           if ternary_assignment?(node)
             variable, default = take_variable_and_default_from_ternary(node)
@@ -68,18 +69,25 @@ module RuboCop
           end
 
           lambda do |corrector|
-            corrector.replace(node.source_range,
+            corrector.replace(node,
                               "#{variable} ||= #{default.source}")
           end
         end
 
+        private
+
         def take_variable_and_default_from_ternary(node)
           variable, if_statement = *node
           [variable, if_statement.else_branch]
         end
 
         def take_variable_and_default_from_unless(node)
-          variable, default = *node.if_branch
+          if node.if_branch
+            variable, default = *node.if_branch
+          else
+            variable, default = *node.else_branch
+          end
+
           [variable, default]
         end
       end

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

@@ -25,7 +25,7 @@ module RuboCop
       class ParallelAssignment < Cop
         include RescueNode
 
-        MSG = 'Do not use parallel assignment.'.freeze
+        MSG = 'Do not use parallel assignment.'
 
         def on_masgn(node)
           lhs, rhs = *node
@@ -38,6 +38,19 @@ module RuboCop
           add_offense(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)
+
+            corrector.replace(correction.correction_range,
+                              correction.correction)
+          end
+        end
+
         private
 
         def allowed_masign?(lhs_elements, rhs_elements)
@@ -68,19 +81,6 @@ module RuboCop
           node.block_type? || node.send_type?
         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)
-
-            corrector.replace(correction.correction_range,
-                              correction.correction)
-          end
-        end
-
         def assignment_corrector(node, order)
           _assignment, modifier = *node.parent
           if modifier_statement?(node.parent)
@@ -174,7 +174,7 @@ module RuboCop
 
         # An internal class for correcting parallel assignment
         class GenericCorrector
-          include AutocorrectAlignment
+          include Alignment
 
           attr_reader :config, :node
 
@@ -229,7 +229,7 @@ module RuboCop
             # 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 && node.parent.parent.def_type?
+            if node.parent.parent&.def_type?
               super + def_correction(rescue_result)
             else
               begin_correction(rescue_result)

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

@@ -5,6 +5,54 @@ module RuboCop
     module Style
       # This cop checks for the presence of superfluous parentheses around the
       # condition of if/unless/while/until.
+      #
+      # `AllowSafeAssignment` option for safe assignment.
+      # By safe assignment we mean putting parentheses around
+      # an assignment to indicate "I know I'm using an assignment
+      # as a condition. It's not a mistake."
+      #
+      # @example
+      #   # bad
+      #   x += 1 while (x < 10)
+      #   foo unless (bar || baz)
+      #
+      #   if (x > 10)
+      #   elsif (x < 3)
+      #   end
+      #
+      #   # good
+      #   x += 1 while x < 10
+      #   foo unless bar || baz
+      #
+      #   if x > 10
+      #   elsif x < 3
+      #   end
+      #
+      # @example AllowSafeAssignment: true (default)
+      #   # good
+      #   foo unless (bar = baz)
+      #
+      # @example AllowSafeAssignment: false
+      #   # bad
+      #   foo unless (bar = baz)
+      #
+      # @example AllowInMultilineConditions: false (default)
+      #   # bad
+      #   if (x > 10 &&
+      #      y > 10)
+      #   end
+      #
+      #   # good
+      #    if x > 10 &&
+      #       y > 10
+      #    end
+      #
+      # @example AllowInMultilineConditions: true
+      #   # good
+      #   if (x > 10 &&
+      #      y > 10)
+      #   end
+      #
       class ParenthesesAroundCondition < Cop
         include SafeAssignment
         include Parentheses
@@ -20,9 +68,13 @@ module RuboCop
         end
         alias on_until on_while
 
+        def autocorrect(node)
+          ParenthesesCorrector.correct(node)
+        end
+
         private
 
-        def_node_matcher :control_op_condition, <<-PATTERN
+        def_node_matcher :control_op_condition, <<~PATTERN
           (begin $_ ...)
         PATTERN
 
@@ -31,8 +83,7 @@ module RuboCop
 
           control_op_condition(cond) do |first_child|
             return if modifier_op?(first_child)
-            return if parens_required?(node.children.first)
-            return if safe_assignment?(cond) && safe_assignment_allowed?
+            return if parens_allowed?(cond)
 
             add_offense(cond)
           end
@@ -42,8 +93,7 @@ module RuboCop
           return false if node.if_type? && node.ternary?
           return true if node.rescue_type?
 
-          MODIFIER_NODES.include?(node.type) &&
-            node.modifier_form?
+          node.basic_conditional? && node.modifier_form?
         end
 
         def message(node)
@@ -51,6 +101,16 @@ module RuboCop
           article = kw == 'while' ? 'a' : 'an'
           "Don't use parentheses around the condition of #{article} `#{kw}`."
         end
+
+        def parens_allowed?(node)
+          parens_required?(node) ||
+            (safe_assignment?(node) && safe_assignment_allowed?) ||
+            (node.multiline? && allow_multiline_conditions?)
+        end
+
+        def allow_multiline_conditions?
+          cop_config['AllowInMultilineConditions']
+        end
       end
     end
   end

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

@@ -55,8 +55,6 @@ module RuboCop
           "`#{delimiters[0]}` and `#{delimiters[1]}`."
         end
 
-        private
-
         def autocorrect(node)
           type = type(node)
 
@@ -68,32 +66,61 @@ module RuboCop
           end
         end
 
+        private
+
         def on_percent_literal(node)
           type = type(node)
           return if uses_preferred_delimiter?(node, type) ||
-                    contains_preferred_delimiter?(node, type)
+                    contains_preferred_delimiter?(node, type) ||
+                    include_same_character_as_used_for_delimiter?(node, type)
 
           add_offense(node)
         end
 
+        def preferred_delimiters_for(type)
+          PreferredDelimiters
+            .new(type, @config, nil)
+            .delimiters
+        end
+
         def uses_preferred_delimiter?(node, type)
           preferred_delimiters_for(type)[0] == begin_source(node)[-1]
         end
 
         def contains_preferred_delimiter?(node, type)
-          preferred_delimiters = preferred_delimiters_for(type)
+          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])
+          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| preferred_delimiters.any? { |d| s.include?(d) } }
+            .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?
+          elsif node.respond_to?(:type) && (node.str_type? || node.sym_type?)
             node.source
           end
         end
+
+        def matchpairs(begin_delimiter)
+          {
+            '(' => %w[( )],
+            '[' => %w[[ ]],
+            '{' => %w[{ }],
+            '<' => %w[< >]
+          }.fetch(begin_delimiter, [begin_delimiter])
+        end
       end
     end
   end

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

@@ -4,18 +4,45 @@ module RuboCop
   module Cop
     module Style
       # This cop 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
+      #   # interpolation is needed.
+      #   # bad
+      #   %Q[Mix the foo into the baz.]
+      #   %Q(They all said: 'Hooray!')
+      #
+      #   # good
+      #   %q[Mix the foo into the baz]
+      #   %q(They all said: 'Hooray!')
+      #
+      # @example EnforcedStyle: upper_case_q
+      #   # The `upper_case_q` style requires the sole use of `%Q`.
+      #   # bad
+      #   %q/Mix the foo into the baz./
+      #   %q{They all said: 'Hooray!'}
+      #
+      #   # good
+      #   %Q/Mix the foo into the baz./
+      #   %Q{They all said: 'Hooray!'}
       class PercentQLiterals < Cop
         include PercentLiteral
         include ConfigurableEnforcedStyle
 
         LOWER_CASE_Q_MSG = 'Do not use `%Q` unless interpolation is ' \
-                           'needed.  Use `%q`.'.freeze
-        UPPER_CASE_Q_MSG = 'Use `%Q` instead of `%q`.'.freeze
+                           '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, corrected(node.source))
+          end
+        end
+
         private
 
         def on_percent_literal(node)
@@ -37,12 +64,6 @@ module RuboCop
           style == :lower_case_q ? LOWER_CASE_Q_MSG : UPPER_CASE_Q_MSG
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, corrected(node.source))
-          end
-        end
-
         def corrected(src)
           src.sub(src[1], src[1].swapcase)
         end

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

@@ -5,8 +5,15 @@ module RuboCop
     module Style
       # This cop looks for uses of Perl-style regexp match
       # backreferences like $1, $2, etc.
+      #
+      # @example
+      #   # bad
+      #   puts $1
+      #
+      #   # good
+      #   puts Regexp.last_match(1)
       class PerlBackrefs < Cop
-        MSG = 'Avoid the use of Perl-style backrefs.'.freeze
+        MSG = 'Avoid the use of Perl-style backrefs.'
 
         def on_nth_ref(node)
           add_offense(node)
@@ -17,10 +24,10 @@ module RuboCop
             backref, = *node
             parent_type = node.parent ? node.parent.type : nil
             if %i[dstr xstr regexp].include?(parent_type)
-              corrector.replace(node.source_range,
+              corrector.replace(node,
                                 "{Regexp.last_match(#{backref})}")
             else
-              corrector.replace(node.source_range,
+              corrector.replace(node,
                                 "Regexp.last_match(#{backref})")
             end
           end

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

@@ -8,10 +8,7 @@ module RuboCop
       # It is configurable to enforce the inverse, using `verbose` method
       # names also.
       #
-      # @example
-      #
-      #  # EnforcedStyle: short (default)
-      #
+      # @example EnforcedStyle: short (default)
       #  # bad
       #  Hash#has_key?
       #  Hash#has_value?
@@ -20,10 +17,7 @@ module RuboCop
       #  Hash#key?
       #  Hash#value?
       #
-      # @example
-      #
-      #  # EnforcedStyle: verbose
-      #
+      # @example EnforcedStyle: verbose
       #  # bad
       #  Hash#key?
       #  Hash#value?
@@ -34,7 +28,7 @@ module RuboCop
       class PreferredHashMethods < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use `Hash#%s` instead of `Hash#%s`.'.freeze
+        MSG = 'Use `Hash#%<prefer>s` instead of `Hash#%<current>s`.'
 
         OFFENDING_SELECTORS = {
           short: %i[has_key? has_value?],
@@ -47,6 +41,7 @@ module RuboCop
 
           add_offense(node, location: :selector)
         end
+        alias on_csend on_send
 
         def autocorrect(node)
           lambda do |corrector|
@@ -58,7 +53,9 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, proper_method_name(node.method_name), node.method_name)
+          format(MSG,
+                 prefer: proper_method_name(node.method_name),
+                 current: node.method_name)
         end
 
         def proper_method_name(method_name)

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

@@ -3,13 +3,21 @@
 module RuboCop
   module Cop
     module Style
-      # This cops checks for uses of Proc.new where Kernel#proc
+      # This cop checks for uses of Proc.new where Kernel#proc
       # would be more appropriate.
+      #
+      # @example
+      #   # bad
+      #   p = Proc.new { |n| puts n }
+      #
+      #   # good
+      #   p = proc { |n| puts n }
+      #
       class Proc < Cop
-        MSG = 'Use `proc` instead of `Proc.new`.'.freeze
+        MSG = 'Use `proc` instead of `Proc.new`.'
 
         def_node_matcher :proc_new?,
-                         '(block $(send (const nil? :Proc) :new) ...)'
+                         '(block $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|
@@ -18,7 +26,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          ->(corrector) { corrector.replace(node.source_range, 'proc') }
+          ->(corrector) { corrector.replace(node, 'proc') }
         end
       end
     end

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

@@ -13,10 +13,7 @@ module RuboCop
       # will also suggest constructing error objects when the exception is
       # passed multiple arguments.
       #
-      # @example
-      #
-      #   # EnforcedStyle: exploded
-      #
+      # @example EnforcedStyle: exploded (default)
       #   # bad
       #   raise StandardError.new("message")
       #
@@ -26,10 +23,7 @@ module RuboCop
       #   raise MyCustomError.new(arg1, arg2, arg3)
       #   raise MyKwArgError.new(key1: val1, key2: val2)
       #
-      # @example
-      #
-      #   # EnforcedStyle: compact
-      #
+      # @example EnforcedStyle: compact
       #   # bad
       #   raise StandardError, "message"
       #   raise RuntimeError, arg1, arg2, arg3
@@ -42,9 +36,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         EXPLODED_MSG = 'Provide an exception class and message ' \
-          'as arguments to `%s`.'.freeze
+          'as arguments to `%<method>s`.'
         COMPACT_MSG = 'Provide an exception object ' \
-          'as an argument to `%s`.'.freeze
+          'as an argument to `%<method>s`.'
 
         def on_send(node)
           return unless node.command?(:raise) || node.command?(:fail)
@@ -57,8 +51,6 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           replacement = if style == :compact
                           correction_exploded_to_compact(node)
@@ -66,18 +58,22 @@ module RuboCop
                           correction_compact_to_exploded(node)
                         end
 
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
+        private
+
         def correction_compact_to_exploded(node)
           exception_node, _new, message_node = *node.first_argument
 
-          message = message_node && message_node.source
+          arguments =
+            [exception_node, message_node].compact.map(&:source).join(', ')
 
-          correction = exception_node.const_name.to_s
-          correction = "#{correction}, #{message}" if message
-
-          "#{node.method_name} #{correction}"
+          if node.parent && requires_parens?(node.parent)
+            "#{node.method_name}(#{arguments})"
+          else
+            "#{node.method_name} #{arguments}"
+          end
         end
 
         def correction_exploded_to_compact(node)
@@ -85,7 +81,12 @@ module RuboCop
           return node.source if message_nodes.size > 1
 
           argument = message_nodes.first.source
-          "#{node.method_name} #{exception_node.const_name}.new(#{argument})"
+
+          if node.parent && requires_parens?(node.parent)
+            "#{node.method_name}(#{exception_node.const_name}.new(#{argument}))"
+          else
+            "#{node.method_name} #{exception_node.const_name}.new(#{argument})"
+          end
         end
 
         def check_compact(node)
@@ -126,11 +127,16 @@ module RuboCop
           arg.hash_type? || arg.splat_type?
         end
 
+        def requires_parens?(parent)
+          parent.and_type? || parent.or_type? ||
+            parent.if_type? && parent.ternary?
+        end
+
         def message(node)
           if style == :compact
-            format(COMPACT_MSG, node.method_name)
+            format(COMPACT_MSG, method: node.method_name)
           else
-            format(EXPLODED_MSG, node.method_name)
+            format(EXPLODED_MSG, method: node.method_name)
           end
         end
       end