rubocop 0.90.0 → 0.93.1

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

@@ -22,7 +22,7 @@ module RuboCop
       #   alive_threads.map do |t|
       #     t.object_id
       #   end
-      class MultilineBlockChain < Cop
+      class MultilineBlockChain < Base
         include RangeHelp
 
         MSG = 'Avoid multi-line chains of blocks.'
@@ -36,7 +36,7 @@ module RuboCop
             range = range_between(receiver.loc.end.begin_pos,
                                   node.send_node.source_range.end_pos)
 
-            add_offense(nil, location: range)
+            add_offense(range)
 
             # Done. If there are more blocks in the chain, they will be
             # found by subsequent calls to on_block.

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

@@ -5,6 +5,9 @@ module RuboCop
     module Style
       # This cop checks for multi-line ternary op expressions.
       #
+      # NOTE: `return if ... else ... end` is syntax error. If `return` is used before
+      # multiline ternary operator expression, it cannot be auto-corrected.
+      #
       # @example
       #   # bad
       #   a = cond ?
@@ -29,9 +32,13 @@ module RuboCop
               'use `if` or `unless` instead.'
 
         def on_if(node)
-          return unless node.ternary? && node.multiline?
+          return unless offense?(node)
 
           add_offense(node) do |corrector|
+            # `return if ... else ... end` is syntax error. If `return` is used before
+            # multiline ternary operator expression, it cannot be auto-corrected.
+            next unless offense?(node) && !node.parent.return_type?
+
             corrector.replace(node, <<~RUBY.chop)
               if #{node.condition.source}
                 #{node.if_branch.source}
@@ -41,6 +48,12 @@ module RuboCop
             RUBY
           end
         end
+
+        private
+
+        def offense?(node)
+          node.ternary? && node.multiline?
+        end
       end
     end
   end

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

@@ -58,6 +58,7 @@ module RuboCop
         private
 
         def require_then?(when_node)
+          return true if when_node.conditions.count >= 2
           return false unless when_node.body
 
           when_node.loc.line == when_node.body.loc.line

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

@@ -49,6 +49,8 @@ module RuboCop
         end
 
         def remove_parentheses(source)
+          return source unless source.start_with?('(')
+
           source.gsub(/\A\(/, '').gsub(/\)\z/, '')
         end
       end

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

@@ -35,6 +35,8 @@ module RuboCop
         PREDICATE_MSG = 'Prefer the use of the `nil?` predicate.'
         EXPLICIT_MSG = 'Prefer the use of the `==` comparison.'
 
+        RESTRICT_ON_SEND = %i[== === nil?].freeze
+
         def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
         def_node_matcher :nil_check?, '(send _ :nil?)'
 

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

@@ -41,6 +41,8 @@ module RuboCop
       class NonNilCheck < Base
         extend AutoCorrector
 
+        RESTRICT_ON_SEND = %i[!= nil? !].freeze
+
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
         def_node_matcher :nil_check?, '(send _ :nil?)'

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

@@ -18,6 +18,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Use `!` instead of `not`.'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         OPPOSITE_METHODS = {
           :== => :!=,

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

@@ -54,11 +54,9 @@ module RuboCop
           'negative?' => '<'
         }.freeze
 
-        COMPARISON_METHODS = %i[== > < positive? negative? zero?].to_set.freeze
+        RESTRICT_ON_SEND = %i[== > < positive? negative? zero?].freeze
 
         def on_send(node)
-          return unless COMPARISON_METHODS.include?(node.method_name)
-
           numeric, replacement = check(node)
           return unless numeric
 

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

@@ -89,7 +89,9 @@ module RuboCop
         end
 
         def else_branch_to_multiline(else_branch, indentation)
-          if else_branch.if_type? && else_branch.elsif?
+          if else_branch.nil?
+            'end'
+          elsif else_branch.if_type? && else_branch.elsif?
             multiline_replacement(else_branch, indentation)
           else
             <<~RUBY.chomp

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for places where keyword arguments can be used instead of
-      # boolean arguments when defining methods.
+      # boolean arguments when defining methods. `respond_to_missing?` method is allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad
@@ -23,11 +24,21 @@ module RuboCop
       #     puts bar
       #   end
       #
+      # @example AllowedMethods: ['some_method']
+      #   # good
+      #   def some_method(bar = false)
+      #     puts bar
+      #   end
+      #
       class OptionalBooleanParameter < Base
+        include AllowedMethods
+
         MSG = 'Use keyword arguments when defining method with boolean argument.'
         BOOLEAN_TYPES = %i[true false].freeze
 
         def on_def(node)
+          return if allowed_method?(node.method_name)
+
           node.arguments.each do |arg|
             next unless arg.optarg_type?
 

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

@@ -36,6 +36,8 @@ module RuboCop
           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)
 

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

@@ -41,6 +41,8 @@ module RuboCop
         COMPACT_MSG = 'Provide an exception object ' \
           'as an argument to `%<method>s`.'
 
+        RESTRICT_ON_SEND = %i[raise fail].freeze
+
         def on_send(node)
           return unless node.command?(:raise) || node.command?(:fail)
 
@@ -82,8 +84,6 @@ module RuboCop
 
         def check_compact(node)
           if node.arguments.size > 1
-            return unless opposite_style_detected
-
             add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
               replacement = correction_exploded_to_compact(node)
 
@@ -101,7 +101,6 @@ module RuboCop
 
           return unless first_arg.send_type? && first_arg.method?(:new)
           return if acceptable_exploded_args?(first_arg.arguments)
-          return unless opposite_style_detected
 
           add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
             replacement = correction_compact_to_exploded(node)

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

@@ -28,6 +28,7 @@ module RuboCop
 
         MSG = 'Prefer ranges when generating random numbers instead of ' \
           'integers with offsets.'
+        RESTRICT_ON_SEND = %i[+ - succ pred next].freeze
 
         def_node_matcher :integer_op_rand?, <<~PATTERN
           (send
@@ -35,7 +36,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange}))
+              {int (irange int int) (erange int int)}))
         PATTERN
 
         def_node_matcher :rand_op_integer?, <<~PATTERN
@@ -43,7 +44,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange})
+              {int (irange int int) (erange int int)})
             {:+ :-}
             int)
         PATTERN
@@ -53,7 +54,7 @@ module RuboCop
             (send
               {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange})
+              {int (irange int int) (erange int int)})
             {:succ :pred :next})
         PATTERN
 

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

@@ -94,21 +94,13 @@ module RuboCop
             add_offense(assignment) do |corrector|
               expression = assignment.children[1]
               corrector.replace(assignment, expression.source)
-              corrector.remove(right_sibling_of(assignment))
+              corrector.remove(assignment.right_sibling)
             end
           else
             last_expr = node.children.last
             check_branch(last_expr)
           end
         end
-
-        def right_sibling_of(node)
-          siblings_of(node)[node.sibling_index + 1]
-        end
-
-        def siblings_of(node)
-          node.parent.children
-        end
       end
     end
   end

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

@@ -28,6 +28,14 @@ module RuboCop
       #   end
       #
       #   # bad
+      #   begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   do_something
+      #
+      #   # bad
       #   # When using Ruby 2.5 or later.
       #   do_something do
       #     begin
@@ -60,7 +68,9 @@ module RuboCop
         MSG = 'Redundant `begin` block detected.'
 
         def on_def(node)
-          check(node)
+          return unless node.body&.kwbegin_type?
+
+          register_offense(node.body)
         end
         alias on_defs on_def
 
@@ -69,20 +79,38 @@ module RuboCop
 
           return if node.send_node.lambda_literal?
           return if node.braces?
+          return unless node.body&.kwbegin_type?
 
-          check(node)
+          register_offense(node.body)
         end
 
-        private
+        def on_kwbegin(node)
+          return if contain_rescue_or_ensure?(node) || valid_context_using_only_begin?(node)
 
-        def check(node)
-          return unless node.body&.kwbegin_type?
+          register_offense(node)
+        end
+
+        private
 
-          add_offense(node.body.loc.begin) do |corrector|
-            corrector.remove(node.body.loc.begin)
-            corrector.remove(node.body.loc.end)
+        def register_offense(node)
+          add_offense(node.loc.begin) do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
           end
         end
+
+        def contain_rescue_or_ensure?(node)
+          first_child = node.children.first
+
+          first_child.rescue_type? || first_child.ensure_type?
+        end
+
+        def valid_context_using_only_begin?(node)
+          parent = node.parent
+
+          node.each_ancestor.any?(&:assignment?) || parent&.post_condition_loop? ||
+            parent&.send_type? || parent&.operator_keyword?
+        end
       end
     end
   end

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

@@ -75,7 +75,7 @@ module RuboCop
         def offense?(node)
           condition, if_branch, else_branch = *node
 
-          return false if use_if_branch?(else_branch)
+          return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           condition == if_branch && !node.elsif? && (
             node.ternary? ||
@@ -88,6 +88,10 @@ module RuboCop
           else_branch&.if_type?
         end
 
+        def use_hash_key_assignment?(else_branch)
+          else_branch&.send_type? && else_branch&.method?(:[]=)
+        end
+
         def else_source(else_branch)
           if require_parentheses?(else_branch)
             "(#{else_branch.source})"

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

@@ -24,8 +24,9 @@ module RuboCop
       #
       #   # good
       #   x != y
-      class RedundantConditional < Cop
+      class RedundantConditional < Base
         include Alignment
+        extend AutoCorrector
 
         operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
         COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
@@ -36,11 +37,9 @@ module RuboCop
         def on_if(node)
           return unless offense?(node)
 
-          add_offense(node)
-        end
+          message = message(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement_condition(node))
           end
         end

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

@@ -23,13 +23,11 @@ module RuboCop
         MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
                 'just the message.'
 
-        RAISE_METHODS = %i[raise fail].freeze
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
         # `raise RuntimeError.new('message')` to `raise 'message'`.
         def on_send(node)
-          return unless RAISE_METHODS.include?(node.method_name)
-
           fix_exploded(node) || fix_compact(node)
         end
 

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

@@ -28,6 +28,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant `.rb` file extension detected.'
+        RESTRICT_ON_SEND = %i[require require_relative].freeze
 
         def_node_matcher :require_call?, <<~PATTERN
           (send nil? {:require :require_relative} $str_type?)

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

@@ -17,9 +17,10 @@ module RuboCop
 
         MSG = 'Do not freeze immutable objects, as freezing them has no ' \
               'effect.'
+        RESTRICT_ON_SEND = %i[freeze].freeze
 
         def on_send(node)
-          return unless node.receiver && node.method?(:freeze) &&
+          return unless node.receiver &&
                         (immutable_literal?(node.receiver) ||
                          operation_produces_immutable_object?(node.receiver))
 

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

@@ -51,7 +51,12 @@ module RuboCop
         end
 
         def single_variable_interpolation?(node)
-          node.children.one? && variable_interpolation?(node.children.first)
+          return false unless node.children.one?
+
+          first_child = node.children.first
+
+          variable_interpolation?(first_child) ||
+            first_child.send_type? && !first_child.operator_method?
         end
 
         def interpolation?(node)

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

@@ -26,9 +26,7 @@ module RuboCop
                          '^^(block (send _ _ equal?(%0) ...) ...)'
 
         def on_begin(node)
-          return if !parentheses?(node) || parens_allowed?(node)
-          return if node.parent && (node.parent.while_post_type? ||
-                                    node.parent.until_post_type?)
+          return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
 
           check(node)
         end
@@ -42,6 +40,13 @@ module RuboCop
             allowed_expression?(node)
         end
 
+        def ignore_syntax?(node)
+          return false unless (parent = node.parent)
+
+          parent.while_post_type? || parent.until_post_type? ||
+            like_method_argument_parentheses?(parent)
+        end
+
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
@@ -68,6 +73,10 @@ module RuboCop
           !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
         end
 
+        def like_method_argument_parentheses?(node)
+          node.send_type? && node.arguments.size == 1 && !node.arithmetic_operation?
+        end
+
         def empty_parentheses?(node)
           # Don't flag `()`
           node.children.empty?
@@ -166,10 +175,9 @@ module RuboCop
         def raised_to_power_negative_numeric?(begin_node, node)
           return false unless node.numeric_type?
 
-          siblings = begin_node.parent&.children
-          return false if siblings.nil?
+          next_sibling = begin_node.right_sibling
+          return false unless next_sibling
 
-          next_sibling = siblings[begin_node.sibling_index + 1]
           base_value = node.children.first
 
           base_value.negative? && next_sibling == :**