rubocop 0.78.0 → 1.13.0

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

@@ -25,37 +25,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

@@ -13,21 +13,21 @@ module RuboCop
       #   # good
       #   p = proc { |n| puts n }
       #
-      class Proc < Cop
+      class Proc < Base
+        extend AutoCorrector
+
         MSG = 'Use `proc` instead of `Proc.new`.'
 
-        def_node_matcher :proc_new?,
-                         '(block $(send (const nil? :Proc) :new) ...)'
+        # @!method proc_new?(node)
+        def_node_matcher :proc_new?, '(block $(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
       end
     end
   end

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

@@ -13,32 +13,40 @@ module RuboCop
       # will also suggest constructing error objects when the exception is
       # passed multiple arguments.
       #
+      # The exploded style has an `AllowedCompactTypes` configuration
+      # option that takes an Array of exception name Strings.
+      #
       # @example EnforcedStyle: exploded (default)
       #   # bad
-      #   raise StandardError.new("message")
+      #   raise StandardError.new('message')
       #
       #   # good
-      #   raise StandardError, "message"
-      #   fail "message"
+      #   raise StandardError, 'message'
+      #   fail 'message'
       #   raise MyCustomError.new(arg1, arg2, arg3)
       #   raise MyKwArgError.new(key1: val1, key2: val2)
       #
+      #   # With `AllowedCompactTypes` set to ['MyWrappedError']
+      #   raise MyWrappedError.new(obj)
+      #   raise MyWrappedError.new(obj), 'message'
+      #
       # @example EnforcedStyle: compact
       #   # bad
-      #   raise StandardError, "message"
+      #   raise StandardError, 'message'
       #   raise RuntimeError, arg1, arg2, arg3
       #
       #   # good
-      #   raise StandardError.new("message")
+      #   raise StandardError.new('message')
       #   raise MyCustomError.new(arg1, arg2, arg3)
-      #   fail "message"
-      class RaiseArgs < Cop
+      #   fail 'message'
+      class RaiseArgs < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        EXPLODED_MSG = 'Provide an exception class and message ' \
-          'as arguments to `%<method>s`.'
-        COMPACT_MSG = 'Provide an exception object ' \
-          'as an argument to `%<method>s`.'
+        EXPLODED_MSG = 'Provide an exception class and message as arguments to `%<method>s`.'
+        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)
@@ -51,23 +59,12 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          replacement = if style == :compact
-                          correction_exploded_to_compact(node)
-                        else
-                          correction_compact_to_exploded(node)
-                        end
-
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
-        end
-
         private
 
         def correction_compact_to_exploded(node)
           exception_node, _new, message_node = *node.first_argument
 
-          arguments =
-            [exception_node, message_node].compact.map(&:source).join(', ')
+          arguments = [exception_node, message_node].compact.map(&:source).join(', ')
 
           if node.parent && requires_parens?(node.parent)
             "#{node.method_name}(#{arguments})"
@@ -81,17 +78,21 @@ 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
 
           if node.parent && requires_parens?(node.parent)
-            "#{node.method_name}(#{exception_node.const_name}.new(#{argument}))"
+            "#{node.method_name}(#{exception_class}.new(#{argument}))"
           else
-            "#{node.method_name} #{exception_node.const_name}.new(#{argument})"
+            "#{node.method_name} #{exception_class}.new(#{argument})"
           end
         end
 
         def check_compact(node)
           if node.arguments.size > 1
-            add_offense(node) do
+            add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
+              replacement = correction_exploded_to_compact(node)
+
+              corrector.replace(node, replacement)
               opposite_style_detected
             end
           else
@@ -105,10 +106,14 @@ 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)
 
-          add_offense(node) do
+          return if allowed_non_exploded_type?(first_arg)
+
+          add_offense(node, message: format(EXPLODED_MSG, method: node.method_name)) do |corrector|
+            replacement = correction_compact_to_exploded(node)
+
+            corrector.replace(node, replacement)
             opposite_style_detected
           end
         end
@@ -127,17 +132,14 @@ module RuboCop
           arg.hash_type? || arg.splat_type?
         end
 
-        def requires_parens?(parent)
-          parent.and_type? || parent.or_type? ||
-            parent.if_type? && parent.ternary?
+        def allowed_non_exploded_type?(arg)
+          type = arg.receiver.const_name
+
+          Array(cop_config['AllowedCompactTypes']).include?(type)
         end
 
-        def message(node)
-          if style == :compact
-            format(COMPACT_MSG, method: node.method_name)
-          else
-            format(EXPLODED_MSG, method: node.method_name)
-          end
+        def requires_parens?(parent)
+          parent.and_type? || parent.or_type? || parent.if_type? && parent.ternary?
         end
       end
     end

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

@@ -23,68 +23,68 @@ module RuboCop
       #   # good
       #   rand(1..6)
       #   rand(1...7)
-      class RandomWithOffset < Cop
-        MSG = 'Prefer ranges when generating random numbers instead of ' \
-          'integers with offsets.'
+      class RandomWithOffset < Base
+        extend AutoCorrector
 
+        MSG = 'Prefer ranges when generating random numbers instead of integers with offsets.'
+        RESTRICT_ON_SEND = %i[+ - succ pred next].freeze
+
+        # @!method integer_op_rand?(node)
         def_node_matcher :integer_op_rand?, <<~PATTERN
           (send
             int {:+ :-}
             (send
-              {nil? (const nil? :Random) (const nil? :Kernel)}
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
-              {int irange erange}))
+              {int (irange int int) (erange int int)}))
         PATTERN
 
+        # @!method rand_op_integer?(node)
         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})
+              {int (irange int int) (erange int int)})
             {:+ :-}
             int)
         PATTERN
 
+        # @!method rand_modified?(node)
         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})
+              {int (irange int int) (erange int int)})
             {:succ :pred :next})
         PATTERN
 
         def on_send(node)
-          return unless integer_op_rand?(node) ||
-                        rand_op_integer?(node) ||
-                        rand_modified?(node)
-
-          add_offense(node)
-        end
+          return unless node.receiver
+          return unless integer_op_rand?(node) || rand_op_integer?(node) || rand_modified?(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if integer_op_rand?(node)
-              corrector.replace(node.source_range,
-                                corrected_integer_op_rand(node))
-            elsif rand_op_integer?(node)
-              corrector.replace(node.source_range,
-                                corrected_rand_op_integer(node))
-            elsif rand_modified?(node)
-              corrector.replace(node.source_range,
-                                corrected_rand_modified(node))
-            end
-          end
+          add_offense(node) { |corrector| autocorrect(corrector, node) }
         end
 
         private
 
+        # @!method random_call(node)
         def_node_matcher :random_call, <<~PATTERN
           {(send (send $_ _ $_) ...)
            (send _ _ (send $_ _ $_))}
         PATTERN
 
+        def autocorrect(corrector, node)
+          if integer_op_rand?(node)
+            corrector.replace(node, corrected_integer_op_rand(node))
+          elsif rand_op_integer?(node)
+            corrector.replace(node, corrected_rand_op_integer(node))
+          elsif rand_modified?(node)
+            corrector.replace(node, corrected_rand_modified(node))
+          end
+        end
+
         def corrected_integer_op_rand(node)
           random_call(node) do |prefix_node, random_node|
             prefix = prefix_from_prefix_node(prefix_node)
@@ -128,14 +128,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)
@@ -149,6 +143,7 @@ module RuboCop
           end
         end
 
+        # @!method to_int(node)
         def_node_matcher :to_int, <<~PATTERN
           (int $_)
         PATTERN

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

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a redundant argument passed to certain methods.
+      #
+      # Limitations:
+      #
+      # 1. This cop matches for method names only and hence cannot tell apart
+      #    methods with same name in different classes.
+      # 2. This cop is limited to methods with single parameter.
+      # 3. This cop is unsafe if certain special global variables (e.g. `$;`, `$/`) are set.
+      #    That depends on the nature of the target methods, of course.
+      #
+      # Method names and their redundant arguments can be configured like this:
+      #
+      # Methods:
+      #   join: ''
+      #   split: ' '
+      #   chomp: "\n"
+      #   chomp!: "\n"
+      #   foo: 2
+      #
+      # @example
+      #   # bad
+      #   array.join('')
+      #   [1, 2, 3].join("")
+      #   string.split(" ")
+      #   "first\nsecond".split(" ")
+      #   string.chomp("\n")
+      #   string.chomp!("\n")
+      #   A.foo(2)
+      #
+      #   # good
+      #   array.join
+      #   [1, 2, 3].join
+      #   string.split
+      #   "first second".split
+      #   string.chomp
+      #   string.chomp!
+      #   A.foo
+      class RedundantArgument < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Argument %<arg>s is redundant because it is implied by default.'
+
+        def on_send(node)
+          return if node.receiver.nil?
+          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))
+          end
+        end
+
+        private
+
+        def redundant_argument?(node)
+          redundant_argument = redundant_arg_for_method(node.method_name.to_s)
+          return false if redundant_argument.nil?
+
+          node.arguments.first == redundant_argument
+        end
+
+        def redundant_arg_for_method(method_name)
+          arg = cop_config['Methods'].fetch(method_name) { return }
+
+          @mem ||= {}
+          @mem[method_name] ||= parse(arg.inspect).ast
+        end
+
+        def argument_range(node)
+          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)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# 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 < Base
+        extend AutoCorrector
+
+        MSG = 'Redundant assignment before returning detected.'
+
+        # @!method redundant_assignment?(node)
+        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
+
+        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 { |child_node| check_branch(child_node) }
+        end
+
+        def check_ensure_node(node)
+          check_branch(node.body)
+        end
+
+        def check_begin_node(node)
+          if (assignment = redundant_assignment?(node))
+            add_offense(assignment) do |corrector|
+              expression = assignment.children[1]
+              corrector.replace(assignment, expression.source)
+              corrector.remove(assignment.right_sibling)
+            end
+          else
+            last_expr = node.children.last
+            check_branch(last_expr)
+          end
+        end
+      end
+    end
+  end
+end