rubocop 0.87.1

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/style/redundant_sort_by.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `sort_by { ... }` can be replaced by
+      # `sort`.
+      #
+      # @example
+      #   # bad
+      #   array.sort_by { |x| x }
+      #   array.sort_by do |var|
+      #     var
+      #   end
+      #
+      #   # good
+      #   array.sort
+      class RedundantSortBy < Cop
+        include RangeHelp
+
+        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
+
+        def on_block(node)
+          redundant_sort_by(node) do |send, var_name|
+            range = sort_by_range(send, node)
+
+            add_offense(node,
+                        location: range,
+                        message: format(MSG, var: var_name))
+          end
+        end
+
+        def autocorrect(node)
+          send = node.send_node
+          ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
+        end
+
+        private
+
+        def sort_by_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces using // or %r around regular expressions.
+      #
+      # @example EnforcedStyle: slashes (default)
+      #   # bad
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # bad
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      #   # good
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # good
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      # @example EnforcedStyle: percent_r
+      #   # bad
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # bad
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # good
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # good
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
+      #   snake_case = %r{^[\dA-Z_]+$}
+      #
+      #   # bad
+      #   regex = /
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   /x
+      #
+      #   # good
+      #   snake_case = /^[\dA-Z_]+$/
+      #
+      #   # good
+      #   regex = %r{
+      #     foo
+      #     (bar)
+      #     (baz)
+      #   }x
+      #
+      # @example AllowInnerSlashes: false (default)
+      #   # If `false`, the cop will always recommend using `%r` if one or more
+      #   # slashes are found in the regexp string.
+      #
+      #   # bad
+      #   x =~ /home\//
+      #
+      #   # good
+      #   x =~ %r{home/}
+      #
+      # @example AllowInnerSlashes: true
+      #   # good
+      #   x =~ /home\//
+      class RegexpLiteral < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_USE_SLASHES = 'Use `//` around regular expression.'
+        MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'
+
+        def on_regexp(node)
+          if slash_literal?(node)
+            check_slash_literal(node)
+          else
+            check_percent_r_literal(node)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            correct_delimiters(node, corrector)
+            correct_inner_slashes(node, corrector)
+          end
+        end
+
+        private
+
+        def check_slash_literal(node)
+          return if allowed_slash_literal?(node)
+
+          add_offense(node, message: MSG_USE_PERCENT_R)
+        end
+
+        def check_percent_r_literal(node)
+          return if allowed_percent_r_literal?(node)
+
+          add_offense(node, message: MSG_USE_SLASHES)
+        end
+
+        def allowed_slash_literal?(node)
+          style == :slashes && !contains_disallowed_slash?(node) ||
+            allowed_mixed_slash?(node)
+        end
+
+        def allowed_mixed_slash?(node)
+          style == :mixed && node.single_line? &&
+            !contains_disallowed_slash?(node)
+        end
+
+        def allowed_percent_r_literal?(node)
+          style == :slashes && contains_disallowed_slash?(node) ||
+            style == :percent_r ||
+            allowed_mixed_percent_r?(node)
+        end
+
+        def allowed_mixed_percent_r?(node)
+          style == :mixed && node.multiline? ||
+            contains_disallowed_slash?(node)
+        end
+
+        def contains_disallowed_slash?(node)
+          !allow_inner_slashes? && contains_slash?(node)
+        end
+
+        def contains_slash?(node)
+          node_body(node).include?('/')
+        end
+
+        def allow_inner_slashes?
+          cop_config['AllowInnerSlashes']
+        end
+
+        def node_body(node, include_begin_nodes: false)
+          types = include_begin_nodes ? %i[str begin] : %i[str]
+          node.each_child_node(*types).map(&:source).join
+        end
+
+        def slash_literal?(node)
+          node.loc.begin.source == '/'
+        end
+
+        def preferred_delimiters
+          config.for_cop('Style/PercentLiteralDelimiters') \
+            ['PreferredDelimiters']['%r'].split(//)
+        end
+
+        def correct_delimiters(node, corrector)
+          replacement = calculate_replacement(node)
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
+        end
+
+        def correct_inner_slashes(node, corrector)
+          regexp_begin = node.loc.begin.end_pos
+
+          inner_slash_indices(node).each do |index|
+            start = regexp_begin + index
+
+            corrector.replace(
+              range_between(
+                start,
+                start + inner_slash_before_correction(node).length
+              ),
+              inner_slash_after_correction(node)
+            )
+          end
+        end
+
+        def inner_slash_indices(node)
+          text    = node_body(node, include_begin_nodes: true)
+          pattern = inner_slash_before_correction(node)
+          index   = -1
+          indices = []
+
+          while (index = text.index(pattern, index + 1))
+            indices << index
+          end
+
+          indices
+        end
+
+        def inner_slash_before_correction(node)
+          inner_slash_for(node.loc.begin.source)
+        end
+
+        def inner_slash_after_correction(node)
+          inner_slash_for(calculate_replacement(node).first)
+        end
+
+        def inner_slash_for(opening_delimiter)
+          if ['/', '%r/'].include?(opening_delimiter)
+            '\/'
+          else
+            '/'
+          end
+        end
+
+        def calculate_replacement(node)
+          if slash_literal?(node)
+            ['%r', ''].zip(preferred_delimiters).map(&:join)
+          else
+            %w[/ /]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for uses of rescue in its modifier form.
+      #
+      # The cop to check `rescue` in its modifier form is added for following
+      # reasons:
+      #
+      # * The syntax of modifier form `rescue` can be misleading because it
+      #   might led us to believe that `rescue` handles the given exception
+      #   but it actually rescue all exceptions to return the given rescue
+      #   block. In this case, value returned by handle_error or
+      #   SomeException.
+      #
+      # * Modifier form `rescue` would rescue all the exceptions. It would
+      #   silently skip all exception or errors and handle the error.
+      #   Example: If `NoMethodError` is raised, modifier form rescue would
+      #   handle the exception.
+      #
+      # @example
+      #   # bad
+      #   some_method rescue handle_error
+      #
+      #   # bad
+      #   some_method rescue SomeException
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue
+      #     handle_error
+      #   end
+      #
+      #   # good
+      #   begin
+      #     some_method
+      #   rescue SomeException
+      #     handle_error
+      #   end
+      class RescueModifier < Cop
+        include Alignment
+        include RescueNode
+
+        MSG = 'Avoid using `rescue` in its modifier form.'
+
+        def on_resbody(node)
+          return unless rescue_modifier?(node)
+
+          add_offense(node.parent)
+        end
+
+        def autocorrect(node)
+          operation, rescue_modifier, = *node
+          *_, rescue_args = *rescue_modifier
+
+          indent = indentation(node)
+          correction =
+            "begin\n" \
+            "#{operation.source.gsub(/^/, indent)}" \
+            "\n#{offset(node)}rescue\n" \
+            "#{rescue_args.source.gsub(/^/, indent)}" \
+            "\n#{offset(node)}end"
+
+          lambda do |corrector|
+            corrector.replace(node, correction)
+          end
+        end
+      end
+    end
+  end
+end