rubocop 0.85.0 → 0.88.0

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

@@ -81,7 +81,7 @@ module RuboCop
 
         private
 
-        def check_branches(branches)
+        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
           return if branches.any?(&:nil?)

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

@@ -61,7 +61,7 @@ module RuboCop
       class IfInsideElse < Cop
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
-        def on_if(node)
+        def on_if(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if node.ternary? || node.unless?
 
           else_branch = node.else_branch

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

@@ -41,11 +41,8 @@ module RuboCop
         MSG_USE_NORMAL =
           'Modifier form of `%<keyword>s` makes the line too long.'
 
-        ASSIGNMENT_TYPES = %i[lvasgn casgn cvasgn
-                              gvasgn ivasgn masgn].freeze
-
         def on_if(node)
-          msg = if eligible_node?(node)
+          msg = if single_line_as_modifier?(node)
                   MSG_USE_MODIFIER unless named_capture_in_condition?(node)
                 elsif too_long_due_to_modifier?(node)
                   MSG_USE_NORMAL
@@ -125,13 +122,15 @@ module RuboCop
           node.condition.match_with_lvasgn_type?
         end
 
-        def eligible_node?(node)
-          !non_eligible_if?(node) && !node.chained? &&
-            !node.nested_conditional? && single_line_as_modifier?(node)
+        def non_eligible_node?(node)
+          non_simple_if_unless?(node) ||
+            node.chained? ||
+            node.nested_conditional? ||
+            super
         end
 
-        def non_eligible_if?(node)
-          node.ternary? || node.modifier_form? || node.elsif? || node.else?
+        def non_simple_if_unless?(node)
+          node.ternary? || node.elsif? || node.else?
         end
 
         def another_statement_on_same_line?(node)
@@ -153,8 +152,9 @@ module RuboCop
           # Parenthesize corrected expression if changing to modifier-if form
           # would change the meaning of the parent expression
           # (due to the low operator precedence of modifier-if)
-          return false if node.parent.nil?
-          return true if ASSIGNMENT_TYPES.include?(node.parent.type)
+          parent = node.parent
+          return false if parent.nil?
+          return true if parent.assignment? || parent.operator_keyword?
 
           node.parent.send_type? && !node.parent.parenthesized?
         end

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

@@ -33,6 +33,18 @@ module RuboCop
           add_offense(node, location: :keyword,
                             message: format(MSG, keyword: node.keyword))
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            keyword = node.if? ? 'if' : 'unless'
+
+            corrector.replace(node, <<~RUBY.chop)
+              #{keyword} #{node.condition.source}
+              #{node.if_branch.source}
+              end
+            RUBY
+          end
+        end
       end
     end
   end

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

@@ -178,7 +178,7 @@ module RuboCop
         end
 
         def camel_case_constant?(node)
-          node.const_type? && node.source =~ CAMEL_CASE
+          node.const_type? && CAMEL_CASE.match?(node.source)
         end
 
         def dot_range(loc)

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

@@ -34,7 +34,7 @@ module RuboCop
           # shortcut out if the string does not look like an IP address
           return false unless could_be_ip?(contents)
 
-          contents =~ ::Resolv::IPv4::Regex || contents =~ ::Resolv::IPv6::Regex
+          ::Resolv::IPv4::Regex.match?(contents) || ::Resolv::IPv6::Regex.match?(contents)
         end
 
         # Dummy implementation of method in ConfigurableEnforcedStyle that is

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

@@ -119,17 +119,7 @@ module RuboCop
         private
 
         def check(node)
-          return if node.else?
-
-          if empty_else_cop_enabled?
-            if empty_else_style == :empty
-              add_offense(node)
-            elsif empty_else_style == :nil
-              add_offense(node)
-            end
-          end
-
-          add_offense(node)
+          add_offense(node) unless node.else?
         end
 
         def message(node)

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

@@ -8,11 +8,20 @@ module RuboCop
       #
       # @example
       #
-      #   Thread.list.find_all do |t|
+      #   # bad
+      #   Thread.list.select do |t|
       #     t.alive?
       #   end.map do |t|
       #     t.object_id
       #   end
+      #
+      #   # good
+      #   alive_threads = Thread.list.select do |t|
+      #     t.alive?
+      #   end
+      #   alive_threads.map do |t|
+      #     t.object_id
+      #   end
       class MultilineBlockChain < Cop
         include RangeHelp
 

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

@@ -42,7 +42,7 @@ module RuboCop
         private
 
         def non_modifier_then?(node)
-          node.loc.begin && node.loc.begin.source_line =~ NON_MODIFIER_THEN
+          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
         end
       end
     end

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

@@ -17,12 +17,11 @@ module RuboCop
       #
       #   # good
       #   a = cond ? b : c
-      #   a =
-      #     if cond
-      #       b
-      #     else
-      #       c
-      #     end
+      #   a = if cond
+      #     b
+      #   else
+      #     c
+      #   end
       class MultilineTernaryOperator < Cop
         MSG = 'Avoid multi-line ternary operators, ' \
               'use `if` or `unless` instead.'
@@ -32,6 +31,18 @@ module RuboCop
 
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, <<~RUBY.chop)
+              if #{node.condition.source}
+                #{node.if_branch.source}
+              else
+                #{node.else_branch.source}
+              end
+            RUBY
+          end
+        end
       end
     end
   end

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

@@ -150,14 +150,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`.'
 
@@ -54,13 +55,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/nested_ternary_operator.rb

@@ -26,6 +26,33 @@ module RuboCop
             add_offense(nested_ternary)
           end
         end
+
+        def autocorrect(node)
+          if_node = if_node(node)
+
+          lambda do |corrector|
+            corrector.replace(if_node, <<~RUBY.chop)
+              if #{if_node.condition.source}
+                #{remove_parentheses(if_node.if_branch.source)}
+              else
+                #{if_node.else_branch.source}
+              end
+            RUBY
+          end
+        end
+
+        private
+
+        def if_node(node)
+          node = node.parent
+          return node if node.if_type?
+
+          if_node(node)
+        end
+
+        def remove_parentheses(source)
+          source.gsub(/\A\(/, '').gsub(/\)\z/, '')
+        end
       end
     end
   end

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

@@ -191,7 +191,7 @@ module RuboCop
         end
 
         def end_followed_by_whitespace_only?(source_buffer, end_pos)
-          source_buffer.source[end_pos..-1] =~ /\A\s*$/
+          /\A\s*$/.match?(source_buffer.source[end_pos..-1])
         end
 
         def reindentable_lines(node)
@@ -201,7 +201,7 @@ module RuboCop
           lines = (node.source_range.line + 1)...node.loc.end.line
           lines = lines.to_a - heredoc_lines(node)
           # Skip blank lines
-          lines.reject { |lineno| buffer.source_line(lineno) =~ /\A\s*\z/ }
+          lines.reject { |lineno| /\A\s*\z/.match?(buffer.source_line(lineno)) }
         end
 
         # Adjust indentation of `lines` to match `node`

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

@@ -77,9 +77,9 @@ module RuboCop
         end
 
         def octal_literal_type(literal)
-          if literal =~ OCTAL_ZERO_ONLY_REGEX && octal_zero_only?
+          if OCTAL_ZERO_ONLY_REGEX.match?(literal) && octal_zero_only?
             :octal_zero_only
-          elsif literal =~ OCTAL_REGEX && !octal_zero_only?
+          elsif OCTAL_REGEX.match?(literal) && !octal_zero_only?
             :octal
           end
         end

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

@@ -54,15 +54,14 @@ module RuboCop
         }.freeze
 
         def on_send(node)
+          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/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? ||

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

@@ -102,7 +102,7 @@ module RuboCop
           delimiters_regexp = Regexp.union(delimiters)
           node
             .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp =~ s }
+            .any? { |s| delimiters_regexp.match?(s.scrub) }
         end
 
         def string_source(node)

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,7 +49,7 @@ 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})
@@ -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)

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