rubocop 0.86.0 → 0.89.1

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

@@ -14,7 +14,7 @@ module RuboCop
       #   # good
       #   a = 'a'
       #   foo if ['a', 'b', 'c'].include?(a)
-      class MultipleComparison < Cop
+      class MultipleComparison < Base
         MSG = 'Avoid comparing a variable with multiple items ' \
           'in a conditional, use `Array#include?` instead.'
 

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

@@ -50,9 +50,10 @@ module RuboCop
       #       puts 1
       #     end
       #   end.freeze
-      class MutableConstant < Cop
+      class MutableConstant < Base
         include FrozenStringLiteral
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Freeze mutable objects assigned to constants.'
 
@@ -69,23 +70,6 @@ module RuboCop
           on_assignment(value)
         end
 
-        def autocorrect(node)
-          expr = node.source_range
-
-          lambda do |corrector|
-            splat_value = splat_value(node)
-            if splat_value
-              correct_splat_expansion(corrector, expr, splat_value)
-            elsif node.array_type? && !node.bracketed?
-              corrector.wrap(expr, '[', ']')
-            elsif requires_parentheses?(node)
-              corrector.wrap(expr, '(', ')')
-            end
-
-            corrector.insert_after(expr, '.freeze')
-          end
-        end
-
         private
 
         def on_assignment(value)
@@ -101,7 +85,9 @@ module RuboCop
           return if operation_produces_immutable_object?(value)
           return if frozen_string_literal?(value)
 
-          add_offense(value)
+          add_offense(value) do |corrector|
+            autocorrect(corrector, value)
+          end
         end
 
         def check(value)
@@ -112,7 +98,24 @@ module RuboCop
           return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
                     frozen_string_literals_enabled?
 
-          add_offense(value)
+          add_offense(value) do |corrector|
+            autocorrect(corrector, value)
+          end
+        end
+
+        def autocorrect(corrector, node)
+          expr = node.source_range
+
+          splat_value = splat_value(node)
+          if splat_value
+            correct_splat_expansion(corrector, expr, splat_value)
+          elsif node.array_type? && !node.bracketed?
+            corrector.wrap(expr, '[', ']')
+          elsif requires_parentheses?(node)
+            corrector.wrap(expr, '(', ')')
+          end
+
+          corrector.insert_after(expr, '.freeze')
         end
 
         def mutable_literal?(value)
@@ -150,14 +153,14 @@ module RuboCop
         def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
           {
             (const _ _)
-            (send (const nil? :Struct) :new ...)
-            (block (send (const nil? :Struct) :new ...) ...)
+            (send (const {nil? cbase} :Struct) :new ...)
+            (block (send (const {nil? cbase} :Struct) :new ...) ...)
             (send _ :freeze)
             (send {float int} {:+ :- :* :** :/ :% :<<} _)
             (send _ {:+ :- :* :** :/ :%} {float int})
             (send _ {:== :=== :!= :<= :>= :< :>} _)
-            (send (const nil? :ENV) :[] _)
-            (or (send (const nil? :ENV) :[] _) _)
+            (send (const {nil? cbase} :ENV) :[] _)
+            (or (send (const {nil? cbase} :ENV) :[] _) _)
             (send _ {:count :length :size} ...)
             (block (send _ {:count :length :size} ...) ...)
           }

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

@@ -14,6 +14,7 @@ module RuboCop
       #   method1(method2 arg)
       class NestedParenthesizedCalls < Cop
         include RangeHelp
+        include AllowedMethods
 
         MSG = 'Add parentheses to nested method call `%<source>s`.'
 
@@ -36,7 +37,9 @@ module RuboCop
 
           leading_space =
             range_with_surrounding_space(range: first_arg.begin,
-                                         side: :left)
+                                         side: :left,
+                                         whitespace: true,
+                                         continuations: true)
 
           lambda do |corrector|
             corrector.replace(leading_space, '(')
@@ -54,13 +57,9 @@ module RuboCop
 
         def allowed?(send_node)
           send_node.parent.arguments.one? &&
-            allowed_methods.include?(send_node.method_name.to_s) &&
+            allowed_method?(send_node.method_name) &&
             send_node.arguments.one?
         end
-
-        def allowed_methods
-          cop_config['AllowedMethods'] || []
-        end
       end
     end
   end

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

@@ -53,16 +53,19 @@ module RuboCop
           'negative?' => '<'
         }.freeze
 
+        COMPARISON_METHODS = %i[== > < positive? negative? zero?].to_set.freeze
+
         def on_send(node)
+          return unless COMPARISON_METHODS.include?(node.method_name)
+
+          numeric, replacement = check(node)
+          return unless numeric
+
           return if ignored_method?(node.method_name) ||
                     node.each_ancestor(:send, :block).any? do |ancestor|
                       ignored_method?(ancestor.method_name)
                     end
 
-          numeric, replacement = check(node)
-
-          return unless numeric
-
           add_offense(node,
                       message: format(MSG,
                                       prefer: replacement,

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where keyword arguments can be used instead of
+      # boolean arguments when defining methods.
+      #
+      # @example
+      #   # bad
+      #   def some_method(bar = false)
+      #     puts bar
+      #   end
+      #
+      #   # bad - common hack before keyword args were introduced
+      #   def some_method(options = {})
+      #     bar = options.fetch(:bar, false)
+      #     puts bar
+      #   end
+      #
+      #   # good
+      #   def some_method(bar: false)
+      #     puts bar
+      #   end
+      #
+      class OptionalBooleanParameter < Base
+        MSG = 'Use keyword arguments when defining method with boolean argument.'
+        BOOLEAN_TYPES = %i[true false].freeze
+
+        def on_def(node)
+          node.arguments.each do |arg|
+            next unless arg.optarg_type?
+
+            _name, value = *arg
+            add_offense(arg) if BOOLEAN_TYPES.include?(value.type)
+          end
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

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

@@ -30,7 +30,7 @@ module RuboCop
         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)
@@ -42,7 +42,7 @@ module RuboCop
           lambda do |corrector|
             left, right = *node
             left_elements = *left
-            right_elements = [*right].compact
+            right_elements = Array(right).compact
             order = find_valid_order(left_elements, right_elements)
             correction = assignment_corrector(node, order)
 
@@ -69,7 +69,7 @@ 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? ||
@@ -131,8 +131,8 @@ module RuboCop
             @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)

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

@@ -107,7 +107,7 @@ module RuboCop
 
         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/proc.rb

@@ -17,7 +17,7 @@ module RuboCop
         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|

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

@@ -31,7 +31,7 @@ module RuboCop
           (send
             int {:+ :-}
             (send
-              {nil? (const nil? :Random) (const nil? :Kernel)}
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
               {int irange erange}))
         PATTERN
@@ -39,7 +39,7 @@ module RuboCop
         def_node_matcher :rand_op_integer?, <<~PATTERN
           (send
             (send
-              {nil? (const nil? :Random) (const nil? :Kernel)}
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
               {int irange erange})
             {:+ :-}
@@ -49,13 +49,14 @@ module RuboCop
         def_node_matcher :rand_modified?, <<~PATTERN
           (send
             (send
-              {nil? (const nil? :Random) (const nil? :Kernel)}
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
               {int irange erange})
             {:succ :pred :next})
         PATTERN
 
         def on_send(node)
+          return unless node.receiver
           return unless integer_op_rand?(node) ||
                         rand_op_integer?(node) ||
                         rand_modified?(node)
@@ -128,14 +129,8 @@ module RuboCop
           end
         end
 
-        def_node_matcher :namespace, <<~PATTERN
-          {$nil? (const nil? $_)}
-        PATTERN
-
         def prefix_from_prefix_node(node)
-          namespace(node) do |namespace|
-            [namespace, 'rand'].compact.join('.')
-          end
+          [node&.source, 'rand'].compact.join('.')
         end
 
         def boundaries_from_random_node(random_node)

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant assignment before returning.
+      #
+      # @example
+      #   # bad
+      #   def test
+      #     x = foo
+      #     x
+      #   end
+      #
+      #   # bad
+      #   def test
+      #     if x
+      #       z = foo
+      #       z
+      #     elsif y
+      #       z = bar
+      #       z
+      #     end
+      #   end
+      #
+      #   # good
+      #   def test
+      #     foo
+      #   end
+      #
+      #   # good
+      #   def test
+      #     if x
+      #       foo
+      #     elsif y
+      #       bar
+      #     end
+      #   end
+      #
+      class RedundantAssignment < Cop
+        MSG = 'Redundant assignment before returning detected.'
+
+        def_node_matcher :redundant_assignment?, <<~PATTERN
+          (... $(lvasgn _name _expression) (lvar _name))
+        PATTERN
+
+        def on_def(node)
+          check_branch(node.body)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            expression = node.children[1]
+            corrector.replace(node, expression.source)
+            corrector.remove(right_sibling_of(node))
+          end
+        end
+
+        private
+
+        def check_branch(node)
+          return unless node
+
+          case node.type
+          when :case   then check_case_node(node)
+          when :if     then check_if_node(node)
+          when :rescue, :resbody
+            check_rescue_node(node)
+          when :ensure then check_ensure_node(node)
+          when :begin, :kwbegin
+            check_begin_node(node)
+          end
+        end
+
+        def check_case_node(node)
+          node.when_branches.each { |when_node| check_branch(when_node.body) }
+          check_branch(node.else_branch)
+        end
+
+        def check_if_node(node)
+          return if node.modifier_form? || node.ternary?
+
+          check_branch(node.if_branch)
+          check_branch(node.else_branch)
+        end
+
+        def check_rescue_node(node)
+          node.child_nodes.each do |child_node|
+            check_branch(child_node)
+          end
+        end
+
+        def check_ensure_node(node)
+          check_branch(node.body)
+        end
+
+        def check_begin_node(node)
+          if (assignment = redundant_assignment?(node))
+            add_offense(assignment)
+          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
+end

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

@@ -90,10 +90,10 @@ module RuboCop
         end
 
         def else_source(else_branch)
-          if else_branch.basic_conditional? &&
-             else_branch.modifier_form? ||
-             else_branch.range_type?
+          if require_parentheses?(else_branch)
             "(#{else_branch.source})"
+          elsif without_argument_parentheses_method?(else_branch)
+            "#{else_branch.method_name}(#{else_branch.arguments.map(&:source).join(', ')})"
           else
             else_branch.source
           end
@@ -118,6 +118,18 @@ module RuboCop
 
           corrector.wrap(node.else_branch, '(', ')')
         end
+
+        def require_parentheses?(node)
+          node.basic_conditional? &&
+            node.modifier_form? ||
+            node.range_type? ||
+            node.rescue_type? ||
+            node.respond_to?(:semantic_operator?) && node.semantic_operator?
+        end
+
+        def without_argument_parentheses_method?(node)
+          node.send_type? && !node.arguments.empty? && !node.parenthesized?
+        end
       end
     end
   end