rubocop 0.49.1 → 0.50.0

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

@@ -9,7 +9,7 @@ module RuboCop
         MSG = 'Avoid the use of Perl-style backrefs.'.freeze
 
         def on_nth_ref(node)
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -13,7 +13,7 @@ module RuboCop
 
         def on_block(node)
           proc_new?(node) do |block_method|
-            add_offense(block_method, :expression)
+            add_offense(block_method)
           end
         end
 

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

@@ -60,38 +60,37 @@ module RuboCop
         private
 
         def autocorrect(node)
-          new_exception = if style == :compact
-                            correction_exploded_to_compact(node.arguments)
-                          else
-                            correction_compact_to_exploded(node.first_argument)
-                          end
-          replacement = "#{node.method_name} #{new_exception}"
+          replacement = if style == :compact
+                          correction_exploded_to_compact(node)
+                        else
+                          correction_compact_to_exploded(node)
+                        end
 
           ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
         def correction_compact_to_exploded(node)
-          exception_node, _new, message_node = *node
+          exception_node, _new, message_node = *node.first_argument
 
           message = message_node && message_node.source
 
           correction = exception_node.const_name.to_s
           correction = "#{correction}, #{message}" if message
 
-          correction
+          "#{node.method_name} #{correction}"
         end
 
         def correction_exploded_to_compact(node)
-          exception_node, *message_nodes = *node
+          exception_node, *message_nodes = *node.arguments
+          return node.source if message_nodes.size > 1
 
-          messages = message_nodes.map(&:source).join(', ')
-
-          "#{exception_node.const_name}.new(#{messages})"
+          argument = message_nodes.first.source
+          "#{node.method_name} #{exception_node.const_name}.new(#{argument})"
         end
 
         def check_compact(node)
           if node.arguments.size > 1
-            add_offense(node, :expression, message(node.method_name)) do
+            add_offense(node) do
               opposite_style_detected
             end
           else
@@ -108,7 +107,7 @@ module RuboCop
 
           return if acceptable_exploded_args?(first_arg.arguments)
 
-          add_offense(node, :expression, message(node.method_name)) do
+          add_offense(node) do
             opposite_style_detected
           end
         end
@@ -127,11 +126,11 @@ module RuboCop
           arg.hash_type? || arg.splat_type?
         end
 
-        def message(method)
+        def message(node)
           if style == :compact
-            format(COMPACT_MSG, method)
+            format(COMPACT_MSG, node.method_name)
           else
-            format(EXPLODED_MSG, method)
+            format(EXPLODED_MSG, node.method_name)
           end
         end
       end

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

@@ -25,15 +25,16 @@ module RuboCop
       #     something
       #   end
       class RedundantBegin < Cop
-        include OnMethodDef
-
         MSG = 'Redundant `begin` block detected.'.freeze
 
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body && body.kwbegin_type?
+        def on_def(node)
+          return unless node.body && node.body.kwbegin_type?
 
-          add_offense(body, :begin)
+          add_offense(node.body, :begin)
         end
+        alias on_defs on_def
+
+        private
 
         def autocorrect(node)
           lambda do |corrector|

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant returning of true/false in conditionals.
+      #
+      # @example
+      #   # bad
+      #   x == y ? true : false
+      #
+      #   # bad
+      #   if x == y
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # good
+      #   x == y
+      #
+      #   # bad
+      #   x == y ? false : true
+      #
+      #   # good
+      #   x != y
+      class RedundantConditional < Cop
+        include AutocorrectAlignment
+
+        COMPARISON_OPERATORS = RuboCop::AST::Node::COMPARISON_OPERATORS
+
+        MSG = 'This conditional expression can just be replaced by `%s`.'.freeze
+
+        def on_if(node)
+          return unless offense?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          replacement = replacement_condition(node)
+          msg = node.elsif? ? "\n#{replacement}" : replacement
+
+          format(MSG, msg)
+        end
+
+        def_node_matcher :redundant_condition?, <<-RUBY
+          (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) true false)
+        RUBY
+
+        def_node_matcher :redundant_condition_inverted?, <<-RUBY
+          (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) false true)
+        RUBY
+
+        def offense?(node)
+          return if node.modifier_form?
+          redundant_condition?(node) || redundant_condition_inverted?(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement_condition(node))
+          end
+        end
+
+        def replacement_condition(node)
+          condition = node.condition.source
+          expression = invert_expression?(node) ? "!(#{condition})" : condition
+
+          node.elsif? ? indented_else_node(expression, node) : expression
+        end
+
+        def invert_expression?(node)
+          (
+            (node.if? || node.elsif? || node.ternary?) &&
+            redundant_condition_inverted?(node)
+          ) || (
+            node.unless? &&
+            redundant_condition?(node)
+          )
+        end
+
+        def indented_else_node(expression, node)
+          "else\n#{indentation(node)}#{expression}"
+        end
+
+        def configured_indentation_width
+          super || 2
+        end
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module RuboCop
           return unless node.receiver && node.method?(:freeze) &&
                         immutable_literal?(node.receiver)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -31,11 +31,17 @@ module RuboCop
           check(node)
         end
 
+        private
+
         def parens_allowed?(node)
           empty_parentheses?(node) ||
-            allowed_ancestor?(node) ||
             hash_literal_as_first_arg?(node) ||
             rescue?(node) ||
+            allowed_expression?(node)
+        end
+
+        def allowed_expression?(node)
+          allowed_ancestor?(node) ||
             allowed_method_call?(node) ||
             allowed_array_or_hash_element?(node) ||
             allowed_multiple_expression?(node)
@@ -52,7 +58,7 @@ module RuboCop
         end
 
         def allowed_multiple_expression?(node)
-          return false if node.children.size == 1
+          return false if node.children.one?
           ancestor = node.ancestors.first
           return false unless ancestor
           !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
@@ -65,7 +71,7 @@ module RuboCop
 
         def hash_literal_as_first_arg?(node)
           # Don't flag `method ({key: value})`
-          node.children.first.hash_type? && first_arg?(node) &&
+          node.children.first.hash_type? && first_argument?(node) &&
             !parentheses?(node.parent)
         end
 
@@ -177,16 +183,12 @@ module RuboCop
         end
 
         def only_begin_arg?(args)
-          args.size == 1 && args.first && args.first.begin_type?
+          args.one? && args.first.begin_type?
         end
 
-        def first_arg?(node)
-          send_node = node.parent
-          return false unless send_node && send_node.send_type?
-
-          _receiver, _method_name, *args = *send_node
-          node.equal?(args.first)
-        end
+        def_node_matcher :first_argument?, <<-PATTERN
+          ^(send _ _ equal?(%0) ...)
+        PATTERN
 
         def call_chain_starts_with_int?(begin_node, send_node)
           recv = first_part_of_call_chain(send_node)

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

@@ -21,9 +21,15 @@ module RuboCop
       # It should be extended to handle methods whose body is if/else
       # or a case expression with a default branch.
       class RedundantReturn < Cop
-        include OnMethodDef
-
         MSG = 'Redundant `return` detected.'.freeze
+        MULTI_RETURN_MSG = 'To return multiple values, use an array.'.freeze
+
+        def on_def(node)
+          return unless node.body
+
+          check_branch(node.body)
+        end
+        alias on_defs on_def
 
         private
 
@@ -64,18 +70,12 @@ module RuboCop
           !args.first.begin_type? || !args.first.children.empty?
         end
 
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body
-
-          check_branch(body)
-        end
-
         def check_branch(node)
           case node.type
           when :return then check_return_node(node)
-          when :case then check_case_node(node)
-          when :if then check_if_node(node)
-          when :begin then check_begin_node(node)
+          when :case   then check_case_node(node)
+          when :if     then check_if_node(node)
+          when :begin  then check_begin_node(node)
           end
         end
 
@@ -115,6 +115,18 @@ module RuboCop
 
           check_return_node(last_expr)
         end
+
+        def allow_multiple_return_values?
+          cop_config['AllowMultipleReturnValues'] || false
+        end
+
+        def message(node)
+          if !allow_multiple_return_values? && node.children.size > 1
+            "#{MSG} #{MULTI_RETURN_MSG}"
+          else
+            MSG
+          end
+        end
       end
     end
   end

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

@@ -30,6 +30,10 @@ module RuboCop
       #     self.bar # resolves name clash with local variable
       #   end
       #
+      #   %w[x y z].select do |bar|
+      #     self.bar == bar # resolves name clash with argument of a block
+      #   end
+      #
       # * Calling an attribute writer to prevent an local variable assignment
       #
       #   attr_writer :bar
@@ -57,7 +61,6 @@ module RuboCop
           lhs, _rhs = *node
           allow_self(lhs)
         end
-
         alias on_and_asgn on_or_asgn
 
         def on_op_asgn(node)
@@ -70,7 +73,6 @@ module RuboCop
         def on_def(node)
           add_scope(node)
         end
-
         alias on_defs on_def
 
         def on_args(node)
@@ -90,12 +92,17 @@ module RuboCop
           return unless node.self_receiver? && regular_method_call?(node)
           return if node.parent && node.parent.mlhs_type?
 
-          return if @allowed_send_nodes.include?(node) ||
-                    @local_variables_scopes[node].include?(node.method_name)
+          return if allowed_send_node?(node)
+
+          add_offense(node)
+        end
 
-          add_offense(node, :expression)
+        def on_block(node)
+          add_scope(node, @local_variables_scopes[node])
         end
 
+        private
+
         def autocorrect(node)
           lambda do |corrector|
             corrector.remove(node.receiver.source_range)
@@ -103,15 +110,17 @@ module RuboCop
           end
         end
 
-        private
-
-        def add_scope(node)
-          local_variables = []
+        def add_scope(node, local_variables = [])
           node.descendants.each do |child_node|
             @local_variables_scopes[child_node] = local_variables
           end
         end
 
+        def allowed_send_node?(node)
+          @allowed_send_nodes.include?(node) ||
+            @local_variables_scopes[node].include?(node.method_name)
+        end
+
         def regular_method_call?(node)
           !(operator?(node.method_name) ||
             keyword?(node.method_name) ||

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

@@ -58,15 +58,23 @@ module RuboCop
 
         def allowed_slash_literal?(node)
           style == :slashes && !contains_disallowed_slash?(node) ||
-            style == :mixed && node.single_line? &&
-              !contains_disallowed_slash?(node)
+            allowed_mixed_slash?(node)
+        end
+
+        def allowed_mixed_slash?(node)
+          style == :mixed && node.single_line? &&
+            !contains_disallowed_slash?(node)
         end
 
         def allowed_percent_r_literal?(node)
           style == :slashes && contains_disallowed_slash?(node) ||
             style == :percent_r ||
-            style == :mixed && node.multiline? ||
-            style == :mixed && contains_disallowed_slash?(node)
+            allowed_mixed_percent_r?(node)
+        end
+
+        def allowed_mixed_percent_r?(node)
+          style == :mixed && node.multiline? ||
+            contains_disallowed_slash?(node)
         end
 
         def contains_disallowed_slash?(node)

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

@@ -12,7 +12,7 @@ module RuboCop
 
         def on_resbody(node)
           return unless rescue_modifier?(node)
-          add_offense(node.parent, :expression)
+          add_offense(node.parent)
         end
 
         def autocorrect(node)

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces consistency between 'return nil' and 'return'.
+      #
+      # Supported styles are: return, return_nil.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: return (default)
+      #
+      #   # bad
+      #   def foo(arg)
+      #     return nil if arg
+      #   end
+      #
+      #   # good
+      #   def foo(arg)
+      #     return if arg
+      #   end
+      #
+      #   # EnforcedStyle: return_nil
+      #
+      #   # bad
+      #   def foo(arg)
+      #     return if arg
+      #   end
+      #
+      #   # good
+      #   def foo(arg)
+      #     return nil if arg
+      #   end
+      class ReturnNil < Cop
+        include ConfigurableEnforcedStyle
+
+        RETURN_MSG = 'Use `return` instead of `return nil`.'.freeze
+        RETURN_NIL_MSG = 'Use `return nil` instead of `return`.'.freeze
+
+        def_node_matcher :return_node?, '(return)'
+        # TODO: fix (return nil) on the NodePattern class
+        # def_node_matcher :return_nil_node?, '(return nil)'
+
+        def on_return(node)
+          # Check Lint/NonLocalExitFromIterator first before this cop
+          node.each_ancestor(:block, :def, :defs) do |n|
+            break if scoped_node?(n)
+
+            send_node, args_node, _body_node = *n
+
+            # if a proc is passed to `Module#define_method` or
+            # `Object#define_singleton_method`, `return` will not cause a
+            # non-local exit error
+            break if define_method?(send_node)
+
+            next if args_node.children.empty?
+
+            return nil if chained_send?(send_node)
+          end
+
+          add_offense(node) unless correct_style?(node)
+        end
+
+        private
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrected = style == :return ? 'return' : 'return nil'
+            corrector.replace(node.source_range, corrected)
+          end
+        end
+
+        def message(_node)
+          style == :return ? RETURN_MSG : RETURN_NIL_MSG
+        end
+
+        def correct_style?(node)
+          style == :return && !return_nil_node?(node) ||
+            style == :return_nil && !return_node?(node)
+        end
+
+        def return_nil_node?(node)
+          !node.children.empty? && node.children.first.nil_type?
+        end
+
+        def scoped_node?(node)
+          node.def_type? || node.defs_type? || node.lambda?
+        end
+
+        def_node_matcher :chained_send?, '(send !nil ...)'
+        def_node_matcher :define_method?, <<-PATTERN
+          (send _ {:define_method :define_singleton_method} _)
+        PATTERN
+      end
+    end
+  end
+end