rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant escapes inside Regexp literals.
+      #
+      # @example
+      #   # bad
+      #   %r{foo\/bar}
+      #
+      #   # good
+      #   %r{foo/bar}
+      #
+      #   # good
+      #   /foo\/bar/
+      #
+      #   # good
+      #   %r/foo\/bar/
+      #
+      #   # good
+      #   %r!foo\!bar!
+      #
+      #   # bad
+      #   /a\-b/
+      #
+      #   # good
+      #   /a-b/
+      #
+      #   # bad
+      #   /[\+\-]\d/
+      #
+      #   # good
+      #   /[+\-]\d/
+      class RedundantRegexpEscape < Cop
+        include RangeHelp
+        include RegexpLiteralHelp
+
+        MSG_REDUNDANT_ESCAPE = 'Redundant escape inside regexp literal'
+
+        ALLOWED_ALWAYS_ESCAPES = ' []^\\#'.chars.freeze
+        ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
+        ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
+
+        def on_regexp(node)
+          each_escape(node) do |char, index, within_character_class|
+            next if allowed_escape?(node, char, within_character_class)
+
+            add_offense(
+              node,
+              location: escape_range_at_index(node, index),
+              message: MSG_REDUNDANT_ESCAPE
+            )
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            each_escape(node) do |char, index, within_character_class|
+              next if allowed_escape?(node, char, within_character_class)
+
+              corrector.remove_leading(escape_range_at_index(node, index), 1)
+            end
+          end
+        end
+
+        private
+
+        def allowed_escape?(node, char, within_character_class)
+          # Strictly speaking a few single-letter metachars are currently
+          # unnecessary to "escape", e.g. g, i, E, F, but enumerating them is
+          # rather difficult, and their behaviour could change over time with
+          # different versions of Ruby so that e.g. /\g/ != /g/
+          return true if /[[:alnum:]]/.match?(char)
+          return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
+
+          if within_character_class
+            ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+          else
+            ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES.include?(char)
+          end
+        end
+
+        def delimiter?(node, char)
+          delimiters = [
+            node.loc.begin.source.chars.last,
+            node.loc.end.source.chars.first
+          ]
+
+          delimiters.include?(char)
+        end
+
+        def each_escape(node)
+          pattern_source(node).each_char.with_index.reduce(
+            [nil, false]
+          ) do |(previous, within_character_class), (current, index)|
+            if previous == '\\'
+              yield [current, index - 1, within_character_class]
+
+              [nil, within_character_class]
+            elsif previous == '[' && current != ':'
+              [current, true]
+            elsif previous != ':' && current == ']'
+              [current, false]
+            else
+              [current, within_character_class]
+            end
+          end
+        end
+
+        def escape_range_at_index(node, index)
+          regexp_begin = node.loc.begin.end_pos
+
+          start = regexp_begin + index
+
+          range_between(start, start + 2)
+        end
+      end
+    end
+  end
+end

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

@@ -6,11 +6,15 @@ module RuboCop
       # This cop checks for redundant `return` expressions.
       #
       # @example
+      #   # These bad cases should be extended to handle methods whose body is
+      #   # if/else or a case expression with a default branch.
       #
+      #   # bad
       #   def test
       #     return something
       #   end
       #
+      #   # bad
       #   def test
       #     one
       #     two
@@ -18,66 +22,100 @@ module RuboCop
       #     return something
       #   end
       #
-      # It should be extended to handle methods whose body is if/else
-      # or a case expression with a default branch.
+      #   # good
+      #   def test
+      #     return something if something_else
+      #   end
+      #
+      #   # good
+      #   def test
+      #     if x
+      #     elsif y
+      #     else
+      #     end
+      #   end
+      #
+      # @example AllowMultipleReturnValues: false (default)
+      #   # bad
+      #   def test
+      #     return x, y
+      #   end
+      #
+      # @example AllowMultipleReturnValues: true
+      #   # good
+      #   def test
+      #     return x, y
+      #   end
+      #
       class RedundantReturn < Cop
-        MSG = 'Redundant `return` detected.'.freeze
-        MULTI_RETURN_MSG = 'To return multiple values, use an array.'.freeze
+        include RangeHelp
 
-        def on_def(node)
-          return unless node.body
+        MSG = 'Redundant `return` detected.'
+        MULTI_RETURN_MSG = 'To return multiple values, use an array.'
 
+        def on_def(node)
           check_branch(node.body)
         end
         alias on_defs on_def
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
-            unless arguments?(node.children)
-              corrector.replace(node.source_range, 'nil')
-              next
-            end
-
-            return_value, = *node
-            if node.children.size > 1
-              add_brackets(corrector, node)
-            elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless return_value.braces?
+            if node.arguments?
+              correct_with_arguments(node, corrector)
+            else
+              correct_without_arguments(node, corrector)
             end
-            return_kw = range_with_surrounding_space(node.loc.keyword, :right)
-            corrector.remove(return_kw)
           end
         end
 
-        def add_brackets(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '[')
-          corrector.insert_after(kids.last, ']')
+        private
+
+        def correct_without_arguments(return_node, corrector)
+          corrector.replace(return_node, 'nil')
         end
 
-        def add_braces(corrector, node)
-          kids = node.children.map(&:source_range)
-          corrector.insert_before(kids.first, '{')
-          corrector.insert_after(kids.last, '}')
+        def correct_with_arguments(return_node, corrector)
+          if return_node.arguments.size > 1
+            add_brackets(corrector, return_node)
+          elsif hash_without_braces?(return_node.first_argument)
+            add_braces(corrector, return_node.first_argument)
+          end
+
+          keyword = range_with_surrounding_space(range: return_node.loc.keyword,
+                                                 side: :right)
+          corrector.remove(keyword)
+        end
+
+        def hash_without_braces?(node)
+          node.hash_type? && !node.braces?
         end
 
-        def arguments?(args)
-          return false if args.empty?
-          return true if args.size > 1
+        def add_brackets(corrector, node)
+          corrector.insert_before(node.children.first, '[')
+          corrector.insert_after(node.children.last, ']')
+        end
 
-          !args.first.begin_type? || !args.first.children.empty?
+        def add_braces(corrector, node)
+          corrector.insert_before(node.children.first, '{')
+          corrector.insert_after(node.children.last, '}')
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
+          return unless 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 :rescue, :resbody
+            check_rescue_node(node)
+          when :ensure then check_ensure_node(node)
+          when :begin, :kwbegin
+            check_begin_node(node)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def check_return_node(node)
           return if cop_config['AllowMultipleReturnValues'] &&
@@ -87,33 +125,31 @@ module RuboCop
         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
+          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?
 
-          _cond, if_node, else_node = *node.node_parts
-
-          check_branch(if_node) if if_node
-          check_branch(else_node) if else_node
+          check_branch(node.if_branch)
+          check_branch(node.else_branch)
         end
 
-        def check_begin_node(node)
-          expressions = *node
-          last_expr = expressions.last
+        def check_rescue_node(node)
+          node.child_nodes.each do |child_node|
+            check_branch(child_node)
+          end
+        end
 
-          return unless last_expr && last_expr.return_type?
+        def check_ensure_node(node)
+          rescue_node = node.node_parts[0]
+          check_branch(rescue_node)
+        end
 
-          check_return_node(last_expr)
+        def check_begin_node(node)
+          last_expr = node.children.last
+          check_branch(last_expr)
         end
 
         def allow_multiple_return_values?

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

@@ -5,49 +5,54 @@ 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
-      #   end
+      # Note we allow uses of `self` with operators because it would be awkward
+      # otherwise.
       #
+      # @example
+      #
+      #   # bad
       #   def foo(bar)
-      #     self.bar # resolves name clash with argument
+      #     self.baz
       #   end
       #
-      #   def foo2
-      #     bar = 1
-      #     self.bar # resolves name clash with local variable
+      #   # good
+      #   def foo(bar)
+      #     self.bar  # Resolves name clash with the argument.
       #   end
       #
-      #   %w[x y z].select do |bar|
-      #     self.bar == bar # resolves name clash with argument of a block
+      #   def foo
+      #     bar = 1
+      #     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
+        MSG = 'Redundant `self` detected.'
+        KERNEL_METHODS = Kernel.methods(false)
+        KEYWORDS = %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 __FILE__ __LINE__ __ENCODING__].freeze
+
+        def self.autocorrect_incompatible_with
+          [ColonMethodCall]
+        end
 
         def initialize(config = nil, options = nil)
           super
@@ -83,14 +88,21 @@ module RuboCop
           on_argument(node)
         end
 
+        def on_masgn(node)
+          lhs, rhs = *node
+          lhs.children.each do |child|
+            add_lhs_to_local_variables_scopes(rhs, child.to_a.first)
+          end
+        end
+
         def on_lvasgn(node)
           lhs, rhs = *node
-          @local_variables_scopes[rhs] << lhs
+          add_lhs_to_local_variables_scopes(rhs, lhs)
         end
 
         def on_send(node)
           return unless node.self_receiver? && regular_method_call?(node)
-          return if node.parent && node.parent.mlhs_type?
+          return if node.parent&.mlhs_type?
 
           return if allowed_send_node?(node)
 
@@ -101,15 +113,15 @@ module RuboCop
           add_scope(node, @local_variables_scopes[node])
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
-            corrector.remove(node.receiver.source_range)
+            corrector.remove(node.receiver)
             corrector.remove(node.loc.dot)
           end
         end
 
+        private
+
         def add_scope(node, local_variables = [])
           node.descendants.each do |child_node|
             @local_variables_scopes[child_node] = local_variables
@@ -118,12 +130,13 @@ module RuboCop
 
         def allowed_send_node?(node)
           @allowed_send_nodes.include?(node) ||
-            @local_variables_scopes[node].include?(node.method_name)
+            @local_variables_scopes[node].include?(node.method_name) ||
+            KERNEL_METHODS.include?(node.method_name)
         end
 
         def regular_method_call?(node)
-          !(operator?(node.method_name) ||
-            keyword?(node.method_name) ||
+          !(node.operator_method? ||
+            KEYWORDS.include?(node.method_name) ||
             node.camel_case_method? ||
             node.setter_method? ||
             node.implicit_call?)
@@ -134,19 +147,21 @@ module RuboCop
           @local_variables_scopes[node] << name
         end
 
-        def keyword?(method_name)
-          %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.send_type? && node.self_receiver?
 
           @allowed_send_nodes << node
         end
+
+        def add_lhs_to_local_variables_scopes(rhs, lhs)
+          if rhs&.send_type? && !rhs.arguments.empty?
+            rhs.arguments.each do |argument|
+              @local_variables_scopes[argument] << lhs
+            end
+          else
+            @local_variables_scopes[rhs] << lhs
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop is used to identify instances of sorting and then
+      # taking only the first or last element. The same behavior can
+      # be accomplished without a relatively expensive sort by using
+      # `Enumerable#min` instead of sorting and taking the first
+      # element and `Enumerable#max` instead of sorting and taking the
+      # last element. Similarly, `Enumerable#min_by` and
+      # `Enumerable#max_by` can replace `Enumerable#sort_by` calls
+      # after which only the first or last element is used.
+      #
+      # @example
+      #   # bad
+      #   [2, 1, 3].sort.first
+      #   [2, 1, 3].sort[0]
+      #   [2, 1, 3].sort.at(0)
+      #   [2, 1, 3].sort.slice(0)
+      #
+      #   # good
+      #   [2, 1, 3].min
+      #
+      #   # bad
+      #   [2, 1, 3].sort.last
+      #   [2, 1, 3].sort[-1]
+      #   [2, 1, 3].sort.at(-1)
+      #   [2, 1, 3].sort.slice(-1)
+      #
+      #   # good
+      #   [2, 1, 3].max
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).first
+      #   arr.sort_by(&:foo)[0]
+      #   arr.sort_by(&:foo).at(0)
+      #   arr.sort_by(&:foo).slice(0)
+      #
+      #   # good
+      #   arr.min_by(&:foo)
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).last
+      #   arr.sort_by(&:foo)[-1]
+      #   arr.sort_by(&:foo).at(-1)
+      #   arr.sort_by(&:foo).slice(-1)
+      #
+      #   # good
+      #   arr.max_by(&:foo)
+      #
+      class RedundantSort < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<suggestion>s` instead of '\
+              '`%<sorter>s...%<accessor_source>s`.'
+
+        def_node_matcher :redundant_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 numblock} $(send _ ${:sort_by :sort}) ...) ${:last :first})
+            (send
+              ({block numblock} $(send _ ${:sort_by :sort}) ...)
+              ${:[] :at :slice} {(int 0) (int -1)}
+            )
+          }
+        MATCHER
+
+        def on_send(node)
+          redundant_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 = redundant_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&.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/{performance → style}/redundant_sort_by.rb

@@ -2,23 +2,25 @@
 
 module RuboCop
   module Cop
-    module Performance
+    module Style
       # This cop identifies places where `sort_by { ... }` can be replaced by
       # `sort`.
       #
       # @example
-      #   @bad
+      #   # bad
       #   array.sort_by { |x| x }
       #   array.sort_by do |var|
       #     var
       #   end
       #
-      #   @good
+      #   # good
       #   array.sort
       class RedundantSortBy < Cop
-        MSG = 'Use `sort` instead of `sort_by { |%s| %s }`.'.freeze
+        include RangeHelp
 
-        def_node_matcher :redundant_sort_by, <<-PATTERN
+        MSG = 'Use `sort` instead of `sort_by { |%<var>s| %<var>s }`.'
+
+        def_node_matcher :redundant_sort_by, <<~PATTERN
           (block $(send _ :sort_by) (args (arg $_x)) (lvar _x))
         PATTERN
 
@@ -28,12 +30,12 @@ module RuboCop
 
             add_offense(node,
                         location: range,
-                        message: format(MSG, var_name, var_name))
+                        message: format(MSG, var: var_name))
           end
         end
 
         def autocorrect(node)
-          send, = *node
+          send = node.send_node
           ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
         end