rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,96 @@
+# 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 Alignment
+
+        COMPARISON_OPERATORS = RuboCop::AST::Node::COMPARISON_OPERATORS
+
+        MSG = 'This conditional expression can just be replaced ' \
+              'by `%<msg>s`.'.freeze
+
+        def on_if(node)
+          return unless offense?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement_condition(node))
+          end
+        end
+
+        private
+
+        def message(node)
+          replacement = replacement_condition(node)
+          msg = node.elsif? ? "\n#{replacement}" : replacement
+
+          format(MSG, 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 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_exception.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -23,8 +22,8 @@ module RuboCop
                 'just the message.'.freeze
 
         def on_send(node)
-          exploded?(node) { return add_offense(node, :expression, MSG_1) }
-          compact?(node) { add_offense(node, :expression, MSG_2) }
+          exploded?(node) { return add_offense(node, message: MSG_1) }
+          compact?(node) { add_offense(node, message: MSG_2) }
         end
 
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
@@ -44,11 +43,11 @@ module RuboCop
         end
 
         def_node_matcher :exploded?, <<-PATTERN
-          (send nil ${:raise :fail} (const nil :RuntimeError) $_)
+          (send nil? ${:raise :fail} (const nil? :RuntimeError) $_)
         PATTERN
 
         def_node_matcher :compact?, <<-PATTERN
-          (send nil {:raise :fail} $(send (const nil :RuntimeError) :new $_))
+          (send nil? {:raise :fail} $(send (const nil? :RuntimeError) :new $_))
         PATTERN
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -15,16 +14,14 @@ module RuboCop
       class RedundantFreeze < Cop
         include FrozenStringLiteral
 
-        MSG = 'Freezing immutable objects is pointless.'.freeze
+        MSG = 'Do not freeze immutable objects, as freezing them has no ' \
+              'effect.'.freeze
 
         def on_send(node)
-          receiver, method_name, *args = *node
+          return unless node.receiver && node.method?(:freeze) &&
+                        immutable_literal?(node.receiver)
 
-          return unless method_name == :freeze &&
-                        args.empty? &&
-                        immutable_literal?(receiver)
-
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)
@@ -37,10 +34,10 @@ module RuboCop
         private
 
         def immutable_literal?(node)
-          return false unless node
           return true if node.immutable_literal?
+
           FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-            frozen_string_literals_enabled?(processed_source)
+            frozen_string_literals_enabled?
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -17,9 +16,10 @@ module RuboCop
       class RedundantParentheses < Cop
         include Parentheses
 
-        ALLOWED_LITERALS = [:irange, :erange].freeze
+        ALLOWED_LITERALS = %i[irange erange].freeze
 
-        def_node_matcher :square_brackets?, '(send (send _recv _msg) :[] ...)'
+        def_node_matcher :square_brackets?,
+                         '(send {(send _recv _msg) str array hash} :[] ...)'
         def_node_matcher :range_end?, '^^{irange erange}'
         def_node_matcher :method_node_and_args, '$(send _recv _msg $...)'
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
@@ -31,32 +31,52 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          ParenthesesCorrector.correct(node)
+        end
+
+        private
+
         def parens_allowed?(node)
-          # don't flag `()`
           empty_parentheses?(node) ||
-            # don't flag `break(1)`, etc
-            (keyword_ancestor?(node) && parens_required?(node)) ||
-            # don't flag `method ({key: value})`
             hash_literal_as_first_arg?(node) ||
-            # don't flag `rescue(ExceptionClass)`
             rescue?(node) ||
-            # don't flag `method (arg) { }`
-            (arg_in_call_with_block?(node) && !parentheses?(node.parent)) ||
-            # don't flag
-            # ```
-            # { a: (1
-            #      ), }
-            # ```
-            allowed_array_or_hash_element?(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)
+        end
+
+        def allowed_ancestor?(node)
+          # Don't flag `break(1)`, etc
+          keyword_ancestor?(node) && parens_required?(node)
+        end
+
+        def allowed_method_call?(node)
+          # Don't flag `method (arg) { }`
+          arg_in_call_with_block?(node) && !parentheses?(node.parent)
+        end
+
+        def allowed_multiple_expression?(node)
+          return false if node.children.one?
+          ancestor = node.ancestors.first
+          return false unless ancestor
+          !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
         end
 
         def empty_parentheses?(node)
+          # Don't flag `()`
           node.children.empty?
         end
 
         def hash_literal_as_first_arg?(node)
-          child = node.children.first
-          child.hash_type? && first_arg?(node) && !parentheses?(node.parent)
+          # Don't flag `method ({key: value})`
+          node.children.first.hash_type? && first_argument?(node) &&
+            !parentheses?(node.parent)
         end
 
         def check(begin_node)
@@ -64,7 +84,9 @@ module RuboCop
           if keyword_with_redundant_parentheses?(node)
             return offense(begin_node, 'a keyword')
           end
-          return offense(begin_node, 'a literal') if disallowed_literal?(node)
+          if disallowed_literal?(begin_node, node)
+            return offense(begin_node, 'a literal')
+          end
           return offense(begin_node, 'a variable') if node.variable?
           return offense(begin_node, 'a constant') if node.const_type?
           check_send(begin_node, node) if node.send_type?
@@ -92,7 +114,7 @@ module RuboCop
         end
 
         def offense(node, msg)
-          add_offense(node, :expression, "Don't use parentheses around #{msg}.")
+          add_offense(node, message: "Don't use parentheses around #{msg}.")
         end
 
         def keyword_ancestor?(node)
@@ -100,6 +122,11 @@ module RuboCop
         end
 
         def allowed_array_or_hash_element?(node)
+          # Don't flag
+          # ```
+          # { a: (1
+          #      ), }
+          # ```
           (hash_element?(node) || array_element?(node)) &&
             only_closing_paren_before_comma?(node)
         end
@@ -119,8 +146,21 @@ module RuboCop
           line_range.source =~ /^\s*\)\s*,/
         end
 
-        def disallowed_literal?(node)
-          node.literal? && !ALLOWED_LITERALS.include?(node.type)
+        def disallowed_literal?(begin_node, node)
+          node.literal? &&
+            !ALLOWED_LITERALS.include?(node.type) &&
+            !raised_to_power_negative_numeric?(begin_node, node)
+        end
+
+        def raised_to_power_negative_numeric?(begin_node, node)
+          return false unless node.numeric_type?
+
+          siblings = begin_node.parent && begin_node.parent.children
+          return false if siblings.nil?
+          next_sibling = siblings[begin_node.sibling_index + 1]
+          base_value = node.children.first
+
+          base_value < 0 && next_sibling == :**
         end
 
         def keyword_with_redundant_parentheses?(node)
@@ -129,7 +169,7 @@ module RuboCop
 
           args = *node
 
-          if args.size == 1 && args.first && args.first.begin_type?
+          if only_begin_arg?(args)
             parentheses?(args.first)
           else
             args.empty? || parentheses?(node)
@@ -146,19 +186,18 @@ module RuboCop
           args.empty? || parentheses?(send_node) || square_brackets?(send_node)
         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)
+        def only_begin_arg?(args)
+          args.one? && args.first.begin_type?
         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)
           recv && recv.int_type? && (parent = begin_node.parent) &&
-            parent.send_type? &&
-            (parent.method_name == :-@ || parent.method_name == :+@)
+            parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -22,13 +21,17 @@ 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
 
-        private
+        def on_def(node)
+          return unless node.body
+
+          check_branch(node.body)
+        end
+        alias on_defs on_def
 
-        def autocorrect(node)
+        def autocorrect(node) # rubocop:disable Metrics/MethodLength
           lambda do |corrector|
             unless arguments?(node.children)
               corrector.replace(node.source_range, 'nil')
@@ -39,16 +42,15 @@ module RuboCop
             if node.children.size > 1
               add_brackets(corrector, node)
             elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless braces?(return_value)
+              add_braces(corrector, return_value) unless return_value.braces?
             end
-            return_kw = range_with_surrounding_space(node.loc.keyword, :right)
+            return_kw = range_with_surrounding_space(range: node.loc.keyword,
+                                                     side: :right)
             corrector.remove(return_kw)
           end
         end
 
-        def braces?(arg)
-          arg.loc.begin
-        end
+        private
 
         def add_brackets(corrector, node)
           kids = node.children.map(&:source_range)
@@ -69,18 +71,12 @@ module RuboCop
           !args.first.begin_type? || !args.first.children.empty?
         end
 
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body
-
-          if body.type == :return
-            check_return_node(body)
-          elsif body.type == :begin
-            expressions = *body
-            last_expr = expressions.last
-
-            if last_expr && last_expr.type == :return
-              check_return_node(last_expr)
-            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)
           end
         end
 
@@ -88,7 +84,49 @@ module RuboCop
           return if cop_config['AllowMultipleReturnValues'] &&
                     node.children.size > 1
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
+        end
+
+        def check_case_node(node)
+          _cond, *when_nodes, else_node = *node
+          when_nodes.each { |when_node| check_when_node(when_node) }
+          check_branch(else_node) if else_node
+        end
+
+        def check_when_node(node)
+          return unless node
+          _cond, body = *node
+          check_branch(body) if body
+        end
+
+        def check_if_node(node)
+          return if node.modifier_form? || node.ternary?
+
+          _cond, if_node, else_node = *node.node_parts
+
+          check_branch(if_node) if if_node
+          check_branch(else_node) if else_node
+        end
+
+        def check_begin_node(node)
+          expressions = *node
+          last_expr = expressions.last
+
+          return unless last_expr && last_expr.return_type?
+
+          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

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,50 +5,53 @@ module RuboCop
     module Style
       # This cop checks for redundant uses of `self`.
       #
-      # `self` is only needed when:
+      # The usage of `self` is only needed when:
       #
       # * Sending a message to same object with zero arguments in
       #   presence of a method name clash with an argument or a local
       #   variable.
       #
-      #   Note, with using explicit self you can only send messages
-      #   with public or protected scope, you cannot send private
-      #   messages this way.
+      # * Calling an attribute writer to prevent an local variable assignment.
       #
-      #   Example:
+      # Note, with using explicit self you can only send messages with public or
+      # protected scope, you cannot send private messages this way.
       #
-      #   def bar
-      #     :baz
+      # Note we allow uses of `self` with operators because it would be awkward
+      # otherwise.
+      #
+      # @example
+      #
+      #   # bad
+      #   def foo(bar)
+      #     self.baz
       #   end
       #
+      #   # good
       #   def foo(bar)
-      #     self.bar # resolves name clash with argument
+      #     self.bar  # Resolves name clash with the argument.
       #   end
       #
-      #   def foo2
+      #   def foo
       #     bar = 1
-      #     self.bar # resolves name clash with local variable
+      #     self.bar  # Resolves name clash with the local variable.
       #   end
       #
-      # * Calling an attribute writer to prevent an local variable assignment
-      #
-      #   attr_writer :bar
-      #
       #   def foo
-      #     self.bar= 1 # Make sure above attr writer is called
+      #     %w[x y z].select do |bar|
+      #       self.bar == bar  # Resolves name clash with argument of the block.
+      #     end
       #   end
-      #
-      # Special cases:
-      #
-      # We allow uses of `self` with operators because it would be awkward
-      # otherwise.
       class RedundantSelf < Cop
         MSG = 'Redundant `self` detected.'.freeze
 
+        def self.autocorrect_incompatible_with
+          [ColonMethodCall]
+        end
+
         def initialize(config = nil, options = nil)
           super
           @allowed_send_nodes = []
-          @local_variables = []
+          @local_variables_scopes = Hash.new { |hash, key| hash[key] = [] }
         end
 
         # Assignment of self.x
@@ -58,7 +60,6 @@ module RuboCop
           lhs, _rhs = *node
           allow_self(lhs)
         end
-
         alias on_and_asgn on_or_asgn
 
         def on_op_asgn(node)
@@ -68,13 +69,10 @@ module RuboCop
 
         # Using self.x to distinguish from local variable x
 
-        def on_def(_node)
-          @local_variables = []
-        end
-
-        def on_defs(_node)
-          @local_variables = []
+        def on_def(node)
+          add_scope(node)
         end
+        alias on_defs on_def
 
         def on_args(node)
           node.children.each { |arg| on_argument(arg) }
@@ -85,64 +83,68 @@ module RuboCop
         end
 
         def on_lvasgn(node)
-          lhs, _rhs = *node
-          @local_variables << lhs
+          lhs, rhs = *node
+          @local_variables_scopes[rhs] << lhs
         end
 
-        # Detect offenses
-
         def on_send(node)
-          receiver, method_name, *_args = *node
-          return unless receiver && receiver.self_type?
-          return unless regular_method_call?(node)
+          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.include?(method_name)
+          return if allowed_send_node?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
+        end
+
+        def on_block(node)
+          add_scope(node, @local_variables_scopes[node])
         end
 
         def autocorrect(node)
-          receiver, _method_name, *_args = *node
           lambda do |corrector|
-            corrector.remove(receiver.source_range)
+            corrector.remove(node.receiver.source_range)
             corrector.remove(node.loc.dot)
           end
         end
 
         private
 
-        def regular_method_call?(node)
-          _receiver, method_name, *_args = *node
+        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
 
-          !(operator?(method_name) ||
-            keyword?(method_name) ||
-            constant_name?(method_name) ||
-            node.asgn_method_call?)
+        def regular_method_call?(node)
+          !(operator?(node.method_name) ||
+            keyword?(node.method_name) ||
+            node.camel_case_method? ||
+            node.setter_method? ||
+            node.implicit_call?)
         end
 
         def on_argument(node)
           name, = *node
-          @local_variables << name
+          @local_variables_scopes[node] << name
         end
 
         def keyword?(method_name)
-          [:alias, :and, :begin, :break, :case, :class, :def, :defined?, :do,
-           :else, :elsif, :end, :ensure, :false, :for, :if, :in, :module,
-           :next, :nil, :not, :or, :redo, :rescue, :retry, :return, :self,
-           :super, :then, :true, :undef, :unless, :until, :when, :while,
-           :yield].include?(method_name)
-        end
-
-        def constant_name?(method_name)
-          method_name.match(/^[A-Z]/)
+          %i[alias and begin break case class def defined? do
+             else elsif end ensure false for if in module
+             next nil not or redo rescue retry return self
+             super then true undef unless until when while
+             yield].include?(method_name)
         end
 
         def allow_self(node)
-          return unless node.type == :send
+          return unless node.send_type? && node.self_receiver?
 
-          receiver, _method_name, *_args = *node
-          @allowed_send_nodes << node if receiver && receiver.type == :self
+          @allowed_send_nodes << node
         end
       end
     end