rubocop 0.70.0 → 1.6.1

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for uses of Perl-style regexp match
-      # backreferences like $1, $2, etc.
+      # backreferences and their English versions like
+      # $1, $2, $&, &+, $MATCH, $PREMATCH, etc.
       #
       # @example
       #   # bad
@@ -12,24 +13,98 @@ module RuboCop
       #
       #   # good
       #   puts Regexp.last_match(1)
-      class PerlBackrefs < Cop
-        MSG = 'Avoid the use of Perl-style backrefs.'
+      class PerlBackrefs < Base
+        extend AutoCorrector
+
+        MESSAGE_FORMAT = 'Prefer `%<preferred_expression>s` over `%<original_expression>s`.'
+
+        def on_back_ref(node)
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
+
+        def on_gvar(node)
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
 
         def on_nth_ref(node)
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            backref, = *node
-            parent_type = node.parent ? node.parent.type : nil
-            if %i[dstr xstr regexp].include?(parent_type)
-              corrector.replace(node.source_range,
-                                "{Regexp.last_match(#{backref})}")
-            else
-              corrector.replace(node.source_range,
-                                "Regexp.last_match(#{backref})")
+          on_back_ref_or_gvar_or_nth_ref(node)
+        end
+
+        private
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [Boolean]
+        def derived_from_braceless_interpolation?(node)
+          %i[
+            dstr
+            regexp
+            xstr
+          ].include?(node.parent&.type)
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @param [String] preferred_expression
+        # @return [String]
+        def format_message(node:, preferred_expression:)
+          original_expression = original_expression_of(node)
+          format(
+            MESSAGE_FORMAT,
+            original_expression: original_expression,
+            preferred_expression: preferred_expression
+          )
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String]
+        def original_expression_of(node)
+          first = node.to_a.first
+          if first.is_a?(::Integer)
+            "$#{first}"
+          else
+            first.to_s
+          end
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        # @return [String, nil]
+        def preferred_expression_to(node)
+          first = node.to_a.first
+          case first
+          when ::Integer
+            "Regexp.last_match(#{first})"
+          when :$&, :$MATCH
+            'Regexp.last_match(0)'
+          when :$`, :$PREMATCH
+            'Regexp.last_match.pre_match'
+          when :$', :$POSTMATCH
+            'Regexp.last_match.post_match'
+          when :$+, :$LAST_PAREN_MATCH
+            'Regexp.last_match(-1)'
+          end
+        end
+
+        # @private
+        # @param [RuboCop::AST::Node] node
+        def on_back_ref_or_gvar_or_nth_ref(node)
+          preferred_expression = preferred_expression_to(node)
+          return unless preferred_expression
+
+          add_offense(
+            node,
+            message: format_message(
+              node: node,
+              preferred_expression: preferred_expression
+            )
+          ) do |corrector|
+            if derived_from_braceless_interpolation?(node)
+              preferred_expression = "{#{preferred_expression}}"
             end
+
+            corrector.replace(node, preferred_expression)
           end
         end
       end

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

@@ -25,8 +25,9 @@ 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`.'
 
@@ -35,27 +36,23 @@ 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)
+          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) ...)'
+                         '(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,33 +13,43 @@ 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`.'
 
+        RESTRICT_ON_SEND = %i[raise fail].freeze
+
         def on_send(node)
           return unless node.command?(:raise) || node.command?(:fail)
 
@@ -51,16 +61,6 @@ 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)
@@ -91,8 +91,10 @@ module RuboCop
 
         def check_compact(node)
           if node.arguments.size > 1
-            add_offense(node) do
-              opposite_style_detected
+            add_offense(node, message: format(COMPACT_MSG, method: node.method_name)) do |corrector|
+              replacement = correction_exploded_to_compact(node)
+
+              corrector.replace(node, replacement)
             end
           else
             correct_style_detected
@@ -105,11 +107,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
-            opposite_style_detected
+          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)
           end
         end
 
@@ -127,18 +132,16 @@ module RuboCop
           arg.hash_type? || arg.splat_type?
         end
 
+        def allowed_non_exploded_type?(arg)
+          type = arg.receiver.const_name
+
+          Array(cop_config['AllowedCompactTypes']).include?(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, method: node.method_name)
-          else
-            format(EXPLODED_MSG, method: node.method_name)
-          end
-        end
       end
     end
   end

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

@@ -23,68 +23,69 @@ module RuboCop
       #   # good
       #   rand(1..6)
       #   rand(1...7)
-      class RandomWithOffset < Cop
+      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
 
-        def_node_matcher :integer_op_rand?, <<-PATTERN
+        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
 
-        def_node_matcher :rand_op_integer?, <<-PATTERN
+        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
 
-        def_node_matcher :rand_modified?, <<-PATTERN
+        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 node.receiver
           return unless integer_op_rand?(node) ||
                         rand_op_integer?(node) ||
                         rand_modified?(node)
 
-          add_offense(node)
-        end
-
-        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
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
         private
 
-        def_node_matcher :random_call, <<-PATTERN
+        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 +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)
@@ -149,7 +144,7 @@ module RuboCop
           end
         end
 
-        def_node_matcher :to_int, <<-PATTERN
+        def_node_matcher :to_int, <<~PATTERN
           (int $_)
         PATTERN
       end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+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: ' '
+      #   foo: 2
+      #
+      # @example
+      #   # bad
+      #   array.join('')
+      #   [1, 2, 3].join("")
+      #   string.split(" ")
+      #   "first\nsecond".split(" ")
+      #   A.foo(2)
+      #
+      #   # good
+      #   array.join
+      #   [1, 2, 3].join
+      #   string.split
+      #   "first second".split
+      #   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)
+          return nil unless cop_config['Methods'].key?(method_name)
+
+          @mem ||= {}
+          @mem[method_name] ||=
+            begin
+              arg = cop_config['Methods'].fetch(method_name)
+              buffer = Parser::Source::Buffer.new('(string)', 1)
+              buffer.source = arg.inspect
+              builder = RuboCop::AST::Builder.new
+              Parser::CurrentRuby.new(builder).parse(buffer)
+            end
+        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,107 @@
+# 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.'
+
+        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 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) 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