rubocop 0.46.0 → 0.47.0

data/lib/rubocop/cop/mixin/multiline_expression_indentation.rb

@@ -101,9 +101,9 @@ module RuboCop
           next unless a.loc.respond_to?(:keyword)
 
           case a.type
-          when :if, :while, :until then expression, = *a
-          when :for                then _, expression, = *a
-          when :return             then expression, = *a
+          when :for                  then _, expression, = *a
+          when :return               then expression, = *a
+          when *Util::MODIFIER_NODES then expression, = *a
           end
 
           within_node?(node, expression) if expression

data/lib/rubocop/cop/mixin/negative_conditional.rb

@@ -2,28 +2,42 @@
 
 module RuboCop
   module Cop
-    # Some common code shared between FavorUnlessOverNegatedIf and
-    # FavorUntilOverNegatedWhile.
+    # Some common code shared between `NegatedIf` and
+    # `NegatedWhile` cops.
     module NegativeConditional
       extend NodePattern::Macros
-      include IfNode
 
       def_node_matcher :single_negative?, '(send !(send _ :!) :!)'
       def_node_matcher :empty_condition?, '(begin)'
 
       def check_negative_conditional(node)
-        condition, _body, _rest = *node
+        condition = node.condition
 
         return if empty_condition?(condition)
 
-        # Look at last expression of contents if there are parentheses
-        # around condition.
         condition = condition.children.last while condition.begin_type?
 
-        return unless single_negative?(condition) && !if_else?(node)
+        return unless single_negative?(condition)
+        return if node.if_type? && node.else?
 
         add_offense(node, :expression)
       end
+
+      def negative_conditional_corrector(node)
+        condition = negated_condition(node)
+
+        lambda do |corrector|
+          corrector.replace(node.loc.keyword, node.inverse_keyword)
+          corrector.replace(condition.source_range,
+                            condition.children.first.source)
+        end
+      end
+
+      def negated_condition(node)
+        condition = node.condition
+        condition = condition.children.first while condition.begin_type?
+        condition
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/on_method_def.rb

@@ -14,6 +14,20 @@ module RuboCop
         on_method_def(node, method_name, args, body)
       end
 
+      # This method provides scope agnostic method node destructuring by moving
+      # the scope to the end where it can easily be ignored.
+      def method_def_node_parts(node)
+        if node.def_type?
+          method_name, args, body = *node
+        elsif node.defs_type?
+          scope, method_name, args, body = *node
+        else
+          return []
+        end
+
+        [method_name, args, body, scope]
+      end
+
       private
 
       # Returns true for constructs such as

data/lib/rubocop/cop/mixin/on_normal_if_unless.rb

@@ -4,34 +4,11 @@ module RuboCop
   module Cop
     # Common functionality for cops checking if and unless expressions.
     module OnNormalIfUnless
-      include IfNode
-
       def on_if(node)
-        invoke_hook_for_normal_if_unless(node)
-      end
+        return if node.modifier_form? || node.ternary?
 
-      def invoke_hook_for_normal_if_unless(node)
-        # We won't check modifier or ternary conditionals.
-        return if modifier_if?(node) || ternary?(node)
         on_normal_if_unless(node)
       end
-
-      def if_else_clause(node)
-        return unless node.if_type?
-
-        keyword = node.loc.keyword
-        if keyword.is?('if')
-          node.children.last
-        elsif keyword.is?('elsif')
-          node.children.last
-        elsif keyword.is?('unless')
-          node.children[1]
-        end
-      end
-
-      def case_else_clause(node)
-        node.children.last if node.case_type?
-      end
     end
   end
 end

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -4,13 +4,10 @@ module RuboCop
   module Cop
     # Common functionality for modifier cops.
     module StatementModifier
-      include IfNode
-
       def single_line_as_modifier?(node)
-        cond, body, = if_node_parts(node)
-
-        return false if non_eligible_node?(node) || non_eligible_body?(body) ||
-                        non_eligible_condition?(cond)
+        return false if non_eligible_node?(node) ||
+                        non_eligible_body?(node.body) ||
+                        non_eligible_condition?(node.condition)
 
         modifier_fits_on_single_line?(node)
       end
@@ -20,9 +17,7 @@ module RuboCop
       end
 
       def non_eligible_body?(body)
-        return true unless body
-
-        body.begin_type? || empty_body?(body) || commented?(body.source_range)
+        empty_body?(body) || body.begin_type? || commented?(body.source_range)
       end
 
       def non_eligible_condition?(condition)
@@ -30,10 +25,10 @@ module RuboCop
       end
 
       def modifier_fits_on_single_line?(node)
-        cond, body, = if_node_parts(node)
-        body_length = body_length(body)
+        modifier_length = length_in_modifier_form(node, node.condition,
+                                                  body_length(node.body))
 
-        length_in_modifier_form(node, cond, body_length) <= max_line_length
+        modifier_length <= max_line_length
       end
 
       def length_in_modifier_form(node, cond, body_length)
@@ -54,7 +49,7 @@ module RuboCop
       end
 
       def empty_body?(body)
-        body_length(body).zero?
+        !body || body_length(body).zero?
       end
 
       def body_length(body)

data/lib/rubocop/cop/mixin/target_ruby_version.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking target ruby version.
+    module TargetRubyVersion
+      def minimum_target_ruby_version(version)
+        @minimum_target_ruby_version = version
+      end
+
+      def support_target_ruby_version?(version)
+        @minimum_target_ruby_version <= version
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -9,7 +9,7 @@ module RuboCop
 
       MSG = '%s comma after the last %s'.freeze
 
-      def parameter_name
+      def style_parameter_name
         'EnforcedStyleForMultiline'
       end
 
@@ -95,8 +95,7 @@ module RuboCop
           # For each argument, if it is a multi-line hash without braces,
           # then promote the hash elements to method arguments
           # for the purpose of determining multi-line-ness.
-          if a.hash_type? && a.loc.first_line != a.loc.last_line &&
-             !brackets?(a)
+          if a.hash_type? && a.multiline? && !a.braces?
             a.children
           else
             a

data/lib/rubocop/cop/offense.rb

@@ -44,7 +44,7 @@ module RuboCop
       # @!attribute [r] cop_name
       #
       # @return [String]
-      #   a cop class name without namespace.
+      #   a cop class name without department.
       #   i.e. type of the violation.
       #
       # @example

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -61,13 +61,8 @@ module RuboCop
         PERCENT_I = '%i'.freeze
         PERCENT_CAPITAL_I = '%I'.freeze
 
-        def on_case(node)
-          _case_branch, *when_branches, _else_branch = *node
-          when_conditions =
-            when_branches.each_with_object([]) do |branch, conditions|
-              *condition, _ = *branch
-              condition.each { |c| conditions << c }
-            end
+        def on_case(case_node)
+          when_conditions = case_node.when_branches.flat_map(&:conditions)
 
           splat_offenses(when_conditions).reverse_each do |condition|
             range = condition.parent.loc.keyword.join(condition.source_range)
@@ -77,99 +72,101 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          *conditions, _body = *node
+        private
 
+        def autocorrect(when_node)
           lambda do |corrector|
-            if needs_reorder?(node)
-              reorder_condition(corrector, node, replacement(conditions))
+            if needs_reorder?(when_node)
+              reorder_condition(corrector, when_node)
             else
-              inline_fix_branch(corrector, node, conditions,
-                                replacement(conditions))
+              inline_fix_branch(corrector, when_node)
             end
           end
         end
 
-        private
-
         def replacement(conditions)
-          ordered_conditions = conditions.partition { |cond| !cond.splat_type? }
-          ordered_conditions.flatten!
-          ordered_conditions.map!(&:source)
-          ordered_conditions.join(', ')
+          reordered = conditions.partition(&:splat_type?).reverse
+          reordered.flatten.map(&:source).join(', ')
         end
 
-        def inline_fix_branch(corrector, _node, conditions, new_condition)
+        def inline_fix_branch(corrector, when_node)
+          conditions = when_node.conditions
           range = range_between(conditions[0].loc.expression.begin_pos,
                                 conditions[-1].loc.expression.end_pos)
-          corrector.replace(range, new_condition)
+
+          corrector.replace(range, replacement(conditions))
         end
 
-        def reorder_condition(corrector, node, new_condition)
-          *_conditions, body = *node
-          _case_branch, *when_branches, _else_branch = *node.parent
-          return if when_branches.size == 1 # Can't reorder one branch
+        def reorder_condition(corrector, when_node)
+          when_branches = when_node.parent.when_branches
+
+          return if when_branches.one?
 
-          corrector.remove(when_branch_range(node, when_branches))
+          corrector.remove(when_branch_range(when_node))
+          corrector.insert_after(when_branches.last.source_range,
+                                 reordering_correction(when_node))
+        end
 
-          correction = if same_line?(node, body)
-                         new_condition_with_then(node, new_condition)
-                       else
-                         new_branch_without_then(node, body, new_condition)
-                       end
+        def reordering_correction(when_node)
+          new_condition = replacement(when_node.conditions)
 
-          corrector.insert_after(when_branches.last.source_range, correction)
+          if same_line?(when_node, when_node.body)
+            new_condition_with_then(when_node, new_condition)
+          else
+            new_branch_without_then(when_node, new_condition)
+          end
         end
 
-        def when_branch_range(node, when_branches)
-          current_index = when_branches.index { |branch| branch == node }
-          next_branch = when_branches[current_index + 1]
+        def when_branch_range(when_node)
+          next_branch =
+            when_node.parent.when_branches[when_node.branch_index + 1]
 
-          range_between(node.source_range.begin_pos,
+          range_between(when_node.source_range.begin_pos,
                         next_branch.source_range.begin_pos)
         end
 
-        def same_line?(node, other)
-          node.loc.first_line == other.loc.first_line
+        def new_condition_with_then(node, new_condition)
+          "\n#{indent_for(node)}when " \
+          "#{new_condition} then #{node.body.source}"
         end
 
-        def new_condition_with_then(node, new_condition)
-          "\n#{' ' * node.loc.column}when " \
-          "#{new_condition} then #{node.children.last.source}"
+        def new_branch_without_then(node, new_condition)
+          "\n#{indent_for(node)}when #{new_condition}" \
+          "\n#{indent_for(node.body)}#{node.body.source}"
         end
 
-        def new_branch_without_then(node, body, new_condition)
-          "\n#{' ' * node.loc.column}when #{new_condition}\n" \
-          "#{' ' * body.loc.column}#{node.children.last.source}"
+        def indent_for(node)
+          ' ' * node.loc.column
         end
 
         def splat_offenses(when_conditions)
           found_non_splat = false
-          when_conditions.reverse.each_with_object([]) do |condition, result|
-            found_non_splat ||= error_condition?(condition)
 
-            next unless condition.splat_type?
-            variable, = *condition
-            next if variable.array_type?
-            result << condition if found_non_splat
+          offenses = when_conditions.reverse.map do |condition|
+            found_non_splat ||= non_splat?(condition)
+
+            next if non_splat?(condition)
+
+            condition if found_non_splat
           end
+
+          offenses.compact
         end
 
-        def error_condition?(condition)
+        def non_splat?(condition)
           variable, = *condition
 
           (condition.splat_type? && variable.array_type?) ||
             !condition.splat_type?
         end
 
-        def needs_reorder?(node)
-          _case_condition, *when_branches, _else_branch = *node.parent
-          current_index = when_branches.index { |branch| branch == node }
-          when_branches[(current_index + 1)..-1].any? do |branch|
-            *conditions, _ = *branch
-            conditions.none? do |condition|
-              variable, = *condition
-              condition.splat_type? && !(variable && variable.array_type?)
+        def needs_reorder?(when_node)
+          following_branches =
+            when_node.parent.when_branches[(when_node.branch_index + 1)..-1]
+
+          following_branches.any? do |when_branch|
+            when_branch.conditions.any? do |condition|
+              non_splat?(condition)
             end
           end
         end

data/lib/rubocop/cop/performance/detect.rb

@@ -45,7 +45,7 @@ module RuboCop
             receiver, _args, body = *receiver if receiver.block_type?
             return if accept_first_call?(receiver, body)
 
-            offense(node, receiver, second_method)
+            register_offense(node, receiver, second_method)
           end
         end
 
@@ -79,7 +79,7 @@ module RuboCop
           lazy?(caller)
         end
 
-        def offense(node, receiver, second_method)
+        def register_offense(node, receiver, second_method)
           _caller, first_method, _args = *receiver
           range = receiver.loc.selector.join(node.loc.selector)
 

data/lib/rubocop/cop/performance/flat_map.rb

@@ -54,14 +54,14 @@ module RuboCop
 
         def offense_for_levels(node, map_node, first_method, flatten)
           message = MSG + FLATTEN_MULTIPLE_LEVELS
-          offense(node, map_node, first_method, flatten, message)
+          register_offense(node, map_node, first_method, flatten, message)
         end
 
         def offense_for_method(node, map_node, first_method, flatten)
-          offense(node, map_node, first_method, flatten, MSG)
+          register_offense(node, map_node, first_method, flatten, MSG)
         end
 
-        def offense(node, map_node, first_method, flatten, message)
+        def register_offense(node, map_node, first_method, flatten, message)
           range = range_between(map_node.loc.selector.begin_pos,
                                 node.loc.expression.end_pos)
 

data/lib/rubocop/cop/performance/redundant_merge.rb

@@ -73,13 +73,10 @@ module RuboCop
         def to_assignments(receiver, pairs)
           pairs.map do |pair|
             key, value = *pair
-            key_src = if key.sym_type? && !key.source.start_with?(':')
-                        ":#{key.source}"
-                      else
-                        key.source
-                      end
 
-            format(AREF_ASGN, receiver.source, key_src, value.source)
+            key = key.sym_type? && pair.colon? ? ":#{key.source}" : key.source
+
+            format(AREF_ASGN, receiver.source, key, value.source)
           end
         end
 

data/lib/rubocop/cop/performance/regexp_match.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # In Ruby 2.4, `String#match?`, `Regexp#match?` and `Symbol#match?`
+      # have been added. The methods are faster than `match`.
+      # Because the methods avoid creating a `MatchData` object or saving
+      # backref.
+      # So, when `MatchData` is not used, use `match?` instead of `match`.
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     if x =~ /re/
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     if x.match(/re/)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     if /re/ === x
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if x.match?(/re/)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if x =~ /re/
+      #       do_something(Regexp.last_match)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if x.match(/re/)
+      #       do_something($~)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     if /re/ === x
+      #       do_something($~)
+      #     end
+      #   end
+      class RegexpMatch < Cop
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.4
+
+        MSG =
+          'Use `match?` instead of `%s` when `MatchData` is not used.'.freeze
+
+        def_node_matcher :match_method?, <<-PATTERN
+          {
+            (send _recv :match _)
+            (send _recv :match _ (:int ...))
+          }
+        PATTERN
+
+        def_node_matcher :match_operator?, <<-PATTERN
+          (send !nil :=~ !nil)
+        PATTERN
+
+        def_node_matcher :match_threequals?, <<-PATTERN
+          (send (regexp (str _) {(regopt) (regopt _)}) :=== !nil)
+        PATTERN
+
+        def_node_matcher :match_with_lvasgn?, <<-PATTERN
+          (match_with_lvasgn !nil !nil)
+        PATTERN
+
+        MATCH_NODE_PATTERN = <<-PATTERN.freeze
+          {
+            #match_method?
+            #match_operator?
+            #match_threequals?
+            #match_with_lvasgn?
+          }
+        PATTERN
+
+        def_node_matcher :match_node?, MATCH_NODE_PATTERN
+        def_node_search :search_match_nodes, MATCH_NODE_PATTERN
+
+        def_node_search :last_matches, <<-PATTERN
+          {
+            (send (const nil :Regexp) :last_match)
+            (send (const nil :Regexp) :last_match _)
+            ({back_ref nth_ref} _)
+            (gvar #dollar_tilde)
+          }
+        PATTERN
+
+        def on_if(node)
+          check_condition(node.condition)
+        end
+
+        def on_case(node)
+          return if node.condition
+
+          node.each_when do |when_node|
+            when_node.each_condition do |condition|
+              check_condition(condition)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if match_method?(node)
+              corrector.replace(node.loc.selector, 'match?')
+            elsif match_operator?(node) || match_threequals?(node)
+              recv, _, arg = *node
+              correct_operator(corrector, recv, arg)
+            elsif match_with_lvasgn?(node)
+              recv, arg = *node
+              correct_operator(corrector, recv, arg)
+            end
+          end
+        end
+
+        private
+
+        def check_condition(cond)
+          match_node?(cond) do
+            return if last_match_used?(cond)
+            add_offense(cond, :expression,
+                        format(MSG, cond.loc.selector.source))
+          end
+        end
+
+        def last_match_used?(match_node)
+          scope_root = scope_root(match_node)
+          body = scope_root ? scope_body(scope_root) : match_node.ancestors.last
+          match_node_pos = match_node.loc.expression.begin_pos
+
+          next_match_pos = next_match_pos(body, match_node_pos, scope_root)
+          range = match_node_pos..next_match_pos
+
+          find_last_match(body, range, scope_root)
+        end
+
+        def next_match_pos(body, match_node_pos, scope_root)
+          node = search_match_nodes(body).find do |match|
+            match.loc.expression.begin_pos > match_node_pos &&
+              scope_root(match) == scope_root
+          end
+          node ? node.loc.expression.begin_pos : Float::INFINITY
+        end
+
+        def find_last_match(body, range, scope_root)
+          last_matches(body).find do |ref|
+            ref_pos = ref.loc.expression.begin_pos
+            range.cover?(ref_pos) &&
+              scope_root(ref) == scope_root
+          end
+        end
+
+        def scope_body(node)
+          node.children[2]
+        end
+
+        def scope_root(node)
+          node.each_ancestor.find do |ancestor|
+            ancestor.def_type? ||
+              ancestor.class_type? ||
+              ancestor.module_type?
+          end
+        end
+
+        def dollar_tilde(sym)
+          sym == :$~
+        end
+
+        def correct_operator(corrector, recv, arg)
+          buffer = processed_source.buffer
+          op_begin_pos = recv.loc.expression.end_pos
+          op_end_pos = arg.loc.expression.begin_pos
+          op_range = Parser::Source::Range.new(buffer, op_begin_pos, op_end_pos)
+          corrector.replace(op_range, '.match?(')
+          corrector.insert_after(arg.loc.expression, ')')
+        end
+      end
+    end
+  end
+end