rubocop 0.54.0 → 0.55.0

data/lib/rubocop/cop/lint/shadowed_argument.rb

@@ -95,6 +95,9 @@ module RuboCop
           argument.assignments.reduce(true) do |location_known, assignment|
             assignment_node = assignment.meta_assignment_node || assignment.node
 
+            # Shorthand assignments always use their arguments
+            next false if assignment_node.shorthand_asgn?
+
             node_within_block_or_conditional =
               node_within_block_or_conditional?(assignment_node.parent,
                                                 argument.scope.node)

data/lib/rubocop/cop/lint/void.rb

@@ -72,13 +72,20 @@ module RuboCop
         UNARY_OPERATORS = %i[+@ -@ ~ !].freeze
         OPERATORS = (BINARY_OPERATORS + UNARY_OPERATORS).freeze
         VOID_CONTEXT_TYPES = %i[def for block].freeze
-        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact downcase
+        NONMUTATING_METHODS = %i[capitalize chomp chop collect compact
+                                 delete_prefix delete_suffix downcase
                                  encode flatten gsub lstrip map next reject
                                  reverse rotate rstrip scrub select shuffle
                                  slice sort sort_by squeeze strip sub succ
                                  swapcase tr tr_s transform_values
                                  unicode_normalize uniq upcase].freeze
 
+        def on_block(node)
+          return unless node.body && !node.body.begin_type?
+          return unless in_void_context?(node.body)
+          check_expression(node.body)
+        end
+
         def on_begin(node)
           check_begin(node)
         end
@@ -90,17 +97,21 @@ module RuboCop
           expressions = *node
           expressions = expressions.drop_last(1) unless in_void_context?(node)
           expressions.each do |expr|
-            check_void_op(expr)
-            check_literal(expr)
-            check_var(expr)
-            check_self(expr)
-            check_defined(expr)
-            if cop_config['CheckForMethodsWithNoSideEffects']
-              check_nonmutating(expr)
-            end
+            check_expression(expr)
           end
         end
 
+        def check_expression(expr)
+          check_void_op(expr)
+          check_literal(expr)
+          check_var(expr)
+          check_self(expr)
+          check_defined(expr)
+          return unless cop_config['CheckForMethodsWithNoSideEffects']
+
+          check_nonmutating(expr)
+        end
+
         def check_void_op(node)
           return unless node.send_type? && OPERATORS.include?(node.method_name)
 

data/lib/rubocop/cop/metrics/block_length.rb

@@ -13,12 +13,28 @@ module RuboCop
         LABEL = 'Block'.freeze
 
         def on_block(node)
-          return if excluded_methods.include?(node.send_node.method_name.to_s)
+          return if excluded_method?(node)
           check_code_length(node)
         end
 
         private
 
+        def excluded_method?(node)
+          node_receiver = node.receiver && node.receiver.source.gsub(/\s+/, '')
+          node_method = String(node.method_name)
+
+          excluded_methods.any? do |config|
+            receiver, method = config.split('.')
+
+            unless method
+              method = receiver
+              receiver = node_receiver
+            end
+
+            method == node_method && receiver == node_receiver
+          end
+        end
+
         def excluded_methods
           cop_config['ExcludedMethods'] || []
         end

data/lib/rubocop/cop/metrics/line_length.rb

@@ -76,11 +76,10 @@ module RuboCop
 
         def extract_heredocs(ast)
           return [] unless ast
-          ast.each_node.with_object([]) do |node, heredocs|
-            next unless node.location.is_a?(Parser::Source::Map::Heredoc)
+          ast.each_node(:str, :dstr, :xstr).select(&:heredoc?).map do |node|
             body = node.location.heredoc_body
             delimiter = node.location.heredoc_end.source.strip
-            heredocs << [body.first_line...body.last_line, delimiter]
+            [body.first_line...body.last_line, delimiter]
           end
         end
 

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

@@ -61,11 +61,12 @@ module RuboCop
       def autocorrect_multiline_words(node, escape, delimiters)
         base_line_number = node.first_line
         previous_line_number = base_line_number
-        contents = node.children.map do |word_node|
+        contents = node.children.map.with_index do |word_node, index|
           line_breaks = line_breaks(word_node,
                                     node.source,
                                     previous_line_number,
-                                    base_line_number)
+                                    base_line_number,
+                                    index)
           previous_line_number = word_node.first_line
           content = escaped_content(word_node, escape, delimiters)
           line_breaks + content
@@ -85,14 +86,14 @@ module RuboCop
         end.join(' ')
       end
 
-      def line_breaks(node, source, previous_line_number, base_line_number)
+      def line_breaks(node, source, previous_line_num, base_line_num, node_idx)
         source_in_lines = source.split("\n")
-        if node.first_line == previous_line_number
-          node.first_line == base_line_number ? '' : ' '
+        if node.first_line == previous_line_num
+          node_idx.zero? && node.first_line == base_line_num ? '' : ' '
         else
-          begin_line_number = previous_line_number - base_line_number + 1
-          end_line_number = node.first_line - base_line_number + 1
-          lines = source_in_lines[begin_line_number...end_line_number]
+          begin_line_num = previous_line_num - base_line_num + 1
+          end_line_num = node.first_line - base_line_num + 1
+          lines = source_in_lines[begin_line_num...end_line_num]
           "\n" + lines.join("\n").split(node.source).first
         end
       end

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

@@ -8,6 +8,7 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   'abc'.match?(/bc\Z/)
       #   'abc' =~ /bc\Z/
       #   'abc'.match(/bc\Z/)
       #
@@ -19,7 +20,7 @@ module RuboCop
         SINGLE_QUOTE = "'".freeze
 
         def_node_matcher :redundant_regex?, <<-PATTERN
-          {(send $!nil? {:match :=~} (regexp (str $#literal_at_end?) (regopt)))
+          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_end?) (regopt)))
            (send (regexp (str $#literal_at_end?) (regopt)) {:match :=~} $_)}
         PATTERN
 

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

@@ -19,6 +19,13 @@ module RuboCop
       #
       #   # bad
       #   def foo
+      #     if x !~ /re/
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def foo
       #     if x.match(/re/)
       #       do_something
       #     end
@@ -40,6 +47,13 @@ module RuboCop
       #
       #   # good
       #   def foo
+      #     if !x.match?(/re/)
+      #       do_something
+      #     end
+      #   end
+      #
+      #   # good
+      #   def foo
       #     if x =~ /re/
       #       do_something(Regexp.last_match)
       #     end
@@ -63,6 +77,9 @@ module RuboCop
 
         minimum_target_ruby_version 2.4
 
+        # Constants are included in this list because it is unlikely that
+        # someone will store `nil` as a constant and then use it for comparison
+        TYPES_IMPLEMENTING_MATCH = %i[const regexp str sym].freeze
         MSG =
           'Use `match?` instead of `%<current>s` when `MatchData` ' \
           'is not used.'.freeze
@@ -75,7 +92,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :match_operator?, <<-PATTERN
-          (send !nil? :=~ !nil?)
+          (send !nil? {:=~ :!~} !nil?)
         PATTERN
 
         def_node_matcher :match_threequals?, <<-PATTERN
@@ -128,8 +145,8 @@ module RuboCop
             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)
+              recv, oper, arg = *node
+              correct_operator(corrector, recv, arg, oper)
             elsif match_with_lvasgn?(node)
               recv, arg = *node
               correct_operator(corrector, recv, arg)
@@ -214,13 +231,32 @@ module RuboCop
           ].include?(sym)
         end
 
-        def correct_operator(corrector, recv, arg)
+        def correct_operator(corrector, recv, arg, oper = nil)
+          op_range = correction_range(recv, arg)
+
+          if TYPES_IMPLEMENTING_MATCH.include?(recv.type)
+            corrector.replace(op_range, '.match?(')
+          elsif TYPES_IMPLEMENTING_MATCH.include?(arg.type)
+            corrector.replace(op_range, '.match?(')
+            swap_receiver_and_arg(corrector, recv, arg)
+          else
+            corrector.replace(op_range, '&.match?(')
+          end
+
+          corrector.insert_after(arg.loc.expression, ')')
+          corrector.insert_before(recv.loc.expression, '!') if oper == :!~
+        end
+
+        def swap_receiver_and_arg(corrector, recv, arg)
+          corrector.replace(recv.loc.expression, arg.source)
+          corrector.replace(arg.loc.expression, recv.source)
+        end
+
+        def correction_range(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, ')')
+          Parser::Source::Range.new(buffer, op_begin_pos, op_end_pos)
         end
       end
     end

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

@@ -8,6 +8,7 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   'abc'.match?(/\Aab/)
       #   'abc' =~ /\Aab/
       #   'abc'.match(/\Aab/)
       #
@@ -19,7 +20,7 @@ module RuboCop
         SINGLE_QUOTE = "'".freeze
 
         def_node_matcher :redundant_regex?, <<-PATTERN
-          {(send $!nil? {:match :=~} (regexp (str $#literal_at_start?) (regopt)))
+          {(send $!nil? {:match :=~ :match?} (regexp (str $#literal_at_start?) (regopt)))
            (send (regexp (str $#literal_at_start?) (regopt)) {:match :=~} $_)}
         PATTERN
 

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

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop is used to identify instances of sorting and then taking
+      # only the first or last element.
+      #
+      # @example
+      #   # bad
+      #   [].sort.first
+      #   [].sort_by(&:length).last
+      #
+      #   # good
+      #   [].min
+      #   [].max_by(&:length)
+      class UnneededSort < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<suggestion>s` instead of '\
+              '`%<sorter>s...%<accessor_source>s`.'.freeze
+
+        def_node_matcher :unneeded_sort?, <<-MATCHER
+          {
+            (send $(send _ $:sort ...) ${:last :first})
+            (send $(send _ $:sort ...) ${:[] :at :slice} {(int 0) (int -1)})
+
+            (send $(send _ $:sort_by _) ${:last :first})
+            (send $(send _ $:sort_by _) ${:[] :at :slice} {(int 0) (int -1)})
+
+            (send (block $(send _ ${:sort_by :sort}) ...) ${:last :first})
+            (send
+              (block $(send _ ${:sort_by :sort}) ...)
+              ${:[] :at :slice} {(int 0) (int -1)}
+            )
+          }
+        MATCHER
+
+        def on_send(node)
+          unneeded_sort?(node) do |sort_node, sorter, accessor|
+            range = range_between(
+              sort_node.loc.selector.begin_pos,
+              node.loc.expression.end_pos
+            )
+
+            add_offense(node,
+                        location: range,
+                        message: message(node,
+                                         sorter,
+                                         accessor))
+          end
+        end
+
+        def autocorrect(node)
+          sort_node, sorter, accessor = unneeded_sort?(node)
+
+          lambda do |corrector|
+            # Remove accessor, e.g. `first` or `[-1]`.
+            corrector.remove(
+              range_between(
+                accessor_start(node),
+                node.loc.expression.end_pos
+              )
+            )
+
+            # Replace "sort" or "sort_by" with the appropriate min/max method.
+            corrector.replace(
+              sort_node.loc.selector,
+              suggestion(sorter, accessor, arg_value(node))
+            )
+          end
+        end
+
+        private
+
+        def message(node, sorter, accessor)
+          accessor_source = range_between(
+            node.loc.selector.begin_pos,
+            node.loc.expression.end_pos
+          ).source
+
+          format(MSG,
+                 suggestion: suggestion(sorter,
+                                        accessor,
+                                        arg_value(node)),
+                 sorter: sorter,
+                 accessor_source: accessor_source)
+        end
+
+        def suggestion(sorter, accessor, arg)
+          base(accessor, arg) + suffix(sorter)
+        end
+
+        def base(accessor, arg)
+          if accessor == :first || (arg && arg.zero?)
+            'min'
+          elsif accessor == :last || arg == -1
+            'max'
+          end
+        end
+
+        def suffix(sorter)
+          if sorter == :sort
+            ''
+          elsif sorter == :sort_by
+            '_by'
+          end
+        end
+
+        def arg_node(node)
+          node.arguments.first
+        end
+
+        def arg_value(node)
+          arg_node(node).nil? ? nil : arg_node(node).node_parts.first
+        end
+
+        # This gets the start of the accessor whether it has a dot
+        # (e.g. `.first`) or doesn't (e.g. `[0]`)
+        def accessor_start(node)
+          if node.loc.dot
+            node.loc.dot.begin_pos
+          else
+            node.loc.selector.begin_pos
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/http_status.rb

@@ -5,7 +5,7 @@ module RuboCop
     module Rails
       # Enforces use of symbolic or numeric value to define HTTP status.
       #
-      # @example `EnforcedStyle: symbolic` (default)
+      # @example EnforcedStyle: symbolic (default)
       #   # bad
       #   render :foo, status: 200
       #   render json: { foo: 'bar' }, status: 200
@@ -18,7 +18,7 @@ module RuboCop
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
       #
-      # @example `EnforcedStyle: numeric`
+      # @example EnforcedStyle: numeric
       #   # bad
       #   render :foo, status: :ok
       #   render json: { foo: 'bar' }, status: :not_found
@@ -43,24 +43,20 @@ module RuboCop
 
         def_node_matcher :http_status, <<-PATTERN
           {
-            (send nil? {:render :redirect_to}
-              _
-              (hash
-                (pair
-                  (sym :status)
-                  ${int sym})))
-            (send nil? {:render}
-              (hash
-                _
-                (pair
-                  (sym :status)
-                  ${int sym})))
+            (send nil? {:render :redirect_to} _ $hash)
+            (send nil? {:render :redirect_to} $hash)
           }
         PATTERN
 
+        def_node_matcher :status_pair?, <<-PATTERN
+          (pair (sym :status) ${int sym})
+        PATTERN
+
         def on_send(node)
-          http_status(node) do |ast_node|
-            checker = checker_class.new(ast_node)
+          http_status(node) do |hash_node|
+            status = status_code(hash_node)
+            return unless status
+            checker = checker_class.new(status)
             return unless checker.offensive?
             add_offense(checker.node, message: checker.message)
           end
@@ -79,6 +75,13 @@ module RuboCop
 
         private
 
+        def status_code(node)
+          node.each_pair.each do |pair|
+            status_pair?(pair) { |code| return code }
+          end
+          false
+        end
+
         def checker_class
           case style
           when :symbolic